数值型（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!"

以下是一些字符串的举例：

0. 空字符串：'' 或 ""
1. 单个字符的字符串：'a' 或 "b"
2. 包含特殊字符的字符串：'Hello, \nworld!' 或 "Hello, \tworld!"
3. 使用转义字符的字符串：'I\'m a programmer.' 或 "She said, \"Yes!\""
4. 使用字符串格式化的字符串：'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中常用的数据结构之一，可以容纳多个元素，并且元素的类型可以不同。列表使用方括号（[]）表示，元素之间使用逗号分隔。以下是一些列表的举例：

0. 空列表：[]
1. 包含整数的列表：[1, 2, 3, 4, 5]
2. 包含字符串的列表：['apple', 'banana', 'orange']
3. 包含不同类型元素的列表：[1, 'apple', 2.5, True]
4. 嵌套列表：[[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）与列表类似，也是一种容纳多个元素的数据结构，不同之处在于元组一旦创建就不可修改，因此也被称为不可变序列。元组使用圆括号（()）表示，元素之间使用逗号分隔。以下是一些元组的举例：

0. 空元组：()
1. 包含整数的元组：(1, 2, 3, 4, 5)
2. 包含字符串的元组：('apple', 'banana', 'orange')
3. 包含不同类型元素的元组：(1, 'apple', 2.5, True)
4. 嵌套元组：((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中常用的数据结构之一，用于存储键值对。字典使用花括号（{}）表示，每个键值对之间使用冒号（:）分隔，键值对之间使用逗号分隔。以下是一些字典的举例：

0. 空字典：{}
1. 包含字符串键和整数值的字典：{'apple': 1, 'banana': 2, 'orange': 3}
2. 包含字符串键和列表值的字典：{'fruits': ['apple', 'banana', 'orange'], 'prices': [1, 2, 3]}
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中的一种数据结构，它是一组无序且不重复的元素。集合使用花括号（{}）表示，元素之间使用逗号分隔。以下是一些集合的举例：

0. 空集合：set()
1. 包含整数的集合：{1, 2, 3, 4, 5}
2. 包含字符串的集合：{'apple', 'banana', 'orange'}
3. 包含不同类型元素的集合：{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对象只能进行查询、比较等操作，不能进行修改操作，因此它在一些需要不可变集合的场景中很有用。