9.列表类型+初识队列与堆栈+元组类型+字典类型

1.列表类型

1.作用：按位置存放多个值

2.定义：

l=[1,21,'a']#l=list([1,21,'a'])
print(type(l))#<class 'list'>

3.类型转换：

但凡能被for循环遍历的类型都可以当做参数用list()转换成列表

res=list('hello')
print(res)#['h', 'e', 'l', 'l', 'o']
dic={'k1':'a','k2':'b','k3':'c'}
print(list(dic))#['k1', 'k2', 'k3']

4.内置方法：

优先掌握的操作

1.按照索引取值（正向取、反向取），可以改也可以取

l=[111,222,333]
print(l[0])#正向取 111
print(l[-1])#反向取 333
l[0]=444
print(l)#[444, 222, 333] 可以取也可以改

2.切片（顾头不顾尾，步长）

l=[111,222,333,4444,555,66,[111,222,333]]
print(l[0:3])#[111, 222, 333]
print(l[0:5:2])#[111, 333, 555]
new_l=l
l[-1][0]=999
print(new_l)#[111, 222, 333, 4444, 555, 66, [999, 222, 333]],切片等于浅拷贝
print(l[::-1])#[[999, 222, 333], 66, 555, 4444, 333, 222, 111]，反向排列

3.长度

l=[111,222,333,4444,555,66,[111,222,333]]
print(len(l))#7

4.成员运算in 和not in

l=[111,222,333,4444]
print(111 in l)#True
print(555 not in l)#True

5.往列表里增加值

5.1追加 append 在列表后面加入元素

l=[111,222,333]
l.append(666)
l.append(7777)
print(l) #[111, 222, 333, 666, 7777]

5.2 插入值 在索引前面插入元素

l=[111,222,333]
l.insert(0,'999')
print(l)#['999', 111, 222, 333]

6. 加入可迭代元素

l=[111,222,333]
new_1=['a','b','c']
new_2=['hello']

l.append(new_1)
print(l)#[111, 222, 333, ['a', 'b', 'c']] 
#用追加，只会将新列表以一个元素的形式追加进去

l.extend(new_1)
print(l)#[111, 222, 333, ['a', 'b', 'c'], 'a', 'b', 'c']

l.extend(new_2)
print(l)#[111, 222, 333, ['a', 'b', 'c'], 'a', 'b', 'c', 'hello'] 
#与教程中不同，字符串没有被拆开

7.删除

方式一：通用的删除方法，只是单纯的删除，没有返回值

l=[111,222,333]
del l[1]
print(l) #[111, 333]

方式二：l.pop() 根据索引进行删除 会返回值

l=[111,222,333]
l.pop()
print(l)#[111, 222] 不指定索引，默认删最后一个
l.pop(0)
print(l)#[222]

方式三：l.remove()根据元素删除 返回None

l=[111,222,333]
l.remove(222)
print(l) #[111, 333]

8.循环

for i in [111,222,333]:
    print(i)
# 111
# 222
# 333

需要掌握的操作

1.count() 某个元素在列表中的个数

l=[1,11,22,11,22,33]
print(l.count(11))# 2

2.index() 某个元素在列表中第一次出现的索引

找不到就报错，且没有find方法

l=[1,11,22,11,22,33]
print(l.index(11))#1

3.clear() 清空列表，返回None

l=[1,11,22,11,22,33]
print(l.clear())#None
print(l)#[]

4.reverse() 翻转列表

l=[1,11,22,11,22,33]
l.reverse()
print(l)#[33, 22, 11, 22, 11, 1]

5.sort() 排序 列表内元素必须是同种类型

l=[1,11,22,11,22,33]
l.sort()
print(l)#[1, 11, 11, 22, 22, 33] 默认升序
l.sort(reverse=True)
print(l)#[33, 22, 22, 11, 11, 1] 设置为降序

2.队列与堆栈

1.队列 FIFO先进先出

l=[]
# 入队操作
l.append('111')
l.append('222')
l.append('333')
print(l) #['111', '222', '333']
#出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
# 111
# 222
# 333

2.堆栈 LIFO后进先出

l=[]
# 入栈操作
l.append('111')
l.append('222')
l.append('333')
print(l) #['111', '222', '333']
# 出栈操作
print(l.pop())
print(l.pop())
print(l.pop())
# 333
# 222
# 111

3.元组类型tuple

元组就是一个“不可变的列表”

1.作用：按照索引存放多个值，只用于读不用于改

2.定义：()内用逗号分隔开多个任意类型的元素

t=(1,1.3,'aa') #t=tuple((1,1.3,'aa'))
print(t,type(t)) #(1, 1.3, 'aa') <class 'tuple'>

