python基础知识-容器（序列）--字典

于 2023-03-15 21:27:26 发布
阅读量171 收藏
点赞数
文章标签： python 开发语言 numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_57952909/article/details/129569427
版权
本文介绍了Python中的序列数据结构，重点讨论了列表和字典。列表是最常用的Python数据类型，可变且有序，允许存储不同类型的元素。文章详细讲解了列表的创建、查询、修改和遍历，包括切片、添加、删除和排序等操作。此外，还探讨了列表相关函数如`sum`、`max`、`min`、`sorted`和`len`。接着，文章介绍了字典，它是无序的键值对集合，支持增删改查操作。文章通过实例展示了字典的查询和增删改方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

python基础知识-容器

序列是python中最基本的数据结构，序列中的每个元素都分配一个数字–它的位置，或索引，第一个索引是0，第二个索引是1，以此类推。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外python已经内置确定序列的长度以及确定最大和最小的元素的方法。

一.列表(list)

（1）认识列表

​ 1）列表是最常用的python数据类型，它以方括号作为标志出现，里面的多个数据用逗号隔开。列表的数据项不需要具有相同的类型。创建一个列表们只要把逗号分隔的不同的数据项使用方括号括起来即可，如果要同时处理多个数据，可以考虑列表。

​ 2 )列表是可变的（可变是指列表元素的个数和元素的值可变–列表支持增删改）

​ 3）列表是有序的（元素有顺序对应的位置信息；元素的顺序影响结果–列表支持下标操作）

​ 4）列表对元素的要求：没有要求（任何类型的数据都可以作为列表的元素）

注：元素 —容器中每一个独立的数据，就是这个容器的元素

（2）创建列表

变量名=[数据项1,数据项2,·····，数据项n]；括号中的数据可以是任何数据类型，但数据有位置（索引），相同的元素在不同的位置都是不一样的（[10,20,30]!=[30,10,20]），因为列表中的下标都是从0开始，顺序改变下标所对应的值也会改变。

注意：列表中加一个空格也是一个空列表

​ 1）一个列表中的元素可以是多个相同类型的数据

list1=[10,20,30]

​ 2）一个列表中的元素可以是多个不同类型的数据

list2=[10,20,'xiaohua',True]

​ 3）列表中的元素也可以是列表

list3=[10,20,[80,600]]
#列表中的元素个数有三个

（3）.列表的查询

​ 1）查单个：获取一个元素

​ a.语法：列表[索引]–获取列表中指定索引对应的元素

​ b.说明：

​ 列表-需要获取元素的列表对象（可以是保存一个列表的变量，，也可以是具体的列数据）

​ [ ]-固定写法

​ 索引-又叫下标，指的是元素在列表中的位置（从0开始），列表一旦确定，列表中的每个元素的对应的索引就确定了（元素从前往后索引从0开始不断递增；元素从后往前从-1开始不断减少）

nums=[1,2,3,4]
print(num[0])
#结果
1

print([10,20,30,40][1])
#结果
20

​ 2）切片：同时获取多个元素（列表的结果还是列表）

​ a.完整的语法：

​ 列表[开始下标：结束下标：步长]

​ 列表-需要获取的元素列表

​ [ ]-固定写法

​ 开始下标，结束下标，步长-必须是整数

​ 开始下标-决定从哪里取（可以为负）

​ 结束下标-取到哪里结束（可以为负）

​ 步长-如何取（一个一个按顺序取还是跳着取；从前往后还是从后往前）

​ b.切片的结果

  • 第一步：先确定结果是否为空，看开始下标的对应的位置到结束下标对应的位置的方向和步长的方向是否一致，一致结果不为空，不一致结果为空（例：[5,0,2]从下标为5开始到0的位置，从后往前，但步长的方向是从前往后，方向不一致，结果为空）

  • 第二步：如果结果不为空，再确定切片的有效范围：开始下标对应的元素能取到，结束下标对应的元素取不到

  • 第三步：在有效范围内，按照步长的返方向和绝对值获取元素（方向：步长为正，从开始下标到结束下标从前往后取；步长为负就从后往前；绝对值：绝对值为1，就一个一个的取，绝对值为2，取一个跳一个再取一个…）

    movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
