一 列表
1.列表（list）
容器型数据类型（序列），有序、可变
2.元素
任何类型的数据都可以作为列表元素
3.元素的增删改查（*******）
1.查
查单个元素：列表[下标]
查部分元素(切片)：列表[开始下标：结束下标：步长]，列表[：]，列表[::-1]
遍历：直接遍历，遍历下标
2.增
列表.append（元素）， 列表.insert（下标，元素）
3,.删
del 列表[下标]
列表.remove（元素）
列表.pop（） 列表.pop（下标）
4.改
列表[下标]=新值
4 . + * == != in /not in len（） list（）
5. 列表常用方法
1） count
列表.count(元素) -------统计列表中指定元素的个数，返回一个整数
nums = [1,2,3,4,1]
print(nums.count(1))
2)extend
列表.extend（序列） ----将序列中的元素全部添加到列表中
nums.extend('abc')
print(nums) # [1, 2, 3, 4, 1, 'a', 'b', 'c']
nums.extend([12,432,345])
print(nums) #[1, 2, 3, 4, 1, 'a', 'b', 'c', 12, 432, 345]
3)index
列表.index（元素） ----获取指定元素的下标（如果元素有多个只取第一个）
注意：如果元素不存在会报错！！！！！
4)reverse
列表.reverse() ------反向列表（直接修改原列表）
reversed（序列） -----反向序列，不修改原序列而是产生新的序列
nums = [1,2,3,4,1]
print(nums.reverse())
print(reversed(nums))
5）sort
列表.sort ---将列表中的元素从小到大排列
列表.sort(reverse=True) --将列表中的元素从大到小排序
sorted（序列） ---排序的时候不修改原序列，产生新的序列
注意：能够进行排序的列表要求列表中的元素一致，并支持比较运算
nums = [1,2,3,4,1,4,3,1]
nums.sort()
print(nums)
nums.sort(reverse=True)
print(nums)
print(sorted(nums)) #小 ----> 大
print(sorted(nums,reverse=True)) # 大 --- 小
6）clear
列表.clear（） -----删除列表中的所有数据
nums = [1,2,3,4,1,4,3,1]
nums.clear()
print(nums)
7.copy
列表.copy（） -----相当于[:]，将列表中的元素拷贝一份产生一个新的列表
nums = [100, 60, 34, 101]
new_nums = nums.copy()
print(nums, new_nums)
print(id(nums), id(new_nums))
new_nums2 = nums # 一个变量给另一个变量赋值，赋的是地址
new_nums2.insert(0, 1000)
print(new_nums2, nums)
二 元祖（tuple）
1.什么是元祖（tuple）
元祖是Python提供的容器型数据类型(序列)，不可变（特色），有序
元祖就是不可变的列表，一般保存一些不让修改的数据
（元素1，元素2，元素3，.....）
2.元素
tuple1=() # 无意义
1)元素个数是1的元祖 : 如果一个元祖中只有一个元素，这个元素后面一定要加逗号
tuple2 = (10)
print(tuple2,type(tuple2)) # 10
tuple2 = (10,)
print(tuple2,type(tuple2)) #(10,)
2)元祖数据中小括号可以省略。（多个数据直接用逗号隔开，表示的是一个元祖）
tuple5 = 10,20,31
print(tuple5[0])
3.获取元素和列表一样
1)让变量的个数和元祖中的个数保持一致，来一一获取
point = (100,90)
x, y = point
print(x, y)
2)让多个变量同时获取元祖中的元素的时候，可以在一个变量前加星号将这个变量变成一个列表来获取不带的变量获取后剩下的数据。
（注意：带*的变量只有一个）
student = ('小明', 18, 89, 68, 89, 90, 'abc')
name, age, *scores = student
print(name, age, scores) # 小明 18 [89, 68, 89, 90, 100]
name, *scores, age, a = student
print(name, age, scores, a) # 小明 90 [18, 89, 68, 89] 100
*items, a, b = student
print(items, a, b)
注意：如果在一个列表或者元祖前加星号，则是将这个列表或者元祖分开打印出来
三 字典（dict）
1.什么是字典(dict)
字典是python提供的容器型数据类型(序列), 可变, 无序
2.字典中的元素
{键值对1, 键值对2, 键值对3,...} ------字典的元素就是键值对
键值对 -------- 以'键:值'的形式成对出现
键(key) - 要求不可变，唯一 (建议用字符串作为key, 用来对值进行说明和区分的)
值(value) - 任何类型的数据都可以作为值
dict1 = {10: 100, 'name': 100, (1, 2): 100, 'a': 'abc', 'b': True, 'c': [1, 2], 'd': {'a': 2}}
print(dict1)
# dict2 = {10: 100, 'name': 100, [1, 2]: 100} # TypeError: unhashable type: 'list'
# dict1 = {10: 100, 'name': 100, {'a': 1}: 100} # TypeError: unhashable type: 'dict'
dict1 = {10: 100, 'name': 100, (1, 2): 100, 10: 200}
print(dict1) # {10: 200, 'name': 100, (1, 2): 100}
3.元素的操作
1) 查 - 获取值
1. 字典[key] --------- 获取字典中key对应的value。（如果key不存在会报错！）
2. 字典.get(key) ------- 获取字典中key对应的value。（如果key不存在不报错，结果是None）
3.字典.get(key, 默认值) ------ 获取字典中key对应的value。（如果key不存在不报错，结果是默认值）
dog = {'name': '旺财', 'color': '黄色', 'age': 3, 'type': '土狗'}
print(dog['type'])
# print(dog['gender']) # KeyError: 'gender'
print(dog.get('name'))
print(dog.get('gender')) # None
print(dog.get('age', 100))
print(dog.get('gender', '公狗')) # 公狗
4.遍历字典
直接通过for循环遍历字典的时候，获取到的是所有的key
# 1.直接遍历(只用这个)
for key in dog:
print(key, dog[key])
# 2.间接遍历
print('===================')
print(dog.values())
for value in dog.values():
print(value)
print('====================')
print(dog.items())
for key, value in dog.items():
print(key, value)
# 只做了解
2) 增/改
字典[key] = value - 如果key存在, 修改key对应的值; 如果key不存在，添加键值对
class1 = {'name': 'py1902', 'address': '19楼5教室'}
print(class1) # {'name': 'py1902', 'address': '19楼5教室'}
增
class1['num'] = 50
print(class1) # {'name': 'py1902', 'address': '19楼5教室', 'num': 50}
改
class1['name'] = 'python1902'
print(class1)
3) 删
1. del 字典[key] - 删除字典中指定key对应的键值对。如果key不存在会报错
2. 字典.pop(key) - 取出字典中key对应的值。如果key不存在会报错
class2 = {'name': 'python1902', 'address': '19楼5教室', 'num': 50}
del class2['num']
print(class2) # {'name': 'python1902', 'address': '19楼5教室'}
name = class2.pop('name')
print(class2, name) # {'name': 'python1902', 'address': '19楼5教室'} python1902
4. 字典相关操作
1) 运算符：不支持数学运算，比较运算符只支持比较相等不支持比较大小
print({'a': 100, 'b': 10} == {'b': 10, 'a': 100}) # True
2) in / not in
key not in/ in 字典 - 判断字典中是否存在指定的key
class2 = {'name': 'python1902', 'address': '19楼5教室', 'num': 50}
print('name' in class2) # True
print(50 not in class2) # True
3) len
print(len(class2))
4) dict
能转换成字典的数据要求： 数据本身是序列，序列中的每个元素也是长度是2的序列，并且小序列中第一个元素是不可变的
data = [(1, 2), ['a', 23]]
print(dict(data))
dict2 = {'a': 10, 'b': 20}
print(list(dict2)) # ['a', 'b']
5.相关方法
1) clear
字典.clear() - 清空字典
dict2 = {'a': 10, 'b': 20}
dict2.clear()
print(dict2)
2)copy
字典.copy() - 拷贝字典中的键值对产生一个新的字典
dict2 = {'a': 10, 'b': 20}
dict3 = dict2
dict3['a'] = 100
print(dict2) # {'a': 100, 'b': 20}
dict2 = {'a': 10, 'b': 20}
dict3 = dict2.copy()
dict3['a'] = 100
print(dict2) # {'a': 10, 'b': 20}
3)fromkeys
dict.fromkeys(序列, 值) - 创建一个新的字典，字典的key是序列的元素， key对应的value是值
new_dict = dict.fromkeys('hello', 100)
print(new_dict)
4)keys, values, items
字典.keys() - 获取字典中所有的key, 结果是一个序列
字典.values() - 获取字典中所有的value, 结果是一个序列
字典.items() - 获取字典中中的key和value， key和value以元祖的形式返回
students = {'name': '张三', 'age': 18, 'stu_id': 'stu001', 'gender': '女'}
print(students.keys())
print(students.values())
print(students.items())
5)setdefault
字典.setdefault(key, value) - 添加键值对(不能修改)
students.setdefault('tel', '15300022783')
print(students)
6)update
字典1.update(字典2) - 使用字典2中的键值对去更新字典1(不存在添加、存在修改)
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 200, 'd': 300, 'e': 400}
dict1.update(dict2)
print(dict1) # {'a': 1, 'b': 200, 'c': 3, 'd': 300, 'e': 400}
四 集合
1.什么是集合(set)
容器型数据类型(序列), 可变、无序
2.集合中的元素
{元素1, 元素2, 元素3,...}
元素: 不可变、唯一(自带去重功能)
注意: {}不是能表示空的集合,他表示字典的空集合，set() - 空集合
set1 = set()
set2 = {1, 'abc', (1, 3), False, 1, 1, 1}
print(set2) # {False, 1, (1, 3), 'abc'}
集合可以去重
str1 = 'hekskfahhheuwjseaaa'
print(''.join(set(str1))) # hfkaweujs
list1 = [1, 34, 34, 2, 2]
print(list(set(list1))) # [1, 34, 2]
3.元素相关操作
1) 查
集合不能单独获取指定的某一个元素, 只支持遍历
set3 = {12, 34, 56, 2, 7, 88}
for x in set3:
print(x)
2) 增
集合.add(元素) - 往集合中添加一个元素
集合.update(序列) - 将序列中的元素添加到集合中(自带去重)
set1 = {1}
print(set1)
set1.add(100)
print(set1)
set1.update('abc')
print(set1)
set1.update({'name': '张三', 'age': 20})
print(set1) # 1,100,abc,name,age
3) 删
集合.remove(元素) - 删除集合中指定的元素。（元素不存在会报错!）
set4 = {1, 'b', 100, 'a', 'age', 'c', 'name'}
set4.remove(100)
print(set4)
(*)4.数学集合运算
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
1) 并集: |
集合1 | 集合2 - 将两个集合中的元素合并产生新的集合
print(set1 | set2)
2) 交集: & - 求两个集合公共的部分
print(set1 & set2) # {4, 5, 6}
3) 差集: 集合1 - 集合2 --- 获取集合1中除了集合2以外的部分
print(set1 - set2) # {1, 2, 3}
print(set2 - set1) # {7, 8}
4) 补集: 集合1^集合2 --- 两个集合除了公共部分以外的部分
print(set1 ^ set2)
5) 包含关系
集合1 >= 集合2 ------- 集合1中是否包含集合2
集合1 <= 集合2 ------ 集合2中是否包含集合1
print({5, 6, 7, 8, 9} >= {1, 2, 3}) # False
print({5, 6, 7, 8, 9} >= {5, 9}) # True