前言

数据类型是用来存储不同类型的数据，它们是构建复杂数据结构的基础，也是我们学好一门编程语言的基础。
Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

接下来我们逐个来学习每种类型的基本使用

一、 Number（数字）

数字数据类型用于存储数值。
它是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

1.1 数字类型分类

上一节我们提过，数字类型又分为三种：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
  下面看下三者的对比：
  

# 声明一个整型变量  
a = 100  
# 输出变量的值  
print(a)
# 声明一个浮点型变量  
b = 3.14159  
# 输出变量的值  
print(b)
# 声明一个复数变量  
c = 3.14j  
# 输出变量的值  
print(c)

1.2 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

# 声明一个浮点型变量  
c = 3.14159  
# 将浮点型变量转换为整型  
d = int(c)  
# 输出变量的值  
print(d)

1.3 数字运算

Python语言支持各种数字运算，包括加法、减法、乘法、除法、求模等基本运算，还支持幂运算、指数运算、对数运算等高级运算。以下是一些数字运算的总结和代码示例：

# 两个整数相加  
a = 10 + 20  

# 两个浮点数相加  
b = 3.14 + 2.71

# 两个整数相减  
c = 20 - 10  

# 两个浮点数相减  
d = 3.14 - 2.71

# 两个整数相乘  
e = 10 * 20  

# 两个浮点数相乘  
f = 3.14 * 2.71

# 两个整数相除，结果为整数除法，即向下取整  
g = 10 // 3  
# 两个浮点数相除，结果为浮点数除法，即精确除法  
h = 3.14 / 2.71

# 两个整数求模  
i = 10 % 3  
# 两个浮点数求模，可以使用内置的 math.fmod() 函数  
import math  
j = math.fmod(3.14, 2.71)

# 使用 ** 运算符计算幂运算，例如计算 a 的 b 次方  
k = a ** b  # 等价于 pow(a, b)

# 使用 pow() 函数计算指数运算，例如计算 a 的 b 次方，c 为底数（可选）  
l = pow(a, b)  # 等价于 a ** b，如果 c 不指定，则默认 c 为 e（自然对数的底数）

下面列出一些常用的Python内置数学函数：

acos()：计算给定数字的反余弦值，以弧度为单位。
asin()：计算给定数字的反正弦值，以弧度为单位。
atan()：计算给定数字的反正切值，以弧度为单位。
radians()：将角度转换为弧度。
degrees()：将弧度转换为角度。
log10()：计算给定数字的以10为底的对数。
log()：计算给定数字的自然对数（底数为 e）。还可以指定第二个参数为底数，来计算以该底数为底的对数。
pow()：计算a的b次方，或者x的y次方（x为整数或浮点数，y为整数）。
fmod()：返回两个数相除的余数。
cmath.sqrt()：计算复数的平方根。

二、 String（字符串）

字符串用于存储文本数据，它也是不可变的，如果重新赋值也就意味着会开辟新的内存空间。

2.1 字符串的创建：

• 使用单引号或双引号括起来表示字符串。例如：‘Hello’，“World”。
• 使用三引号（单引号或双引号）可以创建多行字符串。例如：“”“Hello World”""或’‘‘Hello World’’'。
• 使用转义字符表示特殊字符，如换行符（\n），制表符（\t）等。例如：‘Hello\nWorld’或’Hello\tWorld’。

2.2 字符串的基本操作：

• 拼接：使用加号（+）将两个字符串连接在一起。例如：str1 = ‘Hello’ + ’ World’。
• 重复：使用乘法运算符（*）将字符串重复指定的次数。例如：str2 = ‘Hello’ * 3，输出结果为’HelloHelloHello’。
• 长度：使用len()函数获取字符串的长度。例如：len(‘Hello World’)返回7。
• 子串索引：使用索引和切片操作获取字符串中的子串。例如：str3 = ‘Hello World’，str3[0]返回’H’，str3[1:5]返回’ello’。
• 查找：使用find()或index()函数查找子串在字符串中的位置。如果子串不存在，则返回-1。例如：str4 = ‘Hello World’，str4.find(‘World’)返回6。

2.3 字符串常用方法：

