列表的常用函数字典和元组 及作业

本文详细介绍了Python中列表、字典和元组的基本概念、常用操作及其应用场景,包括列表的增删改查、元组的特性及使用、字典的键值对管理等核心知识点。

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

列表的常用函数字典和元组

  1. 列表的常用函数

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

      nums = [10, 2, 4, 5]
      nums.clear()
      print(nums)   # []
      
    2. 列表.copy() - 复制原列表产生一个一模一样的新列表,将新列表返回

      nums = [10, 2, 4, 5]
      new_nums = nums.copy()
      
      print(new_nums)  #[10, 2, 4, 5]
      
    3. 列表.count(元素) - 统计列表中指定元素的个数

      nums = [10, 2, 4, 5, 4, 2, 2, 3, 10]
      
      print(nums.count(2))   #3
      print(nums.count(10))  #2
      
    4. 列表.extend(序列) - 将指定序列中所有的元素全面添加到列表的后面

      i = 'abc13'
      list1 = [1, 3, 4]
      
      list1.extend(i)
      print(list1)  #[1, 3, 4, 'a', 'b', 'c', '1', '3']
      
    5. 列表.index(元素) - 获取指定元素在列表中的下标(下标是0开始增加的下标)

      # 如果元素有多个,只返回最前面那一个的下标
      # 如果元素不存会报错
      
      movies = ['怦然心动', '阿甘正传', '绿皮书', '肖生克的救赎', '触不可及', '阿甘正传', '当幸福来敲门']
      
      print(movies.index('绿皮书'))  		#2
      print(movies.index('触不可及')) 		#4
      # print(movies.index('沉默的羔羊'))     # 如果元素不存会报错
      
      
    6. 列表.reverse() - 将列表倒序

      movies = ['怦然心动', '阿甘正传', '绿皮书', '肖生克的救赎', '触不可及', '阿甘正传', '当幸福来敲门']
      
      movies.reverse()
      print(movies)  # ['当幸福来敲门', '阿甘正传', '触不可及', '肖生克的救赎', '绿皮书', '阿甘正传', '怦然心动']
      
      
    7. 列表.sort() - 将列表中的元素从小到大排序(不会产生新的列表)

      # 列表.sort(reverse = True)
      
      nums = [23, 89, 90, 23, 45, 28, 78]
      
      result = nums.sort()
      print(result)    # None    不会产生新的列表,所以返回 None
      
      print(nums)   # [23, 23, 28, 45, 78, 89, 90]
      
      nums = [23, 89, 90, 23, 45, 28, 78]
      nums.sort(reverse=True)     #从大到小排序
      print(nums)  				#[90, 89, 78, 45, 28, 23, 23]
      
  2. 元组

    1. 什么是元组(tuple)

      """
      元组是容器型数据类型(序列);将()作为容器的标志,里面多个元素用逗号隔开:(元素1, 元素2, 元素3,...)
      元组是不可变(不支持增删改);元组是有序的(支持下标操作)
      元素:任何类型的数据都可以作为元组的元素
      """
      
      # 空元组
      t1 = ()
      
      # 元组
      t2 = (10, 23.8, 'abc', 10)
      print(t2)   #(10, 23.8, 'abc', 10)
      
    2. 元组和列表 通用的部分 - 列表中除了增删改以外的操作都适用于元组

      1. 获取元素

        t3 = ('绿色', '黄色', '粉色', '红色', '白色')
        
        print(t3[1])    #黄色
        print(t3[1:-1]) #('黄色', '粉色', '红色')
        print(t3[::-2]) # ('白色', '粉色', '绿色')
        
        # 遍历元组
        for index in t3:
           print(index,t3[index])
        '''
        0 绿色
        1 黄色
        2 粉色
        3 红色
        4 白色
        '''
        
      2. 相关操作

        1. 元组可以innot in操作

          t3 = ('绿色', '黄色', '粉色', '红色', '白色')
          print('黑色' in t3)    # False
          print('白色' in t3)    # True
          
        2. 可以+*

          t4 = (10, 20)
          t5 = (100, 200, 300)
          
          print(t4 + t5)      # (10, 20, 100, 200, 300)
          print(t4 * 3)       # (10, 20, 10, 20, 10, 20)
          
        3. 可以比较

          t4 = (10, 20)
          t5 = (100, 200, 300)
          
          print(t4 > t5)   #False
          print(t4 == t5)  #False
          print(t4 < t5)   #True
          
        4. 可以用函数

          t5 = (100, 200, 300)
          
          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]
          
    3. 元组特有和更常用的相关操作

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

        t1 = (100,)
        
        print(t1, type(t1), len(t1))
        # () <class 'tuple'>
        
      2. 在没有歧义的情况下元组的小括号可以省略

        t2 = 23, 56, 78
        
        print(t2, type(t2))     # (23, 56, 78) <class 'tuple'>
        
      3. 直接使用多个变量获取元组中的元素

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

          subjects = ('Python', 'Java', 'H5', 'UI')
          x1, x2, x3, x4 = subjects
          print(x1, x2, x3, x4)
          # Python Java H5 UI
          
          p1 = (100, 200)
          x, y = p1
          print(x, y)
          # 100 200
          
        2. 让变量的个数小于元组中元素的个数,并且在其中某一个变量前加*

          # 获取的时候先让不带*的变量按位置获取对应的元素,剩下的元素全部由带*的变量获取(列表)
          
          student = ('小明', 18, 89, 78, 23, 8, '男')
          name, *others, sex = student
          print(name, sex, others)  # 小明 男 [18, 89, 78, 23, 8]
          
          name, age, *s, sex = student
          print(s, name, age, sex)   # [89, 78, 23, 8] 小明 18 男
          
          *x, y, z = student
          print(x, y, z)     # ['小明', 18, 89, 78, 23] 8 男
          
          
          
    4. 元组相关方法

      1. 元组.count(元素) - 统计元组中指定元素的个数
      2. 元组.index(元素) - 获取元素在元组的下标
  3. 字典

    1. 什么是字典(dict)

      """
      字典是容器型数据类型(序列);
      将{}作为容器的标志, 里面多个元素用逗号隔开,每一个元素都是一个键值对:{键1: 值1, 键2: 值2, 键3: 值3, ...}
      字典是可变的(支持增删改); 字典是无序(不支持下标操作)
      
      字典保存数据其实真正想要保存的是值,键是用来对值进行区分和说明。
      
      元素:字典的一个元素是一个键值对
           键  -   必须是不可变的类型的数据(数字、字符串和元组),但是一般使用字符串;键是唯一的
           值  -   可以是任何类型的数据
      """
      
      # 空字典
      dl = {}
      
      # 键是不可变的数据
      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})    # True
      
    2. 字典的增删改查

      1. 查 - 获取字典中某个元素的值

        1. 查单个

          # 字典[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'
          
          # 字典.get(key)   -   获取字典中指定key对应的值,如果key不存在返回None
          # 字典.get(key, 默认值)  -   获取字典中指定key对应的值,如果key不存在返回默认值
          rint(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])
          '''
          x: 姓名 小明
          x: age 30
          x: gender 男
          x: height 175
          x: weight 73
          x: grade 65
          '''
          
          
  4. 列表推导式 - 通过序列创建列表的一种特殊的表达式

    1. 变换

      """
      [表达式 for 变量 in 序列]
      
      功能:创建一个列表;让变量去序列中取值,每取一个值产生一个元素(元素就是对应表达式的值)
      
      同义:
      list1 = []
      for 变量 in 序列:
          list1.append(表达式)
      """
      
      result = [x for x in range(3)]
      print(result)    # [0, 1, 2]
      
      result = [x*2 for x in range(3)]
      print(result)      # [0, 2, 4]
      
      result = [100 for x in range(4)]
      print(result)   # [100, 100, 100, 100]
      

      实例:

      # 练习:提取数字序列中所有元素的个位,创建一个新的列表(推导式)
      # nums = [239, 78, 27, 90, 23, 112]  -> [9, 8, 7, 0, 3, 2]
      nums = [239, 78, 27, 90, 23, 112]
      result = [x % 10 for x in nums]
      print(result)
      
      #如列表包含字符串,取余数
      nums = [239, 78, '27', 90, 23, '112']
      result = [int(x) % 10 for x in nums]
      print(result)
      
      
    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]
      
      
      nums = [12, 21, 30, 8, 9, 33, 2]
      # [6, 42, 15, 4, 18, 66, 1]
      # 三目运算符:  表达式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]
