补充列表
- 修改列表元素
通过下标获取元素，然后重新赋值：列表名[下标] = 新的值
names = ['宋小宝','保罗','科比','詹姆斯','恩比德']
print(type(names))
names[0] = '塔图姆'
print(names)
结果：
['塔图姆', '保罗', '科比', '詹姆斯', '恩比德']
- 列表的其他操作
（1）.len(列表)：获取列表的长度（元素的个数）
（2）.列表1+列表2：让列表1和列表2的元素组合在一起产生一个新的列表
new_names = names +['桂纶镁','张杰']
print(new_names)
print([1,2]*3)
结果：
['塔图姆', '保罗', '科比', '詹姆斯', '恩比德', '桂纶镁', '张杰']
[1, 2, 1, 2, 1, 2]
- in，not in操作
- 元素 in 列表：判断指定的元素是否在指定的列表中
ret = '张杰' not in new_names
print(ret)
结果：
False
- 获取列表中最大的元素和最小元素
max（列表）
min（列表）
print(max([1, 34, 67, 8]))
print(max(['a', 'asd', 'xs', 'xxxx']))
# 获取一个数字列表中的最大值
number1 = [1,23,56,2,445,7]
su1 = number1[0]
for x in number1:
if su1 < x:
su1 = x
print(su1)
# 获取一个字母列表中的最大值
number2 = ['a', 'asd', 'xs', 'xxxx']
su1 = str(number2[0])
for x in number2:
y1 = len(su1) #比较列表中字母的大小就是比较长度，所以先转换成长度
y2 = len(x)
if y1 < y2:
su1 = x
print(su1)
结果：
67
xxxx
445
xxxx
- 其他方法
count:获取指定元素在列表中出现的次数
- 列表名.count(元素)
- 列表.extend（序列）：将序列中的每一个元素，添加到列表中"""
names.extend(['IU'])
print(names)
结果：
['塔图姆', '保罗', '科比', '詹姆斯', '恩比德', 'IU']
- 列表.index（元素）：获取指定元素在指定列表中的索引（如果元素有多个，取第一个）
print(names.index('IU'))
结果：
5
- 列表.reverse（）：反向列表中的的元素（直接操作的原列表，不会产生新的列表）
number3 = [1,22,33,54,9,89,444]
number3.reverse()
print(number3)
结果：
[444, 89, 9, 54, 33, 22, 1]
- 列表.sort（）：对列表元素进行排序（默认是从小到大排序 - 升序）
number3 = [1,22,33,54,9,89,444]
number3.sort()
print(number3)
number3.sort(reverse=True)
print(number3)
结果：
[1, 9, 22, 33, 54, 89, 444]
[444, 89, 54, 33, 22, 9, 1]
- 列表.clear（）：清空列表中的元素
number3.clear()
# number3 = [] 效果同上
print(number3)
结果：
[]
- 列表.copy（）：将列表中的元素全部拷贝一份创建一个新的列表
names = [500,3,5,6]
# new_names = names[:] 效果一样
new_names = names.copy()
print(new_names)
结果：
[500, 3, 5, 6]
元组
- 什么是元组
- 元组就是不可变的列表，列表中除了可变的操作以外，其他的操作都适用于元组
- 元组值：
a.使用（）将元素包含起来，多个元素之间用逗号隔开，比如：（1， 2，'sad'）
b.元素的类型可以是任何类型
2.改、增、删相关操作不能作用于元组。查可以
（1）. 查（和列表的查一样，没有任何区别）
tup = ('red','blue','yellow','black')
print(type(tup))
print(tup[2])
print(tup[::2])
for _ in tup:
print(_)
names = ('sd','sda','sdaf')
x, y, z = names
print(x, y, z)
结果：
yellow
('red', 'yellow')
red
blue
yellow
black
sd sda sdaf
（2）.len
print(len(tup))
结果：
4
（3）.in , not in
print('blue'in tup)
结果：
True
（4）.+和*
print((1,2)+(3,4))
print((1,2) * 2)
结果：
(1, 2, 3, 4)
(1, 2, 1, 2)
（5）.元组补充：
a. 获取元组的元素
names = ('name1','name2','name3')
x, y, z= names #通过多个变量分别获取元组的元素（变量个数和元组元素个数一样）
print(x,y)
names = ('name1','name2','name2_2','name2_3','name3')
first, *midel, last = names #通过变量名前加*可以把变量编程列表，获取多个元素
print(first,midel,last)
*name1,name = names
print(name1,name)
结果：
name1 name2
name1 ['name2', 'name2_2', 'name2_3'] name3
['name1', 'name2', 'name2_2', 'name2_3'] name3
字典
- 字典也是一种容器类型的数据类型（序列），存的数据是以键值对的形式出现的，字典中的元素全部都
- 字典是可变的（可以增删改），但是是无序的（不能使用下标）
- 字典里的键是唯一的,如若不一，后面的值会覆盖前面相同的键的值
- 键值对：键：值（key：value） 键值对中key是形式，值才是真正要存的内容
键理论上可以是任何不可变的数据类型，但是实际开发的时候一般使用字符串作为key - 值：可以是任意数据类型数据
- 声明一个字典
a. 创建一个字典变量
dict1 = {} #创建一个空的字典
print(type(dict1))
dict2 = {'a': 1, 'c': 'xxx', 10: 100, ('sd', 'asd'): 5}
print(dict2)
dict2 = {'a': 1, 'c': 'xxx', 'a': 100}
print(dict2)
结果：
{'a': 1, 'c': 'xxx', 10: 100, ('sd', 'asd'): 5}
{'a': 100, 'c': 'xxx'}
b. 将其他数据类型转换成字典
dict3 = dict([(1, 2),(3, 4)]) #了解
print(dict3)
结果：
{1: 2, 3: 4}
- 字典的增删改查
a. 查：获取字典的元素的值
- 字典获取元素的值是通过key来获取的
- 字典[key]
person = {'name': '保罗', 'age': 23, 'face': 99}
print(person['name'],person['face'])
# print(person['aaa']) #如果key不存在，会报keyError
结果：
保罗 99
- 字典.get(key)
print(person.get('name'))
print(person.get('saa')) #如果key不存在，返回None
结果：
保罗
None
- 注意：如果key值确定存在，使用[]语法去获取值。不确定key值是否存在才使用get方法去获取值
b. 增加元素\修改元素
- 通过key获取字典元素，然后赋值。当key本身就存在的时候，就修改元素的值；不存在的时候就是给字典添加键值对
person['height'] = 185
print(person)
person['age'] = 20
print(person)
结果：
{'name': '保罗', 'age': 23, 'face': 99, 'height': 185}
{'name': '保罗', 'age': 20, 'face': 99, 'height': 185}
c. 删除：删除的是键值对
- del 字典[key] ---注意： key如果不存在会报错
del person['face']
print(person)
结果：
{'name': '保罗', 'age': 20, 'height': 185}
- 字典.pop（key） --- 会返回被删除的值
age = person.pop('age')
print(person,age)
结果：
{'name': '保罗', 'height': 185} 20
- 相关的数组
- 字典.keys():获取字典所有的key，返回值的类型是dict——keys，但是可以把他当成列表来使用
- 字典.values():获取字典所有的值（value）
- 字典.items():将字典中所有的键值对转换成一个一个的元组，key作为元组的第一个元素，value作为元组的第二个元素
student_dict = {'name': '张三', 'study_id': 'py1805001', 'scores': {'english' : 60, 'match' : 70}}
keys = student_dict.keys()
print(keys, type(keys))
for key in keys:
print(key)
print(student_dict.values())
print(student_dict.items())
结果：
dict_keys(['name', 'study_id', 'scores'])
name
study_id
scores
dict_values(['张三', 'py1805001', {'english': 60, 'match': 70}])
dict_items([('name', '张三'), ('study_id', 'py1805001'), ('scores', {'english': 60, 'match': 70})])
- 遍历字典
# a. 直接遍历字典获取到的是所有的key(推荐使用)
for key in student_dict:
print(key,student_dict[key])
# b.遍历直接获取到key和value（不推荐使用）
for key,value in student_dict.items():
print(key, value)
结果：
name 张三
study_id py1805001
scores {'english': 60, 'match': 70}
name 张三
study_id py1805001
scores {'english': 60, 'match': 70}
- 列表中有字典、字典中有字典、字典中有列表
练习：声明一个变量，作用是用来存储一个班级的学生的信息。其中学生的信息包括姓名、性别、年龄、电话，
至少存三个学生信息
class1 = [
{'name': '老王', 'sex': '男', 'age': 23, 'tel': 123131322},
{'name': '小明', 'sex': '女', 'age': 20, 'tel': 123111111},
{'name': '老王', 'sex': '男', 'age': 23, 'tel': 133333333}
]
print(class1)
class2 = {
'name':'py1805',
'address':'19-1',
'sdudents':[
{'name':'张三','age':'18'},
{'name':'张三','age':'18'},
]
}
print(class2)
结果：
[{'name': '老王', 'sex': '男', 'age': 23, 'tel': 123131322}, {'name': '小明', 'sex': '女', 'age': 20, 'tel': 123111111}, {'name': '老王', 'sex': '男', 'age': 23, 'tel': 133333333}]
{'name': 'py1805', 'address': '19-1', 'sdudents': [{'name': '张三', 'age': '18'}, {'name': '张三', 'age': '18'}]}
- 其他操作
（1）.fromkeys（）
dict.fromkeys(序列， value）：创建一个新的字典，序列中的元素作为key，value作为值
# new_dict = dict.fromkeys('abc', '100')
# new_dict = dict.fromkeys(range(10), '100')
new_dict = dict.fromkeys(['abc', 'ddc', '123'],'100')
print(new_dict)
结果：
{'abc': '100', 'ddc': '100', '123': '100'}
（2）.in
- key in 字典：判断字典中是否存在指定的key
dog_dict = {'color': 'white', 'age': 3, 'type': '土狗'}
print('color' in dog_dict)
print('white' in dog_dict)
结果：
True
False
（3）.update
- 字典1..update（字典2）：使用字典2的键值对去更新字典1中的键值对。如果字典2中对应键值对在字典1中不存在，就添加。不存在就修改键值对中的值。
dict1 = {'1': 'a', '2': 's'}
dict1.update({'1': 'aaa', '3': 'ccc'})
print(dict1)
结果：
{'1': 'aaa', '2': 's', '3': 'ccc'}
集合
集合也是一种容器类型的数据类型（序列）；数据放在｛｝中，多个之间只用逗号隔开：｛1，2，‘a’｝
集合是无序的（不能通过索引取取值），可变（可以增删改）， 元素不能重复
集合可以进行数学中集合相关的操作：
- 怎么声明集合
a. 声明一个变量，赋一个集合值
set1 = {1, 2, 3}
print(set1)
结果：
{1, 2, 3}
b. 将其他的数据转换成集合
set2 = set('abc1233s') #将其他数据转换成集合，自带一个去重的功能
print(set2)
set3 = set([12, 'abc', 'hh', 32, 12, 'abcs'])
print(set3)
print(list(set3))
结果：
{'2', 'b', '1', 's', 'a', '3', 'c'}
{32, 'abcs', 'abc', 12, 'hh'}
[32, 'abcs', 'abc', 12, 'hh']
- 增删改查
a. 查：遍历
- 注意：集合没有办法单独获取某一个元素
for item in set2:
print(item)
结果：
2
b
1
s
a
3
c
b. 增加
# 集合.add（元素）：在指定的集合中添加指定的元素
set1 = {1, 2, 3}
set1.add(100)
print(set1)
# 集合1.update（集合2）：将集合2中的元素添加到集合1中，自动去重
set1.update({'abs','dd'})
print(set1)
结果：
{1, 2, 3, 100}
{'dd', 1, 2, 3, 100, 'abs'}
c. 删除
# 集合.remove（元素）：在指定的集合中删除指定的元素
set1.remove('dd')
print(set1)
# pop删除是随机删除一个
set1.pop()
print(set1)
结果：
{1, 2, 3, 100, 'abs'}
{2, 3, 100, 'abs'}
- 判断是否包含
- 集合1 >= 集合2 --判断集合1中是否包含集合2
- 集合1 <= 集合2 --判断集合2中是否包含集合1
print({1, 2, 3, 4} >= {1, 4}) #True
print({1, 2, 3, 4} <= {1, 2}) #False
- 数学的集合运算
# 求并集：|
print({1,2,3,4} | {2,3,3,4,5,6,7})
# 求交集：&
print({1,2,3,4}&{4,3,2,5})
# 求差集： -
print({1,2,3,4}-{1,4,5})
# 求补集：^
print({1,2,3}^{2,3,4,5})
结果：
{1, 2, 3, 4, 5, 6, 7}
{2, 3, 4}
{2, 3}
{1, 4, 5}
- 其他方法
# clear：清空集合
set1.clear()
print(set1, type(set1))
# len:获取集合中元素的个数
print(len(set1))
结果：
set()
5