lower()：将字符串转换为小写字母形式。
upper()：将字符串转换为大写字母形式。
title()：将字符串中的每个单词首字母大写，其余字母小写。
capitalize()：将字符串的首字母转换为大写字母，其余字母小写。
swapcase()：将字符串中的大写字母转换为小写字母，小写字母转换为大写字母。
count()：统计子串在字符串中出现的次数。
replace()：将字符串中的某个子串替换为另一个子串。
strip()：删除字符串开头和结尾的空格、制表符和换行符。
rstrip()：删除字符串结尾的空格、制表符和换行符。
lstrip()：删除字符串开头的空格、制表符和换行符。

三、 List（列表）

Python中的列表（list）是一种有序的集合，可以包含任意类型的对象，包括数字、字符串、列表等。列表是可变的，意味着可以添加、删除和修改列表中的元素。

3.1 创建列表：

• 使用方括号[]创建空列表。例如：my_list = []。
• 使用逗号分隔的元素列表创建列表。例如：my_list = [1, 2, 3]。
• 使用list()函数将其他数据类型转换为列表。例如：my_list = list(“hello”)。

3.2 列表的基本操作：

• 添加元素：使用append()方法向列表末尾添加一个元素。例如：my_list.append(4)。
• 插入元素：使用insert()方法在指定位置插入一个元素。例如：my_list.insert(1, ‘a’)。
• 删除元素：使用remove()方法删除指定元素。例如：my_list.remove(3)。
• 替换元素：使用索引和赋值操作替换指定位置的元素。例如：my_list[0] = ‘b’。

3.3 列表的遍历：

• 使用for循环遍历列表中的每个元素。例如：for item in my_list: print(item)。

3.4 列表的排序：

• 使用sort()方法对列表进行原地排序。例如：my_list.sort()。
• 使用sorted()函数返回排序后的新列表。例如：sorted_list = sorted(my_list)。

3.5 列表的切片操作：

• 使用切片语法获取列表中的子序列。例如：sub_list = my_list[1:4]。

3.6 列表的长度和查找：

• 使用len()函数获取列表的长度。例如：length = len(my_list)。
• 使用index()方法查找元素在列表中的索引位置。例如：index = my_list.index(‘a’)。

3.7 列表推导式：

• 使用列表推导式快速生成新的列表。例如：new_list = [x**2 for x in my_list]。

3.8 嵌套列表：

• 将一个列表作为元素存储在另一个列表中，形成嵌套列表。例如：nested_list = [[1, 2], [3, 4], [5, 6]]。

# 创建一个包含数字的列表  
my_list = [1, 2, 3, 4, 5]  
  
# 输出列表的长度  
print("Length of the list:", len(my_list))  
  
# 输出列表中的所有元素  
print("Elements in the list:", my_list)  
  
# 在列表末尾添加一个元素  
my_list.append(6)  
print("After appending an element:", my_list)  
  
# 在指定位置插入一个元素  
my_list.insert(2, 7)  
print("After inserting an element:", my_list)  
  
# 删除指定位置的元素  
del my_list[0]  
print("After deleting an element:", my_list)  
  
# 替换指定位置的元素  
my_list[2] = 8  
print("After replacing an element:", my_list)  
  
# 对列表进行排序  
my_list.sort()  
print("After sorting the list:", my_list)

四、 Tuple（元组）

元组（tuple）是Python中的一种基本数据结构，类似于列表，但与列表有一些重要的区别。

4.1 定义和创建元组：

• 使用圆括号创建元组，逗号分隔每个元素。例如：t = (1, 2, 3)。
• 使用tuple()函数将可迭代对象转换为元组。例如：t = tuple([1, 2, 3])。

4.2 元组的基本操作：

• 访问元组中的元素：使用索引，例如t[0]获取第一个元素。
• 修改元组中的元素：元组是不可变的，不能直接修改元素。但可以通过重新赋值来“修改”元组。
• 删除元组中的元素：元组是不可变的，不能直接删除元素。但可以使用del语句删除整个元组。

4.3 元组的特性：

元组是不可变的，一旦创建就不能修改其内容。这使得元组在表示一些不应该被改变的信息时非常有用。
元组可以包含其他元组，形成嵌套元组。

4.5 元组与列表的区别：

• 元组是不可变的，而列表是可变的。
• 元组通常用于表示一组固定不变的值，而列表用于表示一组可变的数据。

4.6 元组的常用场景：

• 作为字典的键，因为元组的不可变性使其成为安全的键类型。
• 作为集合的元素，因为集合只关心元素的唯一性而不关心其顺序。

示例：

# 定义一个元组  
t = (1, 2, 3)  
print(t[0])  # 输出: 1  
  