print(movies[1:-1:1])#['霸王别姬'，'阿甘正传','钢铁侠','蜘蛛侠','蝙蝠侠','蚁人','雷神']
print(movies[-1:1:-2])#['复仇者联盟','蚁人','蜘蛛侠','阿甘正传']
print(movies[-2:5:2])#[]  开始下标和结束下标的方向与步长方向不一致，结果为空
print(movies[0:-2:4])#['肖申克的救赎','蜘蛛侠']
print(movies[5:-1:2])#['蝙蝠侠','雷神']
print(movies[6:-6:-1])#['蚁人','蝙蝠侠','蜘蛛侠']

​ c.怎么写切片代码获取指定元素

  • 确定开始下标：需要的结果中的第一个数据再列表的下标

  • 确定结束下标：结束下标是结果中最后一项的后一个数据或者前一个数据的下标

  • 确定步长：正负看趋势（从前往后还是从后往前）；再看绝对值（看取得时候是一个一个的取还是跳着取）

    # ['肖生克的救赎', '钢铁侠', '蚁人']
# ['复仇者联盟', '雷神', '蚁人', '蝙蝠侠']
# ['钢铁侠', '霸王别姬']
# ['雷神', '蝙蝠侠', '钢铁侠']
# ['霸王别姬', 蝙蝠侠']
print(movies[0: -2: 3])
print(movies[-1: -5: -1])
print(movies[3: 0: -1])
print(movies[-2: -7:-2])
print(movies[1: 6:4])

