Python入门Day3

Python的基础数据类型

1.Python中提供了六种内置的数据类型，一般用于存储数据：
–数值Number
–字符串String
–列表List
–元组Tuple
–字典Dictionary
–集合Set
2.Python中的数据类型可以做以下几个分类：
–有序：可以使用下标（索引）访问元素
–无序：不可以使用下标（索引）访问元素
–可变：可以被修改
–不可变：不可以被修改

	有序	无序
可变	列表	字典、集合
不可变	字符串、元组	数值

数值类型

Python3中数值类型支持：

类型	值	范围
int	1,2	（-无穷，+无穷）
float(无double)	1.2,3.7E-2（科学计数法，10的-2次方）	（-无穷，+无穷）
boolean（继承了int类型）	True（参与计算的话，True默认1，False默认0）	[True,False]
complex	x+yj	x是实数部分，y是虚数部分

基本算术运算

a = 10
b = 3

# 加法
sum_result = a + b  # 结果为13

# 减法
sub_result = a - b  # 结果为7

# 乘法
mul_result = a * b  # 结果为30

# 除法（浮点数）
div_result = a / b  # 结果为3.333...

# 整数除法（向下取整）
floor_div = a // b  # 结果为3

# 取模（余数）
mod_result = a % b  # 结果为1

# 幂运算
power_result = a ** b  # 结果为1000
 

数值类型转换

x = 5.7

# 转换为整数（截断小数）
int_x = int(x)  # 结果为5

# 转换为浮点数
float_x = float(10)  # 结果为10.0

# 复数运算
complex_num = complex(2, 3)  # 结果为2+3j
 

数学函数

import math

# 平方根
sqrt_val = math.sqrt(16)  # 结果为4.0

# 对数
log_val = math.log(10, 2)  # 以2为底10的对数

# 三角函数
sin_val = math.sin(math.pi / 2)  # 结果为1.0

# 阶乘
factorial_val = math.factorial(5)  # 结果为120

# 求和
c = math.sum(a,b) 

# 最大值最小值
a = math.max(c,b)
a = math.min(c,b)

# 返回两个数值的商和余数
a,b = math.divmod(y,x)

#### 其他常用函数
- 幂运算：`math.pow(x, y)` 计算x的y次方
- 绝对值：`math.fabs(x)` 浮点数绝对值,整数求绝对值math.abs(x)
- 取整：`math.ceil(x)`向上取整，`math.floor(x)`向下取整
- 常量：`math.pi`圆周率，`math.e`自然对数底数

注意：对于复数运算，需要使用cmath模块而非math模块。## 数学函数详解

随机数生成

import random

# 生成0到1之间的随机浮点数
rand_float = random.random()

# 生成指定范围内的整数
rand_int = random.randint(1, 100)

# 从序列中随机选择
rand_choice = random.choice([1, 2, 3, 4, 5])

数值比较与逻辑运算

x = 5
y = 10

# 比较运算
greater = x > y  # False
equal = x == 5  # True

# 逻辑运算
logical_and = (x < 10) and (y > 5)  # True
logical_or = (x == 5) or (y == 0)  # True
 

字符和字符串

字符串的基本定义

在Python中，字符串是由零个或多个字符组成的不可变序列，用单引号（'）、双引号（"）或三引号（'''或"""）包裹。例如：

str1 = 'Hello'
str2 = "World"
str3 = '''多行
字符串'''

字符串的特性

• 不可变性：字符串一旦创建，其内容无法修改。若需改变，需创建新字符串。
• 编码支持：Python 3默认使用Unicode编码（UTF-8），可直接处理多语言字符。
• 转义字符：通过反斜杠（\）插入特殊字符，如\n（换行）、\t（制表符）。

多行字符串

三引号允许字符串跨越多行，保留换行和缩进格式：

multi_line = """这是
一个多行
字符串"""

原始字符串（Raw String）

在字符串前加r或R，忽略转义字符，常用于正则表达式或文件路径：

raw_str = r"C:\new_folder\temp"

字符串的常见操作

• 拼接：用+连接字符串。
• 重复：用*重复字符串，如'a' * 3得到'aaa'。
• 索引与切片：通过下标访问字符或子串，如str1[0]或str1[1:4]。
• 切片的批量操作：str[a: b :c]，a是其实元素的位置，b是终止元素的位置，c是步长。str[::]表示取所有；str[::2]表示每两个取一个。abc同样可以为负数。

字符串格式化

Python提供多种格式化方法：

• f-string（Python 3.6+）：

  name = "Alice"
  greeting = f"Hello, {name}"
  

• format()方法：

  template = "{} {}".format("Hello", "Bob")
  

• 百分号（%）格式化（旧式）：

  formatted = "Value: %d" % 42
  

字符串的基本定义

在Python中，字符串是由零个或多个字符组成的不可变序列，用单引号（'）、双引号（"）或三引号（'''或"""）包裹。例如：

