1. 前言
Python是一种非常流行的编程语言，因为它易于学习、易于阅读，并且拥有广泛的应用领域。Python支持许多数据类型，包括数字、字符串、列表、元组、集合和字典。在这篇文章中，我们将重温Python的基本数据类型，并深入探讨它们的特性。
2. 数字类型
2.1 整数类型
整数是Python中最基本的数据类型之一，它可以是正数、负数或零。Python 3.x的整数类型是int。它可以表示任何大小的整数，因为它会自动转换为长整型（long），这使得Python的整数类型是非常强大的。
以下是Python中的整数类型的示例：
a = 42
b = -13
c = 0
print(type(a)) # <class 'int'>
print(type(b)) # <class 'int'>
print(type(c)) # <class 'int'>
2.2 浮点数类型
浮点数是一种用于表示小数的数字类型，它在Python中被称为float。它可以表示非常大和非常小的数字，并且可以进行基本算术运算。
以下是Python中的浮点数类型的示例：
a = 3.14
b = -0.123
c = 2.0
print(type(a)) # <class 'float'>
print(type(b)) # <class 'float'>
print(type(c)) # <class 'float'>
注意：在Python中进行浮点数运算时要小心。由于计算机的限制，在进行浮点数运算时可能会发生精度丢失的问题。例如：
a = 0.1 + 0.2
print(a) # 0.30000000000000004
要避免这种情况，可以使用decimal模块，它可以进行精确的十进制运算。
2.3 复数类型
复数是一种用于表示实部和虚部的数学对象，它在Python中被称为complex。它可以使用j或J后缀来表示虚部，例如：
a = 2 + 3j
b = 5j
c = -4.2j
print(type(a)) # <class 'complex'>
print(type(b)) # <class 'complex'>
print(type(c)) # <class 'complex'>
3. 字符串类型
3.1 定义字符串
字符串是Python中最常用的数据类型之一，它用于表示文本和字符序列。在Python中，字符串可以使用单引号或双引号来定义。例如：
a = 'Hello, World!'
b = "Python is great!"
print(a) # Hello, World!
print(b) # Python is great!
如果字符串包含单引号或双引号，可以使用双引号或单引号（与定义字符串时不同的那个）来定义字符串，例如：
a = "I'm a programmer."
b = 'She said, "Hello, World!"'
print(a) # I'm a programmer.
print(b) # She said, "Hello, World!"
还可以使用triple quotes定义多行字符串：
a = '''This is a
multiline string.'''
print(a) # This is a
# multiline string.
3.2 字符串索引和切片
字符串是一个字符序列，因此可以对它进行索引和切片操作。
字符串的索引从0开始，表示第一个字符。例如：
s = 'Hello, World!'
print(s[0]) # H
print(s[1]) # e
print(s[2]) # l
print(s[3]) # l
print(s[4]) # o
字符串的切片操作可以返回一个子字符串。它的语法如下：
s[start:stop:step]其中，start表示起始位置（默认为0），stop表示结束位置（默认为字符串长度），step表示步长（默认为1）。例如：
s = 'Hello, World!'
print(s[0:5]) # Hello
print(s[7:]) # World!
print(s[-6:]) # World!
print(s[::2]) # Hlo ol!
print(s[::-1]) # !dlroW ,olleH
3.3 字符串方法
Python中的字符串是不可变的，这意味着一旦定义后就不能修改。但是，Python提供了许多字符串方法，可以对字符串进行操作并返回一个新的字符串。
以下是一些常用的字符串方法：
len()：返回字符串的长度。
lower()：返回字符串的小写版本。
upper()：返回字符串的大写版本。
strip()：返回去除字符串两端空格的版本。
replace(old, new)：返回将字符串中所有旧字符串替换为新字符串后的版本。
split(separator)：返回将字符串分割成列表的版本，分割符为separator。
例如：
s = ' Hello, World! '
print(len(s)) # 15
print(s.lower()) # hello, world!
print(s.upper()) # HELLO, WORLD!
print(s.strip()) # Hello, World!
print(s.replace('l', 'L', 2)) # HeLLo, World!
print(s.split(',')) # [' Hello', ' World! ']
4. 列表类型
4.1 定义列表
列表是Python中最常用的数据结构之一，它表示一个可变的有序序列。列表可以包含任何类型的数据，甚至可以包含其他列表。在Python中，列表可以写成用方括号括起来的逗号分隔的项目的列表。
a = [1, 2, 3, 4]
b = ['apple', 'banana', 'orange']
c = [1, 'apple', True, 2.5]
print(a) # [1, 2, 3, 4]
print(b) # ['apple', 'banana', 'orange']
print(c) # [1, 'apple', True, 2.5]
列表可以使用len()函数获取其长度，使用索引和切片操作来访问其元素。
4.2 列表方法
列表是可变的对象，因此Python提供了许多用于添加、移除和修改列表元素的方法。
以下是一些常用的列表方法：
append(item)：将item添加到列表的末尾。
pop(index)：从列表中删除并返回index位置的元素，如果没有指定索引，则默认弹出最后一个元素。
insert(index, item)：在index位置插入item。
remove(item)：从列表中删除item。
sort()：将列表按升序排序。
reverse()：反转列表。
例如：
a = [1, 2, 3, 4]
b = ['apple', 'banana', 'orange']
c = [1, 'apple', True, 2.5]
a.append(5)
b.pop()
c.insert(0, 'hello')
c.remove(True)
a.sort()
print(a) # [1, 2, 3, 4, 5]
print(b) # ['apple', 'banana']
print(c) # ['hello', 1, 'apple', 2.5]
5. 元组类型
5.1 定义元组
元组是Python中的另一种序列类型。与列表不同，元组是不可变的，这意味着一旦定义后就不能修改。元组也可以包含任何类型的数据。
a = (1, 2, 3, 4)
b = ('apple', 'banana', 'orange')
c = (1, 'apple', True, 2.5)
print(a) # (1, 2, 3, 4)
print(b) # ('apple', 'banana', 'orange')
print(c) # (1, 'apple', True, 2.5)
元组可以使用len()函数获取其长度，使用索引和切片操作来访问其元素。但是，元组不能进行修改。
6. 集合类型
6.1 定义集合
集合是一组无序且不重复的元素，它是Python中的另一种内置数据类型。集合通常用于去重和测试成员资格。
a = {1, 2, 3, 4}
b = {'apple', 'banana', 'orange'}
c = set([1, 'apple', True, 2.5])
print(a) # {1, 2, 3, 4}
print(b) # {'banana', 'orange', 'apple'}
print(c) # {1, 'apple', 2.5, True}
注意，元素是无序的，并且不允许重复。集合的元素必须是可哈希的，因此列表是不允许作为集合的元素。
6.2 集合运算
集合可以进行常见的数学运算，如并集、交集和差集。
并集：将两个集合合并，返回一个包含两个集合中所有不重复元素的新集合。可以使用union()方法或|运算符。
交集：返回两个集合中共同存在的元素的新集合。可以使用intersection()方法或&运算符。
差集：返回存在于第一个集合中但不存在于第二个集合中的元素的新集合。可以使用difference()方法或-运算符。
对称差集：返回存在于两个集合中但不重复的元素的新集合。可以使用symmetric_difference()方法或^运算符。
例如：
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a.union(b)) # {1, 2, 3, 4, 5, 6}
print(a.intersection(b)) # {3, 4}
print(a.difference(b)) # {1, 2}
print(a.symmetric_difference(b)) # {1, 2, 5, 6}
7. 字典类型
7.1 定义字典
字典是Python中另一种重要的数据类型，它用于表示键值对。在Python中，字典是由一系列逗号分隔的键值对组成的，每个键值对由冒号分隔。字典用花括号括起来。例如：
a = {'name': 'John', 'age': 30, 'city': 'New York'}
b = {1: 'apple', 2: 'banana', 3: 'orange'}
c = {'list': [1, 2, 3], 'tuple': (4, 5, 6)}
print(a) # {'name': 'John', 'age': 30, 'city': 'New York'}
print(b) # {1: 'apple', 2: 'banana', 3: 'orange'}
print(c) # {'list': [1, 2, 3], 'tuple': (4, 5, 6)}
字典中的键必须是不可变的，因此可以使用数字、字符串、元组等作为键，但不能使用列表作为键。
7.2 字典方法
字典是可变的对象，因此Python提供了许多用于添加、移除和修改字典的方法。
以下是一些常用的字典方法：
keys()：返回一个包含字典所有键的列表。
values()：返回一个包含字典所有值的列表。
items()：返回包含字典所有键值对的列表。
get(key, default)：返回指定键的值，如果键不存在则返回默认值。
update(other_dict)：用其它字典中的键值对更新当前字典。
pop(key, default)：从字典中删除指定键，并返回其值，如果键不存在则返回默认值。
例如：
a = {'name': 'John', 'age': 30, 'city': 'New York'}
print(a.keys()) # dict_keys(['name', 'age', 'city'])
print(a.values()) # dict_values(['John', 30, 'New York'])
print(a.items()) # dict_items([('name', 'John'), ('age', 30), ('city', 'New York')])
print(a.get('name')) # John