一、列表及其常用内置方法
l = [1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 7]
print(l.count(1)) # 计数 记录一个元素在列表中出现的次数
l.clear()
print(l) # 清除列表中的所有元素,无返回值
l = [1, 2, 3, 4, 5, 6, 7]
print(id(l))
l.reverse() # 将列表中的元素翻转,直接修改列表
print(l)
print(id(l))
l = [12, 2, 5, 1, 89, 1002, 684]
l.sort()
print(l)
# 将列表中的数字排序,默认从小到大排序
l.sort(reverse=True)
print(l)
# 通过指定参数来修改默认的排序规则(降序)
# 模拟队列 先进先出
l1 = []
# 先进
l1.append('first')
l1.append('second')
l1.append('third')
# 先出
print(l1.pop(0))
print(l1.pop(0))
print(l1.pop(0))
# 模拟堆栈 先进后出
l1 = []
# 先进
l1.append('first')
l1.append('second')
l1.append('third')
# 后出
print(l1.pop())
print(l1.pop())
print(l1.pop())
二、元组及其常用内置方法
# 作用:能够存储多个元素,元素与元素之间逗号隔开 元素可以是任意类型,元组不能被修改
# 定义:与列表类型比,只不过[]换成()
age = (11, 22, 33, 44, 55) # 本质age=tuple((11,22,33,44,55))
# 优先掌握的操作:
# 1、按索引取值(正向取+反向取),只能取
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(t[0])
t[1] = 'hahah' # 报错
t[-1][0] = 'hahah' # 不报错
# 元组是不可变类型,但是如果元组内部有可变类型数据如list、dict、set等,这些元素内部的值是可以改变的
del t[0] # 报错
# 2、切片(顾头不顾尾,步长)
print(t[::2])
# 3、长度
print(len(t))
# 4、成员运算in和not in
print('a' in t)
# 5、循环
for i in t:
print(i)
三、字典及其内置方法
# 作用:能存存储多组 key:value键值对 key是对value的描述 key通常情况下都是字符串
# 其实这个key只能是不可变类型,value可以是任意数据类型
d1 = {1: '1', 0: '0', 1.11: '1.11', (1, 2): '到底能不能呢?'}
# 定义:
d = {'name': 'jason', 'password': 123} # d = dict( {'name':'jason','password':123})
d2 = {'name': 'jason', 'name': 'tank', 'name': 'nick', 'password': 123}
print(d2) # 输出{'name': 'nick', 'password': 123}
# 强调:字典的key是不能重复的 要唯一标识一条数据
# 如果重复了 只会按照最后一组重复的键值对存储
# 优先掌握的操作:
# 1、按key存取值:可存可取
d3 = {'name': 'jason', 'password': '123'}
print(d3['name'])
d3['name'] = 'egon'
print(d3) # {'name': 'egon', 'password': '123'}
# d3['age'] = 18 # 赋值语句当key不存在的情况下,会自动新增一个键值对(******)
print(d3, id(d3))
# 2、长度len
# 统计键值对的个数
# 3、成员运算in和not in 对于字典来说只能判断key值
d3 = {'name': 'jason', 'password': '123'}
print('123' in d3) # False
print('name' in d3) # True
# 4、删除
d3 = {'name': 'jason', 'password': '123'}
del d3['name']
print(d3) # {'password': '123'}
res = d3.pop('name')
print(res) # jason 弹出仅仅是value
res = d3.pop('age') # 当键不存在的时候直接报错
d3.clear() # 清空元素
print(d3)
# 定义字典的三种方式
# 掌握
d1 = {'name': 'jason', 'password': 123}
d2 = dict(name='jason', password=123, age=18) # (******)
# 了解即可
l = [
['name','jason'],
['age',18],
['hobby','read']
]
d = {}
# for i in l: # ['name','jason'],['age',18]...
for k, v in l: # ['name','jason'],['age',18]... 这里相当于k,v=['name','jason'] 解压赋值操作
# d[i[0]] = i[1]
d[k] = v
print(d) # {'name': 'jason', 'age': 18, 'hobby': 'read'}
l = [
['name','jason'],
['age',18],
['hobby','read']
]
d3 = dict(l)
print(d3) # {'name': 'jason', 'age': 18, 'hobby': 'read'}
# 5、键keys(),值values(),键值对items()
d1 = {'name': 'jason', 'password': 123}
print(d1.keys()) # dict_keys(['name', 'password']) 老母猪
# for k in d1.keys():
# print(k)
print(d1.values()) # dict_values(['jason', 123]) 老母猪 现在就把它当成一个列表来看即可
print(d1.items()) # dict_items([('name', 'jason'), ('password', 123)])
# 就把它看成是列表套元组,元组的第一个元素是字典的key 第二个元素是字典的value
# get()根据key获取value(*******************************)
d1 = {'name': 'jason', 'pwd': 123}
print(d1['name'])
print(d1['age']) # 报错 不存在该key值
print(d1.get('name', '你给我的name在字典的key中')) # 即使key不存在也不会报错
res = d1.get('age') # 当字典的key不存在的情况 不报错 返回None
res1 = d1.get('xxx', '你给我的age在字典的key中') # 当字典的key不存在的情况 不报错 返回None
print(res1) # 输出 你给我的age在字典的key中
# get可以传第二个参数。当你的key不存在的情况下,返回第二个你写好的参数信息
print(d1.get('xxx', 'asdsad')) # 输出 asdsad
# 第二个参数不写的话 当key不存在的情况下返回None,写了就返回写的内容
# dict.fromkeys() # 快速的创建一个字典
l1 = ['name', 'password', 'age', 'hobby']
print(dict.fromkeys(l1, 123))
# {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
# dict.popitem()
d1 = {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
print(d1.popitem()) # 尾部以元组的形式弹出键值对 ('hobby', 123)
dict.setdefault()
d1 = {'name': 'jason', 'pwd': 123}
res1 = d1.setdefault('name', 'xxoo') # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1, res1)
res2 = d1.setdefault('age', 18) # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1, res2)
# {'name': 'jason', 'pwd': 123} jason
# {'name': 'jason', 'pwd': 123, 'age': 18} 18
# dict.update()
d1 = {'name': 'jason', 'pwd': 123}
d2 = {"age": 18}
d1.update(d2)
print(d1) # {'name': 'jason', 'pwd': 123, 'age': 18}
# 只添加一个元素,用赋值同样可以实现
d1['age'] = 18
print(d1) # {'name': 'jason', 'pwd': 123, 'age': 18}
# 另一种方式
d1.update(age=666, message='hahah')
print(d1)
# 6、循环
d1 = {'name': 'jason', 'password': 123}
for i in d1:
print(i)
四、集合及其内置方法
# 定义:
# 集合:可以包含多个元素,用逗号分割
s = {1, 2, 3, 4, 5, 6} # <class 'set'> # s = set()
print(type(s))
s1 = set()
print(type(s1)) # 注意在定义空集合的只能用关键字set
x = {} # <class 'dict'> 如果你仅仅只写了一个大括号 那么python默认将它当做字典类型
print(type(x))
# 集合的元素遵循三个原则:
# 1:每个元素必须是不可变类型
# 可变:不可hash
# 不可变:可hash
s = {1, 2, 3, 4, 5, 6, 'a', (1, 2), [1, 2]} # 报错
s = {1, 2, 3, 4, 5, 6, 'a', (1, 2), {"name": 'jason'}} # 报错
# 2: 没有重复的元素
s = {1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5}
print(s) # 自动将重复的元素去除 {1, 2, 3, 4, 5}
# 3:无序
s = {1, 2, 3, 4, 5, 6}
print(s[1]) # 报错,无法通过索引取值
# 注意集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值
# 优先掌握的操作:
# 1、长度len
# 2、成员运算in和not in
# 3、|合集
# 4、&交集
# 5、-差集
# 6、^对称差集
# 7、==
# 8、父集:>,>=
# 9、子集:<,<=
# 1、长度len
s = {1, 2, 3, 4}
print(len(s))
# 2、成员运算in和not in
s = {1, 2, 3, 4}
print(1 in s) # True
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
# 既报名python也报名linux的学生姓名
print(pythons & linux) # 交集
# 只报名python的学生姓名
print(pythons - linux)
# 只报名linux的学生姓名
print(linux - pythons)
# 没有同时报名两门课程的学生姓名
print(pythons ^ linux) # 对称差集
# 取出所有报了名的学生姓名
print(pythons | linux)
s = {1, 2, 3, 4, 5}
print(s.add(666))
print(s.add((1, 2, 3, 4))) # 将容器类型也当成一个元素传入
print(s.remove(1))
print(s) # 移除的元素不在集合中时会报错
print(s.discard(888888888))
print(s) # 移除的元素不在集合中时不会报错