python列表、元组、字典

一.列表

（一）获取列表中的元素

1.通过索引获取列表中的元素

lst=[1,2.34,'hello',False]
ret=lst[4]
print(ret)
结果：索引越界，报错
ret1=lst[0]
print(ret1)
结果：1

2.使用for循环获取列表中的元素

lst=[1,2.34,'hello',False]
for i in lst:
    print(i)

结果：1,2.34,'hello',False

（二）列表的增加

append	追加，将数据追加到列表后面
inster	插入，指定索引位置，添加元素，查到指定位置的前面
+	列表之间可以相加，将所有内容放到一个新的列表，不能自动去重
extend	可迭代的，不会自动去重

可迭代的：能取出其中的每个元素。

lst=['悟空','八戒','唐三藏']
lst.append('白龙马')
print(lst)
结果:['悟空','白龙马','八戒','唐三藏']

lst.inster(1,'哈哈哈')
prin(lst)
print(lst)
结果：['悟空','']

lst2=['宋江','李逵']
lst.extend(lst2)
print(lst)
结果：['悟空'，'八戒','唐三藏','宋江','李逵']


s='hello'
lst.extend(s)
print(lst)
结果：['悟空','八戒','唐三藏','h','e','l','l','o']

（三）列表的删除操作

 

列表的删除操作
pop（）	指定索引删除数据，如果索引不到会报错
remove（）	根据内容删除
clear	清除所有内容，只剩空列表[ ]
del	删除列表，从内容中将变量删除，打印输出会报错

 

lst=['悟空','八戒','唐三藏']
lst.pop(0)
print(lst)
结果：['八戒','唐三藏']


lst.remove('八戒')
print（lst）
结果：['悟空','唐三藏']


lst.clear()
print(list)
结果：[ ]


lst.del()
print(lst)
结果：报错

（四）列表的修改操作

 通过索引修改内容

lst=['悟空','八戒','唐三藏']
lst[0]='猴哥'
print(lst)
结果：['猴哥','八戒','唐三藏']

（五）列表的查询

通过索引获取元素
index()	根据内容返回索引，可以指定开始和结束的位置
count()计数
切片	[起始值，终止值，步长]----->取完后，列表内容不变

 

lst=['悟空','八戒','唐三藏','悟空','悟空']
ret=lst[1]
print(ret)
结果：八戒


index=lst.index('八戒')
print(index)
结果：1



ret=lst.count('悟空',1,len(lst))
print(ret)
结果：3

（六）列表的排序

sort	默认升序
reverse	降序      lst.sort(reverse=True)

 

（七）列表的拷贝

浅拷贝：对于浅拷贝，第一层创建的新的内容地址，从第二层开始，指的都是同一个内存地址。

lst=['貂蝉','西施']
lst1=['悟空','八戒',lst]
print(lst1)
 结果：['悟空','八戒',['貂蝉','西施']]

lst1[0]='猴哥'
print(lst1)
结果：['猴哥','八戒',['貂蝉','西施']]


lst1[2][0]='杨贵妃'
print(lst1)
print(lst)
结果：['猴哥','八戒',['杨贵妃','西施']]
      ['悟空','八戒',['杨贵妃','西施']]

深度拷贝：导入模块copy

import copy 

copy.deepcopy()

lst=['貂蝉','西施']

lst1=['悟空','八戒',lst]
lst2=['悟空','八戒',lst]
lst2[2][0]='杨贵妃'
print(lst2)
结果：['悟空','八戒',['杨贵妃','西施']]

lst1中的lst ID不等于 lst2 重lst的ID

 

二.元组

元组特点：元组是有序的，不能修改的

格式：变量名称=（元素一,元素二.,.....）

注意：可以存放任意类型的数据

元组的优点：元组是不可变得，所以遍历元组必列表要快

切片切出来的仍然是元组

tup=(1,2.2,True,'赵四'，'刘能')
tup1=tup[0:4:1]
print(tup1)
结果：（1,2.2，True,'赵四'）

（一）、访问多维元组

使用多个变量来接受元组中的值

注意：变量的个数一定要和元组中的个数一一对应

name,age,weight=('李华',19,120)
print(name)
print(age)
print(weight)
结果：李华
      19
      120

面试小例子：

1.a=10,b=20 .现在想要a,b值互换

a,b=(b,a)
print(a)
print(b)
结果：20
      10

2.遍历去除元组中的每个值  tup=(('zs',10),('yu',9),('tg',20))

tup=(('zs',10),('yu',9),('tg',20))
for name,age in tup:
    print(anme,age)
结果：zs  10
      yu  9
     tg   20

（二）、元组的修改

注意：元组本身不能修改，元组中的元素如果是可变的数据类型，才能最元素进行修改

tup=(1,3.4,True,[3,5,6])
tup[3].append('加油')
print(tup)
结果：(1,3.4,True,[3,5,6,'加油'])