str1 = 'Hello'
str2 = "World"
str3 = '''多行
字符串'''

字符串的特性

• 不可变性：字符串一旦创建，其内容无法修改。若需改变，需创建新字符串。
• 编码支持：Python 3默认使用Unicode编码（UTF-8），可直接处理多语言字符。
• 转义字符：通过反斜杠（\）插入特殊字符，如\n（换行）、\t（制表符）。

多行字符串

三引号允许字符串跨越多行，保留换行和缩进格式：

multi_line = """这是
一个多行
字符串"""

原始字符串（Raw String）

在字符串前加r或R，忽略转义字符，常用于正则表达式或文件路径：

raw_str = r"C:\new_folder\temp"

字符串的常见操作

• 拼接1：用+连接字符串。
• 拼接2：“–”.join(“HUAWEI”) ==> ‘H–U–A–W–E–I’
• 重复：用*重复字符串，如'a' * 3得到'aaa'。
• 索引与切片：通过下标访问字符或子串，如str1[0]或str1[1:4]。
• 分割：str.split(str1),以str1为分隔符对字符串切割， “python”.split(‘t’) ==> [‘py’, ‘hon’]
• 替换：“python”.replace(‘py’,‘PY’) ==> ‘PYthon’
• 大写： “python”.upper()==>‘PYTHON’
• 小写：“PYTHON”.lower()==>‘python’
• 格式化输出：print(“我的名字叫%s，今年%a岁”%(“Zonda”,26))==>我的名字叫Zonda，今年26岁

元组

元组的定义

元组（Tuple）是Python中的一种不可变有序序列，用于存储多个元素。元组使用圆括号()定义，元素之间用逗号分隔。即使只有一个元素，也需要在元素后加逗号以区分元组和其他数据类型。

# 定义元组
tuple1 = (1, 2, 3)          # 多元素元组
tuple2 = ("a",)             # 单元素元组（需加逗号）
tuple3 = tuple([4, 5, 6])   # 通过构造函数创建

元组的特性

不可变性：元组一旦创建，其 元素不可修改、删除或添加。但若元素本身是可变对象（如列表），其内容可修改。
有序性：元组中的元素按定义顺序存储，支持索引和切片操作。

# 不可变示例
t = (1, 2, [3, 4])
t[2][0] = 5  # 合法，修改元组中的列表元素
t[0] = 10    # 非法，抛出TypeError

元组的常见操作

索引与切片：通过下标访问元素，切片返回新元组。
遍历：使用for循环遍历元组。
拼接与重复：+拼接元组，*重复元组。

t = (1, 2, 3, 4)
print(t[1])       # 输出: 2
print(t[1:3])     # 输出: (2, 3)
new_t = t + (5,)  # 拼接: (1, 2, 3, 4, 5)

元组与列表的区别

可变性：列表可变，元组不可变。
性能：元组因不可变性，通常比列表更高效，适合作为字典键或常量集合。
用途：列表用于动态数据，元组用于保护数据不被修改。

# 元组作为字典键
dict_key = {("a", "b"): "value"}
```### 元组的定义  
元组（Tuple）是Python中的一种不可变有序序列，用于存储多个元素。元组使用圆括号`()`定义，元素之间用逗号分隔。即使只有一个元素，也需要在元素后加逗号以区分元组和其他数据类型。  

```python
# 定义元组
tuple1 = (1, 2, 3)          # 多元素元组
tuple2 = ("a",)             # 单元素元组（需加逗号）
tuple3 = tuple([4, 5, 6])   # 通过构造函数创建

