06 列表、字典、集合、元祖的内置方法

1.列表内置方法
l=[1,2,3,4,5,6,7] res = l.clear() print(res)#None 因此.clear方法没有返回值 print(l)#[] 现在列表为空了
将列表反转reserse()
l = [1,2,1,3,4,5,6,7]
l.reverse()
print(l)#[7, 6, 5, 4, 3, 1, 2, 1]
sort()排序
l1 = [43,6,1,7,99] l1.sort(reverse=False) # 可以通过指定参数来修改默认的拍讯规则(降序) print(l1)

总结:列表类型:能存多个值;有序的;可变类型

队列:先进先出

复制代码
l=[]
l.append('1')
l.append('2')
l.append('3')
print(l)
#['1', '2', '3']
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
#1,2,3
复制代码

堆栈:先进后出

复制代码
l.append('1')
l.append('2')
l.append('3')
print(l)
#['1', '2', '3']
print(l.pop())
print(l.pop())
print(l.pop())
#3,2,1
复制代码

 

 

 

 

2.元祖

2.1作用:存储多个值,元素与元素之间逗号隔开,元素可以是任意类型,元祖不能被修改

2.2定义:与列表类型比,只不过将【】换成了()

age = (1,3,4,5,6,67)本质上age = tuple((1,3,4,5,6,67))

元祖内必须传容器类型

1
2
3
4
5
6
7
a=(1,32,32,'sdf','fsd',[1,2,3])#tuple((1,32,32,'sdf','fsd',[1,2,3]))
print(type(a))
#<class 'tuple'>
tuple(1)
print(tuple(1))
#TypeError: 'int' object is not iterable.
            #元祖内必须传容器类型

 在定义容器类型的时候,哪怕只有一个元素,也必须加上逗号。否则识别为字符串。(***)

n=('a')
print(n,type(n))
#a <class 'str'>
n=('a',)
print(n,type(n))
#('a',) <class 'tuple'>

2.3优先掌握的操作:

#优先掌握的操作:
#1、按索引取值(正向取+反向取):只能取
#2、切片(顾头不顾尾,步长)
#3、长度
#4、成员运算in和not in

#5、循环

1.按索引取值(正向取+反向取):只能取

a=(1,32,23,4,'sd','fsd',[1,32,43])
print(a[0])

a[-1]='aaaaaaaa'
#ypeError: 'tuple' object does not support item assignment
a[-1][0]='改了元祖内列表中的值'
print(a)
#(1, 32, 23, 4, 'sd', 'fsd', ['改了元祖内列表中的值', 32, 43])

元祖内的值,不能修改

del a[0]
print(a)
#TypeError: 'tuple' object doesn't support item deletion

2.切片(还是顾头不顾尾)

连续两个::,代表从开始取到最后一个值

a=(1,32,23,4,'sd','fsd',[1,32,43])
print(a[::2])
#(1, 23, 'sd', [1, 32, 43])

3.长度len

a=(1,32,23,4,'sd','fsd',[1,32,43])
print(len(a))
# 7

4.成员运算 in 和 not in

a=(1,32,23,4,'sd','fsd',[1,32,43])
print('d' in a)
#False

5.循环for

a=(1,32,23,4,'sd','fsd',[1,32,43])
for i in a:
    print(i,end=' ')
# 1 32 23 4 sd fsd [1, 32, 43] 

总结:

能存多个值

有序

不可变

1.能存多个值。由于元祖是不可变类型。不能修改值,但是如果元祖里面有列表,可以先取出列表,再给修改。

比如在元祖内的列表中增加值.append

a=(1,32,23,4,'sd','fsd',[1,32,43])
print(id(a))
#6029824 a[
-1].append(666) print(a,id(a))
#(1, 32, 23, 4, 'sd', 'fsd', [1, 32, 43, 666])
#6029824

 

 

 

 

3.字典及其内置方法

3.1作用:字典能存储多组(key:value)键值对。由于key是不可变类型,而value是任意类型

3.2定义;

c = {'name':'zdq','pwd':123,(1,3):'可不可行'}
print(c['name'])
print(type(c))
print(c[(1,3)])
# zdq
# <class 'dict'>
# 可不可行

3.3注意字典的Key是不能重复的。若重复,则存储最后一组键值对

f={'name':'wuxi','name':'zdq','name':'abd'}
print(f['name'])
#abd

3.4len

f={'name':'wuxi','name':'zdq','name':'abd'}
print(len(f))
print(f)
#1
#{'name': 'abd'}

 优先掌握的操作:

1.key存取值:可存可取

