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列表的定义

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

集合的应用场景

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

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

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

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

Python的基础数据类型

数值类型

基本算术运算

数值类型转换

数学函数

随机数生成

数值比较与逻辑运算

字符和字符串

字符串的基本定义

字符串的特性

多行字符串

原始字符串（Raw String）

字符串的常见操作

字符串格式化

字符串的基本定义

字符串的特性

多行字符串

原始字符串（Raw String）

字符串的常见操作

元组

元组的定义

元组的特性

元组的常见操作

元组与列表的区别

元组的特性

元组的常见操作

元组与列表的区别

列表

Python列表的定义

Python列表的特点

列表的常用操作

列表查找

列表排序

列表逆序

数量统计

列表的方法

列表的遍历

列表与元组的区别

列表和数组

字典

字典的创建

字典的访问

字典的修改

字典的删除

字典的遍历

字典的常用方法

字典的嵌套

字典推导式

集合

集合的定义

集合的操作方法

添加元素

删除元素

集合的运算

基本运算

判断方法

集合的应用场景

相关文章