元组的特性

不可变性：元组一旦创建，其元素不可修改、删除或添加。但若元素本身是可变对象（如列表），其内容可修改。
有序性：元组中的元素按定义顺序存储，支持索引和切片操作。

# 不可变示例
t = (1, 2, [3, 4])
t[2][0] = 5  # 合法，修改元组中的列表元素
t[0] = 10    # 非法，抛出TypeError

元组的常见操作

索引与切片：通过下标访问元素，切片返回新元组。
遍历：使用for循环遍历元组。
拼接与重复：+拼接元组，*重复元组。

t = (1, 2, 3, 4)
print(t[1])       # 输出: 2
print(t[1:3])     # 输出: (2, 3)
new_t = t + (5,)  # 拼接: (1, 2, 3, 4, 5)

元组与列表的区别

可变性：列表可变，元组不可变。
性能：元组因不可变性，通常比列表更高效，适合作为字典键或常量集合。
用途：列表用于动态数据，元组用于保护数据不被修改。

# 元组作为字典键
dict_key = {("a", "b"): "value"}

列表

Python列表的定义

Python列表是一种有序、可变的数据结构，用于存储多个元素。列表用方括号[]表示，元素之间用逗号分隔。列表可以包含不同类型的元素，例如整数、字符串、浮点数，甚至其他列表。

my_list = [1, 2, 3, "apple", 5.5]

Python列表的特点

列表是动态的，可以随时添加或删除元素。列表允许重复元素，并且可以通过索引访问或修改元素。索引从0开始，负数索引表示从列表末尾开始计数。

fruits = ["apple", "banana", "cherry"]
print(fruits[1])  # 输出: banana
print(fruits[-1]) # 输出: cherry

列表的常用操作

列表支持多种操作，包括切片、拼接、复制等。切片操作可以获取列表的子集，格式为list[start:end:step]。拼接操作可以使用+合并两个列表。

numbers = [1, 2, 3, 4, 5]
print(numbers[1:4])  # 输出: [2, 3, 4]
print(numbers[::2])  # 输出: [1, 3, 5]

列表拼接操作：

list1 = [1, 2]
list2 = [3, 4]
combined = list1 + list2   # [1, 2, 3, 4]
list1.extend(list2)        # list1变为[1, 2, 3, 4]

可以将元组转化为列表：

t1=(2,3,(1,2,3))
list1 = list(t1)
print(list1) #输出[2, 3, (1, 2, 3)]

列表复制操作
复制分为浅拷贝和深拷贝。浅拷贝（copy()或切片）仅复制外层对象，深拷贝（deepcopy()）会递归复制所有嵌套对象。

import copy
original = [1, [2, 3]]
shallow = original.copy()          # 浅拷贝，嵌套列表共享引用
deep = copy.deepcopy(original)     # 深拷贝，完全独立

列表查找

使用index()方法查找元素首次出现的索引，in运算符判断元素是否存在。查找失败时index()会抛出ValueError。

lst = [10, 20, 30, 20]
idx = lst.index(20)  # 返回1
exists = 30 in lst   # 返回True

列表排序

sort()方法原地排序，sorted()函数返回新列表。可通过key参数定制排序规则，reverse控制升降序。

lst = [3, 1, 4, 2]
lst.sort()                      # 原地排序变为[1, 2, 3, 4]
new_lst = sorted(lst, reverse=True)  # 生成[4, 3, 2, 1]

列表逆序

reverse()方法原地逆序，切片[::-1]生成新逆序列表。

lst = [1, 2, 3]
lst.reverse()       # 变为[3, 2, 1]
reversed_lst = lst[::-1]  # 生成[1, 2, 3]

数量统计

count()统计元素出现次数，len()获取列表长度。

lst = [1, 2, 2, 3]
cnt = lst.count(2)   # 返回2
length = len(lst)    # 返回4
```### 列表查找
使用`index()`方法查找元素首次出现的索引，`in`运算符判断元素是否存在。查找失败时`index()`会抛出`ValueError`。
```python
lst = [10, 20, 30, 20]
idx = lst.index(20)  # 返回1
exists = 30 in lst   # 返回True

