列表补充
补充方法
清空列表 clear
# clear 清空列表 l = [1, 2, 3, 4, 4] print(l.clear()) # clear没有返回值(None) print(l) # None # []
统计列表中指定元素出现的次数 count
# count 统计一个元素在列表中出现了几次 l = [1, 2, 3, 4, 4] print(l.count(4)) # 2
列表反向、排序 reverse sort(带参数,可指定按正序/ 反序排)
# reverse 将列表翻转 l = [1, 2, 3, 4, 4, 2] print(l.reverse()) # reverse没有返回值(None) print(l) # None # [2, 4, 4, 3, 2, 1] # sort 排序,默认从小到大排序 l = [1, 2, 3, 4, 4, 2] print(l.sort()) # sort没有返回值(None) print(l) # None # [1, 2, 2, 3, 4, 4] l = [1, 2, 3, 4, 4, 2] print(l.sort(reverse=True)) # sort可以指定参数来确定排序规则 print(l) # None # [4, 4, 3, 2, 2, 1] # 可以排序字符串、标点符号、数字(混排注意点,可能报错) l = list('dasb41564s5.*/-^&#$84') # l.append(1.1) # 包含浮点型的时候不可以排 print(l.sort()) # sort方法可以将列表元素按ASCII码排序 print(l) # None # ['#', '$', '&', '*', '-', '.', '/', '1', '4', '4', '4', '5', '5', '6', '8', '^', 'a', 'b', 'd', 's', 's']
总结
# ------- 列表总结 --------- # 能存多个值 # 有序的 # 可变类型
# 队列:先进先出 (排队)
# 堆栈:先进后出 (叠书、叠衣服 拿出来)
元组
简介
# 作用:能存储多个元素 # 定义:与列表一致,只不过把 [] 变成了 () # 特点 # 能存多个值 # 有序(能用索引取值) # 不可变,不可以改值,不可以加值,删值 # 只能看不能改的场景,推荐用元组 # 存相同的数据,列表比元组占的空间更多(列表多出来的那堆方法也会占很多空间)
内置方法
定义元组
t = (1, 2, 3, 4) # tuple((1, 2, 3, 4)) print(type(t)) # <class 'tuple'> t = tuple(1) # 报错,内部基于for循环,必须传容器类型 print(type(t)) # 定义元组时如果只有一个元素,也得加上 , 逗号 不然会被python 解释成 其他类型 t = (1) print(type(t)) # <class 'int'> t = (1, ) print(type(t)) # <class 'tuple'> t = ('a') print(type(t)) # <class 'str'> t = ('a', ) print(type(t)) # <class 'tuple'>
验证是否可变类型 --->不可变类型
t2 = (1, 2, 3, [1, 2, 3]) print(id(t2)) # 2270010972424 t2[3][0] = 666666 print(t2) print(id(t2)) # (1, 2, 3, [666666, 2, 3]) # 2270010972424 # ---> 内存地址不变,所以他是不可变类型
索引取值
# 索引取值 可取不可改 t = (2, 3, 4) print(t[0]) # t[0] = 4 # TypeError: 'tuple' object does not support item assignment 元组的元素不可以改(如果元素是可变类型,那么可以改) t = (2, 3, 4, [5, 6, 7]) t[3][0] = '我改了' # 不报错,因为改的是列表(具体看原理图(内存指向,实际元组没有改动)) print(t) # (2, 3, 4, ['我改了', 6, 7])
切片
# 切片,顾头不顾尾 暂不举例,与列表和字符串一样的用法
元组中的元素个数 len
# 元组中的元素个数 len, 获取元素的个数 暂不举例,与列表一样的用法
成员运算 in / not in
# 成员运算 in / not in 暂不举例,与列表一样的用法
作为循环的迭代器对象 for in
# 作为循环的迭代器对象 for ... in ...: 暂不举例,与列表一样的用法
统计某个元素在元组中出现的次数 count
# count 统计某个元素在元组中出现的次数 t = ('hello', 'thank', 'you', 1, 1.1, ['hello', 3, 'thank'], 'thank', 'you', 'very', 'much') print(type(t)) print(t.count('hello')) # 元素内部不管,只管第一层 print(t.count('thank')) # <class 'tuple'> # 1 # 2
获取元素的索引 index (找不到会报错)
# index 获取元素的索引(试试字符串类型的?) print(t.index('thank')) # 1 # print(t.index('your')) # 找不到值会报错 ValueError: tuple.index(x): x not in tuple # 可以用count 判断在不在里面(为0 则不在里面,为其他值则在),再用index 找该元素的索引
字典
简介
# 能存储多组key: value键值对,可存可取 # key是对value的描述,并且key 通常情况下都是字符串,其实这个key 只能是不可变类型,value可以是任意数据类型 # 字典的key 是唯一性标识,同一个字典中key 不能重复 # 如果重复了,只会按照最后一组键值对存储 # 无序 # 可变 # 不可变类型: 数字类型(int、float),字符串,元组 都可以作为字典的 key
内置函数
定义字典
d = {'name': 'jason', 'password': 123} # d = dict({'name': 'jason', 'password': 123}) d1 = {1: '1', 0: '0', 1.1: '1.1', 'string': 'string', (1, 2): '到底行不行呢?'} print(d1) print(type(d1)) # {1: '1', 0: '0', 1.1: '1.1', 'string': 'string', (1, 2): '到底行不行呢?'} # <class 'dict'> print(d1[1]) print(d1[1.1]) print(d1['string']) print(d1[(1, 2)]) # 1 # 1.1 # string # 到底行不行呢? # 定义字典的三种方式 # 1 直接定义 d1 = {'name': 'jason', 'password': '123'} # 2 ----> 通过关键字传参来定义 ***重点掌握(后期面向对象的时候好用)*** d2 = dict(name='jason', password=123, age=18) # 3 直接dict 类型转换 l = [ ['name', 'jason'], ['age', 18], ['hobby', 'read'] ] # 简便写法 d3 = {} d3 = dict(l) print(d3) # {'name': 'jason', 'age': 18, 'hobby': 'read'} # 上面写法的原理 d3 = {} for k, v in l: # ['name', 'jason'],['age', 18].... # 这里的 k,v 利用了解压赋值 d3[k] = v print(d3) # {'name': 'jason', 'age': 18, 'hobby': 'read'}
创建字典的其他方式 fromkeys (不怎么好用)
# fromkeys() 用来创造字典 d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.fromkeys('name')) # {'n': None, 'a': None, 'm': None, 'e': None} # 扩展用法 l = ['name', 'password', 'age', 'hobby'] dic = {} print(dic.fromkeys(l, 123)) # 快速创建字典,后续再去更改 # {'name': 123, 'password': 123, 'age': 123, 'hobby': 123} # 试试第二个参数也传列表
给字典中的指定键值对指定默认值 setdefault
# setdefault() d1 = {'name': 'jaoon', 'password': '123'} print(d1.setdefault('name', 'xxoo')) # 当键存在的情况下会返回该键的值 当键存在时不会改变字典的值 print(d1) print(d1.setdefault('age', 18)) # 当键不存在的情况下会给字典添加一个键值对(两个参数),并且会把新增的键值对的值返回 print(d1) # jaoon # {'name': 'jaoon', 'password': '123'} # 18 # {'name': 'jaoon', 'password': '123', 'age': 18}
更新字典的值(也可以添加键值对) update 和 直接通过 不存在的key 赋值的方式添加键值对(具体看下方例子)
# update() # 1 d1 = {'name': 'jaoon', 'password': '123'} d2 = {'age': 18} print(d1.update(d2)) print(d1) # None # {'name': 'jaoon', 'password': '123', 'age': 18} # 2 d1 = {'name': 'jaoon', 'password': '123'} print(d1.update(age=18)) print(d1) # None # {'name': 'jaoon', 'password': '123', 'age': 18} # 3 推荐直接这样写 -----------> !!!! 上面写法太麻烦,不如这个好用 d1 = {'name': 'jaoon', 'password': '123'} print(d1) d1['age'] = 18 print(d1) # {'name': 'jaoon', 'password': '123'} # {'name': 'jaoon', 'password': '123', 'age': 18}
获取字符串中键值对个数 len
dit2 = {'name': 'egon', 'name': 'jason', 'name': 'alex', 'age': 18} print(dit2) print(len(dit2)) # {'name': 'alex', 'age': 18} # 2
成员运算 in / not in (只能取到key 值)
# 成员运算 in/ not in 字典在for循环只暴露出 key, value无法取不到做成员运算 d3 = {'name': 'jaoon', 'password': '123'} print('123' in d3) print('password' in d3) # False # True
按key 取值 (类似列表中的索引取值 ---> 字典是无序的,字典中没有索引取值)
# 按key 存取值:可存可取 d3 = {'name': 'jaoon', 'password': '123'} print(id(d3)) # 2364215340992 print(d3['name']) # jaoon d3['name'] = 'egon' # 改的是指向,不是索引, 字典是无序的, key 重复了是替换的意思 d3['age'] = 18 # 赋值语句当key 不存在的情况下,会自动新增一个键值对 print(d3, id(d3)) # {'name': 'egon', 'password': '123', 'age': 18} 2364215340992
取值的其他方法 keys values items get
# 获取字典value的方法 ----》 keys values items 跟python2.x 产生的结果不同 (记得添加到笔记中去) # 1. 粗暴的循环获取(通过key ) # 字典的 keys() values() items() 方法在 python 2.x 和 3.x 中有区别,像老母猪 # 2. keys() d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.keys()) # dict_keys(['name', 'password', 'sex', 'salary']) ,像老母猪 for k in d1.keys(): print(k) # name # password # sex # salary # 3. values() 与上面类似 d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.values()) # dict_values(['jaoon', '123', 'gender', 16000]) for i in d1.values(): print(i) # jaoon # 123 # gender # 16000 # 4. items() 列表套元组,元组的第一个元素是字典的key , 第二个元素是字典的value d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.items()) # dict_items([('name', 'jaoon'), ('password', '123'), ('sex', 'gender'), ('salary', 16000)]) for i in d1.items(): print(i) # ('name', 'jaoon') # ('password', '123') # ('sex', 'gender') # ('salary', 16000) # 作为迭代器对象循环取值 # for i in ... # get() 根据key 获取 value, 可以传第二个参数,当传入的key 不存在,会返回(提示信息)该参数, 存在则会返回该key 对应的值, 第二个参数不写的话,key 不存在会返回None ,如果存在则会返回该key 对应的value # 推荐字典取值统一用 get ********** d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.get('name')) # jaoon print(d1.get('hahah')) # 当key 不存在时不会报错,返回None, 用 []取不存在的会直接报错 # None print(d1.get('name', '你给我的name 不在字典的key 中')) print(d1.get('hahah', '你给我的hahah 不在字典的key 中')) # jaoon # 你给我的hahah 不在字典的key 中
删除字典中的键值对或清空字典 del pop popitem clear
# 删除 # del d3 = {'name': 'jaoon', 'password': '123'} del d3['name'] print(d3) # {'password': '123'} # pop 传key, key 不存在会直接报错 d3 = {'name': 'jaoon', 'password': '123'} print(d3.pop('name')) # pop 返回的是value print(d3) # jaoon # {'password': '123'} # print(d3.pop('age')) # 当键不存在的时候,直接报错,KeyError: 'age' # popitem 不需要参数,弹出"最后"一个键值对 d3 = {'name': 'jaoon', 'password': '123'} print(d3.popitem()) print(d3) # ('password', '123') # {'name': 'jaoon'} print(d3.popitem()) # ('name', 'jaoon') # print(d3.popitem()) # 会报错,弹空了 # clear 清空字典 d3 = {'name': 'jaoon', 'password': '123'} print(d3.clear()) print(d3) # None # {}
集合
简介
# 群体之间作比较,不涉及单个元素 --> 推荐用集合 (见关系图,整理到博客里去) # 作用: 做关系运算: 共同好友、共同粉丝 ---> 涉及到共同,两个群体之间作比较 # 去重 # 可以定义多个元素,用逗号分隔 # 集合的元素必须遵循的三个原则 # 1:每个元素必须是不可变类型 # 可变: 不可hash # 不可变: 可hash ''' d = {[1, 2]: 'name'} # 会报错,不可hash TypeError: unhashable type: 'list' s = {1, 2, 1.1, 'string', (1, 2)} print('-----------', s) # ----------- {(1, 2), 1, 2, 1.1, 'string'} ''' # 2:没有重复的元素 ''' s = {1, 2, 3, 3, 4, 3} # 自动将重复的元素去除 print(s) # {1, 2, 3, 4} 将其他类型去重成集合,再想办法转回去 l = ['jason', 'egon', 'jason'] s = set() print(s.update(l)) print(s) # None # {'egon', 'jason'} ''' # 3:无序 ''' s = {1, 2, 3, 4, 5} print(s[1]) # 会直接报错,集合不支持索引取值 TypeError: 'set' object does not support indexing '''
内置函数
定义集合
# 定义集合 (跟字典很像,但它内部不是键值对) s = {1, 2, 3} # s = set({1, 2, 3}) print(type(s)) # <class 'set'> # 尝试定义空集合 s = {} # 如果仅仅只写了 {} .那么python 会默认把它当成字典类型 print(type(s)) # <class 'dict'> # 定义空集合 只能用关键字 set s = set() print(type(s)) # <class 'set'> # 定义空元祖 就是本身的元组 t = () print(type(t)) # <class 'tuple'> # print(set(1)) # 会报错,set也是迭代对象 TypeError: 'int' object is not iterable print(set((1,))) # {1}
向集合中添加元素 add
# 集合添加元素 # add s = {1, 2, 3, 4, 5} print(s.add(666)) print(s) print(s.add((1, 2, 3, 4))) print(s) # None # {1, 2, 3, 4, 5, 666} # None # {1, 2, 3, 4, 5, (1, 2, 3, 4), 666}
获取集合元素个数 len
# len 长度 s = {1, 2, 3, 4, 5} print(len(s)) # 5
集合在交集并集关系处理中的运用 & | ^ - < <= > >= == 以及他们的英语方法写法(后续补充一下)
# 交集并集等集合关系的运用 pythons = ['jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'] linux = ['frank', 'jerry', 'tank', 'egon', 'alex'] # 求既在python 又在linux 的同学 # 普通循环写法 for name in pythons: if name in linux: print(name) # tank # egon # alex pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'} linux = {'frank', 'jerry', 'tank', 'egon', 'alex'} # & 交集 # pythons 和 linux中都有的 print(pythons & linux) # {'tank', 'alex', 'egon'} # - 差集 ----------------- # 只在 pythons 中的 print(pythons - linux) # {'kevin', 'nick', 'jason', 'owen'} # 只在 linux 中的 print(linux - pythons) # {'frank', 'jerry'} # ^ 对称差集 # 没有同时在 pythons 和 linux 中的 print(pythons ^ linux) # {'kevin', 'nick', 'jerry', 'owen', 'jason', 'frank'} # | 合集 # pythons 和 linux 所有的元素(不重复) print(pythons | linux) # {'kevin', 'frank', 'alex', 'egon', 'jason', 'tank', 'jerry', 'nick', 'owen'} # == 判断两个集合是否相等 print(pythons == linux) # False # 父级子级 s = {1, 2, 3, 4} s2 = {2, 4} # > >= 是否包含 (父级) issuperset print(s >= s2) # True # < <= 是否被包含 (子级) issubset # 父级自己反过来一样的
删除集合中的元素 clear pop remove discard
# clear # pop # remove 不存在报错 # discard 不存在不报错
区分类型
# 必须分清楚下面这几种类型分别长啥样!!!别写混了 # 列表 list # [1, 2, 3, 4] # 元组 tuple # (1, 2, 3, 4) # 集合 set # {1, 2, 3, 4}