基础数据类型(可变)
5. 列表 (list)
有序和无序
可以使用索引的数据结构就是有序的,反之则是无序的
概述
'''
列表是存放一些数据的容器(一种数据结构),列表中的元素可以是不同数据类型的元素
'''
定义方式
=号定义
lst = []
list()传参
list('123')
list参数必须是可迭代对象
1. append/insert/extend(增加)
在不改变源数据结构地址的情况下增加
1 append(x) 2 3 """ 4 把一个元素添加到链表的结尾,相当于a[len(a):] = [x] 5 """
1 insert(i,x) 2 """ 3 在指定位置插入一个元素,第一个参数是准备插入到其前面的那个元素的索引,第二个参数时想要插入的内容,例如a.insert(0,x)会插入到整个链表之前,而a.inert(len(a):) = [x]相当于a.append(x) 4 """
1 extend(L) 2 """ 3 通过添加指定链表的所有元素来扩充链表,相当于a[len(a):] = L 4 """
1 lst = ['今天','是','个','好日',] 2 lst.append('子') 3 print(lst) """['今天','是','个','好日','子']""" 4 5 6 #插入 尽量不要使用 当数据量比较大的时候会影响效率 7 lst.insert(1,'bilibili') #插在字符下标的前面,插入的内容. 8 lst = ['今天','是','个','好日',] 9 lst.insert(1,'真') 10 11 12 #扩展 -- 迭代添加 13 lst.extend() #整型和布尔值不可以迭代. 14 lst = ['今天','是','个','好日',] 15 lst.extend('你说的对啊') 16 lst.extend([12345])
1 for x in a[:]: 2 # make a slice copy of the entire list ... 3 if len(x) > 6: 4 a.insert(0, x) 5 print(a) 6 7 [’defenestrate’, ’cat’, ’window’, ’defenestrate’]
2. +(合并)
1 #列表合并 开辟了一块空间 2 lst1 = [1,2,3] 3 lst2 = [4,5,6] 4 print(lst1+lst2)
1 def __add__(self, *args, **kwargs): # real signature unknown 2 """ Return self+value. """ 3 pass
3. 删除
#列表的删除
#delete # 强制销毁内存空间
lst = ['今天','是','个','好日',]
del lst #删除了整个列表,不可以
del lst[1] #可以配合下标删除
del lst[0:2] #可以配合切片删除
del lst[0:3:2] #可以配合步长删除
lst.remove('今天')
print(lst) #通过内容删除
lst.pop() #没有指定,默认删除最后一个 具有返回值
lst.pop(0) #可以指定索引删除 不可以通过切片进行删除
ret = lst.pop(0)
print(ret) #返回的是"今天", 返回被删除的内容
lst.clear() #清空列表里的内容 返回的是空列表
#错误示范 用for循环清空列表
li = [1,2,3,4,5]
#li = [1,2,3,4,5,0,0,0,0,0,0,0,0,0]
for i in li:
li.append(0)
print(li) #一直在循环
li = [12,2,3,4,5]
for i in li:
li.append(i)
print(li) #一直进行循环
li = [1,2,3,4,5]
for i in li:
li.remove(i)
print(li) # 结果[2,4] 列表会整个前移 完美错过2,4
for i in li:
li.pop()
print(li) #结果[1,2] 循环1,2删除4,5 循环3的时候自删
li = [1,2,3,4,5]
for i in li:
del li[-1]
print(li) #结果[1,2]
4. 改
# 在内存中开辟空间,值为字符串'我怎么这么好看',在源列表的基础上将之前索引为0的元素指向新的字符串的内存地址
lst = ['今天','是','个','好日',]
lst[0] = '昨天 #通过下标修改.
print(lst)
lst[0:3] = 'xi' #通过切片修改
print(lst) #元素可以超出切片定义的位数,且被迭代添加到起始位置
lst[0:3:2] = 'xi' #通过切片加步长更改,长度要一一对应,
print(lst)
5. 查找
索引查找
lst = ['年后','来玩呗',1,2,3]
print(lst)
print(lst[0]) #从列表中取出hello
print(lst[0][1]) #从列表中取出'后'
for 循环查找
lst = ['今天','是','个','好日',]
for i in lst:
print(i)
print(lst[1])
6. 通过内容找索引
#通过内容找下标
lst = ['今天','是','个','好日',]
ret = lst.index('今天')
print(ret)
7. 统计
#统计
print(lst.count('天'))
8. 复制
#复制
ret = lst.copy()
print(ret)
9. 反转
#反转
lst = [1,2,3,4453,5,6,7]
print(lst[::-1])
lst.reverse() # 反转
print(lst)
lst = [1,2,3,4,5123,21345,231123,4,1235,234,123]
lst.sort()
lst.reverse()
print(lst)
ret = lst.reverse()
print(ret) #None 这是一个动作,没有返回的内容
print(lst) #变化的内容在原数据里查看
10. 排序
# 排序(默认升序)
lst = [1,2,34,5,6] #数字从小到大排序
lst = ['a','c','b','e'] #字母从a到z排序
lst = ['今天','是','个','好日',] #ascii 的排序
lst.sort()
print(lst)
#降序
lst.sort(reverse = True)
print(lst)
11. 嵌套
#列表嵌套
lst = ['a','b','c'['bb','cc'['e','ee']]]
print(lst[2][1])
7. 字典 (dict)
定义方式
dic = {}
dict(k=1,k1=2)
#在其他语言中叫键值对数据,用来存储数据,字典的查找快一些将数据与数据进行关联
#字典是无序的 是可变的数据类型
#呈现形式:dict dic={'键','值'}
#不可哈希的,就是可变的数据;可变的数据不能哈希,不可变的数字能哈希 避免哈希冲突 使用了 (开放了寻址法)
#字典的键:是不可变数据类型
dic = {'02':a,'04':b,6:'c',False:'d',(1,2):'e'}
print(dic)
dic = {'02':a,'04':b,6:'c',False:'d',(1,2):'e','04':dd}
print(dic) #字典的键不能重复,重复的话就会被值覆盖
dic = {'02':a,6:'c',False:'d',(1,2):'e'}
print(dic) #字典的值可以随意 有键必须要有值
dic = {'1':8,'2':9,'3':7}
ret = dic.get('11',你傻啊,没有还要拿)
print(ret) #本应返回None,后面加内容后返回内容你傻啊,没有还要拿
ret = dic.pop('11','没有')
print(ret) #本应报错, 后面加内容后返回内容没有
#####################z这是坑#########################
dic3 = dict.fromkeys([1,2,3,4,5,6,7,8,9,0],[1,2,3])
#第一个参数是键 要是可迭代的对象
#第二个参数是值, 值是无所谓 是因为创建的新字典的值用的都是一个 值是一个可变数据类型
print(dic3)
dic3[3].append(9)
print(dic3)
########################这是坑#########################
1. 增
#字典的增
dic = {'02':a,6:'c',False:'d',(1,2):'e'}
dic[11] = 'gg' #暴力添加
print(dic)
dic.setdefault(11,'gg') #第一步先去字典中通过11这个键去查有没有值,第二步如果有值就不去添加,如果没有值就添加新的键和值
#python3.6版本以上,字典默认是有序的,怎么写的怎么打印.但是对外声称字典是无序的
#fromkeys 批量添加键值对
dic = {'1':'a','2':'b'}
dic = dic.fromkeys('年后啊','消愁')
#或者
dic = dict(空字典).fromkeys('年后啊','消愁')
第一个位置是可迭代对象,也就是字典的键
第二个位置 不写是None 也就是字典的值
dic = dic.fromkeys('年后啊','消愁')
print(dic) #{'年':'消愁','后':'消愁','啊':'消愁'}
dic['年'] = '今天老子不上班' # 字符串不能修改
print(dic)
dic = dic.fromkeys('年后啊','消愁')
dic['年'] = '今天老子不上班'
print(dic) #{'年':'老子今天不上班','后':'消愁','啊':'消愁'}
dic = dict.fromkeys('你好啊',[1,2,3])
print(dic)
dic['你'] = [5,6,7]
print(dic)
dic = dict.fromkeys('你好啊',[1,2,3])
print(dic)
dic['你'].append(99)
print(dic)
2. 删
#字典的删除 #通过键删除
del dic[6]
dic.pop(6) #pop(必须填内容) 通过指定键删除 返回的是被删除键的值
dic.clear() #清空
#随机删除
dic.popitem() #python2版本中随机删除 在python3.6以上中默认删除最后一个 返回的是键值对
#清空字典
dic = {'1':22,'5':'22'}
for i in dic:
dic['6'] = 1 # 不可以
print(dic)
lst = [] #可以
for i in dic:
lst.append(i) # 每个字典的键
for j in lst:
dic.pop(j)
print(dic)
for i in li:
li.clear() # 实在不行的可以写这个
print(li)
3. 改
#字典的更改
dic.update({'55':'gg'}) #更新 被更新的内容如果在要更新的内容中,那值就会被覆盖. 两个字典中都没有就会合并.
dic = {'02':a,[0,4]:b,6:'c',False:'d',(1,2):'e'}
dic[11] = 'gg'
print(dic) #字典的增是字典中没有键值对的时候才叫增,如果字典中的键存在就叫做改
dic = {'02':a,[0,4]:b,6:'c',False:'d',(1,2):'e'}
dic1 = ({'55':'gg'})
dic1.update(dic) #括号里的字典要高于其他字典
print(dic1)
4. 查
#字典的查
dic = {'02':a,6:'c',False:'d',(1,2):'e'}
print(dic['02']) #值的查找 通过键查找值 如果键不存在报错
for i in dic1:
print(i) #获取的都是字典的键
print(dic['02']) #通过键获取值 如果键不存在就报错
print(dic.get('02')) #通过键查找获取值 如果键不存在返回None
print(dic.setdefault('02'))#如果不存在返回None
5. 嵌套
#字典的嵌套
dic = {'汪峰':{'光头强':'电锯','葛慧倩':'熊大','国际章':'熊二'},
'陈冠希':{'张柏芝':'喜剧之王','阿娇':'千机变'},
'韦小宝':{'建宁':'公主','龙儿':'教主夫人',
'双儿':{'大双':'榴莲','小双':'椰子'},'阿珂':'刺客'}}
#查找的时候一层一层通过键查找
dic1 = dic['陈冠希']['阿娇'] #找出千机变
print(dic1)
print(dic['韦小宝']['双儿']) #找出一对
print(dic['韦小宝']['双儿']['小双']) #找出椰子
6. 其他操作
#字典的其他操作
#字典定义方法:dict(k='a',k1='b')
for 循环 返回的是键
for i in dic:
print(dic.get(i)) # 通过键获取值,如果将不存在字典中返回None
print(dic["cx"]) # 通过键获取值,如果键不存在字典中报错
for i in dic.keys(): #只拿到键
print(i)
print(dic.keys()) #dict_keys([]) 高仿列表支持for循环 不能使用索引
print(dic.values) #dic_values([]) 高仿列表支持for循环 不能使用索引
for i in dic.keys(): #只拿到键 存在一个高仿列表中
print(i)
for i in dic.values():
pritn(i) #拿到每个值 存在一个高仿列表中
for i in dic:
print(i,dic[i]) #拿到了键值 存在一个3高仿列表中以元祖的形式显示
for i in dic.items():
print(i) #拿到了键值对 存在高仿列表中以元祖的形式显示
7. 解构
# 解构
a,b,c = 1,2,3
print(a)
print(b)
print(c)
a,b,c = '123'
print(a)
print(b)
print(c)
a,b,c = (1,2,3)
print(a)
print(b)
print(c)
a,b,c = [1,2,3]
print(a)
print(b)
print(c)
a,b,c = {'1':8,'2':9,'3':7}
print(a)
print(b)
print(c)
#数字和布尔值必须用逗号分割
keys() # 获取所有的键 高仿列表
values() # 获取所有的值 高仿列表
item() # 获取键值 以元祖的形式显示
for k,v in dic2.items(): # k,v = ('33','gg')
print(k)
print(v)
8. 集合
特点
当集合中的元素都为数字时,集合为有序的,排序方式为从小到大
定义方式
se = {'a','b'}
set('alex') #迭代添加进集合
set #集合的特点: 存储数据 天然去重 无序 不能使用下标
se = {1,2,3,4,52,234,12,21,12,123,1,11,2,3,1,2,3,21} # 集合像是没有值得字典
print(se)
dic = {}
# dic.setdefault('123','nihao')
# print(dic)
1. 增
#集合的增
se.add(6) #只能增一个
print(se)
se.update(["12334"]) # 可迭代对象
print(se)
2. 删
#集合的删
se.clear()
se = {1,2,3,4}
print(se.pop()) #删的是第一个,以为集合是无序的所以自己也不知道删的是哪个
s1 = {"刘能", "赵四", "皮歌藏"}
s1.remove('刘能') # 通过内容删除
del se
3. 改
#改
先删后加
4. 查
#查
for循环
for i in set:
print(i)
注意：只能在cmd（终端）中使用
5.冻结集合
s1 = {'冯乡长', '刘能', '赵四', '刘科长'}
print(frozenset(s1))
print(frozenset(s1))
print(frozenset(s1))
# {'刘能', '冯乡长', '刘科长', '赵四'}
# {'刘能', '冯乡长', '刘科长', '赵四'}
# {'刘能', '冯乡长', '刘科长', '赵四'}
\将集合冻结,可作为字典的键
dic = {{'冯乡长', '刘能', '赵四', '刘科长'}:1}
#dic = {{'冯乡长', '刘能', '赵四', '刘科长'}:1}
#TypeError: unhashable type: 'set'
dicq = {frozenset({'冯乡长', '刘能', '赵四', '刘科长'}):1}
6..交叉并集,反交集
s1 = {"刘能", "赵四", "皮歌藏"}
s2 = {"刘科长", "冯乡长", "皮歌藏"}
print(s1 & s2) # 俩个都有的叫交集
print(s1 | s2) # 两个合并叫并集
print(s1 - s2) # 不显示共有的叫差集
print(s1 ^ s2) # 显示不共有的叫反交集
print(s1 < s2) #子集 返回布尔值
print(s1 > s2) #超集 返回布尔值
9. 数据类型总结
list是链表
set 是hash表
# 不可变数据：(内存地址不可以被改变)
字符串，数字，布尔值，元祖
# 可变数据：(内存地址可以被改变)
列表，字典，集合
# 有序的数据: (定义时是什么顺序,输出时就是什么顺序)
列表,元组,字符串,整型,布尔值
# 无序的数据: (定义时是什么顺序,输出时不是定义时的顺序)
字典,集合
#取值方式:
索引: 字符串 列表 元祖
直接: 集合 整型 布尔值
键: 字典
1.小数据池:
1.1代码块: 一个文件,一个函数,一个类,一个模块,终端中每一行
1.1.1 数字: -5 ~ 256
1.1.2 字符串: 乘法时总长度不能超过20
1.1.3 布尔值: 内容相同内存地址相同
1.2 小数据池:
1.2.1 数字: -5 ~ 256
1.2.2 字符串: 乘法时总长度不能超过20
1.2.3 布尔值: 内容相同内存地址相同
1.3 先执行代码块后执行小数据池
1.4 == is
1.4.1 == 判断等号两边值是否相等
1.4.2 is 判断两边的值内存地址是否相等
2.深浅拷贝
2.1 赋值:
多个变量名指向同一个内存地址
一个变量对其进行操作,其他变量查看时都变动
2.2 浅拷贝:
lst[1:10] -- 是浅拷贝
浅拷贝只拷贝第一层元素
修改第一层元素是,新开辟的不进行改变
2.3 深拷贝:
不可变的数据类型共用,可变的数据类型重新开辟一个空间
对源数据进行修改,深拷贝的内容不进行改变
3. 集合
3.1 集合是没用值得字典
3.2 集合是无序,可变的
3.3 集合天然去重
3.4
增:add ,update
删:pop remove clear
改:先删后加
查: for循环
3.5 其他操作:
& 交集
| 并集
- 差集
^ 反交集
> 超集
< 子集
frozenset() 冻结集合
3.6 面试题:
list(set(要去去重的数据))
10. 数据类型之间的转换
#list 转换 tuple
tuple(list)
#tuple 转换 list
list(tuple)
#str 转换 list
name = "alex" print(name.split())
#list 转换 str
lst = ["1","2","3"] print(''.join(lst))
#dict 转换 str
dic = {"1":2}
print(str(dic),type(str(dic)))
print(dict("{1:1}"))
#set 转换 list
list(set)
#list 转换 set
set(list)
python防脱发技巧
