python数据类型总结

标准数据类型

Python 有以下几种标准数据类型：

整数（int）：表示整数值，如 1, -5, 0 等。
浮点数（float）：表示小数值，如 3.14, -0.01, 1.0 等。
字符串（str）：表示文本数据，如 “Hello”, “Python”, “123” 等。
列表（list）：表示一个有序的元素集合，可以存储不同类型的数据，如 [1, 2, 3], [“a”, “b”, “c”], [1, “a”, 3.14] 等。
字典（dict）：表示一个无序的键值对集合，可以通过键来访问或修改对应的值，如 {“name”: “Alice”, “age”: 18}, {“a”: 1, “b”: 2, “c”: 3} 等。

每种数据类型都有自己的特点和使用场景。例如：

整数和浮点数可以用来进行数值计算，如加减乘除等。
字符串可以用来处理文本数据，如分割，拼接，替换等。
列表可以用来存储多个相关的数据，如一组学生的成绩，一组城市的名称等。
字典可以用来存储多个具有属性的数据，如一本书的标题，作者，出版年份等。

为了更好地理解每种数据类型的差异，可以通过示例代码来展示它们的用法。例如：

# 创建一个整数变量
x = 10
# 创建一个浮点数变量
y = 3.14
# 创建一个字符串变量
z = "Hello"
# 创建一个列表变量
a = [1, 2, 3]
# 创建一个字典变量
b = {"name": "Alice", "age": 18}# 打印每个变量的类型和值
print(type(x), x)
print(type(y), y)
print(type(z), z)
print(type(a), a)
print(type(b), b)# 对整数和浮点数进行加法运算
print(x + y)# 对字符串进行拼接运算
print(z + " Python")# 对列表进行索引和切片操作
print(a[0]) # 获取第一个元素
print(a[1:3]) # 获取第二个和第三个元素# 对字典进行键值访问和修改操作
print(b["name"]) # 获取"name"对应的值
b["age"] = 19 # 修改"age"对应的值
print(b)

元组与集合

除了标准数据类型，Python 还提供了一些特殊数据类型，如集合（set）和元组（tuple）³⁵。

集合（set）：表示一个无序的元素集合，可以存储不同类型的数据，但是不能有重复的元素，如 {1, 2, 3}, {“a”, “b”, “c”}, {1, “a”, 3.14} 等。
元组（tuple）：表示一个有序的元素集合，可以存储不同类型的数据，但是不能修改元素的值，如 (1, 2, 3), (“a”, “b”, “c”), (1, “a”, 3.14) 等。

每种数据类型都有自己的特点和使用场景。例如：

集合（set）可以用来进行集合运算，如并集，交集，差集等。
元组（tuple）可以用来存储不可变的数据，如一组常量，一组坐标等。

为了更好地理解每种数据类型的差异，可以通过示例代码来展示它们的用法。例如：

# 创建一个集合变量
c = {1, 2, 3}
# 创建一个元组变量
d = (1, 2, 3)# 打印每个变量的类型和值
print(type(c), c)
print(type(d), d)# 对集合进行并集运算
print(c | {4, 5})# 对元组进行索引操作
print(d[0]) # 获取第一个元素

布尔类型

布尔类型（boolean）是 Python 的内置数据类型之一，用于表示表达式的真值（truth value），即 True 或 False¹²。

布尔类型是整数类型（int）的子类型，True 和 False 在大多数情况下可以当作 0 和 1 来使用，但是在 repr() 和 str() 函数中会显示为 True 和 False³。
布尔类型可以用于比较值，检查身份和成员关系，以及控制程序的流程，如 if 语句和 while 循环。
布尔类型可以通过 bool() 函数从其他数据类型转换而来，一般来说，空值（如空字符串，空列表，None 等）会转换为 False，非空值会转换为 True。

以下是一些关于布尔类型的例子：

# 布尔类型的字面量
a = True
b = False
print(type(a), type(b)) # <class 'bool'> <class 'bool'># 布尔类型的算术运算
c = a + b # True + False 等于 1 + 0
print(c) # 1# 布尔类型的比较运算
d = a == b # True == False 返回 False
print(d) # False# 布尔类型的逻辑运算
e = a and b # True and False 返回 False
print(e) # False# 布尔类型的条件语句
if a:print("a is True")
else:print("a is False")
# a is True# 布尔类型的转换
f = bool("") # 空字符串转换为 False
print(f) # Falseg = bool([1, 2, 3]) # 非空列表转换为 True
print(g) # True

