Python数据类型-续
day 6
1、基本使用：
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字（它的位置），或索引，第一个索引是0，第二个索引是1，依此类推。
#列表类型 # ======================================基本使用====================================== # 1、用途：记录多个值（同种属性） # 2、定义方式：在[]内用逗号分隔开多个任意类型的值 # l=['a','b','c'] #l=list(['a','b','c']) # 类型转换 # l=list('hello') # l=list({'x':1,'y':2}) # print(l)
2、列表中值的访问（存取、切片）：
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符（切片）
#按索引存取值(正向存取+反向存取)：即可存也可以取 l=['a','b','c','d'，"e"] # print(l[0]) #取出列表中的第一个值 # print(l[-1]) #取出列表中的最后一个值 # print(id(l)) #取出列表的内存地址 # l[0]='A' #字符串中这种操作回报错 但在列表中不会 这样会改变相应位置上的元素的值 # print(id(l)) #修改过内部索引对应的值以后ID不会改变 列表即为可变型 # l[4]='EEEEEE' # print(l) # l[5]='EEEEEE' #不存在的索引,会出现报错 切片（顾头不顾尾） # print(l[1:4]) # print(l) #结果： ['b','c','d']
3、列表更新（增加、插入）：
增加 # l=['a','b','c','d','e'] # l.append(3333333) # l.append(44444) #在最后增加 # print(l) 插入 # l.insert(0,11111111111) #在指定位置插入 # print(l)
4、删除列表中的元素：
# l=['a','b','c','d','e'] # del l[0] #通用型删除方法 # res=l.remove('b') #直接移除 无返回值 参数一个（删除对象） # print(l) # print(res) # res=l.pop(0) #删除 并且返回删除值 参数默认最后一个值 # print(l) # print(res)
5、循环列表：
# l=['a','b','c','d','e'] # for item in l: # print(item)
6、长度和成员运算：
#长度 # l=['a','b','c','d','e'] # print(len(l)) #成员运算in和not in # print('a' in l) # print('ssssss' not in l)
7、列表的函数和方法汇总：
a、函数
| 序号 | 函数 | 备注 |
|---|---|---|
| 1 | cmp(list1, list2) | 比较两个列表的元素 |
| 2 | len(list) | 列表元素个数 |
| 3 | max(list) | 返回列表元素最大值 |
| 4 | min(list) | 返回列表元素最小值 |
| 5 | list(seq) | 制造列表 |
b、方法
| 序号 | 方法 | 备注 |
|---|---|---|
| 1 | list.append(obj) | 在列表末尾添加新的对象 |
| 2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) | 将对象插入列表 |
| 6 | list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() | 反向列表中元素 |
| 9 | list.sort(cmp=None, key=None, reverse=False) | 对原列表进行排序 |
c、类型总结：
# ======================================该类型总结==================================== # 存多个值 # 有序 # 可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash） # 练习题 #1. 队列：先进先出 l=[] # # 入队 l.append('first') l.append('second') l.append('third') print(l) # # 出队 print(l.pop(0)) print(l.pop(0)) print(l.pop(0)) #2. 堆栈：后进先出 l=[] # 入栈 l.append('first') l.append('second') l.append('third') print(l) # 出栈 print(l.pop()) #pop的参数不写默认为-1 print(l.pop()) print(l.pop())
二、元组
1、基本使用：
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
# ======================================基本使用====================================== # 1、用途：元组就是一个不可变的列表 # 2、定义方式：在()内用逗号分隔开多个任意类型的元素 # t=(1,2.2,'aa',('b','c'),['a','b','c']) # t=tuple(...) # print(type(t)) # 强调： # l=['a'] # print(type(l),l[0]) # t=('a',) #当元组中只有一个元素时，必须要加上一个逗号，不然python解释器无法辨别为元组 # print(type(t)) # print(t) # msg=('hello world') # 类型转换 # t1=tuple('hello') # t2=tuple([1,2,3]) # print(t1) # print(t2)
2、基本操作：
a、内置函数
| 序号 | 函数 | 备注 |
|---|---|---|
| 1 | cmp(tuple1, tuple2) | 比较两个元组元素。 |
| 2 | len(tuple) | 元组元素个数 |
| 3 | max(tuple) | 返回元组元素最大值 |
| 4 | min(tuple) | 返回元组元素最小值 |
| 5 | tuple(seq) | 制造元组 |
基本操作：
#优先掌握的操作： # t=(1,2.2,'aa',('b','c'),['a','b','c']) #1、按索引取值(正向取+反向取)：只能取 # print(t[0]) # print(t[-1]) # t[0]=1111111111 #2、切片(顾头不顾尾，步长) # t=('a','b','c','e','f') # print(t[1:4]) #3、长度 # print(len(t)) #4、成员运算in和not in # print('a' in t) #5、循环 # for item in t: # print(item) # 需要掌握的操作 # t=('a','b','c','e','a','f') # print(t.index('a',1,5)) #查找元素对象 # print(t.count('a')) #对元素进行计数
3、元组总结
# ======================================该类型总结==================================== # 存多个值 # 有序 # 不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash） # t=('a','b','c') # print(id(t)) # t=('A','B','C') # print(id(t)) 注：下面这种看似改变元组的值的操作实质上并没有改变元组，元组中的索引所对应的地址没有发生变化 #t=('a',111,['b','c']) #print(id(t[0]),id(t[1]),id(t[2])) #t[2][0]='B' # print(t) #print(id(t[0]),id(t[1]),id(t[2]))
三、字典
1、基本使用：
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 。
# ======================================基本使用====================================== # 1、用途:记录多个值,列表是索引对应值,而字典是key对应值,其中key对value有描述性的功能 # 2、定义方式:在{}用逗号分隔开多个元素,每个元素都是key:value的形式, 其中key可以是不可变类型,但通常是字符串类型 而value可以是任意类型 # d={1:'aaa',2.2:'bbb','xxx':'ccc',(1,2,3):'dddd'} #d=dict(...) # print(d[(1,2,3)]) # 类转换 字典的三种制造方法 ##1 # d=dict(x=1,y=2,z=3) # print(d) ##2 针对一下这种由多个有两个元素构成的元组组成的列表 # items=[('name','egon'),('age',18),('gender','male')] # d={} # for item in items: # d[item[0]]=item[1] # d=dict(items) # print(d) ##3 # 了解 快速创造一个包含指定key的字典 # keys=['name','age','gender','height','weight'] # d={} # for key in keys: # d[key]=None # d={}.fromkeys(keys,None) # print(d,type(d))
2、字典的操作方法：
a、优先掌握的操作：
# 3、常用操作+内置的方法 #优先掌握的操作： #1、按key存取值：可存可取 dic={'name':'egon','age':18} # dic['xxxx'] #key在字典中不存在，则会发生报错 # print(dic.get('name')) #获取字典中的key（get传入的参数）的值 # print(dic.get('xxx')) #如果get传入的key在字典中不存在，则返回None # print(dic['name']) # dic['name']='EGON' #修改字典中key所对应的值 # dic['gender']='male' #如果字典中没有这个key，则新增一个key：value元素 # print(dic) # l=['a','b','c'] # # l[0]='A' #修改列表中所对应索引的值 # l[4]='AAA' #列表中没有此索引，出现报错 #2、长度len # dic={'name':'egon','age':18} # print(dic) # print(len(dic)) #统计字典中key或者value的个数 #3、成员运算in和not in :是以字典的key为准的 # dic={'name':'egon','age':18} # print('name' in dic) # print('egon' in dic) #4、删除 dic={'name':'egon','age':18} # del dic['name'] #通用删除符 # print(dic) # res=dic.pop('name') #删除name所对应的value病将其返回 # print(dic) # print(res) # res=dic.popitem() #随机删除字典中的一组元素 # print(res) #5、键keys()，值values()，键值对items() # 在python2 # >>> dic={'name':'egon','age':18} # >>> dic.keys() # ['age', 'name'] # >>> dic.values() # [18, 'egon'] # >>> dic.items() # [('age', 18), ('name', 'egon')] # 在python3 # >>> dic={'name':'egon','age':18} # >>> dic.keys() # dict_keys(['name', 'age']) # >>> dic.values() # dict_values(['egon', 18]) # >>> dic.items() # dict_items([('name', 'egon'), ('age', 18)]) #6、循环 # dic={'name':'egon','age':18} # for k in dic: # print(k) # for k in dic.keys(): # print(k) # for v in dic.values(): # print(v) # for k,v in dic.items(): #k,v=('name', 'egon') # print(k,v)
b、需要掌握的操作:
# 需要掌握的操作 # dic={'name':'egon','age':18} # dic={'name':'egon','age':18} # dic.update({'age':19,'gender':'male'}) 将update中的字典更新到旧字典，两边都有的key，值以新字典中的为准，旧字典中没有的进行新增。 # print(dic) # setdefault方法：有返回值 # dic={'name':'egon','age':18} # 当key存在时,不改原值,返回原值 # res=dic.setdefault('name','EGON') # print(dic) # print(res) # 当key不存在时,增加新值 # res=dic.setdefault('gender','male') # print(dic) # print(res)
3、字典总结：
# ======================================该类型总结==================================== # 存多个值 # 无序 # 可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
a、字典的内置函数：| 序号 | 函数 | 备注 |
|---|---|---|
| 1 | cmp(dict1, dict2) | 比较两个字典的元素 |
| 2 | len(dict) | 字典元素个数，即键的总数 |
| 3 | str(dict) | 输出字典可打印的字符串表示。 |
| 4 | type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型 |
b、字典的内置方法：
| 序号 | 方法 | 备注 |
|---|---|---|
| 1 | dict.clear() | 删除字典内所有元素 |
| 2 | dict.copy() | 返回一个字典的浅复制 |
| 3 | dict.get(“key”) | 返回指定键的值，如果值不在字典中返回default值 |
| 4 | dict.update(dict2) | 把字典dict2的键/值对更新到dict里。 |
| 5 | dict.pop(“key”) | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 6 | dict.popitem() | 随机返回并删除字典中的一对键和值。 |
| 7 | dict.setdefault(key，val) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default。 |
| 8 | dict.keys() | 以列表返回一个字典所有的键。 |
| 9 | dict.values() | 以列表返回字典中的所有值。 |
| 10 | dict.items() | 以列表返回可遍历的(键, 值) 元组数组。 |
| 11 | dict.has_key(“key”) | 如果键在字典dict里返回true，否则返回false。 |
| 12 | dict.fromkeys(seq，val) | 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值。 |
四、集合
1、基本使用：
# ======================================基本使用====================================== # 1、用途:I: 关系运算 II:去重 # 2、定义方式:在{}内用逗号分隔开多个元素,但是元素的特点是 # I: 集合内的元素必须是不可变类型 # II: 集合内元素无序 # III: 集合内元素不能重复 # s={1,'aaa',2,} #s=set(...) # print(s,type(s)) # s=set() # print(s,type(s)) # s={1,1,1,1,1,1,1,1,1,1,1,1,'a','a','a'} # print(s) #实际保存的集合为{1,"a"} # 数据类型转换 # res=set('hello') # print(res) #{"h","e","l","o"} # res=set([1,'a','b']) # print(res) #{1, 'a', 'b'}
2、基本操作：
# 3、常用操作+内置的方法 #优先掌握的操作： #1、长度len 同其他类型 #2、成员运算in和not in 同其他类型 pythons={'张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin'} linuxs={'oldboy','张铁蛋','赵银胆','alex','wxx'} 3、|合集:求所有报名的学生 # print(pythons | linuxs) # print(pythons.union(linuxs)) 4、&交集:求同时报名两门课程的学生 # print(pythons & linuxs) 5、-差集: 求只报名python课程的学员 # print(pythons - linuxs) # print(linuxs - pythons) #求只报名linux课程的学员 6、^对称差集:求没有同时报名两门课程的学生 # res=(pythons - linuxs) | (linuxs - pythons) # res=pythons ^ linuxs # print(res) 7、== 判断两个集合是否互为父子集 即是否相等 # s1={1,2,3} # s2={3,2,1} # print(s1 == s2) # 注意:父子集描述的是一种包含与被包含的关系 8、父集：>= 用于判断父子集 判断包含关系 9、子集：<= # s1={1,2,3} # s2={1,2,3,4} # print(s2 >= s1) # print(s1 <= s2) # 需要掌握的 # s1={1,2,3} # s1.update({3,4,5,6}) 同字典的更新 # print(s1) s1={1,'aa','bb',3} # print(s1.pop()) 随机移除一个元素 # res=s1.remove('bbbb') 从集合中删除元素'bbbb', 如果不存在则引发 KeyError # print(s1) # print(res) # s1.discard('bbb') 如果在 set “s”中存在元素 x, 则删除 # s1.add(4) # print(s1)
3、集合总结：
# ======================================该类型总结==================================== # 存多个值 # 无序 # 可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash） # 集合的去重 # 局限性 #1. 只能针对不可变类型 #2. 不能保证原来的顺序