​ d.切片省略的写法

  • 省略步长-相当于默认步长为 +1：列表[开始下标：结束下标]–注意看步长的
  • 省略开始下标：列表[:结束下标：步长]–获取元素从头开始(步长为正，从第一个元素开始取，步长为负，从最后一个元素开始取）
  • 省略结束下标：获取元素从开始下标开始，取完为止（有可能是第一个，也有可能是最后一个，看步长的方向）

​ 3）遍历：一个一个的获取列表中的所有元素

  • 方法1：直接获取元素

    for 变量 in 列表：

    ​ 循环体（变量依次获取到的就是列表中的每个元素）

    count=0
score=[88,69,91,94,78,85]
for x in score:
    if x>90:
        count+=1
print(count)
#结果
2

    • 方法2 ：通过获取所有元素的下标来获取元素

      for 变量 in range(len(列表长度))：

      ​ 循环体（列表[变量]）

for i in range(len(score)):
    print(i,score[i])
    #结果
0 88
1 69
2 91
3 94
4 78
5 85

  • 方法3

    for 变量1，变量2 in enumerate（列表）：

    ​ print（变量1，变量2）

    其中还变量1是下标，变量2是数据

    score=[88,69,91,94,78,85]
for index,num in enumerate(score):#其中index是下标，num是数据
    print(index,num)
#结果

0 88
1 69
2 91
3 94
4 78
5 85

    （4）列表元素的修改

    1）列表元素的增加

    • 列表.append(元素)–在指定列表最后添加指定的元素（不会产生新的元素，而是直接在原列表中添加）

      #案列1
heros=["亚瑟","王昭君","芈月","铠","宫本"]
print(heros)
heros.append("鲁班")
print(heros)

#结果
['亚瑟', '王昭君', '芈月', '铠', '宫本']
['亚瑟', '王昭君', '芈月', '铠', '宫本', '鲁班']

#案列2:将不及格的数提取出来（先创建一个空列表，在原有的列表中进行循环，循环到不及格的分数就将其添加到空列表中）
score=[88,69,91,94,78,85]
score1=[]
for i in score:
    if i <90:
        score1.sppend(i)
print(score1) 

#结果
[88, 76, 66]


#案列3 将偶数提取出来
nums = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
num1 = []
for i in nums:
    if i % 2 == 0:
        num1.append(i)
print(num1)


#案列4 将不及格的分数改为“补考“
num2=[]
for x in nums:
    if x >=60:
        num2.append(x)
    else:
        num2.append("补考")
print(num2)

#结果
[89, '补考', 99, 65, 93, 81, '补考', 88, 76, '补考', 66]
      • 列表.insert(index（下标），元素)–将指定元素插入到指定的位置
heros=["亚瑟","王昭君","芈月","铠","宫本"]
print(heros)
heros.insert(-1,"鲁班七号")
heros.insert(1,"妲己")
print(heros)


#结果
['亚瑟', '王昭君', '芈月', '铠', '宫本']
['亚瑟', '王昭君','妲己', '芈月', '铠', '鲁班七号', '宫本']

（2）列表元素的删除

  • del 列表[下标]–（从内存中删除）
heros=["亚瑟","王昭君","芈月","铠","宫本"]
print(heros)
heros.insert(-1,"鲁班七号")
heros.insert(1,"妲己")
print(heros)

del heros[1]#删除王昭君

#结果
['亚瑟', '王昭君', '芈月', '铠', '宫本']
['亚瑟', '王昭君','妲己', '芈月', '铠', '鲁班七号', '宫本']
['亚瑟', '芈月', '铠', '鲁班七号', '宫本']

  • 列表.remove(元素)–删除列表中的指定元素（同时也删除内存中的）

    注意：如果要删除的元素在列表中不存在，会报错；如果要删除的元素在列表中有多个指，那么只删除列表中最前面的那一个（从前往后找到的第一个）

    heros=["亚瑟","王昭君","芈月","铠","宫本"]
heros.remove("芈月")
print(heros)
#结果
["亚瑟","王昭君","铠","宫本"]
    • 列表.pop(下标)–取出列表中指定下标的元素；列表.pop()不添加下标就是默认取出最后一个元素(注意pop（）是取出列表中的元素，并不是真正意义上的删除，但在内存上还存在)
heros=['亚瑟', '王昭君', '芈月', '铠']
heros.pop()
heros.pop(0)
print(heros)
#结果
['王昭君', '芈月']


#案例 ：将列表中的数分为奇数和偶数
nums = [12, 37, 5, 42, 8, 3]
even = []#创建两个新的列表，分别用于存储技术和偶数
odd = []
while len(nums)>0:
    num = nums.pop()#逐个取出列表中的元素，将它赋值给一个变量
    if num % 2 == 0:
        even.append(num)#如果变量是偶数，将变量中的值添加到存放偶数的列表中
    else:
        odd.append(num)
print(even, odd)
#结果
[8, 42, 12] [3, 5, 37]

（3）列表元素的修改

  • 列表[下标]=新元素–将列表指定下标对应的元素改成新元素
heros=['亚瑟', '王昭君', '芈月', '铠']
heros[0]="典韦"
#结果
['典韦', '王昭君', '芈月', '铠']


#练习:将scores中所有低于60分的成绩改为0
scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
for index in range(len(scores)):
    if scores[index]<60:#如果列表下标对应的元素小于60
        scores[index]=0
print(scores)

#结果
[89, 0, 99, 65, 93, 81, 0, 88, 76, 0, 66]

（5）列表的运算

  • 列表的加法运算

    列表1+列表2–将两个列表合并成一个新的列表

    num1 = [10, 20, 30]

num2 = [100, 200]

num3 = num1 + num2
print(num3)
#结果
[10, 20, 30, 100, 200]

  • 列表的乘法运算

    列表N或者N列表–将列表中的元素重复N次产生一个新的列表

    num1 = [10, 20, 30]
print(num1*2)
#结果
[10, 20, 30, 10, 20, 30]

  • 列表的比较运算

    1）比较是否相等== ,！=

    print([10,20,30]==[10,20,30])
#结果
True


print([10,20,30]==[10,30,20])#列表有顺序
#结果
False

    2）比较大小<,>,>=,<=

    列表1>列表2–两个列表比较大小，比较的是第一对（相同位置上的元素是一对）不相等的元素的大小

    pritn([10,20,30]>[1,100,200,300,400])
#结果
True

print([10,20,30]>[10,2,200,300,400])
#第一对相等的时候比较第二对......
#结果
True

  • in 和not in

    元素 in 列表–判断列表中是否存在指定的元素

    元素 not in列表—判断元素是否不存在指定元素（可以用作删除重复的元素）

    print(10 in [10,20,30])
#结果
True


print(10 in [[10,20],30])
#结果
False

print([10,20] in [10,20,30])
#结果
False



#案例 
# 已知A和B，打印A和B的公共元素
#方法1
A = ['后羿', '甄姬', '鲁班7号', '赵云']
B = ['小乔', '孙悟空', '猪八戒', '后羿', '盾山', '赵云']
for x in range(len(A)):
    for y in range(len(B)):
        if A[x] == B[y]:
            same=A[x]=B[y]
            print(same)
            
            
#方法2，判断前一个循环的值是否也在B
A = ['后羿', '甄姬', '鲁班7号', '赵云']
B = ['小乔', '孙悟空', '猪八戒', '后羿', '盾山', '赵云']
for i in A:
    if i in B:
        print(i)

1.1.列表（序列）相关函数

（1） sum（数字序列）-求数字序列中所有元素的数值和

​ 注意：sum（）函数中必须是数字

score=[98,88,69,70,85]
print(sum(score))

#结果
410

（2）max，min–比较序列中的最大值和最小值

  • max(序列)-求序列中的最大元素

    score=[98,88,69,70,85]
print(max(score))
#结果
98

  • min(序列)-求序列中的最小元素

score=[98,88,69,70,85]
print(min(score))
#结果
69

补充：求最大值和最小值的逻辑（不用max和min函数）：假设第一个元素是最大值，将其赋值给一个变量用于保存最大值，然后依次取出后面的元素与之比较，如果后一个元素比第一个元素（最大值）大，将后面的元素赋值给保存最大值的变量，依次类推，直到找到最大值。

# 最大值的一般逻辑（不用max函数）
score = [98, 88, 69, 70, 85]
max1 = score[0]  # 定义一个变量用于存放最大值，假设第一个元素是最大值
for i in score[1:]:  # 循环遍历所有的元素
    if i > max1:  # 将遍历的元素依次与第一个元素作比较，如果后一个元素比前一个元素大，将后一个元素赋值给存放最大值的变量，依次类推
        max1 = i
print(max1)

（3）sorted()–sorted是函数，不是方法（不能使用列表.sorted()的形式）

  • sorted(序列)-将序列中的元素按照从小到大的方式排序，创建一个新的序列**（并不会修改序列的顺序，而是创建一个新的序列并且返回）**

    score = [98, 88, 69, 70, 85]
result=sorted(score)
print(result)
print(score)
#结果
[69, 70, 85, 88, 98]
[98, 88, 69, 70, 85]

  • sorted(序列，reverse=True)–将序列中的元素按照从大到小的方式排序，创建一个新的列表并且返回（也不会改变原有列表的顺序）

score = [98, 88, 69, 70, 85]
result=sorted(score,reverse=True)
print(result)
[print(score)]

#结果
[98, 88, 85, 70, 69]
[98, 88, 69, 70, 85]

（4）len()

len（序列）-统计序列中元素的个数（长度）

score = [98, 88, 69, 70, 85]
print(len(score))
print(len(range(1,100,2)))
print(len(range(1,100)))
#结果
7
50
100

(5) list()

list（序列）-将指定的序列转换为列表（任何序列都可以转换为列表，转换的时候直接将序列中的元素转换为列表中的元素）

result='asd123'
print(list(result))
#结果
['a', 's', 'd', '1', '2', '3']


num1=list(range(5))
print(num1)
#结果
[0, 1, 2, 3, 4]

1.2.列表相关方法

通用形式：列表.xxx()–查看方式：list，按住ctrl键点击list可以查看所有方法

  • 列表.clear（）-清空列表

    
nums=[10,20,58,66,92]
nums.clear
print(nums)
#结果
[]

nums=[10,20,58,66,92]
print(nums)
nums=[]
print(nums)

#结果
[10,20,58,66,92]#之前
[]#之后

  • 列表.count(元素)-统计列表中指定元素的个数

    nums=[10,20,58,66,92]
print(nums.count(10))
#结果
1

  • 列表.extend(序列)–将序列中的元素全部添加到列表中

    list1=[10,20]
list1.extend([300,500,60])
print(list1)
list1.extend('abc')
print(list1)
list1.extend(range(5))
print(list1)
#结果
[10, 20, 300, 500, 60]
[10, 20, 300, 500, 60, 'a', 'b', 'c']
[10, 20, 300, 500, 60, 'a', 'b', 'c', 0, 1, 2, 3, 4]

  • 列表.index（元素）-获取列表中指定元素对应的的下标

    a.元素不存在列表中会报错（valueError：not in list）

    b.元素存在多个值，会返回第一个值的下标

list1=[10, 20, 300, 500, 60, 'a', 'b', 'c', 0, 1, 2, 3, 4]
print(list1.index(10))
#结果
0
  • 列表.reverse（）-将列表倒序
nums=[10,20,30,40,50,60]
nums.reverse()
print(nums)
#结果
[60, 50, 40, 30, 20, 10]

  • 列表.sort（）-将类表中的元素从小到大排序（直接修改原列表中的顺序，只针对列表，对其他序列无效），基于原列表进行修改，只需要看原列表（不输出任何数据）

    列表sorted（序列）-将序列中的元素从小到大的排序（不修改原序列中的元素的顺序，而是创建一个新的序列）

    我们在平时使用过程中要先考虑原数据是否有价值或影响到后面结果的使用来选择使用sort还是sorted

score = [98, 88, 69, 70, 85]
result=score.sort()
print(score)#sort是在原列表中进行修改，会破坏原有的数据，
print(result)#sort在原列表上进行修改，本身不输出任何数据

#结果
[69, 70, 85, 88, 98]
None

  • 直接赋值和拷贝

    直接赋值和拷贝的区别在于修改操作的时候数据的变化

    直接赋值底层逻辑：当变量在申请内存空间时，变量中存放的是数据在内存空间对应的地址（python中的变量都是指针变量），将数据和内存空间联系（绑定）起来（或者说将数据对应的地址给变量）。

    拷贝的底层逻辑：当我们在拷贝时，系统会根据数据大小申请新的内存空间，变量中存放的是新的内存空间的地址，当我们在拷贝时只复制数据，再将新的内存空间联系起来，在进行数据的修改操作时在新的内存空间中修改（并不会绑定原来的内存空间）。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nPGnJLtR-1678886643408)(C:\Users\杨文琪\Desktop\赋值和拷贝的底层逻辑.png)]

    