可变类型与不可变类型

在 Python 中，数据类型可以分为可变类型（mutable）和不可变类型（immutable）¹²³。

可变类型（mutable）：指的是可以在原地修改值或数据的类型，如列表（list），字典（dict），集合（set）等。
不可变类型（immutable）：指的是不可以在原地修改值或数据的类型，如整数（int），浮点数（float），字符串（str），元组（tuple）等。

可变类型和不可变类型的区别主要体现在以下方面：

可变类型的对象在修改后，其内存地址不会改变，而不可变类型的对象在修改后，会创建一个新的对象，并分配一个新的内存地址。
可变类型的对象可以作为字典的键或集合的元素，而不可变类型的对象不能，因为字典和集合要求键或元素是可哈希的，而可变类型的对象是不可哈希的。
可变类型和不可变类型对函数参数传递的方式也有影响，因为 Python 的函数参数传递是按引用传递的，所以如果参数是可变类型的对象，那么函数内部对该对象的修改会影响到函数外部，而如果参数是不可变类型的对象，那么函数内部对该对象的修改不会影响到函数外部。

总结

有序类型（可以索引）

可按照一定顺序排序的数据类型

1、列表（list ）: 多个数据存储数据：可以放任任意的数据类型
2、元组（ tuple）：多个数据存储数据：可以放任任意的数据类型不能修改和添加里面的值私密的数据
3、字符串（str ）：一个数据描述性质：表示名字

散列类型

不可以进行索引取值，主要体现为没有顺序，一盘散沙。

1、集合（set ）：多个数据，存储数据：可以放任任意的数据类型, 可变类型，无序。

2、字典（dict）：多个数据，存储数据：key里面只能放入不可变类型，最好字符串类型，value里面可以放任任意的数据类型

可变和不可变

1、可变类型（mutable）：指的是可以在原地修改值或数据的类型，如列表（list），字典（dict），集合（set）等。
2、不可变类型（immutable）：指的是不可以在原地修改值或数据的类型，如整数（int），浮点数（float），字符串（str），元组（tuple），布尔（bool）。但是元组这里有个特例：如果元组中的元素类型是可变类型如list，那么其元组中list中的值却是可以变化的，如下案例：

a_tuple  = ([1,2,3],'hello world',11,('a','b','c'),{1,2,3.14,'你好'},{"student_name_1":"张三","sutdent_name_2":"李四"})print(a_tuple)# 循环遍历一个元组，并输出每个元素的类型
for tuple_one in a_tuple:print(type(tuple_one),tuple_one)# 以下是遍历的输出结果 :# <class 'list'> [1, 2, 3]
# <class 'str'> hello world
# <class 'int'> 11
# <class 'tuple'> ('a', 'b', 'c')
# <class 'set'> {1, 2, 3.14, '你好'}
# <class 'dict'> {'student_name_1': '张三', 'sutdent_name_2': '李四'}# 下面来修改元组中的list
print(id(a_tuple))
a_tuple_list = a_tuple[0]
a_tuple_list.append("新手")
print(a_tuple)
print(id(a_tuple))
print(id(a_tuple[0]))
print(id(a_tuple_list))
b_tuple = a_tuple # 一个元组的浅拷贝，内存地址指向一个，一个改变都改变
b_tuple[0][0] = 2 # 修改了b_tuple a_tuple的值也跟着改变了。
print(id(b_tuple))
print(b_tuple)
print(a_tuple)a_tuple[0][1] = 3 # 修改了a_tuple 同时也修改了b_tupleprint(b_tuple)
print(a_tuple)# 元组的深拷贝import copy# 创建一个元组
original_tuple = (1, 2, 3, [4, 5, 6])# 使用copy模块中的deepcopy()函数进行深拷贝
new_tuple = copy.deepcopy(original_tuple)# 修改深拷贝后的元组中的列表内容
new_tuple[3][0] = 7# 打印原始元组和深拷贝后的元组
print(original_tuple) #(1, 2, 3, [4, 5, 6])
print(new_tuple) # (1, 2, 3, [7, 5, 6])print(id(original_tuple))
print(id(new_tuple))