python数据类型总结

雨点打透心脏的1/2处 2024-03-22 00:58 72阅读 0赞

### 标准数据类型 ###

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) # False
    
    g = 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_tuple
    
    print(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))

#### 重复不重复 ####

1、**set（集合）**：不可存在重复的值。

#### 全部数据类型 ####

Python 内置的数据类型总结

*  Numeric - int, long，float, complex
 *  String - str
 *  Sequence - list, tuple, range
 *  Binary - bytes, bytearray, memoryview
 *  Mapping - dict
 *  Boolean - bool
 *  Set - set, frozenset
 *  None - NoneType

![在这里插入图片描述][84277249e79f49e3b73e49146beac76e.png]

[84277249e79f49e3b73e49146beac76e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/647c530e20ce4a259b3b259c7430a63c.png