# 1.列表和直接赋值
# 需求：已知一个列表，现在需要创建以恶搞和原列表一摸一样的新列表

nums = [10, 20, 30, 40]
# （1）直接赋值--一个变量直接给另一个变量赋值，赋的是地址，赋值后两个变量指向的的是同一个地址空间（内存）

nums2 = nums
print(nums)
print("nums2:",nums2)

#(2)拷贝--一个变量通过拷贝的方式给另一个变量，赋值的时候会先复制原来的变量中的数据，创建一个新的数据，然后将新的数据对应的内存地址给新的变量
nums3=nums*1
print("nums3:",nums3)
nums4=nums+[]
print("nums4:",nums4)

nums5=nums[::]
print("nums5:", nums5)

nums6=nums.copy()
print("nums6",nums6)



print("___________分割线___________")
#区别在于直接赋值操作和拷贝在修改数据时



nums.append(100)
print(nums)
print("nums2:",nums2)

print("nums3:",nums3)
print("nums4:",nums4)
print("nums5:", nums5)
print("nums6:",nums6)


#结果
[10, 20, 30, 40]
nums2: [10, 20, 30, 40]
nums3: [10, 20, 30, 40]
nums4: [10, 20, 30, 40]
nums5: [10, 20, 30, 40]
nums6 [10, 20, 30, 40]
___________分割线___________
[10, 20, 30, 40, 100]
nums2: [10, 20, 30, 40, 100]#nums和nums2绑定的地址空间是同一个，我们在修改nums的时候也会修改nums2的数据（nums和nums2对应的地址空间是同一个，我们在nums的内存地址中修改相当于也在nums2的内存地址修改）
nums3: [10, 20, 30, 40]
nums4: [10, 20, 30, 40]
nums5: [10, 20, 30, 40]
nums6: [10, 20, 30, 40]

    1.3. 列表推导式–常用

    列表推导式的作用：快速创建列表的表达式（代码简洁）-（创建的是新列表）

    • 列表推导式结构1

      1） 语法：[表达式 for 变量 in 序列]

      2） 让变量取序列中取值，一个一个的取，取完为止，每取一个就计算一次表达式的结果，并将计算结果作为列表的一个元素