列表的方法

列表提供了一系列内置方法，例如append()、extend()、insert()、remove()、pop()等。这些方法可以用于添加、删除或修改列表中的元素。

#增加：
colors = ["red", "green"]
colors.append("blue")     # 添加元素
colors.insert(1, "yellow") # 插入元素
colors.extend(["yellow","blue","black"])#将可迭代的对象逐个插入列表尾部
#删除：
colors.remove("green")    # 删除元素
colors.pop(0) #删除"red"并输出
#查找：
colors.index("green")#返回给定元素第一次出现位置的下标，输出为1

列表的遍历

可以通过循环遍历列表中的元素。常见的遍历方式包括for循环和while循环。列表推导式是一种简洁的生成列表的方式。

squares = [x**2 for x in range(5)]
print(squares)  # 输出: [0, 1, 4, 9, 16]

也可以在遍历的过程中加上条件

squares = [x**2 for x in range(5) if x % 2 == 1]
print(squares)  # 输出: [1,9]

也可以两个数字一起加条件遍历

print([(x,y) for x in range(5) if x%2==1 for y in range(10) if y % 3 == 1])
#输出[(1, 1), (1, 4), (1, 7), (3, 1), (3, 4), (3, 7)]

列表与元组的区别

列表是可变的，而元组是不可变的。如果需要修改数据，应使用列表；如果需要不可变的数据结构，应使用元组。元组用圆括号()表示。

my_tuple = (1, 2, 3)

以上内容涵盖了Python列表的核心概念和常见操作，适用于初学者和需要快速回顾的开发人员。### Python列表的定义

Python列表是一种有序、可变的数据结构，用于存储多个元素。列表用方括号[]表示，元素之间用逗号分隔。列表可以包含不同类型的元素，例如整数、字符串、浮点数，甚至其他列表。

my_list = [1, 2, 3, "apple", 5.5]

列表和数组

Python中的列表在外观上和数组相似，但是两者并不是一种结构。
–Python的内置数据结构中并没有数组，需要借助工具包numpy实现。
–列表和数组可以相互转化，但是本质是不一样的。数组有维度，列表无维度。

>>> import numpy
>>> l = [1,2,3,4]
>>> print(l)
[1, 2, 3, 4]
>>> print(numpy.array(l))
[1 2 3 4]
>>> l2 = [[1,2],[3,4]]
>>> print(l2)
[[1, 2], [3, 4]]
>>> print(numpy.array(l2))
[[1 2]
 [3 4]]

字典

字典的定义：字典的每个元素由两部分组成-键和值，所以字典的元素也被称为键值对。
–其中键是不可变且唯一的
–如果字典有相同的键，则后面的键对应的值会将前面的值覆盖
–数据量大的时候，字典数据的访问速度比列表快
–字典是无序可变的序列

deepseek解释：字典（Dictionary）是Python中一种可变容器模型，可存储任意类型对象。字典的每个元素由一个键（key）和一个值（value）组成，键和值之间用冒号分隔，元素之间用逗号分隔，整个字典包括在花括号中。

字典的键必须是唯一的，且不可变类型（如字符串、数字或元组）。值可以是任何数据类型，且可以重复。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

字典的创建

字典可以通过多种方式创建。直接使用花括号是最常见的方法。

# 空字典
empty_dict = {}

# 直接赋值
person = {'name': 'Bob', 'age': 30}

# 使用dict()构造函数
person = dict(name='Bob', age=30)

# 从键值对列表创建
person = dict([('name', 'Bob'), ('age', 30)])

字典的访问

可以通过键来访问字典中的值。如果键不存在，会引发KeyError。使用get()方法可以避免KeyError，并返回默认值。

person = {'name': 'Bob', 'age': 30}

# 直接访问
print(person['name'])  # 输出: Bob

# 使用get方法
print(person.get('name'))  # 输出: Bob
print(person.get('gender', 'Unknown'))  # 输出: Unknown

字典的修改

字典是可变的，可以通过键来修改或添加新的键值对。

