列表类型
作用
按位置存放多个值
定义
l=[1,1.2,'1']
print(type(l))
<class 'list'>
类型转换
但凡能够被for循环遍历的类型都可以传参给list（）转换成列表 相当于调用一个for循环
res=list('hello')
print(res)
res=list({'k1':111,'k2':222,'k3':333})#实际上字典是无序的
print(res)
['h', 'e', 'l', 'l', 'o']
['k1', 'k2', 'k3']
内置方法
索引
#1.按照索引取值
#正向 反向
print(l[2])
print(l[-1])
#可以取也可以改
l=[111,'egen','hello']
l[0]=222
print(l)1
1
[222, 'egen', 'hello']
切片
#2.切片 顾头不顾尾 步长
l=[111,'egen','hellp','a','b',[2,3]]
print(l[0:3])
print(l[0:5:2])
print(l[0:len(l)])
new_l=l[:]#切片等同于拷贝行为 且是浅拷贝
print(id(l))
print(id(new_l))
l[-1][0]=1111
print(l)
print(new_l)[111, 'egen', 'hellp']
[111, 'hellp', 'b']
[111, 'egen', 'hellp', 'a', 'b', [2, 3]]
1887291735488
1887298305024
[111, 'egen', 'hellp', 'a', 'b', [1111, 3]]
[111, 'egen', 'hellp', 'a', 'b', [1111, 3]]
长度
成员运算
#3.长度
print(len([1,2,3]))
#4.成员运算
print('aaa' in ['aaa',1,2])
print(not 'aaa' in ['aaa',1,2])
3
True
False
追加值 插入值和拼接
#5.1追加值
l=[111,'egen','hello']
l.append(3333)
l.append(4444)
print(l)
#5.2插入值
l=[111,'egen','hello']
l.insert(1,'alex')#在1号索引前插入alex
print(l)
#5.3列表拼接
new_l=[1,2,3]
l=[111,'egen','hello']
l.append(new_l)#当成一个元素放进末尾 没能实现拼接
print(l)
l=[111,'egen','hello']
for x in new_l:l.append(x)
print(l)
#extend
l=[111,'egen','hello']
l.extend(new_l)
print(l)
l.extend('abc`')
print(l)
[111, 'egen', 'hello', 3333, 4444]
[111, 'alex', 'egen', 'hello']
[111, 'egen', 'hello', [1, 2, 3]]
[111, 'egen', 'hello', 1, 2, 3]
[111, 'egen', 'hello', 1, 2, 3]
[111, 'egen', 'hello', 1, 2, 3, 'a', 'b', 'c', '`']
删除值
#7.删除值
#1-del 公用删除方法，没有返回值 不支持赋值
l=[111,'egen','hello']
del l[1]
print(l)
#2-l.pop 根据索引删除 默认删除最后一个 返回删除的那个值
l=[111,'egen','hello']
l.pop()
print(l)
res=l.pop(0)
print(l)
print(res)
#3-l.remove 根据元素删除,返回None
l=[111,'egen',[1,2,3],'hello']
l.remove([1,2,3])
print(l)[111, 'hello']
[111, 'egen']
['egen']
111
[111, 'egen', 'hello']
循环
#8 循环
for x in ['aaa',1,2]:print(x)
l=[1,'aaa','bbb']
for x in l:l.pop()#忌讳，分不清print(l)
aaa
1
2
[1, 'aaa']
[1]
需要掌握的操作
count
index
clear
reverse
sort
l=[1,'aaa','bbb','aaa']
#l.count()
print(l.count('aaa'))#l.index()返回找到的第一个索引
print(l.index('aaa')) #print(l.index('aaaaaa'))#找不到报错#l.clear 清空列表
l.clear()
print(l)#l.reverse 倒转原列表
l=[1,'aaa','bbb','aaa']
l.reverse()
print(l)#l.sort(key=,reverse=) reverse反转 默认从小到大 升序 只能针对列表元素同种类型排序
l=[11,-3,9,0,1,8.9]
l.sort()
print(l)
l.sort(reverse=True)
print(l)
l=['c','a','e','d']#字符串可以比大小ascll表 越靠后越大
l.sort()
print(l)
print('z'>'abcds')#按照对应位置字符依次比大小
#了解 列表可以比大小 原理和字符串一样，对应位置必须是同种类型
l=[1,'abc','zaa']
l2=[1,'abc','zb']
print(l<l2)
2
1
[]
['aaa', 'bbb', 'aaa', 1]
[-3, 0, 1, 8.9, 9, 11]
[11, 9, 8.9, 1, 0, -3]
['a', 'c', 'd', 'e']
True
True
队列
fifo 先进先出 吃了拉
l=[]
l.append(1)
l.append(2)
l.append(3)
print(l)
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
[1, 2, 3]
1
2
3
堆栈
lifo 后进先出 吃了吐
l=[]
l.append(1)
l.append(2)
l.append(3)
print(l)
print(l.pop())
print(l.pop())
print(l.pop())
[1, 2, 3]
3
2
1
元组类型
可以当成一个不可变的列表
作用
按照索引 位置存放多个值，只用读不用于改
定义
t=(1,2,'aa')
t=(10,)#如果只有一个值必须加逗号
print(t,type(t)) #t=(0->值1的内存地址 1->值2的内存地址 2->值’aaa'的内存地址)
#t[0]=1111 报错，元组不能单个改
t=(1,2,'aa')
t=(1,[11,22])
print(id(t[0]),id(t[1]))
t[1][0]=11111111 #没有改内存地址
print(t)
print(id(t[0]),id(t[1]))
(10,) <class 'tuple'>
140726066529064 2850014357184
(1, [11111111, 22])
140726066529064 2850014357184
类型转换
print(tuple('hello'))
print(tuple([1,2,345]))
print(tuple({'k1':111,'k2':222}))
('h', 'e', 'l', 'l', 'o')
(1, 2, 345)
('k1', 'k2')
内置方法
#1 按索引取值
t=['aaa','bbb','ccc']
print(t[0])
print(t[-1])
#2 切片 顾头不顾尾
t=['aaa','bbb','ccc']
print(t[0:2])
print(t[::-1])
#3 长度
print(len(t))
#4 成员运算
print('aaa' in t)
#5 循环
for x in t:print(x)
#6 index count
t=(1,2,3,111,111)
print(t.index(111))
print(t.count(111))aaa
ccc
['aaa', 'bbb']
['ccc', 'bbb', 'aaa']
3
True
aaa
bbb
ccc
3
2
字典类型
作用
定义
{}内逗号分开多个 key：value 其中 value可以是任意类型，key必须是不可变类型
d={'k1':111,(1,2,3):222}#调用dict
print(type(d))
d=dict()
print(d,type(d))#定义空字典
d={}
print(type(d))
d=dict(x=1,y=2,c=123)
print(d)
<class 'dict'>
{} <class 'dict'>
<class 'dict'>
{'x': 1, 'y': 2, 'c': 123}
数据类型转换
列表转字典
按keys快速初始化
info=[['name','egen'],['age',18],['gender','male']
]
d={}
for item in info:d[item[0]]=item[1]
print(d)
d={}
for k,v in info:#变量解压赋值d[k]=v
print(d)res=dict(info) #实际调用和上面循环相似 必须是两个值
print(res)
#造字典方式
keys=['name','age','gender']
value=None
d={}
for key in keys:d[k]=None
print(d)
#字典快速初始化 fromkeys
d={}.fromkeys(keys,None)
print(d)
{'name': 'egen', 'age': 18, 'gender': 'male'}
{'name': 'egen', 'age': 18, 'gender': 'male'}
{'name': 'egen', 'age': 18, 'gender': 'male'}
{'gender': None}
{'name': None, 'age': None, 'gender': None}
内置方法
1 按key取值 可存可取
#按key取值
d={'k1':111}
d['k1']=222
d['k2']=333#key不存在时创建新值
print(d)
{'k1': 222, 'k2': 333}
2 长度len
3 成员运算
#长度
d={'k1':111,'k2':222,'k1':333}#key不需不可变且只保留一个
print(len(d))
print(d)
#成员运算-针对keys
print('k1' in d)
print(222 in d)
2
{'k1': 333, 'k2': 222}
True
False
4 删除
del pop popitems
#删除
##通用del
d={'k1':111,'k2':222}
del d['k1']
print(d)
## pop
d={'k1':111,'k2':222}
res=d.pop('k2')#根据key删除 返回删除的key对应的value值
print(d)
print(res)
## popitem 随机删除 返回一个元组包含删除的key和对应value
d={'k1':111,'k2':222}
res=d.popitem()#
print(d)
print(res)
{'k2': 222}
{'k1': 111}
222
{'k1': 111}
('k2', 222)
5 键keys（），值values(),键值对items（）
6 循环
d={'k1':111,'k2':222}
print(d.keys())#像range一样不用列表改成老母鸡了
print(d.values())
print(d.items())for key in d.keys():print(key)
for value in d.values():print(value)
for k,v in d.items():print(k,v)
#转成列表
print(list(d.keys()))
dict_keys(['k1', 'k2'])
dict_values([111, 222])
dict_items([('k1', 111), ('k2', 222)])
k1
k2
111
222
k1 111
k2 222
['k1', 'k2']
7 其他内置方法
#clear清空
d={'k1':111,'k2':222}
d.clear()
print(d)
#update
d={'k1':111,'k2':222}
d.update({'k1':000,'k3':333})#没有的追加 相同的以新字典更新
print(d)
#get容错性好
print(d['k1'])#key不存在时报错
print(d.get('k1'))
print(d.get('k0'))#不存在时不报错而返回None
# setdefault 设置默认值 如果key存在则不改变，如果缺少这个key则把设置的默认值加入 返回执行setdefaut后字典中key对应的值
d={'name':'egen','age':18,'gender':'male'}
d={'k1':111}
res1=d.setdefault('k3',222)
res2=d.setdefault('k1',4123452)
print(d)
print(res1)
print(res2)
{}
{'k1': 0, 'k2': 222, 'k3': 333}
0
0
None
{'k1': 111, 'k3': 222}
222
111
