数值型（Numeric）：整型（int）、浮点型（float）、复数型（complex）
数值型（Numeric）是Python中的一种基本数据类型，包括整型、浮点型和复数型。下面是一些数值型数据的举例：
- 整型（int）：-1, 0, 1, 100, 9999
- 浮点型（float）：3.14, 2.0, 1.5, -0.5
- 复数型（complex）：3+4j, -1+2j, 0+1j
在Python中，整数和浮点数可以直接进行算术运算，而复数也支持基本的算术运算。例如：
x = 3
y = 2.0
z = 1+2j
print(x + y) # 5.0
print(x * y) # 6.0
print(z * y) # (2+4j)
注意，在Python中，整数除法（/）的结果可能是浮点数，如果想要得到整数结果，可以使用整除运算符（//）。例如：
a = 5
b = 2
print(a / b) # 2.5
print(a // b) # 2
字符串（String）：用单引号或双引号括起来的一串字符
字符串（String）是Python中的一种基本数据类型，表示一串字符。字符串可以用单引号（'）或双引号（"）括起来，如下所示：
s1 = 'Hello, world!'
s2 = "Python is great!"
以下是一些字符串的举例：
- 空字符串：'' 或 ""
- 单个字符的字符串：'a' 或 "b"
- 包含特殊字符的字符串：'Hello, \nworld!' 或 "Hello, \tworld!"
- 使用转义字符的字符串：'I\'m a programmer.' 或 "She said, \"Yes!\""
- 使用字符串格式化的字符串：'My name is %s.' % 'Alice' 或 "I have %d apples." % 3
在Python中，字符串是不可变的，也就是说，不能直接修改字符串中的某个字符。但是，可以使用字符串的方法来对字符串进行操作。例如，可以使用upper()方法将字符串中的所有字符转换为大写字母：
s = 'Hello, world!'
s_upper = s.upper()
print(s_upper) # 'HELLO, WORLD!'
还可以使用split()方法将字符串按照某个分隔符分割成一个列表：
s = 'apple,banana,orange'
fruits = s.split(',')
print(fruits) # ['apple', 'banana', 'orange']
布尔型（Boolean）：True或False
布尔型（Boolean）是Python中的一种基本数据类型，只有两个取值：True和False。下面是一些布尔型的举例：
x = True
y = False
布尔型通常用于控制程序的流程，比如if语句中的条件判断。例如：
age = 18
if age >= 18:
print('You are an adult.')
else:
print('You are not an adult.')
在上面的例子中，如果age大于等于18，就会输出"You are an adult."，否则输出"You are not an adult."。这里的age >= 18就是一个布尔型的表达式，它的值为True或False。
在Python中，还可以使用布尔型的运算符进行逻辑运算，包括and、or和not。例如：
x = True
y = False
print(x and y) # False
print(x or y) # True
print(not x) # False
列表（List）：有序、可变、元素可以是任意数据类型的集合
列表（List）是Python中常用的数据结构之一，可以容纳多个元素，并且元素的类型可以不同。列表使用方括号（[]）表示，元素之间使用逗号分隔。以下是一些列表的举例：
- 空列表：[]
- 包含整数的列表：[1, 2, 3, 4, 5]
- 包含字符串的列表：['apple', 'banana', 'orange']
- 包含不同类型元素的列表：[1, 'apple', 2.5, True]
- 嵌套列表：[[1, 2], [3, 4], [5, 6]]
可以使用索引（从0开始）访问列表中的元素，也可以使用切片访问列表的子集。例如：
fruits = ['apple', 'banana', 'orange', 'pear']
print(fruits[0]) # 'apple'
print(fruits[1:3]) # ['banana', 'orange']
print(fruits[-1]) # 'pear'
print(fruits[:2] + ['kiwi']) # ['apple', 'banana', 'kiwi']
可以使用各种方法对列表进行操作，例如添加元素、删除元素、排序等。例如：
numbers = [1, 2, 3]
numbers.append(4)
print(numbers) # [1, 2, 3, 4]
numbers.remove(2)
print(numbers) # [1, 3, 4]
numbers.sort()
print(numbers) # [1, 3, 4]
元组（Tuple）：有序、不可变、元素可以是任意数据类型的集合
元组（Tuple）与列表类似，也是一种容纳多个元素的数据结构，不同之处在于元组一旦创建就不可修改，因此也被称为不可变序列。元组使用圆括号（()）表示，元素之间使用逗号分隔。以下是一些元组的举例：
- 空元组：()
- 包含整数的元组：(1, 2, 3, 4, 5)
- 包含字符串的元组：('apple', 'banana', 'orange')
- 包含不同类型元素的元组：(1, 'apple', 2.5, True)
- 嵌套元组：((1, 2), (3, 4), (5, 6))
与列表类似，可以使用索引访问元组中的元素，也可以使用切片访问元组的子集。例如：
fruits = ('apple', 'banana', 'orange', 'pear')
print(fruits[0]) # 'apple'
print(fruits[1:3]) # ('banana', 'orange')
print(fruits[-1]) # 'pear'
可以使用len()函数获取元组的长度，也可以使用in和not in运算符检查元素是否在元组中。例如：
fruits = ('apple', 'banana', 'orange')
print(len(fruits)) # 3
print('apple' in fruits) # True
print('kiwi' not in fruits) # True
元组不支持修改元素，但是可以通过合并两个元组来创建一个新的元组。例如：
fruits1 = ('apple', 'banana', 'orange')
fruits2 = ('pear',)
fruits = fruits1 + fruits2
print(fruits) # ('apple', 'banana', 'orange', 'pear')
字典（Dictionary）：无序、可变、键值对的集合
字典（Dictionary）是Python中常用的数据结构之一，用于存储键值对。字典使用花括号（{}）表示，每个键值对之间使用冒号（:）分隔，键值对之间使用逗号分隔。以下是一些字典的举例：
字典（Dictionary）是Python中常用的数据结构之一，用于存储键值对。字典使用花括号（{}）表示，每个键值对之间使用冒号（:）分隔，键值对之间使用逗号分隔。以下是一些字典的举例：
- 空字典：{}
- 包含字符串键和整数值的字典：{'apple': 1, 'banana': 2, 'orange': 3}
- 包含字符串键和列表值的字典：{'fruits': ['apple', 'banana', 'orange'], 'prices': [1, 2, 3]}
- 嵌套字典：{'fruits': {'apple': 1, 'banana': 2}, 'prices': {'apple': 2.5, 'banana': 3.5}}
可以使用键访问字典中的值，也可以使用keys()方法获取所有键，使用values()方法获取所有值，使用items()方法获取所有键值对。例如：
prices = {'apple': 2.5, 'banana': 3.5, 'orange': 4.0}
print(prices['apple']) # 2.5
print(prices.keys()) # dict_keys(['apple', 'banana', 'orange'])
print(prices.values()) # dict_values([2.5, 3.5, 4.0])
print(prices.items()) # dict_items([('apple', 2.5), ('banana', 3.5), ('orange', 4.0)])
可以使用in和not in运算符检查键是否存在于字典中。例如：
prices = {'apple': 2.5, 'banana': 3.5, 'orange': 4.0}
print('apple' in prices) # True
print('kiwi' not in prices) # True
可以使用del语句删除字典中的键值对，使用update()方法更新字典中的键值对。例如：
prices = {'apple': 2.5, 'banana': 3.5, 'orange': 4.0}
del prices['apple']
print(prices) # {'banana': 3.5, 'orange': 4.0}
prices.update({'banana': 4.0, 'kiwi': 5.0})
print(prices) # {'banana': 4.0, 'orange': 4.0, 'kiwi': 5.0}
集合（Set）：无序、不重复、可变的元素集合
集合（Set）是Python中的一种数据结构，它是一组无序且不重复的元素。集合使用花括号（{}）表示，元素之间使用逗号分隔。以下是一些集合的举例：
- 空集合：set()
- 包含整数的集合：{1, 2, 3, 4, 5}
- 包含字符串的集合：{'apple', 'banana', 'orange'}
- 包含不同类型元素的集合：{1, 'apple', 2.5, True}
可以使用in和not in运算符检查元素是否存在于集合中，可以使用len()函数获取集合的大小。例如：
fruits = {'apple', 'banana', 'orange'}
print('apple' in fruits) # True
print('kiwi' not in fruits) # True
print(len(fruits)) # 3
集合支持一些常见的集合运算，如并集、交集、差集等。例如：
fruits1 = {'apple', 'banana', 'orange'}
fruits2 = {'banana', 'kiwi', 'pear'}
print(fruits1 | fruits2) # {'apple', 'banana', 'kiwi', 'orange', 'pear'}
print(fruits1 & fruits2) # {'banana'}
print(fruits1 - fruits2) # {'apple', 'orange'}
集合也支持添加元素、删除元素和清空集合等操作，例如：
fruits = {'apple', 'banana', 'orange'}
fruits.add('kiwi')
print(fruits) # {'apple', 'banana', 'kiwi', 'orange'}
fruits.remove('banana')
print(fruits) # {'apple', 'kiwi', 'orange'}
fruits.clear()
print(fruits) # set()
除了以上数据类型，Python还有许多其他的数据类型和数据结构，如bytes、bytearray、range、frozenset等。
bytes
bytes是Python中的一种数据类型，它表示一组字节（byte）序列，常用于表示二进制数据或进行网络通信。bytes对象是不可变的，使用bytes()函数或前缀b可以创建一个bytes对象。以下是一些bytes对象的举例：
# 使用bytes()函数创建bytes对象
b1 = bytes([0x41, 0x42, 0x43]) # b'ABC'
b2 = bytes('hello', encoding='utf-8') # b'hello'
# 使用b前缀创建bytes对象
b3 = b'\x01\x02\x03\x04' # b'\x01\x02\x03\x04'
bytes对象可以通过下标索引访问元素，每个元素是一个0~255之间的整数。可以使用len()函数获取bytes对象的长度。例如：
b = b'\x41\x42\x43'
print(b[0]) # 65
print(b[1]) # 66
print(b[2]) # 67
print(len(b)) # 3
bytes对象支持一些常见的操作，如拼接、重复、比较等。例如：
b1 = b'\x41\x42'
b2 = b'\x43\x44'
print(b1 + b2) # b'ABCD'
print(b1 * 3) # b'ABABAB'
print(b1 == b2) # False
print(b1 < b2) # True
bytes对象还支持一些方法，如decode()方法将字节序列解码为字符串，hex()方法将字节序列转换为十六进制字符串等。例如：
b = b'\xe4\xb8\xad\xe6\x96\x87'
s = b.decode('utf-8')
print(s) # 中文
h = b.hex()
print(h) # e4b8ade69687
bytearray
bytearray是Python中的一种数据类型，它是可变的字节数组，即可以修改其中的元素。bytearray对象可以通过bytearray()函数创建，也可以将一个bytes对象转换为bytearray对象。以下是一些bytearray对象的举例：
# 使用bytearray()函数创建bytearray对象
ba1 = bytearray([0x41, 0x42, 0x43]) # bytearray(b'ABC')
ba2 = bytearray(b'hello') # bytearray(b'hello')
# 将bytes对象转换为bytearray对象
b = b'\x01\x02\x03\x04'
ba3 = bytearray(b)
bytearray对象的元素与bytes对象相同，每个元素是一个0~255之间的整数。bytearray对象可以通过下标索引访问元素，并可以修改其中的元素。可以使用len()函数获取bytearray对象的长度。例如：
ba = bytearray(b'\x41\x42\x43')
print(ba[1]) # 66
ba[1] = 0x45
print(ba) # bytearray(b'AEC')
print(len(ba)) # 3
bytearray对象支持一些常见的操作，如拼接、重复、比较等。例如：
ba1 = bytearray(b'\x41\x42')
ba2 = bytearray(b'\x43\x44')
print(ba1 + ba2) # bytearray(b'ABCD')
print(ba1 * 3) # bytearray(b'ABABAB')
print(ba1 == ba2) # False
print(ba1 < ba2) # True
bytearray对象还支持一些方法，如decode()方法将字节数组解码为字符串，append()方法在末尾添加一个元素，pop()方法删除并返回最后一个元素等。例如：
ba = bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
s = ba.decode('utf-8')
print(s) # 中文
ba.append(0x61)
print(ba) # bytearray(b'\xe4\xb8\xad\xe6\x96\x87a')
b = ba.pop()
print(b) # 97
range
range是Python中的一种数据类型，它表示一系列连续的整数。range对象是不可变的，使用range()函数可以创建一个range对象。range()函数的语法如下：
range(stop)
range(start, stop[, step])
其中stop为终止值（不包含），start为起始值（包含，默认为0），step为步长（默认为1）。例如：
r1 = range(5) # range(0, 5)
r2 = range(1, 5) # range(1, 5)
r3 = range(1, 5, 2) # range(1, 5, 2)
range对象可以用于迭代，可以通过len()函数获取range对象的长度，也可以通过下标索引访问元素。例如：
r = range(1, 5)
for i in r:
print(i, end=' ') # 1 2 3 4
print(len(r)) # 4
print(r[1]) # 2
range对象支持一些常见的操作，如比较等。例如：
r1 = range(1, 5)
r2 = range(2, 6)
print(r1 == r2) # False
print(r1 != r2) # True
print(r1 < r2) # True
range对象还支持一些方法，如index()方法返回指定元素在range对象中的索引，count()方法返回指定元素在range对象中出现的次数等。例如：
r = range(1, 10, 2)
print(r.index(5)) # 2
print(r.count(3)) # 0
print(r.count(5)) # 1
frozenset
frozenset是Python中的一种数据类型，它是不可变的集合，即一旦创建，就不能再添加、删除或修改元素。frozenset对象可以通过frozenset()函数创建，也可以将一个可迭代对象转换为frozenset对象。以下是一些frozenset对象的举例：
# 使用frozenset()函数创建frozenset对象
fs1 = frozenset([1, 2, 3]) # frozenset({1, 2, 3})
fs2 = frozenset('hello') # frozenset({'e', 'l', 'h', 'o'})
# 将可迭代对象转换为frozenset对象
s = set([1, 2, 3])
fs3 = frozenset(s)
frozenset对象支持一些常见的集合操作，如交集、并集、差集、对称差集等，例如：
fs1 = frozenset([1, 2, 3])
fs2 = frozenset([2, 3, 4])
print(fs1 & fs2) # frozenset({2, 3})
print(fs1 | fs2) # frozenset({1, 2, 3, 4})
print(fs1 - fs2) # frozenset({1})
print(fs1 ^ fs2) # frozenset({1, 4})
frozenset对象还支持一些常见的集合方法，如union()方法返回当前集合与指定集合的并集，intersection()方法返回当前集合与指定集合的交集，difference()方法返回当前集合与指定集合的差集，symmetric_difference()方法返回当前集合与指定集合的对称差集等。例如：
fs1 = frozenset([1, 2, 3])
fs2 = frozenset([2, 3, 4])
print(fs1.union(fs2)) # frozenset({1, 2, 3, 4})
print(fs1.intersection(fs2)) # frozenset({2, 3})
print(fs1.difference(fs2)) # frozenset({1})
print(fs1.symmetric_difference(fs2)) # frozenset({1, 4})
由于frozenset对象是不可变的，因此它不能被修改，也不能添加、删除元素。例如：
fs = frozenset([1, 2, 3])
fs.add(4) # AttributeError: 'frozenset' object has no attribute 'add'
fs.remove(2) # AttributeError: 'frozenset' object has no attribute 'remove'
frozenset对象只能进行查询、比较等操作，不能进行修改操作，因此它在一些需要不可变集合的场景中很有用。