day6-列表和元组

列表的相关操作

1.数学运算： +，*

• 1)列表1+列表2 - 将两个列表合并成一个新的列表

  list1 = [1,2,3]
  list2 = [100,200]
  print(list1+list2)  # [1, 2, 3, 100, 200]
  

• 2. 列表* N / N *列表 - 列表中的元素重复 N 此产生一个新的列表(N是>=0 的整数)

  list3 = list1*3
  print(list3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
  

2.比较运算符

• 1)比较是否相等： == , !=

  print([1,2,3] ==[1,2,3])    # True
  print([1,2,3] ==[1,3,2])    # False
  

• is的用法

• 数据1 is 数据2 - 判断两个数据是否相等(判读数据的地址)

• 数据1 == 数据2 - 判断两个数据是否相等(判读数据的值)

• 注意： 如果给不同的变量赋相同可变值，地址不一样，赋相同不可变的值，地址一样

  list1 = [1,2,3]
  list2 = [1,2,3]
  list3 = list1
  print(list1 == list2)     # True
  print(list1 is list2)   # False
  print(list1 is list3)   # True
  

• 2. 比较大小：>,<,>=,<=

• 两个列表比较大小，是比较第一对不相等的元素大小

  print([1,2,3,4,5,6,]>[10,20])  # False
  

3. in 和 not in

• 元素 in 列表 - 判断列表中是否有指定的元素

  print(10 in [100.200])  # False
  print(100 in [100,200])  # True
  print([1,2] in [1,2,3])  # False
  print([1,2] in [1,2,[1,2]])  # True
  

4.相关函数

• sum,max,min,sorted,len,list

• 1. sum(序列) - 求序列中所有元素的和: 要求序列中的元素必须是数字

  scores = [90,89,85,2,33,1]
  print(sum(scores)) # 300
  

• a. max(序列) - 获取序列中最大的元素;序列中的元素支持比较运算并且类型一致

• b. min(序列) - 获取序列中最小的元素;序列中的元素支持比较运算并且类型一致

  scores = [90,89,85,2,33,1]
  print(max(scores))   # 90
  print(min(scores))  # 1
  

• 3. sorted()

• sorted(序列 - 将序列中的元素从小到大排序，返回排序之后的新列表

  scores = [90,89,85,2,33,1]
  print(sorted(scores))   # [1, 2, 33, 85, 89, 90]
  a = sorted(scores)
  print(a)    # [1, 2, 33, 85, 89, 90] # 不会修改原列表
  

• sorted(序列,reverse = True) - 将序列中的元素从大到小排序，返回排序之后的新列表

  scores = [90,89,85,2,33,1]
  new_scores = sorted(scores,reverse=True)
  print(new_scores)   # [90, 89, 85, 33, 2, 1]
  

• 4. len(序列) - 获取列表中元素的个数

  scores = [90,89,85,2,33,1]
  print(len(scores))  # 6
  

• 5. list(数据) - 将数据转换成列表

print(list('abc'))  # ['a', 'b', 'c']
print(list(range(4)))  # [0, 1, 2, 3]

列表相关方法

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

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

2.列表.copy() - 复制原列表产生一个相同的新列表(数据相同，地址不同)

nums = [1,2,'abc']
new_nums = nums.copy()
print(new_nums) # [1, 2, 'abc']
print(nums is new_nums)  # False

直接赋值和拷贝

list1 = [1,2,3]
list2 = list1  # 直接赋值
list3 = list1.copy()
print(list2)    # [1, 2, 3]
print(list3)
print(list2 is list1)   # True
print(list3 is list1)   # False

list1.append(100)
print(list2)  # [1, 2, 3, 100]
print(list3)  # 1, 2, 3]

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

scores = [90,89,89,70,100,100,23,100]
print(scores.count(100))  # 3

4. 列表.extend(序列) - 将序列中所有的元素添加到列表中

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

5. 列表.index(元素) - 获取指定元素在列表中下标(0 ~ 长度-1)

• 如果元素有多个，只返回第一个下标
• 如果元素不存在，会报错

song = ['晴天','成都','经济舱','晴天']
print(song.index('成都'))  # 1
print(song.index('晴天'))  # 0
# print(song.index('错误'))  # ValueError: '错误' is not in list

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

song = ['晴天','成都','经济舱','晴天']
song.reverse()
print(song) # ['晴天', '经济舱', '成都', '晴天']

7. 列表.sort() - 将列表中的元素从小到大排序(不会产生新的列表，直接修改原列表中元素的顺序)

nums = [10,2,5,8,9,6,2]
nums.sort()
print(nums)  # [2,2, 5, 6, 8, 9, 10]
nums.sort(reverse=True)
print(nums)  # [10, 9, 8, 6, 5, 2, 2]

列表推导式

1.什么是列表推导式 - 用来快速产生一个列表的表达式

• 1)基本语法

• 基本语法：
  [表达式 for 变量 in 序列]

  产生元素的原理：让变量去序列取值，一个一个的取每一个值就将表达式的结果作为列表的一个元素
  a= []
  for 变量 in 序列:
  a.append(表达式)
  返回 a

  list1 =[1 for i in range(4)]  # [1, 1, 1, 1]
  list2 = [ i for i in range(4)]  # [0,1,2,3]
  list3 = [i**2 for i in range(4)]  # [0,2,4,9]
  list4 = [x+y for x,y in enumerate([10,20,30])]  # [ 10,21,32]
  

