? ? ? ? 整形、浮点型、字符串、布尔类型、None、列表、元组、字典、集合
? ? ? ? 列表是一个可以包含任何数据类型的有序集合，比如数字、字符串甚至是其它列表。列表是可变的，也就是说可以改变一个列表的内容。
? ? ? ? 创建列表，只需要将一些值用逗号隔开，然后用方括号括起来即可。例如：
1、创建一个包含整数的列表
numbers = [1,2,3,4]
2、创建一个包含字符串的列表
fruits = ['apple','banana','cherry']? ? ? ? 列表中的每一个元素都有一个索引，这是一个标识元素在列表中位置的数字。在Python中，索引是从0开始的。我们可以使用索引来访问列表中的特定元素
? ? ? ? 索引也支持负索引，它从列表的末尾开始计数，-1表示最后一个元组，-2表示倒数第二个元素
示例如下：
例1：
fruits = ['apple','banana','cherry']
print(fruits[0]) #输出apple
print[fruits[1]] #输出banana
例2：
fruits = ['apple','banana','cherry']
print(fruits[-1]) #输出：cherry
print(fruits[-2]) #输出：banana
? ? ? ? 由于列表是可变的，我们可以使用索引来修改列表中的元素。
例如：
fruits = ['apple','banana','cherry']
fruits[1] = 'blueberry'
print(fruits) #输出:['apple','blueberry','cherry']
? ? ? ? ?此外，我们可以使用列表的append方法添加新元素，使用remove方法删除元素，使用insert方法在特定的位置插入元素
fruits = ['apple','banana','cherry']
fruits.append('date')
print(fruits) #输出['apple','banana','cherry','date']
fruits.remove('banana')
print(fruits) #输出：['apple','cherry','date']
fruits.insert(1,'banana')
print(fruits) #输出:['apple','banana','cherry',date]
? ? ? ? 切片是一种获取列表子集的操作。通过指定开始索引和结束索引，我们可以获得列表的一部分。需要之一的是切片操作是左闭右开的，也就是说，他会包含开始索引的元素，但是不包含结束索引的元素
numbers = [0,1,2,3,4,5,6,7,8,9]
print(number[:5]) #输出：[0,1,2,3,4]
print(number[5:]) #输出：[5,6,7,8,9]? ? ? ? 列表提供了两种排序方式，sort和sorted。sort方法会直接修改原列表，使其变为有序状态；二sorted函数则会返回一个新的排序列表，原列表保持不变
numbers = [4,2,9,7,5,1]
number.sort()
print(numbers) #输出：[1,2,4,5,7,9]
numbers = [4,2,9,7,5,1]
new_numbers = sorted(numbers)
print(new_numbers) #输出:[1,2,4,5,7,9]
print(numbers) #输出：[4,2,9,7,5,1]? ? ? ? 可以使用python的内建函数len来获取列表的长度
fruits = ['apple','banana','cherry']
print(len(fruits)) #输出3? ? ? ? 元组(tuple)是python中另一种内置的存储有序数据的结构。
? ? ? ? 元组与列表类似，也是一系列按特定顺序排列的元素组成，可存储不同类型的数据，然而元组是不可该表的，创建后不再做任何修改操作
? ? ? ? 使用赋值语句可直接创建元组，需要注意的是列表使用的是方括号，元组使用的是小括号
tuplename = (元素1,元素2,元素3,元素4,....元素n)? ? ? ? ?在python中，可以创建空元组，空元组可以应用在为函数传递一个空值或者返回空值时。
? ? ? ? 可以使用tuple()函数将range()函数循环出来的结果转换为数值元组
data = range(1,11) #range函数左闭右开
tuplename = tuple(data)
print(tuplename) #输出(1,2,3,4,5,6,7,8,9,10)? ? ? ? 元组中的元素值不允许被修改，但是我们可以使用del语句删除整个元组。对于已经创建的元组，不再使用时，可以使用del语句将其删除。
data = range(1,11)
tuplename = tuple(data)
del tuplename
print(tuplename) #输出报错，因为tuplename元组已经被删除
? ? ? ? 元组是不可变序列，所以不能对它的单个元素值进行修改，但是可以对元组重新赋值
data = range(1,11)
tuplename = tuple(data)
tuplename = (1,2)
print(tuplename) #输出：(1,2)
len(tup)：返回元组中元素的个数；
min(tup)：返回元组中元素最小的值；
max(tup)：返回元组中元素最大的值；
tuple(seq)：将列表转化为元组
? ? ? ? 列表内的元素可以被随时修改或删除，元组不可以；
? ? ? ? 元组比列表的访问和处理速度快；
? ? ? ? 列表不能作为字典的键，元组可以
tuples = (1,2,3,4)
print(tuples[:2]
tuple()函数接收一个列表，返回一个包含相同元素的元组；
list()函数接收一个元组，返回一个列表
? ? ? ? 字典是一种无序、可变的数据类型，用于存储键和值之间的映射关系。字典是一种高效的数据结构，可以用于快速查找和检索数据。
? ? ? ? 可以使用大括号{}或者dict()函数来创建一个字典。字典中的键是唯一的，且必须是不可变的(例如字符串、数字、元组，列表就不可以做键)。而值可以是任意类型的对象。
以下几种方法创建的字典均等于{"one":1,"two":2,"three":3}
dict(one=1,two=2,three=3)
{'one': 1, 'two': 2, 'three': 3}
dict(zip(['one', 'two', 'three'], [1, 2, 3]))
dict([('two', 2), ('one', 1), ('three', 3)])
dict({'three': 3, 'one': 1, 'two': 2})
dict({'one': 1, 'three': 3}, two=2)
总结：以下是创建字典的几种方式
?
1、使用大括号创建
???????????????????? my_dict = {}
2、使用dict()函数创建
???????????????????? my_dict = dict(key1=value1,key2=value2,key2=value3)
3、从列表创建字典，列表中的元素是由键值对组成的元组
???????????????????? my_dict = dict([(key1,value1),(key2,value2),(key3,value3)])
? ? ? ? 可以使用方括号来访问字典中的值，将键作为索引传递给字典即可获取对应的值
my_dict = {'name':'Alice','age':25,'city':'New York'}
print(my_dict['name'] #输出：Alice
? ? ? ? 如果访问不存在的键，会触发KeyError异常，可以使用get()方法来避免异常，如果键不存在，get()方法会返回指定的默认值?
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
print(my_dict.get('name')) # 输出: Alice
print(my_dict.get('gender', 'N/A')) # 输出: N/A，键'gender'不存在，返回默认值'N/A'
? ? ? ? 字典的值是可变的，可以通过键来修改字典中的值
my_dict = {'name':'admin','age':25,'city':'shanghai'}
my_dict['age'] = 10 #修改键'age'对应的值为10
print(my_dict) #输出{'name':'admin','age':10,'city':'shanghai'}
? ? ? ? ?如果键不存在，赋值操作将会创建一个新的键值对
? ? ? ? 可以使用del关键字来删除字典中的元素，通过指定要删除的键来完成删除操作
my_dict = {'name':'admin','age':25,'city':'shanghai'}
del my_dict['age'] #删除键'age'及其对应的值
print(my_dict) #删除{'name':'admin','city':'shanghai'}
? ? ? ? 如果删除不存在的键，会触发KEyError异常，可以使用pop()方法来删除键，并返回对应的值，如果键不存在，pop()方法会返回指定的默认值
my_dict = {'name':'admin','age':25,'city':'shanghai'}
removed_age = my_dict.pop('age') #删除键'age'及其对应的值，并返回被删除的值
print(removed_age) #输出25
removed_gender = my_dict.pop('gender','N/A') #键'gender'不存在，返回默认值'N/A'
print(removed_gender) #输出：N/A
? ? ? ? ?还可以使用popitem()方法删除字典中的最后一个键值对，并返回被删除的键值对
? ? ? ? 可以使用for循环遍历字典的键或值，或者同时遍历键和值
遍历键
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key in my_dict:
print(key) # 输出: name, age, city
遍历值
for value in my_dict.values():
print(value) #输出: Alice, 25, New York
遍历键和值
for key,value in my_dict.items():
print(key,value) #输出: name Alice, age 25, city New York? ? ? ? 可以使用in关键字来检查某个键是否存在于字典中
print('name' in my_dict) #输出：true
print('gender' in my_dict) #输出：false
? ? ? ? 用len()函数来获取字典的长度，也就是键值对的数量
length = len(my_dict)
print(lengtg) #输出：3
clear()：清空字典中的所有键值对；
copy()：创建字典的副本(浅拷贝)：
new_dict = my_dict.copy()
print(new_dict) # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}
update()：将一个字典的键值对更新到另一个字典中
my_dict = {'name': 'Alice', 'age': 25}
new_data = {'city': 'New York', 'gender': 'female'}
my_dict.update(new_data)
print(my_dict) # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York', 'gender': 'female'}
keys()：返回一个包含字典所有键的试图(类似于列表)
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
keys = my_dict.keys()
print(keys) # 输出: dict_keys(['name', 'age', 'city'])
values()：返回一个包含字典所有值的试图(类似于列表)
items()：返回一个包含字典所有键值对的试图(类似于列表中的元组)
? ? ? ? 集合用于保存不重复的元素，有可变集合(set)和不可变集合(frozenset)两种。在形式山，集合的所有元素都放在一堆大括号中，两个相邻元素间使用逗号分隔。集合最好的应用就是去重，因为集合中的每一个元素都是唯一的。
? ? ? ? 在python中提供了两种创建集合的方法，一种是直接使用{}创建，一种是通过set()函数将列表、元组等可迭代对象转换为集合
1、collection = {1,2,3,4,5}
2、lists = [1,2,3,4,5]
collection = set(lists)
1、add()：向集合中添加元素；
2、update()：向集合追加的数据是序列；
3、del命令删除整个集合；
4、discard()方法、pop()方法、remove()方法：删除一个元素；
5、clear()：清空集合；
6、in：判断数据在集合中；
7、not in：判断数据不在集合中；
8、set(list)：将列表转换为集合
集合是可修改的数据类型，但集合中的元素必须是不可修改的，也就是说集合中的元素只能是数值、字符串、元组之类
集合最常用的操作就是进行交集、并集、差集和对称差集运算
交集：
collection_01 = {1,2,3}
collection_02 = {1,2}
print(collection_01 & collection_02) #输出：{1,2}
并集
collection_01 = {1,2,3}
collection_02 = {1,2,4}
print(collection_01 | collection_02) #输出：{1,2,3,4}
差集
collection_01 = {1,2,3}
collection_02 = {1,2,4}
print(collection_01 - collection_02) 输出：{3}，注意是集合01对02的差集，如果是02对01，则输出{4}