元组和字典

最新推荐文章于 2025-11-12 11:17:57 发布

原创最新推荐文章于 2025-11-12 11:17:57 发布 · 991 阅读

1 ·

CC 4.0 BY-SA版权

元组和字典

列表的方法

1.列表.clear() - 清空列表(删除列表中所有的元素)

nums = [10, 2, 4, 5]
nums.clear()
print(nums)   # []

2.列表.copy() - 复制原列表产生一个一模一样的新列表，将新列表返回
列表[:]、列表+[]、列表*1的功能和列表.copy()的功能一模一样
id(变量) - 获取变量中保存的数据的地址

nums = [10, 2, 4, 5]    # 变量保存数据其实是保存的数据在内存中的地址
print('nums:', id(nums))

# 将nums中保存的数据的地址赋给nums
nums3 = nums
print(nums3)     # [10, 2, 4, 5]
print('num3:', id(nums3))

# 复制nums中地址对应的数据，在新的内存中保存，然后将新的地址返回
nums2 = nums.copy()
print(nums2)    # [10, 2, 4, 5]
print('nums2:', id(nums2))

del nums[-1]
print(nums3)    # [10, 2, 4]
print(nums2)    # [10, 2, 4, 5]

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

nums = [29, 78, 67, 29, 78, 78, 100]
print(nums.count(78))   # 3

4.列表.extend(序列) - 将指定序列中所有的元素全面添加到列表的后面

nums = [1, 2]
nums.extend('abc')
print(nums)   # [1, 2, 'a', 'b', 'c']

5.列表.index(元素) - 获取指定元素在列表中的下标(下标是0开始增加的下标)
如果元素有多个，只返回最前面那一个的下标
如果元素不存会报错

movies = ['怦然心动', '阿甘正传', '绿皮书', '肖生克的救赎', '触不可及', '阿甘正传', '当幸福来敲门']
print(movies.index('触不可及'))   # 4
print(movies.index('阿甘正传'))   # 1
# print(movies.index('沉默的羔羊'))     # ValueError: '沉默的羔羊' is not in list

6.列表.reverse() - 将列表倒序

movies = ['怦然心动', '阿甘正传', '绿皮书', '肖生克的救赎', '触不可及', '阿甘正传', '当幸福来敲门']
movies.reverse()
print(movies)   # ['当幸福来敲门', '阿甘正传', '触不可及', '肖生克的救赎', '绿皮书', '阿甘正传', '怦然心动']

7.列表.sort()
.sort() - 将列表中的元素从小到大排序（不会产生新的列表）
列表.sort(reverse=True)

nums = [23, 89, 90, 23, 45, 28, 78]
result = nums.sort()
print(result)    # None
print(nums)     # [23, 23, 28, 45, 78, 89, 90]

nums = [23, 89, 90, 23, 45, 28, 78]
nums.sort(reverse=True)
print(nums)

元组

1.什么是元组（tuple）

元组是容器型数据类型（序列）；将()作为容器的标志，里面多个元素用逗号隔开：(元素1, 元素2, 元素3,…)
元组是不可变(不支持增删改);元组是有序的(支持下标操作)
元素：任何类型的数据都可以作为元组的元素

空元组

t1 = ()
print(t1, type(t1))

2.元组就是不可变的列表 - 列表中除了增删改以外的操作都适用于元组

2.1获取元素

t3 = ('绿色', '黄色', '粉色', '红色', '白色')

print(t3[1], t3[-4])    # 黄色 黄色

print(t3[1:3])      # ('黄色', '粉色')
print(t3[::-2])     # ('白色', '粉色', '绿色')

for x in t3:
    print('x:', x)

for index in range(len(t3)):
    print(index, t3[index])

2.2相关操作

t3 = ('绿色', '黄色', '粉色', '红色', '白色')
print('黑色' in t3)    # False
print('白色' in t3)    # True

t4 = (10, 20)
t5 = (100, 200, 300)
print(t4 + t5)      # (10, 20, 100, 200, 300)
print(t4 * 3)       # (10, 20, 10, 20, 10, 20)