result=[10 for i in range(5)]
print(result)
#结果
[10，10，10，10，10]



result=[i*2 for i in range(5)]
print(result)

#结果
[0, 2, 4, 6, 8]

#案例：将nums中所有元素乘2
nums=[10,23,88,69]
result=[i*2 for i in nums]
print(result)
#结果
[20, 46, 176, 138]


#案例2：获取nums中的所有元素个位数
nums=[103,230,22,69]
result=[i%10 for i in nums]
print(result)

#结果
[3, 0, 2, 9]

  • 列表推导式结构2

    1）语法

    [表达式 for 变量 in 序列 if 条件语句]

    2）让变量取序列中取值，一个一个的取，取完为止，每取一个值就判断一次条件是否成立，成立就计算表达式的值作为列表的元素，不成立就取下一个，并将计算结果作为列表的一个元素（遍历–>判断–>计算）。表达式部分只考虑元素和元素的关系。

result=[x*2 for x in range(5) if x%2==0]
print(result)
#结果
[0, 4, 8]

#案例1：删除score中所有不及格的分数--元素和元素本身的关系是它本身
score=[80,99,23,67,82,76,45]
result=[x for x in score if x>=60]
print(result)

#结果
[80, 99, 67, 82, 76]

#案例2：提取奇数的个位数--元素和元素的关系是与10取余的关系
nums=[103,230,22,69]
result=[i%10 for i in nums if i%2!=0 ]
print(result)