# 尝试修改元组中的元素  
# t[0] = 10  # 这会引发错误，因为元组是不可变的  
  
# 重新赋值以“修改”元组的内容  
t = (10, 2, 3)  # 现在t是一个新的元组，不再是原来的(1, 2, 3)  
print(t[0])  # 输出: 10

注意事项：尽管元组是不可变的，但它的元素可以是可变的（如列表或字典）。这意味着如果你在一个元组的元素上做出更改，原始元组不会受到影响，但该元素的内部结构可能会改变。

五、 Set（集合）

Set（集合）是 Python 中的一个无序且不重复的元素序列。

5.1 创建集合：

• 使用大括号 {} 创建空集合。例如：s = {}。
• 使用 set() 函数将可迭代对象转换为集合。例如：s = set([1, 2, 3])。

5.2 集合的添加和删除：

• 使用 add() 方法向集合中添加一个元素。例如：s.add(4)。
• 使用 remove() 方法从集合中删除一个元素。例如：s.remove(3)。

5.3 集合的交集、并集和差集：

• 使用 & 运算符计算两个集合的交集。例如：s1 & s2。
• 使用 | 运算符计算两个集合的并集。例如：s1 | s2。
• 使用 - 运算符计算一个集合相对于另一个集合的差集。例如：s1 - s2。

5.4 集合的对称差集：

• 使用 ^ 运算符计算两个集合的对称差集，即存在于 s1 或 s2 中但不同时存在的元素。例如：s1 ^ s2。

5.5 检查集合中的元素：

• 使用 in 关键字检查一个元素是否存在于集合中。例如：4 in s。

5.6 集合的遍历：

• 使用 for 循环遍历集合中的每个元素。例如：for item in s: print(item)。

5.7 集合的运算：

• 结合 set() 函数和运算符可以对集合进行各种复杂的运算，如合并、筛选等。

示例：

# 创建一个集合  
s = {1, 2, 3}  
print(s)  # 输出: {1, 2, 3}  
  
# 向集合中添加元素  
s.add(4)  
print(s)  # 输出: {1, 2, 3, 4}  
  
# 从集合中删除元素  
s.remove(2)  
print(s)  # 输出: {1, 3, 4}  
  
# 计算交集、并集和差集  
s1 = {1, 2, 3}  
s2 = {2, 3, 4}  
print(s1 & s2)  # 输出: {2, 3}，交集  
print(s1 | s2)  # 输出: {1, 2, 3, 4}，并集  
print(s1 - s2)  # 输出: {1}，差集（s1 中有而 s2 中没有的元素）

六、 Dictionary（字典）

Python中的字典（dictionary）是一种可变的数据类型，用于存储键值对。字典中的键必须是唯一的，而值可以是任何数据类型：数字、字符串、列表、字典等。

6.1 字典的基本操作：

• 创建字典：使用大括号 {} 或者 dict() 函数来创建字典。

dict1 = {"key1": "value1", "key2": "value2"}  
dict2 = dict(key1="value1", key2="value2")

• 从字典中获取值：使用键来获取对应的值。

• 向字典中添加或修改键值对：直接使用键值对赋值。

• 从字典中删除键值对：使用 del 语句或 pop() 方法。

• 检查字典中是否存在某个键：使用 in 关键字。

# 创建一个字典  
my_dict = {"name": "John", "age": 30, "city": "New York"}  
  
# 从字典中获取值  
name = my_dict["name"]  # 返回 "John"  
age = my_dict["age"]  # 返回 30  
city = my_dict["city"]  # 返回 "New York"  
  
# 向字典中添加或修改键值对  
my_dict["job"] = "Engineer"  
  
# 从字典中删除键值对  
del my_dict["age"]  
  
# 检查字典中是否存在某个键  
exists = "city" in my_dict  # 返回 True

6.2 字典的常用方法：

keys(): 返回字典中所有的键，可以传入一个可选的参数来返回指定类型的键。
values(): 返回字典中所有的值。
items(): 返回字典中所有的键值对，以元组的形式表示。
get(): 返回指定键的值，如果键不存在则返回默认值（可选参数）。
clear(): 清空字典中的所有键值对。
update(): 合并两个字典，如果键冲突则后一个值会覆盖前一个值。
copy(): 返回字典的一个浅拷贝。

注意事项：由于字典是可变的，因此在作为函数参数时默认是按值传递，如果要按引用传递需要使用可变对象作为参数。