• 2)带条件语句的推导式

• 语法：
  [表达式 for 变量 in if条件语句]

  相当于：
  a= []
  for 变量 in 序列:
  if 条件语句:
  a.append(表达式)
  返回 a

  list5 = [ i for i in range(10,20)if i %3==0]  # [12, 15, 18]
  print(list5)
  list6 = [ i for i in range(10,20)if i %2]  # [11, 13, 15, 17, 19]
  print(list6)
  # 练习1：删除列表中分数低于60的成绩
  scores =[20,50,66,88,77,44,11,80,70]
  new_scores = [i for i in scores if i>=60]
  print(new_scores)  # [66, 88, 77, 80, 70]
  # 练习2：将列表中所有的元素乘以2
  nums = [2,5,9,20]
  new_nums = [i*2 for i in nums]
  print(new_nums)     # [4, 10, 18, 4  0]
  

  3)双重循环或多循环 （了解）
  [表达式 for变量1 in 序列1 for 变量2 in 序列2]
  相当于：
  a =[]
  for变量1 in 序列1:
  for 变量2 in 序列2]:
  a.append(表达式)
  返回a

元组

1.什么是元组(tuple)

• 元组是容器型数据类型：将()作为容器的标志，多个元用逗号隔开：(元素1，元素2，元素3,…)
  元组元素的要求和列表一样
  不可变(不支持增删改); 有序的(支持下标操作)

  t1 = (10,20,'abc')
  print(type(t1))
  
  print(t1[1])    # 20
  
  t2 = ()  # 空元组
  

2.列表中适用于元组的操作

• 1)列表查操作元组都支持

  t1 = (10,20,'abc')
  print(t1[1])    # 20
  

• 2)列表中相关操作全部适用于元组(数学运算、比较运算、in和not in、相关函数)

• 3.元组特有的内容

• 1)单个元素的元组 - 唯一的那个元素后面必须加逗号

  tuple1 = (10)
  print(type(tuple1),tuple1)  # <class 'int'> 10
  tuple2 = (10,)
  print(type(tuple2),tuple2)  # <class 'tuple'> (10,)
  

• 2)元组的括号在没有歧义的情况下可以省略

  t3 = 10,23,89  # t3 =(10,23,89)
  print(type(t3),t3)  # <class 'tuple'> (10, 23, 89)
  

• 3)用多个变量分别获取元组中元素的值(也适用于列表)

• a.通过下标获取元素

  t4 = (18,'python','男')
  print(t4[1])  # python
  

• b.让变量的个数和元组的个数保持一致

  t4 = (18,'python','男')
  x,y,z = t4
  print(x,y,z)  # 18 python 男
  

• c.让变量个数小于元组中元素的个数，但是必须有一个变量带*

  t5 = (18,'python','男','80','90')
  x,*y,z = t5
  print(x,y,z)  # 18 ['python', '男', '80'] 90
  

列表作业

1.生成50-300之间可重复的 10个数据 存放于列表中, 保证列表中元素的顺序，对列表进行排重,并对列表进行降序排序

from random import randint
# nums = []
# for _ in range(10):
#     nums.append(randint(50, 300))
# print(nums)
# 产生数字列表
nums = [randint(50, 300) for _ in range(10)]
# 去重
new_nums = []
for x in nums:
    if x not in new_nums:
        new_nums.append(x)
# print(new_nums)
# 排序
new_nums.sort(reverse=True)
print(new_nums)

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

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

• 方法一：

  nums = [x for x in range(1, 101) if x % 10 == 3]
  print(nums)
  

• 方法二：

  nums = [x for x in range(3, 100, 10)]
  print(nums)
  

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

• type(数据) == 类型名 - 判断指定数据是否是指定类

• isinstance(数据, 类型) - 判断指定数据是否是指定的类或者它的子类

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

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

• 例如 [“good”, “nice”, “see you”, “bye”] — [4, 4, 7, 3]

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

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

nums = [17, 39, 28, 51]
nums2 = nums
nums2.pop()
print(len(nums)) # 这个结果是什么   请描述原因   # 3  列表是可变的 nums 和nums2 同一个地址




numlist = [17, 22, 39, 58, [55, 43]]
nums3 = numlist.copy()
print(numlist is nums3) # 结果  原因是什么   # False  copy的数据相等，地址不同

numlist[-1][0] = 99
print(nums3) # num3会不会发生变化            #会  [17, 22, 39, 58, [99, 43]]

4.自己用代码实现列表相关方法的功能：count、index、extend、clear

• 1)count

  list1 = [90, 89, 90, 76, 5667, 89, 12, 90, 23]
  item = 90
  count = 0
  for x in list1:
      if x == item:
          count += 1
  print(count)
  

• 2)index

  list1 = [90, 89, 90, 76, 5667, 89, 12, 90, 23]
  item = 120
  for index, x in enumerate(list1):
      if x == item:
          print('下标:', index)
          break
  else:
      print('该元素不存在')
  

• 3. extend

  nums = [1, 2, 3]
  seq = (100, 200)
  for x in seq:
      nums.append(x)
  print(nums)
  

• 4)clear

  list1 = [90, 89, 90, 76, 5667, 89, 12, 90, 23]
  for _ in range(len(list1)):
      # del list1[0]
      # del list1[-1]
      list1.pop()
  print(list1)