person = {'name': 'Bob', 'age': 30}

# 修改值
person['age'] = 31

# 添加新键值对
person['city'] = 'London'

print(person)  # 输出: {'name': 'Bob', 'age': 31, 'city': 'London'}

字典的删除

可以使用del语句、pop()方法或clear()方法来删除字典中的元素。

person = {'name': 'Bob', 'age': 30, 'city': 'London'}

# 删除特定键值对
del person['age']

# 删除并返回值
city = person.pop('city')

# 清空字典
person.clear()

print(person)  # 输出: {}

字典的遍历

字典可以通过多种方式遍历，包括键、值或键值对。

person = {'name': 'Bob', 'age': 30, 'city': 'London'}

# 遍历键
for key in person:
    print(key)

# 遍历值
for value in person.values():
    print(value)

# 遍历键值对
for key, value in person.items():
    print(key, value)

字典的常用方法

字典提供了多种内置方法，用于操作和查询字典。

person = {'name': 'Bob', 'age': 30, 'city': 'London'}

# 获取所有键
keys = person.keys()

# 获取所有值
values = person.values()

# 获取所有键值对
items = person.items()

# 复制字典
person_copy = person.copy()

# 更新字典
person.update({'age': 31, 'gender': 'Male'})

字典的嵌套

字典可以嵌套在其他字典中，形成复杂的数据结构。

people = {
    'person1': {'name': 'Alice', 'age': 25},
    'person2': {'name': 'Bob', 'age': 30}
}

print(people['person1']['name'])  # 输出: Alice

字典推导式

字典推导式提供了一种简洁的创建字典的方法。

# 创建平方字典
squares = {x: x*x for x in range(6)}

print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

集合

集合的定义

集合（set）是Python中的一种无序、可变且不重复元素的容器数据类型。其核心特性包括：

• 无序性：元素存储顺序与添加顺序无关。
• 唯一性：自动去除重复元素。
• 可变性：支持增删操作，但元素本身必须是不可变类型（如数字、字符串、元组）。

集合用大括号 {} 或 set() 函数定义，空集合必须使用 set()（{} 表示空字典）。

s1 = {1, 2, 3}          # 直接定义
s2 = set([1, 2, 2])     # 从列表转换，结果为 {1, 2}

---

集合的操作方法

添加元素

• add(x)：添加单个元素。
• update(iterable)：合并其他可迭代对象（如列表、元组）的元素。

s = {1, 2}
s.add(3)               # {1, 2, 3}
s.update([4, 5])       # {1, 2, 3, 4, 5}

删除元素

• remove(x)：删除指定元素，若不存在则报错。
• discard(x)：删除元素，若不存在则不报错。
• pop()：随机删除并返回一个元素（因集合无序）。
• clear()：清空集合。

s = {1, 2, 3}
s.remove(2)            # {1, 3}
s.discard(4)           # 无变化
s.pop()                # 可能返回 1 或 3，随机删除一个元素并返回

---

集合的运算

集合支持数学中的集合操作：

基本运算

• union() 或 |：并集。
• intersection() 或 &：交集。
• difference() 或 -：差集。
• symmetric_difference() 或 ^：对称差集（仅在其中一个集合存在的元素）。

a = {1, 2, 3}
b = {3, 4, 5}
a.union(b)             # {1, 2, 3, 4, 5}
a & b                  # {3}
a - b                  # {1, 2}
a ^ b                  # {1, 2, 4, 5}

判断方法

• issubset() 或 <=：子集判断。
• issuperset() 或 >=：超集判断。
• isdisjoint()：判断是否无交集。

a = {1, 2}
b = {1, 2, 3}
a.issubset(b)          # True
b.issuperset(a)        # True
a.isdisjoint({4, 5})   # True

---

集合的应用场景

1. 去重：快速去除列表中的重复项。

   lst = [1, 2, 2, 3]
   unique = list(set(lst))  # [1, 2, 3]
   

2. 成员测试：检查元素是否存在（比列表效率更高）。
3. 数学运算：处理交集、并集等逻辑问题。

集合通过哈希表实现，因此查找操作的时间复杂度为 O(1)，适合高频查询场景。