1、列表的常用方法
sort()的用法
l = [1, 2, 3, 4, 5, 6, 7] l.sort() # 排序 默认情况下是从小到大(升序) l1 = [43,6,1,7,99] l1.sort(reverse=True) # 可以通过指定参数来修改默认的拍讯规则(降序) print(l1) # [99, 43, 7, 6, 1]
总结：列表能存多个值，内部元素是有序的，列表是可变数据类型
PS：队列和堆栈
# 队列 先进先出 l1 = [] # 先进 l1.append('first') l1.append('second') l1.append('third') # 先出 print(l1.pop(0)) # first print(l1.pop(0)) # second print(l1.pop(0)) # third # 堆栈 先进后出 # 先进 l1.append('first') l1.append('second') l1.append('third') # 后出 print(l1.pop()) # third print(l1.pop()) # second print(l1.pop()) # first
2、元组及其常用方法
1、定义：与列表类型比，只不过[]换成()
可以写成：age=(11,22,33,44,55)，本质age=tuple((11,22,33,44,55))
2、作用：能够存储多个元素，元素与元素之间逗号隔开。元组中的元素可以是任意类型，元组不能被修改
3、优先掌握的操作
1、按索引取值(正向取+反向取)：只能取
t = (1, 2, 3, 'a', 'b', [1, 2, 3]) print(t[0]) t[1] = 'hahah' t[-1] = 'hahaha' t[-1][0] = '我改了' print(t) del t[0] print(t)
2、切片(顾头不顾尾，具体操作与列表一样）
t = (1, 2, 3, 'a', 'b', [1, 2, 3]) print(t[::2])
3、长度len(具体操作与列表一样）
t = (1, 2, 3, 'a', 'b', [1, 2, 3]) print(len(t)) # 6
4、成员运算in和not in(具体操作与列表一样）
t = (1, 2, 3, 'a', 'b', [1, 2, 3]) print('a' in t) # True
5、循环
t = (1, 2, 3, 'a', 'b', [1, 2, 3]) for i in t: print(i) # 1 2 3 a b [1,2,3]
6、cuont和index
具体使用和列表、字符串中的使用一样。count对相同的元素进行计数；index查找元素是若找到元素则返回元素的索引，反之返回报错
t = (1, 2, 3, 'a', 'b', [1, 2, 3]) print(t.count('a')) # 1 print(t.index('xxx')) # 报错
4、元组总结：元组能存多个值，内部存储的值是有序的，元组是不可变数据类型
t2 = (1, 2, 3, 4, [1, 2]) print(id(t2)) # 1454472798896 t2[-1].append(666) print(t2) # (1, 2, 3, 4, [1, 2, 666]) print(id(t2)) # 1454472798896
3、字典的常用方法
1、定义：能存存储多组 key:value键值对 key是对value的描述 key通常情况下都是字符串其实这个key只能是不可变类型,value可以是任意数据类型
d = {'name':'jason','password':123} # d = dict( {'name':'jason','password':123})
d1 = {1:'1',0:'0',1.11:'1.11',(1,2):'到底能不能呢?'}
print(d1[1.11]) # 1.11
print(type(d1)) # dict
print(d1[(1,2)]) # 到底能不能呢？
d2 = {'name':'jason','name':'tank','name':'nick','password':123}
# print(len(d2))
# print(d2)
# 强调:字典的key是不能重复的 要唯一标识一条数据
# 如果重复了 只会按照最后一组重复的键值对存储
定义字典的三种方法：
# 掌握 # 1 d1 = {'name':'jason','password':123} # 2 # 掌握 d2 = dict(name='jason',password=123,age=18) # (******) print(d2,type(d2)) # 3 # 了解即可 l = [ ['name','jason'], ['age',18], ['hobby','read'] ] d = {} for k,v in l: # ['name','jason'],['age',18]... d[k] = v d3 = dict(l) print(d3)
2、优先掌握的操作
1、按key存取值：可存可取
d3 = {"name": "jason", "age": 18}
print(id(d3)) # 1968293842448
print(d3["name"]) # jason
d3["name"] = "alex"
print(d3["name"]) # alex
d3["pwd"] = "123" # 赋值语句当key不存在的情况下，会自动新增一个键值对
print(d3, id(d3)) # {'name': 'alex', 'age': 18, 'pwd': '123'} 1968293842448
2、长度len：统计的键值对的个数
3、成员运算in和not in 对于字典来说只能判断key值
d3 = {'name':'jason','password':'123'}
print('123' in d3) # False
print('name' in d3) # True
4、删除
del和pop的使用和李彪中大致相同，不过字典中的pop利用key弹出value，当键不存在是直接报错。
d3 = {'name':'jason','password':'123'}
del d3['name']
print(d3) # {'password':'123'}
res1 = d3.pop('name') # 弹出仅仅是value
res2 = d3.pop('age') # 当键不存在的时候直接报错
print(res1) # jason
print(res2) # 报错
print(d3) # {'password':'123'}
d3.clear() # 清空
print(d3) # {}
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.get("name")) # jason
print(d1.get("pwd")) # 123
print(d1.get("xxx")) # None 当key不在字典中时返回None
# 可以在get中添加第二个参数，不管key在不在字典中，都返回所给的参数
print(d1.get('name','你给我的name在字典的key中')) # 你给我的name在字典的key中
print(d1.get('xxx','你给我的xxx不在字典的key中')) # 你给我的xxx不在字典的key中
6、dict.fromkeys()，dict.popitem()，dict.update()
# dict.fromkeys() 快速创建字典 l1 = 'name', 'password', 'age', 'hobby' print(dict.fromkeys(l1, 123)) # {'name': 123, 'password': 123, 'age': 123, 'hobby': 123} l1 = ('name', 'password', 'age', 'hobby') print(dict.fromkeys(l1, 123)) # {'name': 123, 'password': 123, 'age': 123, 'hobby': 123} l1 = 'name' print(dict.fromkeys(l1, 123)) # {'n': 123, 'a': 123, 'm': 123, 'e': 123}
# l1可以为一个可迭代的对象，例如字符串、列表、字典，列表和字典中的元素必须为不可变数据类型
# 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) # {'name': 'jason', 'pwd': 123} jason res2 = d1.setdefault('age', 18) # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你 print(d1, res2) # {'name': 'jason', 'pwd': 123, 'age': 18} 18
d1 = {'name': 'jason', 'pwd': 123}
d2 = {"num": 18}
d1.update(d2)
print(d1) # {'name': 'jason', 'pwd': 123, 'num': 18} 当key不存在时，添加新的键值对
d1.update(num=666)
print(d1) # {'name': 'jason', 'pwd': 123, 'num': 666} 当key存在时更新value
d1.update(age=666)
print(d1) # {'name': 'jason', 'pwd': 123, 'num': 18, 'age': 666} 当key不存在时，添加新的键值对
7、循环
字典中的for循环打印得到是键key
d1 = {'name': 'jason', 'password': 123}
for i in d1:
print(i) # name password
3、字典总结：字典可以存储多个值，字典内部的元素是没有顺序的，字典是可变数据类型
4、集合及其常用的方法
1、什么是集合：群体间作比较，不涉及单个元素
1、集合的作用：可以用来去重，做一些关系比较
2、集合的类型
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
s = {1,2,3,4,5,6} # <class 'set'> # s = set()
3、集合的三个原则
1、每个元素必须是不可变类型
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]) # TypeError: 'set' object does not support indexing
# 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
4、优先掌握的操作
1、长度len
s = {1, 2, 3, 4}
print(len(s)) # 4
2、成员运算in和not in（与列表、字符串中的成员运算方法相同），若查询的元素在集合中则返回True，反之返回False。
3、|合集
# 取出所有报了名的学生姓名
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
print(pythons | linux) # {'tank', 'alex', 'frank', 'nick', 'egon', 'jerry', 'kevin', 'jason', 'owen'}
4、&交集
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
# 既报名python也报名linux的学生姓名
print(pythons & linux) # 交集 {'tank', 'egon', 'alex'}
5、-差集
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
# 只报名linux的学生姓名
print(linux - pythons) # {'jerry', 'frank'}
6、^对称差集
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
# 没有同时报名两门课程的学生姓名
print(pythons ^ linux) # 对称差集 {'jerry', 'frank'}
7、==
s = {1, 2, 3}
s1 = {3, 1, 2}
print(s == s1) # True
8、父集：>,>=
s1 = {1, 2, 3, 4, 55}
s2 = {1, 2, 666}
s3 = {1, 2}
print(s1 > s2) # False
print(s1 > s3) # True
9、子集：<,<=：具体用法和父集相同
s1 = {1, 2, 3, 4, 55}
s2 = {1, 2, 666}
s3 = {1, 2}
print(s2 < s1) # False
print(s3 < s1) # True
PS：
issubset()：判断是否是子集
issuperset()：判断是否是父集
2、集合总结：集合中每个元素必须是不可变类型，且没有重复的元素，元素都是无序的，集合本身是个可变数据类型。
5、数据类型总结
总共有八种数据类型，分别为int、float、str、list、dict、bool、tuple、set。
可分为可变数据类型和不可变数据类型两大类：
可变数据类型：list、dict、set
不可变数据类型：int、float、str、tuple、bool