整理
列表的增、删、改、查
1.修改列表元素
通过下标呼气偶元素，然后重新赋值：列表名[下标]=新的值
注意：这里的下标不能越界
names = ['周星驰','张家辉','刘德华','黄渤','杨洋']
names[4] = '陈奕迅'
#names[-1]
print(names) # ['周星驰', '张家辉', '刘德华', '黄渤', '陈奕迅']
# name = names[4]
# name = 100
# 并不改变列表里面的值
2.列表的其他操作
1.len(列表):获取列表的长度(元素的个数)
2.列表1 + 列表2:让列表1和列表2的元素组合在一起产生一个新的列表
3.列表*数字：让列表中的元素重复n次，产生一个新的列表
# print(len([1, 2, 3, 4, 5]))
print(len(names)) # 5
new_names = names + ['周杰伦','王力宏']
print(new_names) # ['周星驰', '张家辉', '刘德华', '黄渤', '陈奕迅', '周杰伦', '王力宏']
print([1,2]*3) # [1, 2, 1, 2, 1, 2]
- in ,not in操作
元素in列表：判断指定的元素是否在指定的列表中
result = '高以翔' not in names
print(result) # True
3.获取列表中的最大的元素和最小的元素
max(列表)
min(列表)
print(max([1, 34, 67, 8])) # 67
print(max(['a', 'hj', 'uio', 'z'])) # z
print(min([1, 45, 89, 0, -1, 8])) # -1
# 获取一个数字列表中的最大值
numbers = [1, 23, 56, 2, -1, 445, 7, -1]
max1 = numbers[0]
for item in numbers:
if max1 < item:
max1 = item
print(max1) # 445
min1 = numbers[0]
for item in numbers:
if min1 > item:
min1 = item
print(min1) # -1
4.其他方法
1.count：获取指定元素在列表中出现的次数
print(numbers.count(-1)) # 2
2.列表.extend(序列)：将序列中的每一个元素，添加到列表中
names.extend(['王祖贤'])
print(names) # ['周星驰', '张家辉', '刘德华', '黄渤', '陈奕迅', '王祖贤']
names.extend('20')
print(names) # ['周星驰', '张家辉', '刘德华', '黄渤', '陈奕迅', '王祖贤', '2', '0']
# names.extend(20) 报错，必须是序列
3.列表.index(元素)：获取指定元素在指定列表中的索引（如果元素有多个，取第一个）
print(names.index('张家辉')) # 1
4.列表.reverse():反向列表中的元素(直接操作原列表，不会产生新的列表)
numbers = [1, 2, 3, 4]
new_names = numbers.reverse()
print(numbers, new_names) # [4, 3, 2, 1] None
5.列表.sort():对列表进行排序(默认是从下到大排序-升序)
numbers = [1, 42, 45, 6, 90]
numbers.sort() # 升序
print(numbers) # [1, 6, 42, 45, 90]
numbers.sort(reverse=True) # 降序
print(numbers) # [90, 45, 42, 6, 1]
6.列表.clear():清空列表中的元素
numbers.clear()
# number = [] # 效果同上
print(numbers) # []
7.列表.copy():将列表中的元素全部拷贝一份创建一个新的列表
names = ['张三', '李四']
new_names1 = names.copy()
# new_names1 = name[:] # 效果同上
print(new_names1) # ['张三', '李四']
注意：通过一个列表变量给另一个列表变量赋值的时候，赋的是地址。两个列表对元素进行操作的时候会相互影响。
想要避免这个问题就是用copy或者切片
元祖
1.什么是元祖
元祖(tuple)就是不可变的列表，列表中除了可变的从左以外，其他的操作都适用于元祖
元祖值：a.使用()将元素包含起来，多个元素之间用逗号隔开，比如：(1, 2, 'abc')
b.元素的类型可以是任何类型
2.改、增、删相关操作不能作用于元祖。查可以
colors = ('red', 'green', 'yellow', 'purple')
print(type(colors)) #
1.查(和列表的查一模一样，没有任何区别)
print(colors[1]) # green
print(colors[0:3]) # ('red', 'green', 'yellow')
print(colors[0::2]) # ('red', 'yellow')
for item in colors:
print(item)
# red
# green
# yellow
# purple
2.len
print(len(colors)) # 4
3.in, not in
print('red' in colors) # True
4.+和*
print((1, 2)+(3, 4)) # (1, 2, 3, 4)
print((1, 2)* 2) # (1, 2, 1, 2)
5.元祖补充
获取元祖的元素
names = ('name1', 'name2', 'name3',)
x, y, z = names # 通过多个变量分别获取元祖元素(变量个数和元祖元素个数一样,不一样会报错)
print(x, y, z) # name1 name2 name3
names = ('name1', 'name2', 'name2_2', 'name2_3', 'name3')
first, *midel, last = names # 通过变量名前加*可以把变量变成列表，获取多个元素
print(first, midel, last) # name1 ['name2', 'name2_2', 'name2_3'] name3
*name1, name = names
print(name1, name) # ['name1', 'name2', 'name2_2', 'name2_3'] name3
name, *name1 = names # 让name获取第一个元素，剩下的部分作为列表name1的元素
print(name, name1) # name1 ['name2', 'name2_2', 'name2_3', 'name3']
"""
字典
字典也是一种容器类型的数据类型(序列)，存的数据是以键值对的形式出现的，字典中的元素全部都是键值对
字典是可变(可以增、删、改)，但是是无序的(不能使用下标)
键是唯一的,若不唯一后面的覆盖前面的
键值对：键：值(key:value):键值对中key是形式，值才是真正要存的内容
键理论上可以是任何不可变的数据类型，但是实际开发的时候一般使用字符串作为key
值：可以是任意数据类型数据
1.声明一个字典
a.创建一个字典变量
dict1 = {} # 创建一个空的字典
print(type(dict1)) #
dict2 = {'a': 1, 'b': 'abc', 10:[1, 2, 3], ('a', 'b'): 'abc'}
print(dict2) # {'a': 1, 'b': 'abc', 10: [1, 2, 3], ('a', 'b'): 'abc'}
dict2 = {'a': 1, 'b': 'abc', 'a':100} # 键是唯一的,若不唯一后面的覆盖前面的
print(dict2) # {'a': 100, 'b': 'abc'}
b.将其他数据类型转换成字典
dict3 = dict([(1, 2), (2, 3)]) # 了解
print(dict3) # {1: 2, 2: 3}
2.字典的增删改查
a.查：获取字典的元素的值
字典获取元素的值是通过key来获取的
字典[key]
person = {'name': '路飞', 'age': 17, 'face': 90}
print(person['name'], person['face']) # 路飞 90
# print(person['aaa']) 如果key不存在，会报错KeyError
字典.get(key)
print(person.get('name')) # 路飞
print(person.get('aaa')) # None 如果key不存在，返回None
注意：如果key值确定存在，使用[]语法去获取值。不确定key值是否存在才使用get方法去获取值
b.增加元素\修改元素
通过key获取字典元素，然后赋值。当key本身存在的时候，就是修改元素的值；不存在的时候就是给再点添加键值对。
person['height'] = 1.8
print(person) # {'name': '路飞', 'age': 17, 'face': 90, 'height': 1.8}
person['age'] = 18
print(person) # {'name': '路飞', 'age': 18, 'face': 90, 'height': 1.8}
c.删除:删除的是键值对
del 字典 ---注意：这是删除整个字典
del 字典[key] ---注意：key如果不存在会报错
del person['face']
print(person) # {'name': '路飞', 'age': 18, 'height': 1.8}
# del person['aaa'] # 报错 KeyError
字典.pop(key) ---会返回被删除的键值对对应的值
age = person.pop('age')
print(person, age) # {'name': '路飞', 'height': 1.8} 18
3.相关的数组属性(了解)
字典.keys:获取字典所有的key,返回值的类型是dict_keys,但是可以把它当成列表来使用
字典.values:获取字典所有的值(value)
字典.items:将字典中所有的键值对转换成一个一个的元祖，key作为元祖的第一个元素，value作为元祖的第二个元素
student_dict = {'name': '张三', 'study_id': 'py1805001', 'score': {'english': 60, 'math': 100}}
keys = student_dict.keys()
print(keys, type(keys)) # dict_keys(['name', 'study_id', 'score'])
# 遍历获取每个key
for key in keys:
print(key)
# name
# study_id
# score
print(student_dict.values()) # dict_values(['张三', 'py1805001', {'english': 60, 'math': 100}])
print(student_dict.items()) # dict_items([('name', '张三'), ('study_id', 'py1805001'), ('score', {'english': 60, 'math': 100})]) 60, 'math': 100}])
4.遍历字典
a.直接遍历字典获取到的是所有的key(推荐使用)
for key in student_dict:
print(key, student_dict[key])
# name 张三
# study_id py1805001
# score {'english': 60, 'math': 100}
b.遍历直接获取key和value(不推荐使用)
for key, value in student_dict.items():
print(key, value)
# name 张三
# study_id py1805001
# score {'english': 60, 'math': 100}
for value in student_dict.values():
print(value)
# 张三
# py1805001
# {'english': 60, 'math': 100}
5.列表中有字典、字典中有字典、字典中有列表
声明一个变量，作用是用来存储一个班级的学生的信息。其中学生的信息包括姓名、性别、年龄、电话
至少存三个学生信息
a = [{'name': '张三', 'age': 23, 'sex': '男', 'tel': 1},
{'name': '李四', 'age': 25, 'sex': '女', 'tel': 2},
{'name': '王二麻子', 'age': 20, 'sex': '男', 'tel': 3}]
class1 = {'name': 'py1805',
'addiess': '19-1',
'students':[
{'name': '张三', 'age': 18},
{'name': '李四', 'age': 28},
{'name': '王五', 'age': 20}
]
}
6.其他操作
1.fromkeys()
dict.fromkeys(序列，value):创建一个新的字典，序列中的元素作为key,value作为值
dict1 = {'a': 1, 'b': 2}
# new_dict1 = dict1.fromkeys('abc','100')
print(new_dict1) # {'a': '100', 'b': '100', 'c': '100'}
# new_dict1 = dict1.fromkeys(range(10),100)
print(new_dict1) # {0: 100, 1: 100, 2: 100, 3: 100, 4: 100, 5: 100, 6: 100, 7: 100, 8: 100, 9: 100}
new_dict1 = dict.fromkeys(['abc', 'dcc', '123'], '100')
print(new_dict1) # {'abc': '100', 'dcc': '100', '123': '100'}
2.in
key in 字典:判断字典中是否存在指定的key
dog_dict = {'color': 'white', 'age': 3, 'type': '土狗'}
print('color' in dog_dict) # True 判断的是键是否存在
print('white' in dog_dict) # False
3.update
字典1.update(字典2)：使用字典2的键值对去更新字典1中的键值对。如果子弟那2中对应的键值对在字典1中不存在，就添加。存在就更新
dict1 = {'1': 'a', '2': 'b'}
dict1.update({'1': 'aaa', '3': 'bbb'})
print(dict1) # {'1': 'aaa', '2': 'b', '3': 'bbb'}
"""
集合
集合也是一种容器类型的数据类型（序列），数据放在{}中，多个之间只用逗号隔开：{1, 2, 'a'}
集合无序的（不能通过索引去取值），可变（可以增删改），元素不能重复
集合可以进行数学集合相关的操作：判断是否包含，求交集、并集、差集、补集
1.怎么声明集合
a.声明一个变量，赋一个集合值
set0 = set() # 创建一个空的集合
set1 = {1, 2, 3}
print(set1, type(set1)) # {1, 2, 3}
b.将其他的数据转换成集合
set2 = set('abc123') # 将其他数据转换成集合，自带一个去重的功能，顺序会改变
print(set2) # {'a', 'b', '2', '1', '3', 'c'}
set3 = set([12, 'abc', 'hh', 32])
print(set3) # {32, 'abc', 'hh', 12} 集合
print(list(set3)) # [32, 'abc', 'hh', 12] 列表
2.增删改查
a.查：遍历
注意：集合没有办法单独获取某一个元素
for item in set2:
print(item)
# 1
# 3
# 2
# a
# c
# b
b.增
集合.add(元素)：在指定的集合添加指定的元素
set1 = {1, 2, 3}
set1.add(100)
print(set1) # {1, 2, 3, 100}
集合1.update(集合2)：将集合2中的元素添加到集合1中，自动去重
set1.update({'abc','ss'})
print(set1) # {1, 2, 3, 100, 'ss', 'abc'}
c.删
集合.remove(元素)：在指定的集合中删除指定的元素
set1.remove('ss')
print(set1) # {1, 2, 3, 100, 'abc'}
pop删除是随机删除一个
set1.pop()
print(set1) # {2, 3, 100, 'abc'}
3.判断是否包含
集合1 >= 集合2 -- 判断集合1中是否包含集合2(判断集合2中所有的元素是否都在集合1中)
集合1 <= 集合2 -- 判断集合2中是否包含集合1
print({1, 2, 3, 4} >= {1}) # True
print({1, 2, 3, 4} >= {1, 5}) # False
print({1, 2, 3, 4} <= {1, 2}) # False
4.数学的集合运算
求并集:+
print({1, 2, 3} | {2, 3, 4, 5}) # {1, 2, 3, 4, 5}
求交集：&
print({1, 2, 3} & {2, 3, 4, 5}) # {2, 3}
求差集：-
print({1, 2, 3} - {2, 3, 4, 5}) # {1}
print({2, 3, 4, 5} - {1, 2, 3}) # {4, 5}
求补集：^
print({1, 2, 3} ^ {2, 3, 4, 5}) # {1, 4, 5}
5.其他方法
clear:清空集合
set1 = {1, 2, 3}
set1.clear()
print(set1,type(set1)) # set()
len:获取集合中元素的个数
print(len(set1)) # 0