Python数据类型[基本数据类型、容器数据类型]详细定义及其用法

数据类型分类

数据类型分类

Python中的数据类型包括以下几种：

1. 整数（int）：表示整数值，可以是正数、负数或零。

2. 浮点数（float）：表示带有小数点的数字，可以是正数、负数或零。

3. 布尔值（bool）：表示真或假，只有两个取值：True（真）和False（假）。

4. 字符串（str）：表示文本数据，使用单引号、双引号或三引号括起来。

5. 列表（list）：有序可变的集合，用方括号 [] 表示，元素之间用逗号分隔。

6. 元组（tuple）：有序不可变的集合，用圆括号 () 表示，元素之间用逗号分隔。

7. 集合（set）：无序且不重复的集合，用大括号 {} 表示，元素之间用逗号分隔。

8. 字典（dict）：无序的键值对集合，用大括号 {} 表示，每个键值对用冒号 : 分隔，键值对之间用逗号分隔。

9. 空值（NoneType）：表示没有值或空值。

下面是对这些数据类型的详细介绍以及相应的代码示例：

# 整数
integer_variable = 10

# 浮点数
float_variable = 3.14

# 布尔值
bool_variable = True

# 字符串
string_variable = "Hello, World!"

# 列表
list_variable = [1, 2, 3, 4, 5]

# 元组
tuple_variable = (1, 2, 3, 4, 5)

# 集合
set_variable = {1, 2, 3, 4, 5}

# 字典
dict_variable = {'name': 'John', 'age': 30, 'city': 'New York'}

# 空值
none_variable = None

Python 2.x 和 3.x的区别

在Python 2.x 和 3.x 中，有一些数据类型的细节有所不同：

1. print语句：

   • 在Python 2.x 中，print 是一个语句，可以像这样使用：print "Hello, World!"。
   • 在Python 3.x 中，print 是一个函数，需要使用括号：print("Hello, World!")。

2. 除法运算：

   • 在Python 2.x 中，整数除法的结果会取整，即 5 / 2 的结果是 2。
   • 在Python 3.x 中，整数除法的结果会保留小数部分，即 5 / 2 的结果是 2.5。如果想要进行取整除法，可以使用 5 // 2。

3. Unicode支持：

   • 在Python 2.x 中，字符串默认使用ASCII编码，需要使用 u 前缀表示Unicode字符串，如 u"Hello"。
   • 在Python 3.x 中，字符串默认使用Unicode编码，不需要额外指定，直接使用字符串即可。

4. xrange函数：

   • 在Python 2.x 中，xrange 函数返回一个生成器对象，用于节省内存。
   • 在Python 3.x 中，xrange 被移除了，而 range 函数返回的是一个类似于Python 2.x 中 xrange 返回的生成器对象的可迭代对象。

数据类型详解

基本数据类型（整数（int）、浮点数（float）、字符串（str）、布尔值（bool））、容器数据类型（列表（list）、元组Tuple、集合Set、字典（dict））。

1.整数（int）：

• 定义：整数是不带小数部分的数字，可以是正数、负数或零。在Python中，整数类型被称为 int，它可以表示任意大小的整数（取决于系统内存限制）。
• 用法：可以直接将整数赋值给变量，并对整数进行各种数学运算。

# 定义整数变量
my_integer = 10

# 进行加法运算
result = my_integer + 5
print(result)  # 输出：15

# 进行减法运算
result = my_integer - 3
print(result)  # 输出：7

# 进行乘法运算
result = my_integer * 2
print(result)  # 输出：20

# 进行除法运算
result = my_integer / 3
print(result)  # 输出：3.3333333333333335

# 进行取整除法运算
result = my_integer // 3
print(result)  # 输出：3

# 进行取余运算
result = my_integer % 3
print(result)  # 输出：1

# 进行幂运算
result = my_integer ** 2
print(result)  # 输出：100

• Python 2.x 和 3.x 的差异：
  • 在Python 2.x中，整数除法的行为略有不同。当操作数都是整数时，整数除法的结果将会是整数，即舍弃小数部分。例如，5 / 2 的结果在Python 2.x中为 2，而在Python 3.x中为 2.5。要获得类似Python 3.x的整数除法行为，可以使用 from __future__ import division 来导入新的除法行为。