#结果
[3, 9]

（二）三目运算符

三目运算符–运算对象有三个运算符就是三目运算符

1.c语言的三目运算符- ？：

  • 条件语句？表达式1的结果：表达式2的结果 --如果条件为真，整个运算结果是值1，否则就是表达式2的结果

2.python的三目运算符

  • 表达式1 if 条件语句 else 表达式2–判断条件语句是否成立，如果成立整个运算表达式的结果就是表达式1的值，否则就是表达式2的值
age=10
result='成年' if age>=18 else '未成年'
print(result)

#结果
未成年

（三）字典

如果需要同时保存多个意义相同的数据使用列表，如果需要同时保存多个意义不同的数据使用字典

1.认识字典（dict）

1）字典是容器型数据类型；将{}作为容器的标志，里卖弄多个键值对用逗号隔开（一个键值对就是一个元素）：{键1：值1，键2：值2，键3：值3，…}

2）字典是可变的(支持增删改)；字典是无序的（顺序不影响结果，不支持下标操作）

3）字典的元素：由键和值组成，其中值才是真正想要保存的数据，键是用来对值进行区分和说明的

  • 键只能是不可变类型的数据（数字，字符串，布尔都是不可变的类型

  • 键是唯一的（出现重复的不会报错，只会打印一次，会用后面的值覆盖前面的值）

  • 值：没有要求（任何数据类型都可以作为字典的值）