复制代码
正常取值
b={'name':123,'age':18}print(b['age'])
#18

对同一K赋多个值,则以最后一赋值为准 b['name']='789' b['name']='abc' print(b) # {'name': 'abc', 'age': 18} 34615232
复制代码

赋值key。当要复制的key在字典中,会自动新增一个键值对(*****)

1
2
3
4
b={'name':123,'age':18}<br>#weight不在字典中
b['weight']='150'
print(b)
{'name': 'abc', 'age': 18, 'weight': '150'}

2.长度:len

统计字典的键值对个数

3.in 和not in。对于字典来说只能判断key值

1
2
3
d3 = {'name':'wuxi','password':'123'}
print('123' in d3)
print('name' in d3)

4.删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1.del 删除<br># d3 = {'name':'jason','password':'123'}
# del d3['name']
# print(d3)
2.pop弹出值。注意弹出即有返回值,弹出的在返回值中
#d4 = {'name':'jason','password':'123'}
# res = d3.pop('name')  # 弹出仅仅是value<br># print(res)
#jason,弹出值
2.1当键不存在时,直接报错
# res = d3.pop('age')
# print(res)
报错。弹出字典中不存在的内容
3.clear()清除
# d3.clear()
# print(d3)
全部清除,留下{} 

 定义字典的三种方式: 掌握d1 = {'name':'jason','password':123}

1
2
3
4
5
6
7
8
9
10
11
<em id="__mceDel"><em id="__mceDel">1.一般定义<br>d={‘name’:'jason','pwd':123}<br>2.掌握
 d2 = dict(name='jason',password=123,age=18# (******)
 print(d2,type(d2))
 
 3.列表转换字典(了解)
l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]<br><br><br><br>
</em></em>

5.键keys(),值values(),键值对items()。这三个方法分别用来获取字典所有的的key,value和同事取到这两个值

1
2
3
4
5
6
7
8
9
10
11
12
13
# 获取k
# d1 = {'name':'jason','password':123}
# print(d1.keys())  # 结果是dict_keys(['name', 'password'])  老母猪,省内存和之前的一样。就把它当成一个列表来看即可
# for k in d1.keys():
#     print(k)
 
 
# 获取value
# print(d1.values())  # dict_values(['jason', 123])  老母猪  现在就把它当成一个列表来看即可
#
# 拿到k:v两个值
# print(d1.items())  # dict_items([('name', 'jason'), ('password', 123)])
# 就把它看成是列表套元组,元组的第一个元素是字典的key 第二个元素是字典的valueeys(['name', 'password'])  老母猪占用空间小,要值就给几个,不要值就不给

6.for循环

e={‘name’:‘wuix’,‘aeg’:123}

for i in e:

print(i)

7.其他字典内置方法:

7.1   .get()字典获取值得推荐使用方法:取不到key值(当key值不在字典中)不会报错

1
2
3
4
5
6
7
8
9
10
#字典取值,取(value)的推荐使用方法
# get()根据key获取value(*******************************)与索引是有区别的
d1 = {'name':'jason','pwd':123}<br>1.一般方法:
# print(d1['name'])<br>2.get方法
print(d1.get('name'))
当输入内容不在字典中:<br>1.不在逗号后写任何内容,返回none<br># res = d1.get('age')  # 当字典的key不存在的情况 不报错 返回None
# print(res)#None<br>2.在逗号候写内容。返回内容
# res1 = d1.get('xxx','你输入的key值不存在')  # get可以传第二个参数。当你的key不存在的情况下,返回第二个你写好的参数信息
# print(res1)<br>总结:
# 第二个参数不写的话 当key不存在的情况下返回None,写了就返回写了内容 

总结:.get()括号内第二个参数不写,且key不存在,则返回None;

写了就返回,你指定的内容。

 7.2  .fromkeys()从‘列表’(或者其他容器)中快速的创建一个‘字典’

1
2
3
4
5
# dict.fromkeys()  快速的创建一个字典。
# 比如有一个列表
l1 = ['name','password','age','hobby']#。快速以这个4个为键快速建造一个字典
print(dict.fromkeys(l1,123))#.fromkeys(第一个,第二个)第一个写的是列表(容器),第二个为value值
#结果{'name': 123, 'password': 123, 'age': 123, 'hobby': 123}

7.3

.popitem()

1
2
3
d1 = {'name':'jason','pwd':123}
print(d1.popitem())  # 把字典尾部键值对取出来,用()就是写成元祖的形式
#('pwd', 123)

7.4  .setdefault()