# Python 2.x 中的整数除法
from __future__ import division

result = 5 / 2
print(result)  # 输出：2.5

2.浮点数（float）：

• 定义：浮点数是带有小数部分的数字。在Python中，浮点数类型被称为 float，它用于表示任意精度的实数数字。
• 用法：可以直接将浮点数赋值给变量，并对浮点数进行各种数学运算。

# 定义浮点数变量
my_float = 3.14

# 进行加法运算
result = my_float + 1.5
print(result)  # 输出：4.64

# 进行减法运算
result = my_float - 0.5
print(result)  # 输出：2.64

# 进行乘法运算
result = my_float * 2
print(result)  # 输出：6.28

# 进行除法运算
result = my_float / 2
print(result)  # 输出：1.57

# 进行幂运算
result = my_float ** 2
print(result)  # 输出：9.8596

# 进行取整除法运算
result = my_float // 2
print(result)  # 输出：1.0

# 进行取余运算
result = my_float % 2
print(result)  # 输出：1.14

• Python 2.x 和 3.x 的差异：
  • Python 2.x 中的除法默认是整数除法。当操作数都是整数时，整数除法的结果将会是整数，即舍弃小数部分。例如，5 / 2 的结果在Python 2.x中为 2，而在Python 3.x中为 2.5。要获得类似Python 3.x的除法行为，可以使用 from __future__ import division 来导入新的除法行为。

# Python 2.x 中的除法
from __future__ import division

result = 5 / 2
print(result)  # 输出：2.5

3. 字符串（str）：

• 定义：字符串是由字符组成的序列，用于表示文本数据。在Python中，字符串类型被称为 str，可以用单引号、双引号或三引号表示。
• 用法：可以直接将字符串赋值给变量，并对字符串进行各种操作，如索引、切片、连接、重复、替换等。

# 定义字符串变量
my_string = "Hello, World!"

# 获取字符串长度
length = len(my_string)
print("字符串长度:", length)  # 输出：字符串长度: 13

# 访问单个字符
first_char = my_string[0]
print("第一个字符:", first_char)  # 输出：第一个字符: H

# 切片操作
substring = my_string[7:12]
print("切片结果:", substring)  # 输出：切片结果: World

# 连接字符串
new_string = my_string + " How are you?"
print("连接后的字符串:", new_string)  # 输出：连接后的字符串: Hello, World! How are you?

# 字符串重复
repeated_string = my_string * 3
print("重复后的字符串:", repeated_string)  # 输出：重复后的字符串: Hello, World!Hello, World!Hello, World!

# 字符串替换
replaced_string = my_string.replace("World", "Python")
print("替换后的字符串:", replaced_string)  # 输出：替换后的字符串: Hello, Python!

# 字符串拆分
splitted_string = my_string.split(", ")
print("拆分后的字符串列表:", splitted_string)  # 输出：拆分后的字符串列表: ['Hello', 'World!']

• Python 2.x 和 3.x 的差异：
  • 在 Python 2.x 中，Python 2.x 中的字符串默认使用 ASCII 编码，而 Python 3.x 中默认使用 Unicode 编码。此外，Python 3.x 中引入了 bytes 类型来表示字节串，而 str 类型默认就是 Unicode 字符串。因此，在处理字符串时需要注意编码的问题。

# Python 2.x 中字符串默认使用 ASCII 编码
# Python 3.x 中字符串默认使用 Unicode 编码
# Python 2.x
my_string = "Hello, World!"  # 字符串默认使用 ASCII 编码
# Python 3.x
my_string = "Hello, World!"  # 字符串默认使用 Unicode 编码

4. 布尔值（bool）：

• 定义：布尔值只有两个可能的取值：布尔值表示真（True）或假（False）。在Python中，布尔值类型被称为 bool。
• 用法：可以直接将布尔值赋值给变量，也可以通过逻辑运算符（例如and、or、not）或比较运算符（例如==、!=、<、>等）来生成布尔值。

# 定义布尔值变量
is_true = True
is_false = False

# 通过逻辑运算生成布尔值
result_and = True and False  # False
result_or = True or False    # True
result_not = not True        # False