nums = [70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
for i in range(len(nums)):
    x = nums.pop()
    if x not in nums:
        nums.insert(0, x)
nums.sort(reverse=True)
print(nums)
# [282, 234, 197, 177, 107, 91, 88, 70]

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

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

结果为 [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]
nums = [i+3 for i in range(0, 100 ,10)]
print(nums)

# [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]

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

例如:[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]
list1 = [True, 17, "hello", "bye", 98, 34, 21]
ints = [i for i in list1 if type(i) == int ]
print(ints)

# [17, 98, 34, 21]

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

例如 ["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]
str1 = ["good", "nice", "see you", "bye"]
length = [len(i) for i in str1]
print(length)

# [4, 4, 7, 3]

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

nums = [17, 39, 28, 51]
nums2 = nums
nums2.pop()
print(len(nums))
# 这个结果是什么   请描述原因
# (答: 结果为 3 , 因为nums的值赋值给nums2后,nums和num2的id地址是同一个id地址,nums2的值会随着nums的改变而改变)

numlist = [17, 22, 39, 58, [55, 43]]
nums3 = numlist.copy()
print(numlist is nums3)
# 结果  原因是什么
# 答:False  因为nums3复制numlist后,nums3的id地址跟原先被复制的numlist id地址不一样.

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

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

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

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

studen_massages = [{'姓名':'小明', '年龄':18, '成绩':98,'手机号码': '13483958385','性别': '男'},
                   {'姓名':'小宏', '年龄':17, '成绩':59, '手机号码':'14248394828','性别':'不明'},
                   {'姓名':'小城','年龄': 22,'成绩': 97,'手机号码': '13509364738','性别':'不明'},
                   {'姓名':'小峰','年龄': 20,'成绩': 85,'手机号码': '15594735483', '性别':'男'},
                    {'姓名':'小陶','年龄': 16,'成绩': 92,'手机号码': '18827384932','性别': '女'},
                    {'姓名':'小程','年龄': 16,'成绩': 99,'手机号码': '18726374833','性别': '女'}]

# a.统计不及格学生的个数
count = 0
for i in range(len(studen_massages)):
    if studen_massages[i]['成绩'] < 60:
        count += 1
print('不及格个数为:',count)
#不及格个数为: 1

# b.打印不及格学生的名字和对应的成绩

for i in range(len(studen_massages)):
    if studen_massages[i]['成绩'] < 60:
        print(studen_massages[i]['姓名'], ':', studen_massages[i]['成绩'])

#小宏 : 59

# c.统计未成年学生的个数
count1 = 0
for i in range(len(studen_massages)):
    if studen_massages[i]['年龄'] < 18:
        count1 += 1
        
print("未成年个数为:", count1)
# 未成年个数为: 3

# d.打印手机尾号是8的学生的名字

for i in range(len(studen_massages)):
    if int(studen_massages[i]['手机号码']) % 10 == 8:
        print(studen_massages[i]['姓名'], end=" ")
print()
# 小宏 小城


# 	e.打印最高分和对应的学生的名字

max_score = studen_massages[0]["成绩"]
max_name = studen_massages[0]["姓名"]
for i in range(len(studen_massages)):
    if studen_massages[i]['成绩'] > max_score:
        max_score = studen_massages[i]['成绩']
        max_name = studen_massages[i]["姓名"]

print("最高分为:", max_name, max_score)

# 最高分为: 小程 99

# ​	f.删除性别不明的所有学生
for i in range(len(studen_massages)):
    x = studen_massages.pop()
    if x['性别'] != "不明":
        studen_massages.insert(0,x)
print(studen_massages)


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


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值