information={"身高":180,"体重":60,"年龄":18,True:30,10:20}
print(information)

information1={'a':10,10:20,'a':30}
print(information1)

#结果
{'身高': 180, '体重': 60, '年龄': 18, True: 30, 10: 20}
{'a': 30, 10: 20}

2.字典的操作

（1） 字典的查询–获取字典的值

  • 查单个（最重要）–获取字典中的某一个值，如果键不存在会报错

    • 字典[键] --获取字典中指定键对应的值

      information = {"身高": 180, "体重": 60, "年龄": 18, "address": "北京市朝阳区", "门牌号": 20}
print(information['身高'])
print(information["体重"])

#结果
180
60

    • 字典.get(键)–获取字典中指定键对应的值，如果键不存在会返回空（None）（返回空后做运算的时候也会报错）

      注意：可以多个get连用以及用上列表下标

    • 字典.get(键，默认值)–获取字典中指定键对应的值，如果要获取键对应的值不存在则用默认值替代

      information = {"身高": 180, "体重": 60, "年龄": 18, "address": "北京市朝阳区", "门牌号": 20}
print(information.get("address"))
print(information.get("weight",60))#获取weight对应的值，但不存在，不存在则返回60
#结果
北京市朝阳区
60

      • 真正的字典–生活的角度看数据

        #案例：定义一个变量保存一个班级的信息

class1 = {
    'name': 'python2301',
    'location': '21教',
    'lecturer': {
        'name': '余婷',
        'age': 18,
        'gender': '女',
        'tel': '13678192302'
    },
    'headTeacher': {
        'name': '萍姐',
        'age': 18,
        'tel': '110'
    },
    'all_student': [
        {
            'name': 'stu1', 'age': 18, 'tel': '119', '专业': '电子商务', 'score': 78,
            'linkman': {'name': '张三', 'tel': '82223111'}
        },
        {
            'name': 'stu2', 'age': 23, 'tel': '8293', '专业': '计算机软件', 'score': 100,
            'linkman': {'name': '李四', 'tel': '829933'}
        },
        {
            'name': 'stu3', 'age': 30, 'tel': '918111', '专业': '数学', 'score': 96,
            'linkman': {'name': '小明', 'tel': '11929203'}
        },
        {
            'name': 'stu4', 'age': 16, 'tel': '827222', '专业': '数学', 'score': 99,
            'linkman': {'name': '王五', 'tel': '8628101'}
        }
    ]

}

    # 1) 获取班级名字
print(class1["name"])
# 2）获取班级的位置


print(class1["location"])

# 3）获取讲师的名字

print(class1["lecturer"]["name"])
#class1获取的结果还是一个字典，既然是字典那么同样还可以用字典的查值方法：字典[键]或者字典.get(键)
#方法2：print(class1.get("lecturer").get["name"])

# 4）获取班主任的电话
print(class1["headTeacher"]["tel"])


# 5）获取第一个学生的专业

print(class1["all_student"][0]["专业"])
#print(class1["all_student"])--是一个列表
#print(class1["all_student"][0])--取到列表的第一个元素，是一个字典
#print(class1["all_student"][0]["专业"])--取到第一个学生（字典）后取到他的专业

# 6）获取所有学生的名字
all_stu=class1["all_student"]
for i in all_student:#同样遍历的i也是一个字典
    print(i["name"])#取到name的值