# 通过比较运算生成布尔值
result_equal = 10 == 5       # False
result_not_equal = 10 != 5   # True
result_greater = 10 > 5      # True
result_less = 10 < 5         # False
result_greater_equal = 10 >= 10  # True
result_less_equal = 10 <= 5   # False

"""
用于条件判断
"""

age = 20

if age >= 18:
    print("You are an adult.")
else:
    print("You are not an adult.")

5. 列表（list）：

• 定义：列表是由一系列按特定顺序排列的元素组成的有序集合。在Python中，列表使用方括号 [] 表示，元素之间使用逗号 , 分隔。列表是有序可变的序列，其中的元素可以是不同类型的数据。
• 用法：可以直接将一组元素放入方括号中创建列表，也可以通过索引和切片来访问列表中的元素，还可以使用列表相关的方法进行操作。

# 定义列表变量
my_list = [1, 2, 3, 'four', 5.5]

# 访问列表元素
print(my_list[0])    # 输出：1
print(my_list[3])    # 输出：'four'

# 使用负索引访问列表元素
print(my_list[-1])   # 输出：5.5，负索引表示从列表末尾开始计数

# 切片访问列表元素
print(my_list[1:3])  # 输出：[2, 3]，切片包括起始索引但不包括结束索引
print(my_list[:2])   # 输出：[1, 2]，从列表开头到索引2之前的元素
print(my_list[3:])   # 输出：['four', 5.5]，从索引3到列表末尾的元素
print(my_list[::2])  # 输出：[1, 3, 5.5]，步长为2的切片

# 修改列表元素
my_list[0] = 'one'
print(my_list)       # 输出：['one', 2, 3, 'four', 5.5]

# 添加元素到列表末尾
my_list.append(6)
print(my_list)       # 输出：['one', 2, 3, 'four', 5.5, 6]

# 插入元素到指定位置
my_list.insert(2, 'inserted')
print(my_list)       # 输出：['one', 2, 'inserted', 3, 'four', 5.5, 6]

# 删除列表中的元素
del my_list[2]
print(my_list)       # 输出：['one', 2, 3, 'four', 5.5, 6]

# 移除列表中的指定元素
my_list.remove('four')
print(my_list)       # 输出：['one', 2, 3, 5.5, 6]

# 列表扩展
my_list.extend([7, 8, 9])
print(my_list)       # 输出：['one', 2, 3, 5.5, 6, 7, 8, 9]

# 列表排序
my_list.sort()
print(my_list)       # 输出：[2, 3, 5.5, 6, 7, 8, 9, 'one']

# 列表反转
my_list.reverse()
print(my_list)       # 输出：['one', 9, 8, 7, 6, 5.5, 3, 2]

• Python 2.x 和 3.x 的差异：
  • 在 Python 2.x 中，使用 range() 函数会返回一个列表。而在Python 3.x中，range() 函数返回一个可迭代的对象，要生成列表需要使用 list() 函数将其转换为列表。

# Python 2.x 中的列表生成
my_list = range(5)
print(my_list)  # 输出：[0, 1, 2, 3, 4]

# Python 3.x 中的列表生成
my_list = list(range(5))
print(my_list)  # 输出：[0, 1, 2, 3, 4]

• 总结：
  总的来说，列表（list）是Python中常用的数据类型之一，用于存储一组元素，并支持各种常见的操作，如访问元素、修改元素、添加元素、删除元素、列表扩展、排序、反转等。

6. 元组（tuple）：

• 定义：元组是由一系列按特定顺序排列的元素组成的有序集合。在Python中，元组使用圆括号 () 表示，元素之间使用逗号 , 分隔。元组是有序不可变的序列，即一旦创建就不能修改，其中的元素可以是不同类型的数据。
• 用法：可以直接将一组元素放入圆括号中创建元组，也可以通过索引和切片来访问元组中的元素。

# 定义元组变量
my_tuple = (1, 2, 'three', 4.0)

# 访问元组元素
print(my_tuple[0])    # 输出：1
print(my_tuple[2])    # 输出：'three'

# 使用负索引访问元组元素
print(my_tuple[-1])   # 输出：4.0，负索引表示从元组末尾开始计数