（三）、元组中逗号的魅力

tup1=(1)
tup2=(1,)
print(type(tup1))
print(type(tup2))
结果：tup1  ----->int
      tup2------->tuple

（四）、tuple和list的区别

lst=[1,2,3]
tup=tuple(lst)
print(tup)
结果：（1,2,3）


tup3=('a','b','c')
ret=list(tup3)
print(ret)
结果：['a','b','c']

（五）、元组的方法

index	索引
count	计数

tup=('a','b','c','c','b','x')
ret=tup.index('b')
print(ret)
结果：1


ret1=tup.index('c',2,len(tup))
print(ret1)
结果：2


ret2=tup.index('a',2,len(tup))
print(ret)
结果：报错

三.字典

（一）、字典的定义

1.字典是有序的，可修改的，元素成键值对的形式，以逗号隔开的，以大括号包围的序列

格式：变量名={key1:value1，key2:value2，key3:value3......}

注意：使用的符号都是英文下的,

2.字典的key只能是不可变类型（可哈希类型），value可以是任何类型。

可变类型对应不可哈希类型

dic={'name':'zs','age':19,[1,2,3]:(12,3,4)}

print(dic)

结果：会报错，key值不能使可变类型

（二）、字典的增删改查

1.增加

通过key值	info[key]=value
setdefault	key,default_value

dic={'name':'易烊千玺'，'age':18}
dic[height]=1.78
print(dic)
结果：{'name':'易烊千玺'，'age':18,'height':1.78}

 

（三）、删除

pop
popitem	随机删除
clear	清除所有内容，只留下空字典{ }
del	从内存清除字典，打印输出会报错

dic={'name':'悟空','age':100,'height':1.70,'weight':130}
dic.pop('name')
print(dic)
结果：{'age':100,'height':1.70,'weight':130}


dic.popitem()
print(dic)
结果：任意一个键值对被删除

dic.clear()
print(dic)
结果：{}

del dic
print(dic)
结果：报错

 

（四）、字典的修改

通过键值

update方法

 

dic={'name':'长城','age':12,'address':'保定'}
dic['age']=11
print(dic)
结果：{'name':'长城','age':11,'address':'保定'}


dic1={'特色':'雾霾','weight':'156'}
dic.update(dic1)
print(dic)
结果：{'name':'长城','age':12,'address':'保定','特色':'雾霾','weight':'156'}

（五）、字典的查找

keys	获取所有键值
values	获取values值
get	根据键值获取对应的值，定义一个变量接受返回值
update	更新指定键的内容，如果不存在，直接添加
items	一个键值对，返回元组套列表
len	测字典长度

dic={'name':'zs','age':10,'height':1.70}
ret=dic.keys
print(ret)
结果：['name','age','height']

ret1=dic.values
print(ret1)
结果：['zs',10,1.70]

ret2=dic.get('name')
print(ret2)
结果：zs


ret3=dic.items()
print(ret3)
结果：['name':'zs','age':10,'height':1.70]

print(len(dic))
结果：3

formkeys

tup=(1,2,3)
ret=dict.foemkeys(tup)
print(ret)
结果：{1：None，2：None，3：None}

（六）、in和not in

获取所有的键值：

dic={'name':'zs','age':18,'weight':130}
keys=dic.keys()
if 'name' in keys:
    dic['nemr']='赵四'
else：
    dic['name']='尼古拉斯'
print（dic）


for key in dic:
    print(key)


for item in dic.items():
    print（item）
结果：（'name':'zs'）
      ('age':18)
      ('weight':130)


for key,value in dic.item()
    print(key,value)
结果：name zs
      age  18
      weight 130

四、集合

（一）、定义

1.无序的，可以自动去重，关系测试

变量名={元素1，元素2，元素3.....}

变量名=set（可迭代内容）如：list，元组，字符串，字典

注意：集合中的值不能用可变类型

set1={1,2,'hello',True}
print(set1)
结果：{1,2，'hello'}

（二）、类型转换

l

lst=['a','b','c']
set1=set(lst)
print(set1)
结果：{'a','b','c'}

（三）、集合的添加

add

update

set1={'悟空','八戒'}
set1.add（'唐三藏'）
print(set1)
结果：{'悟空','八戒','唐三藏'}

set2={'悟空','白骨精'}
set1.update（set2）
print(set1)
结果：{'悟空','八戒','唐三藏','白骨精'}

（四）、集合的删除
 

pop	随机删除一个
remove	根据指定内容删除
clear	清除所有内容，只剩set（）
del	从内存删除集合，打印输出报错

（五）、集合的遍历

交集	&   intersection	取公共部分
反交集	^ symmetric_difference	取除去公共部分的内容
并集	|   union	取除去重复的部分的所由内容
差集	- difference	取set1，set2 中除去公共部分的内容
子集	<  issubset
超集	>  issuperset

1.数字转化布尔值：除了0其他的都为True，0为False