x=(10)#单独一个括号代表包含的意思
print(x,type(x))#10 <class 'int'>

t=(11,)#如果只有一个元素，需要加个逗号
print(t,type(t))#(11,) <class 'tuple'>

t=(111,222,[222,555])
t[2][0]=666
print(t) #(111, 222, [666, 555])
# 如果元组内的元素中有列表，列表内的元素是可以改的

3.类型转换

print(tuple('hello'))
print(tuple([1,2,3]))
print(tuple({'a':111,'b':222,'c':333}))
# ('h', 'e', 'l', 'l', 'o')
# (1, 2, 3)
# ('a', 'b', 'c')

4.内置方法

优先掌握：

1.按索引值取值（正向取+反向取）只能取不能改

t=('aaa','bbb','ccc')
print(t[0])
print(t[-1])
# aaa
# ccc

2.切片（顾头不顾尾，步长）

t=('aaa','bbb','ccc','ddd')
print(t[0:3])
print(t[::-1])
# ('aaa', 'bbb', 'ccc')
# ('ddd', 'ccc', 'bbb', 'aaa')

3.长度len()

t=('aaa','bbb','ccc','ddd')
print(len(t))#4

4.成员运算in和not in

t=('aaa','bbb','ccc','ddd')
print('bbb' in t)
print('b' in t)
print('b' not in t)
# True
# False
# True

5.循环

t=('aaa','bbb','ccc','ddd')
for i in t:
    print(i)
# aaa
# bbb
# ccc
# ddd

4.字典类型dict

1.定义：

{}内用逗号分隔开多个key:value，其中value可以是任意类型，key只能是不可变类型

d={}
print(d,type(d))#{} <class 'dict'> 空花括号默认定义了一个空字典

2.数据类型转换

info=[['name','bob'],['age',18],['love','you']]
d=dict(info)
print(d)#{'name': 'bob', 'age': 18, 'love': 'you'}

3.内置方法

优先掌握

1.按key取存值：可存可取

d={'k1':111}
d['k1']=110
print(d)#{'k1': 110} k存在，则修改
d['k2']=222
print(d)#{'k1': 110, 'k2': 222} k不存在，则添加

2.长度len()

d={'k1': 110, 'k2': 222}
print(len(d))#2

3.成员运算in和not in ：根据key

d={'k1': 110, 'k2': 222}
print('k1' in d)
print(110 in d)
# True
# False

4.删除

d={'k1': 110, 'k2': 222,'k3':333}
#通用删除
del d['k1']
print(d)#{'k2': 222}

#pop删除：根据key删除元素，返回删除key对应的value值
res=d.pop('k2')
print(d)
print(res)
# {'k3': 333}
# 222

#popitem:随机删除，返回一个元组(key,value)
res=d.popitem()
print(res)#('k3', 333)

5.keys()、 values() 、items() 在python3中生成可迭代的“母鸡”

通过for可以迭代出来

d={'k1': 110, 'k2': 222,'k3':333}
res1=d.keys()
print(res1)#dict_keys(['k1', 'k2', 'k3'])

res2=d.values()
print(res2)#dict_values([110, 222, 333])

res3=d.items()
print(res3)#dict_items([('k1', 110), ('k2', 222), ('k3', 333)])

6.for循环

d={'k1': 110, 'k2': 222,'k3':333}
res1=d.keys()
for k in res1:
    print(k)
# k1
# k2
# k3

res2=d.values()
for v in res2:
    print(v)
# 110
# 222
# 333

res3=d.items()
for k,v in res3:
    print(k,v)
# k1 110
# k2 222
# k3 333

需要掌握

1.clear() 清空字典

d={'k1': 110, 'k2': 222,'k3':333}
d.clear()
print(d)#{}

2.update() 更新字典

d={'k1': 110, 'k2': 222,'k3':333}
d.update({'k1':111,'k6':666})
print(d)#{'k1': 111, 'k2': 222, 'k3': 333, 'k6': 666}
#更新字典，存在的替换，不存在的新建

3.get()根据key取值，如果是字典中没有的key，则返回None，不会报错

d={'k1': 110, 'k2': 222,'k3':333}

print(d.get('k1'))#110
print(d.get('k5'))#None 字典中没有的k值，返回None，不会报错

4.setdefault() 如果有key则不做任何改变 如果没有key则添加

在个人身份信息采集中会很有用

info={'name':'bob'}
res=info.setdefault('name','bobooo')
print(info)#{'name': 'bob'} 如果有key则不做任何改变
print(res)#bob 返回字典中key对应的值

info={}
res=info.setdefault('name','bobooo')
print(info)#{'name': 'bobooo'} 如果没有key则添加
print(res)#bobooo 返回字典中key对应的值