# 切片访问元组元素
print(my_tuple[1:3])  # 输出：(2, 'three')，切片包括起始索引但不包括结束索引
print(my_tuple[:2])   # 输出：(1, 2)，从元组开头到索引2之前的元素
print(my_tuple[2:])   # 输出：('three', 4.0)，从索引2到元组末尾的元素
print(my_tuple[::2])  # 输出：(1, 'three')，步长为2的切片

• Python 2.x 和 3.x 的差异：在Python 2.x中，使用 range() 函数会返回一个列表。而在Python 3.x中，range() 函数返回一个可迭代的对象，要生成元组需要使用 tuple() 函数将其转换为元组。

# Python 2.x 中的元组生成
my_tuple = range(5)
print(my_tuple)  # 输出：(0, 1, 2, 3, 4)

# Python 3.x 中的元组生成
my_tuple = tuple(range(5))
print(my_tuple)  # 输出：(0, 1, 2, 3, 4)

"""
元组是不可变的，一旦创建就不能修改其中的元素。
如果试图修改元组中的元素，将会引发TypeError异常。
"""
# 尝试修改元组中的元素（将会引发TypeError异常）
my_tuple[0] = 'one'

• 总结
  元组（tuple）是Python中常用的数据类型之一，用于存储一组元素，并且与列表类似，但元组是不可变的。因此，元组适用于不希望数据被修改的情况，如表示常量集合、函数返回多个值等。

7. 集合（set）：

• 定义：Python中的集合（set）是一种无序且不重复的数据类型，用于存储唯一的元素。集合中的元素可以是不同类型的数据，但不能包含重复的元素。集合使用花括号 {} 表示，元素之间使用逗号 , 分隔。

• 用法：可以直接将一组元素放入花括号中创建集合，也可以通过集合相关的方法进行操作。

# 定义集合变量
my_set = {1, 2, 3, 'four', 3}

# 输出集合（会自动去除重复元素）
print(my_set)  # 输出：{1, 2, 3, 'four'}

# 访问集合中的元素（集合不支持索引和切片）
# 因为集合是无序的，不能通过索引或切片来访问集合中的元素

# 添加元素到集合
my_set.add(5)
print(my_set)  # 输出：{1, 2, 3, 'four', 5}

# 从集合中移除元素
my_set.remove('four')
print(my_set)  # 输出：{1, 2, 3, 5}

# 检查元素是否存在于集合中
print(3 in my_set)  # 输出：True

# 集合的交集、并集、差集等操作
set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 交集
intersection = set1 & set2
print(intersection)  # 输出：{3}

# 并集
union = set1 | set2
print(union)         # 输出：{1, 2, 3, 4, 5}

# 差集
difference = set1 - set2
print(difference)    # 输出：{1, 2}

• 注意事项：
  - 集合是无序的，因此无法通过索引或切片来访问集合中的元素。
  - 集合中的元素不能重复，如果添加重复的元素，集合会自动去重。
  - 集合是可变的，可以添加、删除元素，但集合本身是不可哈希的，因此不能作为字典的键或其他集合的元素。
  - 集合中的元素必须是不可变的类型，例如整数、浮点数、字符串、元组等，而不能是可变类型，如列表、集合、字典等。
• Python 2.x 和 3.x 的差异：
  • 在 Python 2.x 中，使用花括号 {} 创建空集合会创建一个空字典，而不是空集合。因此，在Python 2.x中要创建空集合需要使用 set() 函数。

# Python 2.x 中创建空集合
empty_set = set()
print(empty_set)  # 输出：set()

而在Python 3.x中，使用花括号 {} 创建的是空集合，而不是空字典。因此，在Python 3.x中可以直接使用 {} 创建空集合。

# Python 3.x 中创建空集合
empty_set = {}
print(empty_set)  # 输出：{}

• 总结
  集合（set）是Python中常用的数据类型之一，用于存储唯一的元素，并支持集合的常见操作，如添加元素、移除元素、判断元素是否存在、集合的交集、并集、差集等操作。

8. 字典（dict）：