print(t4 == (10, 20))       # True
print(t4 == (20, 10))       # False

print(t4 > (1, 100, 200, 300))      # True

print(max(t5))    # 300
print(min(t5))    # 100
print(sum(t5))    # 600
new_nums = sorted((23, 78, 90, 45))
print(new_nums)     # [23, 45, 78, 90]

print(tuple(new_nums))      # (23, 45, 78, 90)

3.元组特有和更常用的相关操作

3.1 只有一个元素的元组: 必须在唯一的元素的后面添加逗号

t1 = (100,)
print(t1, type(t1), len(t1))

3.2 在没有歧义的情况下元组的小括号可以省略

直接将多个数据用逗号隔开表示的也是一个元组

t2 = 23, 56, 78
print(t2, type(t2))     # (23, 56, 78) <class 'tuple'>

3.3 直接使用多个变量获取元组中的元素

1)让变量的个数和元组中元素个数保持一致

subjects = ('Python', 'Java', 'H5', 'UI')
x1, x2, x3, x4 = subjects
print(x1, x2, x3, x4)

让变量的个数小于元组中元素的个数，并且在其中某一个变量前加*。

获取的时候先让不带的变量按位置获取对应的元素，剩下的元素全部由带的变量获取（列表)

student = ('小明', 18, 89, 78, 23, 8, '男')
name, *others, sex = student
print(name, sex, others)    # 小明 男 [18, 89, 78, 23, 8]

4.元组相关方法

1）元组.count(元素) - 统计元组中指定元素的个数

2）元组.index(元素) - 获取元素在元组的下标

字典

1.什么是字典（dict）

字典是容器型数据类型(序列);
将{}作为容器的标志，里面多个元素用逗号隔开，每一个元素都是一个键值对：{键1: 值1, 键2: 值2, 键3: 值3, …}
字典是可变的(支持增删改); 字典是无序(不支持下标操作)

字典保存数据其实真正想要保存的是值，键是用来对值进行区分和说明。

元素：字典的一个元素是一个键值对
键 - 必须是不可变的类型的数据(数字、字符串和元组)，但是一般使用字符串；键是唯一的
值 - 可以是任何类型的数据

空字典

d1 = {}

键是不可变的数据

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

# d3 = {'a': 10, 10: 20, [10, 20]: 30}     # 报错！列表不能作为键

键是唯一的

d4 = {'a': 10, 'b': 20, 'a': 30}
print(d4)       # {'a': 30, 'b': 20}

字典是无序的

print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})    # Tru

增删改查
2.1 查 - 获取字典中某个元素的值
1）查单个
字典[key] - 获取字典中指定key对应的值, 如果key不存在会报错
字典.get(key) - 获取字典中指定key对应的值，如果key不存在返回None
字典.get(key, 默认值) - 获取字典中指定key对应的值，如果key不存在返回默认值

student = {'姓名': '小明', 'age': 30, 'gender': '男', 'height': 175, 'weight': 73, 'grade': 65}
print(student['gender'])   # 男
print(student['weight'])    # 73
# print(student['score'])   # KeyError: 'score'

print(student.get('height'))    # 175
print(student.get('score'))     # None
print(student.get('score', 0))  # 0

2）遍历

for 变量 in 字典:
循环体

注意：变量依次取到的时候字典的键

student = {'姓名': '小明', 'age': 30, 'gender': '男', 'height': 175, 'weight': 73, 'grade': 65}
for x in student:
   print('x:', x, student[x])

序列表达式

1.列表推导式 - 通过序列创建列表的一种特殊的表达式

结构1： - 变换

[表达式 for 变量 in 序列]

功能：创建一个列表；让变量去序列中取值，每取一个值产生一个元素(元素就是对应表达式的值)
list1 = []
for 变量 in 序列:
list1.append(表达式)

result = [x*2 for x in range(3)]
print(result)      # [0, 2, 4]

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

功能：
list1 = []
for 变量 in 序列:
if 条件语句:
list1.append(表达式)

nums = [23, 23.4, True, 'abc', 230, 100, '23', 2.12]
# [23, 230, 100]
result = [x for x in nums if type(x) == int]
print(result)    # [23, 230, 100]