1
2
3
4
5
6
7
d1 = {'name':'jason','pwd':123}
res1 = d1.setdefault('name','xxoo'# 当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1,res1)
#{'name': 'jason', 'pwd': 123} jason
res2 = d1.setdefault('age',18# 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1,res2)
#{'name': 'jason', 'pwd': 123, 'age': 18} 18

7.5  .update()

1
2
3
4
5
6
7
8
d1 = {'name':'jason','pwd':123}
d2 = {"age":18}
d1.update(d2)#d1中无d2内容,则新增<br>print(d1)
#结果{'name': 'jason', 'pwd': 123, 'age': 18}
<br>d1.update(age=666)
# 相当于赋值:d1['age'] = 18
print(d1)#d1中有d2内容,则修改
#结果{'name': 'jason', 'pwd': 123, 'age': 666}

存多个值

无序

 

 

 

8.集合及内置方法

创建集合的目的:仅仅为了找一个容器存放值。因此,无序,不可索引

作用:关系运算、去重

定义:

1
2
3
4
5
s = {1,2,3,4,5,6}
print(type(s))# <class 'set'>
#
s1 = set()
print(type(s1))  # 注意在定义空集合的只能用关键字set<br><br># x = {}  # <class 'dict'>  <br>如果你仅仅只写了一个大括号 那么python默认将它当做字典类型

  

定义集合:可以包含多个元素,用逗号分隔、

集合的元素规则:

1
2
3
4
5
6
7
8
9
10
11
12
13
1:每个元素必须是不可变类型
可变:不可hash
不可变:可hash
s = {1,2,3,4,5,6,'a',(1,2),[1,2]}  # 报错
s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}}  # 报错
 
2: 集合内没有重复的元素
s = {1,2,2,2,2,2,2,2,2,2,3,4,4,4,4,4,5}
print(s)  # 自动将重复的元素 去除
 
3:无序
s = {1, 2, 3, 4, 5, 6}
print(s[1])<br>不可以按索引取值<br>注意集合的目的是将不同的值存放到一起,两个集合之间用来做关系运算,无需纠结于集合中单个值

集合优先掌握的操作:

1
2
3
4
5
6
7
8
9
10
11
<em id="__mceDel">1、长度len
s = {1,2,3,4}
print(len(s))
2、成员运算innot in
#
3、|合集
4、&交集
5-差集
6、^对称差集
7==
8、父集:》,》=<br>9、子集:<,<=</em>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
#交集
# 既报名python也报名linux的学生姓名
print(pythons & linux) 
#差集
# 只报名python的学生姓名
print(pythons - linux)
#对称差集
# 没有同时报名两门课程的学生姓名
print(pythons ^ linux)  
#合集
# 取出所有报了名的学生姓名
print(pythons | linux)
#==判断两个集合是否相等.
s={1,2,4}<br>s1={4,1,2}<br>集合无序所以是相等的<br>
 8、父集:判断‘两个集合是否包含’<br> 标识:>,>=
 s = {1,2,3,4,55}
 s2 = {1,2,666}<br> print(s >= s2)  # s是否包含s2<br>
 """
# issubset()
# issuperset()
 """<br>
# 9、子集:<,<=
1
2
3
4
5
6
7
8
9
10
11
12
13
<br>增加值add<br>s = {1,2,3,4,5}
s.add(666)
print(s)
#{1, 2, 3, 4, 5, 666}
s.add((1,2,3,4)) # 将容器类型也当成一个元素传入
print(s)<br>删除
#{1, 2, 3, 4, 5, (1, 2, 3, 4), 666}
print(s.remove(1))
print(s)
# remove()内若集合没有该值,则报错
print(s.discard(888888888))
print(s)
# discard()内若集合没有该值,不会报错

  

posted @   xg1321  阅读(303)  评论(0编辑  收藏  举报
编辑推荐:
· 智能桌面机器人:用.NET IoT库控制舵机并多方法播放表情
· Linux glibc自带哈希表的用例及性能测试
· 深入理解 Mybatis 分库分表执行原理
· 如何打造一个高并发系统?
· .NET Core GC压缩(compact_phase)底层原理浅谈
阅读排行:
· 手把手教你在本地部署DeepSeek R1,搭建web-ui ,建议收藏!
· 新年开篇:在本地部署DeepSeek大模型实现联网增强的AI应用
· Janus Pro:DeepSeek 开源革新,多模态 AI 的未来
· 互联网不景气了那就玩玩嵌入式吧,用纯.NET开发并制作一个智能桌面机器人(三):用.NET IoT库
· 【非技术】说说2024年我都干了些啥
点击右上角即可分享
微信分享提示