• 定义：Python中的字典（dict）是一种无序的键-值对（key-value）集合，用于存储一组相关的数据。字典中的每个元素由一个键和一个对应的值组成，键必须是唯一的，但值可以重复。字典使用花括号 {} 表示，键和值之间使用冒号 : 分隔，键值对之间使用逗号 , 分隔。
• 用法：可以直接将一组键值对放入花括号中创建字典，也可以通过键来访问和修改字典中的值。

# 定义字典变量
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 访问字典中的值
print(my_dict['name'])   # 输出：'Alice'
print(my_dict['age'])    # 输出：30

# 修改字典中的值
my_dict['age'] = 35
print(my_dict['age'])    # 输出：35

# 添加新的键值对
my_dict['gender'] = 'female'
print(my_dict)           # 输出：{'name': 'Alice', 'age': 35, 'city': 'New York', 'gender': 'female'}

# 删除键值对
del my_dict['city']
print(my_dict)           # 输出：{'name': 'Alice', 'age': 35, 'gender': 'female'}

# 判断键是否存在
if 'age' in my_dict:
    print("Age is present in the dictionary.")

• Python 2.x 和 3.x 的差异：在Python 2.x中，字典的生成方式和基本用法与Python 3.x相同。但在Python 2.x中，dict.keys()、dict.values() 和 dict.items() 返回的是列表，而在Python 3.x中返回的是视图（view），这意味着在Python 3.x中，这些视图对象可以动态地反映字典的变化。

# Python 2.x 中的字典视图
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys = my_dict.keys()
print(keys)  # 输出：['a', 'b', 'c']

# 修改字典后，视图不会更新
my_dict['d'] = 4
print(keys)  # 输出：['a', 'b', 'c']

# Python 3.x 中的字典视图
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys = my_dict.keys()
print(keys)  # 输出：dict_keys(['a', 'b', 'c'])

# 修改字典后，视图会更新
my_dict['d'] = 4
print(keys)  # 输出：dict_keys(['a', 'b', 'c', 'd'])

• 总结：
  字典（dict）是Python中常用的数据类型之一，用于存储一组相关的数据，每个数据都与一个唯一的键相关联。字典的键可以是任何不可变的数据类型，例如整数、浮点数、字符串、元组等，而值可以是任何类型的数据。在Python 2.x 和 3.x 中，字典的基本用法基本相同，但在Python 3.x中，字典的视图对象是动态的，可以反映字典的变化。

数据类型区别汇总

针对基本数据类型（整数（int）、浮点数（float）、字符串（str）、布尔值（bool））、容器数据类型（列表（list）、元组Tuple、集合Set、字典（dict））绘制。

下面是针对基本数据类型（整数、浮点数、字符串、布尔值）和容器数据类型（列表、元组、集合、字典）的特点的详细阐述，以表格形式呈现：

数据类型	特点	元素数量	元素类型	下标索引	重复元素	可修改性	数据有序	常用方法	使用场景
整数	表示整数数字，可以是正数、负数或零	单个	整数	是	否	不可修改	无序	无	算术运算、计数等
浮点数	表示带有小数部分的数字	单个	浮点数	是	可能存在	不可修改	无序	无	数值计算、科学计算等
字符串	表示字符序列，可以是单引号、双引号或三引号表示	可变	字符（单个或序列）	是	可能存在	不可修改	有序	len(), split(), join(), find()	文本处理、格式化输出等
布尔值	表示真（True）或假（False）	单个	布尔值	是	只有两个值	不可修改	无序	无	条件判断、逻辑运算等
列表	有序可变序列，元素可以是不同类型的数据	可变	任意类型	是	可以存在	可修改	有序	append(), extend(), pop(), sort()	存储多个元素，支持动态操作和索引访问
元组	有序不可变序列，元素可以是不同类型的数据	不可变	任意类型	是	可以存在	不可修改	有序	count(), index()	不希望被修改的数据集合
集合	无序不重复元素的集合	可变	任意类型	否	不允许重复	可修改	无序	add(), remove(), union(), intersection()	去重、集合运算等
字典	无序键值对的集合，键必须是唯一的，值可以重复	可变	任意类型	是（键）	不允许重复	可修改	无序	keys(), values(), items(), get()	存储键值对，快速查找、关联数据等