# 7）获取所有学生的联系人名字
for i in all_student :
    print(x["linkman"]["name"])
    

# 8）获取未成年学生的联系人电话

for i in all_student:
    ifi["age"]<18:#在all_student中遍历，如果取到age小于18的值
        print(x[linman][tel])

  • 遍历

    for 变量 in字典：

    ​ 循环体（变量依次获取到的是字典的键）

    注意：循环出来的每一个元素都是一个字典

    • 增删改

      1.增-添加键值对

      1）字典[键]=值-————如果键不存在就添加键值对，键存在就会修改

      information = {"身高": 180, "体重": 60, "年龄": 18, "address": "北京市朝阳区", "门牌号": 20}
information["location"]="三栋"
#结果
{'身高': 180, '体重': 60, '年龄': 18, 'address': '北京市朝阳区', '门牌号': 20, 'location': '三栋'}

      2）字典.setdefault(键，值)————在字典中添加键值对（如果键不存在就添加键值对，如果存在不会修改键的值）

      information = {"身高": 180, "体重": 60, "年龄": 18, "address": "北京市朝阳区", "门牌号": 20}
information["location"]="三栋"

print(information)
information["身高"]=190
information.setdefault("tel",10026)
print(information)


#结果
{'身高': 180, '体重': 60, '年龄': 18, 'address': '北京市朝阳区', '门牌号': 20, 'location': '三栋'}
{'身高': 190, '体重': 60, '年龄': 18, 'address': '北京市朝阳区', '门牌号': 20, 'location': '三栋', 'tel': 10026}

      2）改-修改键对应的值

      字典[键]=值—如果键存在就修改指定键对应的值

      3）删除

      a. del 字典[键]————删除指定键对应的键值对

      information = {"身高": 180, "体重": 60, "年龄": 18, "address": "北京市朝阳区", "门牌号": 20}
del information["年龄"]

#结果
{'身高': 180, '体重': 60, 'address': '北京市朝阳区', '门牌号': 20, '}

      b. 字典.pop()————取走字典中指定键对应的值，并且返回（并不是从内存删除，而且取走，还能用）

information = {"身高": 180, "体重": 60, "年龄": 18, "address": "北京市朝阳区", "门牌号": 20}

information.pop("身高")
print(information)


#结果
{'体重': 60, '年龄': 18, 'address': '北京市朝阳区', '门牌号': 20}

information = {“身高”: 180, “体重”: 60, “年龄”: 18, “address”: “北京市朝阳区”, “门牌号”: 20}
information[“location”]=“三栋”

print(information)
information["身高"]=190
information.setdefault("tel",10026)
print(information)


#结果
{'身高': 180, '体重': 60, '年龄': 18, 'address': '北京市朝阳区', '门牌号': 20, 'location': '三栋'}
{'身高': 190, '体重': 60, '年龄': 18, 'address': '北京市朝阳区', '门牌号': 20, 'location': '三栋', 'tel': 10026}
~~~



2）改-修改键对应的值

字典[键]=值---如果键存在就修改指定键对应的值



3）删除

a.	del 字典[键]————删除指定键对应的**键值对**

~~~python
information = {"身高": 180, "体重": 60, "年龄": 18, "address": "北京市朝阳区", "门牌号": 20}
del information["年龄"]

#结果
{'身高': 180, '体重': 60, 'address': '北京市朝阳区', '门牌号': 20, '}
~~~

b.	字典.pop()————取走字典中指定键对应的值，并且返回（并不是从内存删除，而且取走，还能用）

information = {"身高": 180, "体重": 60, "年龄": 18, "address": "北京市朝阳区", "门牌号": 20}

information.pop("身高")
print(information)


#结果
{'体重': 60, '年龄': 18, 'address': '北京市朝阳区', '门牌号': 20}
TiAmo_bug
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值