目录
一、Int(整型)
Python中使用的是int类型来表示整数。int类型用于存储整数值，可以是正数、负数或零。
# 定义一个int类型的变量
x = 10
# int类型可以是负数
y = -5
# int类型也可以非常大
z = 123456789012345678901234567890
# int类型支持基本的算术运算
sum = x + y
a = x - y
b = x * y
c = x // y # 整除
d = x % y # 求余
print("求和:", sum)
print("求差:", a)
print("求积:", b)
print("求整除:", c)
print("求余:", d)二、Float(浮点型)
在Python中，float 类型用于表示浮点数，即带有小数部分的数字。浮点数可以是正数或负数，用于表示小数、分数、科学记数法等。
# 定义一个float类型的变量
a = 3.14
# float类型也可以是负数
b = -2.718
# float类型可以非常大或非常小，使用科学记数法
c = 1.23e30 # 等同于 12300000000000000000000000000000.0
d = 4.56e-10 # 等同于 0.000000000456
# float类型支持基本的算术运算
sum = a + b
difference = a - b
product = a * b
quotient = a / b # 注意：在Python 3中，/ 表示真除法，结果总是float类型
print("Sum:", sum)
print("Difference:", difference)
print("Product:", product)
print("Quotient:", quotient)
三、Bool(布尔类型)
Python中的布尔类型（bool）是一种基本的数据类型，用于表示逻辑上的真（True）和假（False）两个值。布尔类型只有两个值，分别是True和False。
布尔值的作用：
- 条件判断：布尔类型通常用于表示条件是否成立。在
if语句中，可以根据条件表达式的布尔值（True或False）来决定是否执行特定的代码块。 - 循环控制：在
while循环中，可以根据条件表达式的布尔值来决定是否继续执行循环体内的代码。 - 逻辑运算：Python支持多种布尔运算，包括逻辑与（
and）、逻辑或（or）、逻辑非（not）等，这些运算符可以用于组合多个条件，形成更复杂的判断逻辑。
# 赋值操作
x = True
y = False
# 比较操作
a = 5
b = 10
print(a < b) # True
print(a > b) # False
# 逻辑运算
print(x and y) # False
print(x or y) # True
print(not x) # False
# 类型转换
print(int(x)) # 1
print(int(y)) # 0四、Str(字符串)
Python 中的字符串（String）是不可变的，用于存储数据。字符串可以包含字母、数字、符号，甚至可以是空字符串。在 Python 中，字符串有两种主要的表示方式：单引号（'）和双引号（"），它们之间可以互换使用，但在处理包含引号本身的字符串时，需要使用不同类型的引号来避免语法错误。
# 使用单引号
s1 = 'Hello, world!'
# 使用双引号
s2 = "Hello, world!"
# 使用三引号（单引号或双引号）可以创建多行字符串
s3 = '''这是一个
多行字符串'''
s4 = """这也是一个
多行字符串"""字符串中的每个字符都可以通过索引（或下标）来访问，索引从 0 开始。此外，还可以使用切片来访问字符串的一部分。
s = "Hello, world!"
print(s[0]) # 输出: H
print(s[7:12]) # 输出: world
print(s[:5]) # 输出: Hello
print(s[7:]) # 输出: world!字符串常用操作：
（1）拼接：
使用 + 运算符可以拼接两个或多个字符串
s1 = "Hello, "
s2 = "world!"
s3 = s1 + s2
print(s3) # 输出: Hello, world!（2）格式化：
使用 format() 方法、f-string（Python 3.6+）或 % 操作符来格式化字符串。
name = "Alice"
age = 30
print(f"{name} is {age} years old.") # f-string
print("{} is {} years old.".format(name, age)) # format() 方法
print("%s is %d years old." % (name, age)) # % 操作符（3）查找和替换：
使用 find()、index()、replace() 等方法。
s = "Hello, world!"
print(s.find("world")) # 输出: 7
print(s.replace("world", "Python")) # 输出: Hello, Python!（4）分割和连接：
使用 split() 方法分割字符串，使用 join() 方法连接字符串列表.
s = "apple,banana,cherry"
print(s.split(",")) # 输出: ['apple', 'banana', 'cherry']
print(",".join(['a', 'b', 'c'])) # 输出: a,b,c（5）大小写转换：
使用 upper()、lower()、capitalize()、title() 等方法。
s = "Hello, world!"
print(s.upper()) # 输出: HELLO, WORLD!
print(s.lower()) # 输出: hello, world!（6）去除空白字符：
使用 strip()、lstrip()、rstrip() 方法去除字符串两端的空白字符（包括空格、换行符 \n、制表符 \t 等）。
s = " Hello, world! "
print(s.strip()) # 输出: Hello, world!五、None(空值)
在Python中，None 是一个特殊的类型，用于表示空值或没有值。
None的使用：
初始化变量
x = None
print(x) # 输出: None作为函数的返回值：
def my_function():
# 这里没有返回任何值，所以默认返回 None
pass
result = my_function()
print(result) # 输出: None在条件语句中检查：
None 常用于条件语句中，以检查变量是否已赋值或是否为空。
x = None
if x is None:
print("x 是 None") # 输出: x 是 None六、List(列表)
在Python中，List（列表）是一种非常重要的数据结构，它允许我们存储一个有序的元素集合。这些元素可以是不同类型的，比如整数、浮点数、字符串，甚至是另一个列表。List是可变的。
创建List
使用方括号 [] 来创建列表，元素之间用逗号 , 分隔。
# 创建一个包含整数的列表
numbers = [1, 2, 3, 4, 5]
# 创建一个包含不同类型元素的列表
mixed_list = [1, 'hello', 3.14, [1, 2, 3]]
# 创建一个空列表
empty_list = []访问List元素
你可以通过索引来访问列表中的元素。索引从0开始。
# 访问第一个元素
print(numbers[0]) # 输出: 1
# 访问最后一个元素（索引-1）
print(numbers[-1]) # 输出: 5
# 访问列表中的特定元素
print(mixed_list[3]) # 输出: [1, 2, 3]修改List
你可以通过索引来修改列表中的元素。
# 修改第一个元素
numbers[0] = 10
print(numbers) # 输出: [10, 2, 3, 4, 5]添加元素 ：
使用 append() 方法在列表末尾添加一个元素。
使用 insert(index, element) 方法在指定位置插入一个元素。
numbers.append(6) # 在末尾添加6
print(numbers) # 输出: [10, 2, 3, 4, 5, 6]
numbers.insert(1, 1.5) # 在索引1的位置插入1.5
print(numbers) # 输出: [10, 1.5, 2, 3, 4, 5, 6]删除元素：
使用 remove(element) 方法删除列表中第一个匹配的元素。
使用 pop(index) 方法删除指定索引的元素，并返回该元素的值（如果不指定索引，则默认删除并返回最后一个元素）。
使用 del 语句也可以删除元素。
numbers.remove(1.5) # 删除元素1.5
print(numbers) # 输出: [10, 2, 3, 4, 5, 6]
popped_element = numbers.pop() # 删除并返回最后一个元素
print(popped_element) # 输出: 6
print(numbers) # 输出: [10, 2, 3, 4, 5]
del numbers[0] # 删除索引为0的元素
print(numbers) # 输出: [2, 3, 4, 5]List的遍历
使用 for 循环来遍历列表中的元素。
for num in numbers:
print(num)
# 输出:
# 2
# 3
# 4
# 5七、Tuple(元组)
在Python中，Tuple（元组）是另一种用于存储有序元素集合的数据结构，但与List（列表）不同，Tuple是不可变的。这意味着一旦创建了一个Tuple，就不能更改它的内容（即不能添加、删除或修改元素）。
创建Tuple
使用圆括号 () 来创建Tuple，元素之间用逗号 , 分隔。如果Tuple中只有一个元素，需要在该元素后面加上逗号 “,”。
# 创建一个包含整数的Tuple
numbers = (1, 2, 3, 4, 5)
# 创建一个只包含一个元素的Tuple
singleton = (1,)
# 创建一个空的Tuple（注意：虽然()通常用于函数调用，但空的Tuple也需要用括号表示，但通常使用tuple()构造函数）
empty_tuple = ()
# 或者
empty_tuple_alt = tuple()
# 创建一个包含不同类型元素的Tuple
mixed_tuple = (1, 'hello', 3.14, [1, 2, 3])
# 注意：虽然Tuple本身是不可变的，但它可以包含可变类型的元素（如列表）访问Tuple元素
与List类似，可以通过索引来访问Tuple中的元素。索引从0开始，也可以使用负索引来访问从末尾开始的元素。
# 访问第一个元素
print(numbers[0]) # 输出: 1
# 访问最后一个元素
print(numbers[-1]) # 输出: 5Tuple的不可变性
由于Tuple是不可变的，不能像修改List那样直接修改它的元素。但是，如果Tuple包含可变类型（如列表）的元素，可以修改这些元素的内容（但不能替换整个元素）。
# 尝试修改Tuple的一个元素（这会引发TypeError）
# numbers[0] = 10 # 这会失败
# 如果Tuple包含列表，则可以修改列表的内容
mixed_tuple[3].append(4)
print(mixed_tuple) # 输出: (1, 'hello', 3.14, [1, 2, 3, 4])
# 但不能将整个列表元素替换为另一个列表
# mixed_tuple[3] = [10, 20, 30] # 这会失败Tuple的方法
虽然Tuple是不可变的，但它仍然有一些方法，比如 count(element) 可以计算某个元素在Tuple中出现的次数，index(element) 可以找到某个元素在Tuple中的索引（如果元素不存在，则抛出ValueError异常）。
# 计算元素在Tuple中出现的次数
print(numbers.count(3)) # 输出: 1
# 找到元素的索引
print(numbers.index(4)) # 输出: 3八、Dict(字典)
在Python中，Dict（字典）是一种可变容器模型，且可存储任意类型对象。字典的每个元素都是一个键值对（key-value pair），键必须是唯一的，而值则不必。字典是无序的，不能通过索引来访问元素，而是需要通过键来访问对应的值。
创建字典
使用大括号 {} 来创建字典，键值对之间用冒号 : 分隔，键值对之间用逗号 , 分隔。
# 创建一个空字典
empty_dict = {}
# 创建一个包含几个键值对的字典
person = {'name': 'John', 'age': 30, 'city': 'New York'}
# 字典的键可以是任何不可变类型，但通常是字符串或数字
another_dict = {1: 'one', 2: 'two', 'three': 3}访问字典元素
通过键来访问字典中的值。
# 访问字典中的值
print(person['name']) # 输出: John
# 如果键不存在，将会引发KeyError
# print(person['job']) # 这会失败
# 为了避免KeyError，可以使用get()方法，如果键不存在，则返回None（或你指定的其他值）
print(person.get('job', 'Not specified')) # 输出: Not specified修改字典
通过键来修改字典中的值，或者添加新的键值对。
# 修改字典中的值
person['age'] = 31
# 添加新的键值对
person['job'] = 'Developer'
print(person) # 输出: {'name': 'John', 'age': 31, 'city': 'New York', 'job': 'Developer'}删除字典元素
使用 del 语句或 pop() 方法来删除字典中的键值对。
# 使用del语句删除键值对
del person['job']
# 使用pop()方法删除键值对，并返回被删除的值
job = person.pop('city', 'default') # 如果'city'键不存在，则返回'default'
print(job) # 输出: New York
print(person) # 输出: {'name': 'John', 'age': 31}
# 注意：如果尝试pop不存在的键且没有提供默认值，将会引发KeyError
# job = person.pop('country') # 这会失败字典的遍历
使用 for 循环来遍历字典的键、值或键值对。
# 遍历键
for key in person:
print(key)
# 遍历值
for value in person.values():
print(value)
# 遍历键值对
for key, value in person.items():
print(key, value)字典的方法
Python的字典提供了许多方法，比如 keys() 返回字典中所有的键，values() 返回字典中所有的值，items() 返回字典中所有的键值对（以元组形式），update() 用于更新字典（添加新键值对或更新现有键的值），clear() 用于删除字典中的所有元素，等等。
# 使用keys()、values()和items()
print(person.keys()) # 输出: dict_keys(['name', 'age'])
print(person.values()) # 输出: dict_values(['John', 31])
print(person.items()) # 输出: dict_items([('name', 'John'), ('age', 31)])
# 使用update()更新字典
person.update({'city': 'San Francisco', 'job': 'Engineer'})
print(person) # 输出: {'name': 'John', 'age': 31, 'city': 'San Francisco', 'job': 'Engineer'}
# 使用clear()删除字典中的所有元素
person.clear()
print(person) # 输出: {}九、Set(集合)
在Python中，Set（集合）是一个无序的、不包含重复元素的数据结构。集合主要用于数学上的集合操作，如并集、交集、差集和对称差集等。由于集合是无序的，因此不支持通过索引来访问元素。
创建集合
使用大括号 {} 来创建集合，但需要注意的是，如果大括号内包含的是键值对（即字典的语法），则创建的是字典而不是集合。为了避免混淆，通常使用 set() 函数来创建空集合或包含特定元素的集合。
# 创建一个空集合
empty_set = set()
# 使用set()函数创建包含一些元素的集合
my_set = set([1, 2, 2, 3, 4]) # 注意：重复的元素会自动被去除
# 或者更简洁的方式，直接使用大括号（但不包含键值对）
my_set_literal = {1, 2, 3, 4}
# 尝试使用大括号但包含键值对将创建一个字典，而不是集合
# my_dict = {1: 'one', 2: 'two'} # 这是一个字典访问集合元素
由于集合是无序的，因此你不能通过索引来访问集合中的元素。但是，你可以使用循环来遍历集合中的所有元素。
for element in my_set:
print(element)修改集合
使用 add() 方法向集合中添加元素，使用 remove() 或 discard() 方法从集合中删除元素。注意，remove() 方法在元素不存在时会引发 KeyError，而 discard() 方法则不会。
my_set.add(5) # 添加元素
my_set.remove(2) # 删除元素（如果元素不存在则引发KeyError）
my_set.discard(3) # 删除元素（如果元素不存在则不会引发错误）
# 使用update()方法合并集合
set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.update(set2) # set1 现在变为 {1, 2, 3, 4, 5}
# 使用intersection_update()等方法进行集合操作
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set1.intersection_update(set2) # set1 现在变为 {3, 4}，即set1和set2的交集集合的数学操作
Python支持集合的数学操作，如并集、交集、差集和对称差集。这些操作可以使用集合的方法来实现，也可以使用集合运算符（|、&、-、^）来执行。
# 使用方法
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1.union(set2) # 并集 {1, 2, 3, 4, 5}
intersection = set1.intersection(set2) # 交集 {3}
difference = set1.difference(set2) # 差集 {1, 2}，在set1中但不在set2中的元素
symmetric_difference = set1.symmetric_difference(set2) # 对称差集 {1, 2, 4, 5}，在set1或set2中但不同时在两者中的元素
# 使用运算符
union = set1 | set2
intersection = set1 & set2
difference = set1 - set2
symmetric_difference = set1 ^ set2集合的其他特性
集合中的元素必须是不可变类型（如整数、浮点数、字符串、元组等），因为集合本身是不可变的（即你不能修改集合中的元素，但你可以添加或删除元素）。
集合没有索引或顺序，因此不支持切片操作。
集合是动态数据结构，可以根据需要自动调整大小。
总结：
以上就是python中最核心的九大数据结构，我们在学习时应当特别关注！