目录
一、列表
1、列表的格式
[数据1，数据2，数据3....]
列表可以一次性存储多个数据，且可以为不同的数据类型。
2、列表的查找
- 通过下标查找
name_list = ['Tom','Lily','Rose']
print(name_list[0]) #Tom
print(name_list[2]) #Rose- index()：返回指定数据所在位置的下标。
- count()：统计指定数据在当前列表中出现的次数。
- len()：访问列表长度，即列表中数据的个数。
# 列表.index(数据,开始位置下标,结束位置下标)
print(name_list.index('Lily',0,2)) #1 返回指定数据所在位置下标,若不存在则报错
print(name_list.count('Lily')) #1 统计指定数据出现次数
print(len(name_list)) #3 访问列表长度- 判断是否存在
- in：判断指定数据在某个列表序列，如果在返回True，否则返回False
- not in：判断指定数据不在某个序列，如果不在返回True，否则返回False
#判断数据是否存在列表中
print('Lily' in name_list) #True
print('Lily' not in name_list) #False3、增加
- append()：列表结尾追加数据。
- extend()：将指定的列表元素（或任何可迭代的元素）添加到当前列表的末尾。
- insert()：指定位置新增数据。
name_list = ['Tom','Lily','Rose']
# append()
name_list.append('Jerry')
print(name_list) #['Tom', 'Lily', 'Rose', 'Jerry']
#如果列表追加的是一个序列，则将整个序列追加到列表中。
name_list.append(['a', 'b'])
print(name_list) #['Tom', 'Lily', 'Rose', 'Jerry', ['a', 'b']]
#entend()
name_list.extend(['c','d'])
print(name_list) #['Tom', 'Lily', 'Rose', 'Jerry', ['a', 'b'], 'c', 'd']
#insert()
# 列表.insert(位置下标，数据)
name_list.insert(1,'xing')
print(name_list) #['Tom', 'xing', 'Lily', 'Rose', 'Jerry', ['a', 'b'], 'c', 'd']列表在追加数据的时候，直接追加在原列表中，故列表是可变类型
4、删除
- del
- pop()：删除指定下标的数据(默认为最后一个)，并返回该数据。
- remove():移除列表中某个数据的第一个匹配项。
- chear():清空列表
name_list = ['Tom','Lily','Rose']
#del
# 删除列表
del name_list
print(name_list) #报错提示：NameError: name 'name_list' is not defined
#删除列表指定数据
del name_list[0]
print(name_list) #['Lily', 'Rose']
# pop 列表.pop(下标）
del_name = name_list.pop(1)
print(del_name) #Lily
print(name_list) #['Tom', 'Rose']
#remove() 列表.remove(数据)
name_list.remove('Rose')
print(name_list) #['Tom', 'Lily']
#clear()：清空列表
name_list.clear()
print(name_list) #[]5、修改
- 通过下标修改
- 逆置：reverse()
- 排序：sort()
name_list = ['Tom', 'Lily', 'Rose']
#通过下标修改
name_list[0] = 'aaa'
print(name_list) #['aaa', 'Lily', 'Rose']
#reverse() 逆置
name_list.reverse()
print(name_list) #['Rose', 'Lily', 'aaa']
#sort() 排序
#列表.sort(key=None,reverse=False)
#reverse表示排序规则 ，True降序，False升序
num_list = [2,4,3,6,7,9,1,5,8]
num_list.sort()
print(num_list) #[1, 2, 3, 4, 5, 6, 7, 8, 9]6、复制：copy()
name_list = ['Tom', 'Lily', 'Rose']
copy_list = name_list.copy()
print(copy_list) #['Tom', 'Lily', 'Rose']7、列表的循环遍历
name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
print("---"*5)
for i in name_list:
print(i)执行结果：
8、列表嵌套
列表嵌套是指一个列表中包含其他子列表。
name_list = [["小明","小兰","小红"],["Tom","Lily","Rose"],["张三","李四","王五"]]
name_list = [2][1] #李四9、应用 -- 随机分配办公室
""" 随机分配办公室 """
offices = [[], [], []]
teachaer = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
for i in teachaer:
r = random.randint(0, 2)
offices[r].append(i)
for office in offices:
print("有%s个老师分别是:"%len(office))
for i in office:
print(i,end=" ")
print()二、元组
元组可以存储多个数据，元组内的数据是不能修改的，属于不可变类型。
1、定义元组
定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型
2、查找
- 按下标查找
- index() ：查找某个数据，数据存在返回对应下标，数据不存在报错 与字符串的index方法相同
- count() ：统计某个数据出现次数
- len() ：统计元组中数据的个数
tuple1 = ('aa','bb','cc','bb')
#按下标查找
print(tuple1[1]) #bb
#index()
print(tuple1.index('cc')) #2
#count()
print(tuple1.count('bb')) #2
#len()
print(len(tuple1)) #4ps：元组内的数据直接修改报错，但是如果元组内有列表修改列表数据则支持。
tuple2 = (10,20,['Tom','Lily'],30,40)
tuple2[2][0] = 'aaaa'
print(tuple2) #(10, 20, ['aaaa', 'Lily'], 30, 40)三、字典
字典可以进行修改，所有字典是可变类型
1、创建字典
字典的特点：
- 符号为大括号
- 数值以键值对形式出现
- 各键值对之间由逗号隔开
#有数据字典
dict1 = {'name':'Tom','age':20,'gender':'男'}
#空字典
dict2 = {}
dict3 = dict()冒号前面的为键（key），简称k ；冒号后面的为值（value），简称v。
2、增加
字典[key] = 值
如果key存在则修改这个key对应的值，如果key不存在则新增此键值对。
dict1 = {'name':'Tom','age':20,'gender':'男'}
dict1['name'] = 'Lily'
print(dict1) #{'gender': '男', 'age': 20, 'name': 'Lily'}
dict1['id'] = 1
print(dict1) #{'gender': '男', 'age': 20, 'name': 'Lily', 'id': 1}3、删除
- del() / del ：删除字典或删除字典中指定键值对。
- chear() ：清空字典
#删除
del dict1['gender']
print(dict1) #{'age': 20, 'name': 'Tom'}
dict1.clear()
print(dict1) #{}4、修改
字典[key] = 值
注：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
5、查找
- 通过key值查找 ，若查找的key存在，则返回对应的值，否则报错。
- get()
- keys()
- values()
- items()
#查找
#key值查找
print(dict1['name']) #Tom
print(dict1['age']) #20
#get()
#字典.get(key,默认值)
print(dict1.get('name')) #Tom
print(dict1.get('id',100)) #100 当前查找key不存在则第二个参数(默认值)
print(dict1.get('id')) #None 如果省略第二个参数，则返回None
#keys()
print(dict1.keys()) #dict_keys(['age', 'gender', 'name'])
#values()
print(dict1.values()) #dict_values([20, '男', 'Tom'])
#items()
print(dict1.items()) #dict_items([('age', 20), ('gender', '男'), ('name', 'Tom')])
6、字典的循环遍历
dict1 = {'name':'Tom','age':20,'gender':'男'}
# 遍历字典的key
print("----遍历字典的key----")
for key in dict1.keys():
print(key)
# 遍历字典的value
print("----遍历字典的value----")
for value in dict1.values():
print(value)
# 遍历字典的元素
print("----遍历字典的元素----")
for item in dict1.items():
print(item)
# 遍历字典的键值对
print("----遍历字典的键值对----")
for key,value in dict1.items():
print("%s = %s" %(key,value))
执行结果：
四、集合
1、创建集合
创建集合使用 { } 或者set( ) , 但是如果要创建空集合只能使用set()，因为{ }用户创建字典。
s1 = {1,2,3,4,5,4}
print(s1) #{1, 2, 3, 4, 5}
s2 = set()
print(type(s2)) #<class 'set'>
s3 = {}
print(type(s3)) #<class 'dict'>集合的特点：
- 集合可以去掉重复数据；
- 集合数据是无序的，故不支持下标
2、增加
- add()
- update()：追加的数据为序列
s1 = {10,20,30}
#增加
#add()
s1.add(40)
s1.add(10)
print(s1) #{40, 10, 20, 30}
#update()
s1.update([100,200])
s1.update('abcd')
print(s1) #{100, 40, 200, 10, 'a', 'b', 'c', 'd', 20, 30}集合有去重功能，所有当向集合追加数据是当前集合已有数据的话，则不进行任何操作。
3、删除
- remove()：删除集合中的指定数据，如果数据不存在则报错。
- discard()：删除集合中的指定数据，如果数据不存在也不会报错。
- pop()：随机删除集合中的某个数据，并返回这个数据。
#删除
#remove()
s1.remove(10)
print(s1) #{40, 50, 20, 60, 30}
s1.remove(10)
print(s1) #报错：KeyError: 10
#discard()
s1.discard(30)
print(s1) #{40, 50, 20, 60}
s1.discard(30)
print(s1) #{40, 50, 20, 60}
#pop()
del_num = s1.pop()
print("s1:%s"%s1) #s1:{50, 20, 60}
print("del_num:%s"%del_num) #del_num:404、查找
- in：判断数据在集合中
- not in：判断数据不在集合中
s1 = {10, 20, 30, 40, 50, 60}
print(10 in s1) #True
print(10 not in s1) #False可变类型与不可变类型
可变数据类型：list（列表）、dict（字典）、set（集合）
不可变数据类型：数值类型、string（字符串）、tuple（元组）
五、公共操作
1、运算符
| 运算符 | 描述 | 支持容器类型 |
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典 |
- +
# +
#字符串
str1 = 'aa'
str2 = 'bb'
print(str1 + str2) #aabb
#列表
list1 = [1,2]
list2 = [10,20]
print(list1 + list2) #[1, 2, 10, 20]
#元组
set1 = (1,2)
set2 = (10,20)
print(set1 + set2) #[1, 2, 10, 20]- *
#*
#字符串
print("-" * 10) # ----------
#列表
list1 = ['Hello']
print(list1 * 5) #['Hello', 'Hello', 'Hello', 'Hello', 'Hello']
#元组
set1 = ['Python']
print(set1 * 5) #['Python', 'Python', 'Python', 'Python', 'Python']- in 、 not in
# in 、 not in
#字符串
str1 = "abcd"
print('a' in str1) #True
print('a' not in str1) #False
#列表
list1 = ['a','b','c','d']
print('a' in list1) #True
print('a' not in list1) #False
#元组
set1 = ('a','b','c','d')
print('a' in set1) #True
print('a' not in set1) #False
#字典
dict1 = {'a':1 , 'b':2 ,'c':3}
print('a' in dict1) #True
print('a' not in dict1) #False 2、公共方法
| 函数 | 描述 |
| len() | 计算容器中元素个数 |
| del 或者 del() | 删除 |
| max() | 返回容器中元素最大值 |
| min() | 返回容器中元素最小值 |
| range(start , end , step) | 生成从start到end的数字，步长为step，供for循环只用 |
| enumerate() | 函数用于将一个可遍历的数据对象(如：列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用于for循环 |
- enumerate(可遍历对象，srart=0)
注：start参数用来设置遍历数据下标起始值，默认为0
list1 = ['a','b','c','d','e','f']
for i in enumerate(list1):
print(i)
for index,i in enumerate(list1,start=2):
print("下标为：%s ，对应字符为:%s"%(index,i))执行结果：
3、容器类型转换
- tuple()：将某个序列转换为元组
- list()：将某个序列转换为列表
- set()：将某个序列转换为集合 （集合可以快速完成去重，集合不支持下标）
六、推导式
1、列表推导式
[xx for xx in range()]
# 需求：创建一个0-10的列表
#for循环实现
list1 = []
for i in range(11):
list1.append(i)
print(list1)
#列表推导式
list1 = [i for i in range(11)]
print(list1)
# 需求：创建一个0-10的偶数列表
list1 = [i for i in range(0,11,2)]
print(list1)
list2 = [i for i in range(11) if i % 2 ==0]
print(list2)
#多个for循环实现列表推导式
#创建[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]
list1 = [(i,j) for i in range(1,3) for j in range(3) ]
print(list1)2、字典推导式
[xx1:xx2 for ... in ...]
#需求：字典key为1-5数字，value是这个数字的2次方
dict1 = {i:i**2 for i in range(1,6)}
print(dict1)
#需求：两个列表合并为一个字典
list1 = ['name','age','gender']
list2 = ['Tom',10,'男']
dict1 = {list1[i]:list2[i] for i in range(len(list1))}
print(dict1)
#需求：提取字典中的大于100的数据
counts = {'MBP':268,'HP':123,'DELL':201,'Lenovo':199,'acer':99}
count1 = {key:value for key,value in counts.items() if value>=200}
print(count1)3、集合推导式
[xx for xx in ...]
# 创建一个集合，数据为下方列表的2次方
list1 = [1,1,2]
set1 = {i**2 for i in list1}
print(set1) #{1, 4}
7876
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