三目运算符：表达式1 if 条件语句 else 表达式2 - 如果条件语句为True，整个运算表达式的结果是表达式1的值否则是表达式2的值

作业

1.创建一个列表，列表中有10个舒宗, 保证列表中元素的顺序，对列表进行排重,并对列表使用进行降序排序

例如：随机生成了[70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
		--- 去重之后 [70, 88, 91, 107, 234, 177, 282, 197]
  	---- 降序排序 [282, 234, 197, 177, 107, 91, 88, 70]

list1 = [70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
list2 = []
for i in list1:
    if i not in list2:
        list2.append(i)
list2.reverse()
print(list2)

2.利用列表推导式, 完成以下需求

a. 生成一个存放1-100中各位数为3的数据列表

结果为 [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]

nums = [10* i +3 for i in range(10)]
print(nums)

b. 利用列表推到是将列表中的整数提取出来

例如：[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]

nums = [i for i in [True, 17, "hello", "bye", 98, 34, 21] if type(i) == int]
print(nums)

c.利用列表推导式存放指定列表中字符串的长度

例如 ["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]

lens = [len(i) for i in ["good", "nice", "see you", "bye"]]
print(lens)

3.已知代码如下，请回答出各个print的结果并说明原因

nums = [17, 39, 28, 51]
nums2 = nums
nums2.pop()
print(len(nums)) # 这个结果是什么   请描述原因

结果是:3
赋值后nums和nums2指向的内存地址相同，nums2取出一个元素，nums也会少一个，所以结果是3

numlist = [17, 22, 39, 58, [55, 43]]
nums3 = numlist.copy()
print(numlist is nums3) # 结果  原因是什么

结果是:False
使用.copy()方法，相当于新申请了一块内存存相同的值，但是内存地址和numlist不同，所以是False

numlist[-1][0] = 99
print(nums3) # num3会不会发生变化

不会，因为操作的不同内存地址上的值

4.定义一个列表，在列表中保存6个学生的信息(学生信息中包括: 姓名、年龄、成绩(单科)、电话、性别(男、女、不明) )
a.统计不及格学生的个数
b.打印不及格学生的名字和对应的成绩
c.统计未成年学生的个数
d.打印手机尾号是8的学生的名字
e.打印最高分和对应的学生的名字

f.删除性别不明的所有学生

g.将列表按学生成绩从大到小排序(挣扎一下，不行就放弃)

list1 = [['小1',12,60,18908357845,'男'],['小2',15,90,18908357848,'男'],
         ['小3',11,70,18908357843,'女'],['小4',25,30,18908357844,'女'],
         ['小5',7,40,18908357868,'不明'],['小6',11,20,18908357888,'不明']]
len1 = len(list1)
len2 = len(list1[0][:])
countScoreDown60 = 0
countAgeDown18 = 0
maxscore = 0
#统计不及格学生的个数，打印不及格学生的名字和对应的成绩
for i in range(len1):
    if list1[i][2] < 60:
        countScoreDown60 += 1
        print('不及格学生:',list1[i][0],list1[i][2])
print('不及格学生有：',countScoreDown60,'个')
#统计未成年学生的个数
for i in range(len1):
    if list1[i][1] < 18:
        countAgeDown18 += 1
print('未成年的人数为：', countAgeDown18)
#手机尾号是8的学生的名字
for i in range(len1):
    if list1[i][3] % 10 == 8:
        print('尾号是8的学生：', list1[i][0])
#最高分和对应的学生的名字
for i in range(len1):
    if list1[i][2] > maxscore:
        maxscore = list1[i][2]
for j in range(len1):
    if list1[j][2] == maxscore:
        print('最高分是：', list1[j][0], maxscore)
#删除性别不明的所有学生
list2 = []
for k in range(len1):
    if '不明' not in list1[k]:
        list2.append(list1[k])
print(list2)
#将列表按学生成绩从大到小排序
for i in range(len1-1):
    for j in range(i, len1):
        if list1[i][2] < list1[j][2]:
            list1[i],list1[j] = list1[j],list1[i]
print(list1)