python 7 列表

python 7 列表

列表：相关操作（比较运算）、序列相关函数、列表相关方法、列表推导式、作业

字典、元组。

1.列表相关函数

1) 列表的比较运算符：==、！=、>、<、>=、<=、

相等必须是完全一样

A = [10,23,45,89]
B = [46,90,23,3]
print(A!=B)
A1 = [46,90,23,3]
B1 = [46,90,23,3]
print(A1==B1)
A2 = [46,90,3,23]
B2 = [46,90,23,3]
print(A2==B2)
### 运行结果
True
True
False

2) == 与 !=

• 注意：列表要比较大小，只能是两个列表进行比较

• 比较规则：比较第一对不相等的元素的大小（相同位置的元素是一对）

• 案例

  A=[19,23,78,34,90]
  B=[19,23,67,32,99,90]
  print(A<B)
  print(A>B)
  ##结果显示
  False
  True
  

  第一对不相同元素的数据类型不一样，=就会报错，

  A=[19,23,78,34,90]
  B=[19,'QWE',23,67,5]
  print(A>B)
  ##
  TypeError: '>' not supported between instances of 'int' and 'str'
  

2) 列表（序列）相关函数

(1) sum(列表)

• sum(列表)：求列表中所有元素的数值和（列表中元素必须是数字）

A=[12,34,5,89,78,345]
print(sum(A))
print(sum(range(1,9))) 
##
563
36

(2) max、min

max（列表） - 获取列表中的最大元素（列表中的元素支持比较元素）

score=[10,230,4580,90]
print(max(score))
print(min(score)
##运行结果显示
4580
10     

(3) sorted(列表)

• sorted(列表) - 将列表中的元素从小到大排序，产生一个新的列表

A=[19,34,89,92,40]
new_A=sorted(A)
print(new_A)
##
[19, 34, 40, 89, 92]
new_B=sorted(A,reverse=True)  ##reverse=True
print(new_B)
##
[92, 89, 40, 34, 19]

(4) len（列表）

• len（列表）：统计列表中元素的个数

  A=[10,36,89,92,95]
  print(len(A))
  ##5
  

(5) list（数据）

• list（数据）: 将指定数据转换成列表。

• 可转换成列表的数据必须是：这些数据本身就是容器，目前学过可以转换的就是字符串和range。如何序列都可以转换成列表，转换的时候，直接将序列中的元素作为列表的元素。

  print(list(range(1,9)))
  print(list('anshuisfcgi'))
  print(list([1,,6,8,9])
  ##
  [1, 2, 3, 4, 5, 6, 7, 8]
  ['a', 'n', 's', 'h', 'u', 'i', 's', 'f', 'c', 'g', 'i']
  

2. 列表相关方法

1) 列表.(clear)

• 1.list.(clear) - 清空列表

  A = [19,45,87,24,90]
  A.clear()
  print(A)
  ##
  []
  

2) 列表.copy( )

• 拷贝（浅拷贝）员列列表产生一个一模一样的新的列表、将新列表返回。

• 列表[1:1] (列表切片)或 list*1,（列表数学运算） 或列表+[] (列表求和)，这三种都是浅拷贝

  A = [78,34,65,15,9999,90]
  B = A.copy()
  print(B)
  B.append(23465)
  print(B)
  B.remove(34)
  print(B)
  B.insert(1,8888888)
  print(B)
  ###
  [78, 34, 65, 15, 9999, 90]
  [78, 34, 65, 15, 9999, 90, 23465]
  [78, 65, 15, 9999, 90, 23465]
  [78, 8888888, 65, 15, 9999, 90, 23465]
  

3) 列表. count( )

• 列表.count(数据) - 统计列表中指定数据出现的次数（数据的个数）

A = [78,34,65,78,56,65,78,15,9999,90]
print(A.count(78))
# 
3

4) 列表. extend( )

• 列表.extend（序列） - 将序列中所有的元素都添加到列表的最后

  A = [78,34,65,78,56,65,78,15,9999,90]
  B=A
  C=A.copy()
  B.extend(range(1,9))
  C.extend([45,90,26])
  print(A)
  print(B)
  print(C)
  ###
  [78, 34, 65, 78, 56, 65, 78, 15, 9999, 90, 1, 2, 3, 4, 5, 6, 7, 8]
  [78, 34, 65, 78, 56, 65, 78, 15, 9999, 90, 1, 2, 3, 4, 5, 6, 7, 8]
  [78, 34, 65, 78, 56, 65, 78, 15, 9999, 90, 45, 90, 26]
  

(5) 列表.index( )

A = [78,34,65,78,56,65,78,15,9999,90]
print(A.index(9999),A.index(65))
##
8 2

6) 列表. reverse( )

• 列表.revese( ) :列表倒叙 (列表中的元素倒着排序)

A = [78,34,65,78,56,65,78,15,9999,90]
A.reverse()
print(A)
###
[90, 9999, 15, 78, 65, 56, 78, 65, 34, 78]

7) 列表. sort( ) 与列表. sorted( )

• 列表.sort : 将列表中元素升序排列（直接修改元列表元素顺序，不会产生新的列表）
  列表.sort(reverse=True)

• 列表.sorted（）：将序列中的元素升级排序（不会修改原序列找中元素的顺序，会产生一个新的列表）
  #列表.sorted(reverse=True)

• 案例：

  A=[10,10,20,30,12,34]
  A.sort()
  print(A)
  new_A=sorted(A)
  print(new_A)
  ###
  [10, 10, 12, 20, 30, 34]
  [10, 10, 12, 20, 30, 34]
  

3. 列表推导式

列表推导式：一种创建列表的表达式，表达式是固定的

1) 结构1：

• [表达式 for变量 in 序列] -------- 让变量去序列中取值，一个一个的取，每取一个值就计算一次表达式，并且将计算结果作为列表的元素

• 原理：变量去序列中一个一个值，一次值计算一次表达式的结果，并且将算出来的值放入列表中，列表中的元素个数有序列个数决定，放进列表的内容由表达式决定。

• 应用：基于原序列中的元素得到新的序列（对原序列中的原理进行统一的变换（类型））【新的列表与原来的列表有关系，就可以使用列表推导式，先写for x in range（）或者列表。

  A=[19,34,75,987,203,109]
  list1 = [x+2 for x in A ]
  print(list1)
  list2 = [2*x for x in A]
  print(list2)
  ##
  [21, 36, 77, 989, 205, 111]
  [38, 68, 150, 1974, 406, 218]
  

2）结构2：

• [表达式 for x in 序列 if 条件语句]

• 原理：让变量取序列中取值，一个一个取，取完为止，每取一个值就判断一次条件语句，如果成立，就计算一次结果

• 应用：数据筛选

  nums=[18,90,43,67,88,19,84]
  result = [2x + 5 for x in nums if x % 2]
  print(result)
  #[91, 139, 43]
  #案例2：获取列表中所有数字，并且将数字都乘以10
  list1 = [10, 2.25, 'abc', False, True, 'as12', 4, 2.5]
  result=[x*10 for x in list1 if type(x)==int or type(x) == float] 
  #result=[x*10 for x in list1 if type(x) in [int ,float]]  #可以简写
  print(result)
  ##
  [100, 22.5, 40, 25.0]
  

  day 7 列表作业

  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]
  

  A=[70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
  B=[]
  for x in A:
      if x not in A:
          B.append(x)
  B.sort()
  B.reverse()
  print(B)
  ##
  [282, 234, 197, 177, 107, 91, 88, 70]
  

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

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

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

  list1=[x for x in range(2,94) if x % 10 == 3]
  print(list1)
  ##
  [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]
  result=[x for x in list1 if type(x) == int]
  print(result)
  ##[17, 98, 34, 21]
  

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

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

  A=["good", "nice", "see you", "bye"]
  B=[len(x) for x in A]
  print(B)
  ##[4, 4, 7, 3]
  

  d. 利用列表推导式删除列表中整数个位数小于5的元素

  例如：[24, 'abc', 99, True, 21, 38, 'hello'] --- ['abc', 99, True, 38, 'hello']
  

  A=[24, 'abc', 99, True, 21, 38, 'hello']
  B=[x for x in A if type(x)!=int or x % 10 >=5 ]
  print(B)
  ##
  ['abc', 99, True, 38, 'hello']
  

  e. 利用列表推导式获取元素是元组的列表中每个元组的最后一个元素

  例如：[(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]  --- [30, 'hello', 3.4, False]
  

  X=0
  A=[(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]
  B=[X==list(x) for x in A]
  C=[]
  for x in B:
      b=X(int(len(x)-1))
      C.append(b)
  print(C)  
  

  f.利用列表推导式将数字列表中所有的奇数乘以2，所有的偶数除以2 (用循环做)

  例如: [23, 4, 67, 88, 90, 21]  -> [46, 2, 134, 44, 45, 42]
  

  A=[23, 4, 67, 88, 90, 21]
  B=[]
  for x in A:
      if x % 2 == 1:
          x *= 2
          B.append(int(x))
      else:
          x /= 2
          B.append(int(x))
  print(B)
  ###
  [46, 2, 134, 44, 45, 42]
  

  3. 已知一个列表获取列表中指定元素所有的下标

     例如：[10, 20, 34, 10, 9, 78]
     10的下标：[0, 3]
     20的下标：[1]
     30的下标：[]
     

     A=[10, 20, 34, 10, 9, 78]
     result1 = [ x for x,y in enumerate(A) if y == 10]
     result2 = [ x for x,y in enumerate(A) if y == 20]
     result3 = [ x for x,y in enumerate(A) if y == 30]
     print(result1)
     print(result2)
     print(result3)
     ##
     [0, 3]
     [1]
     []
     

  4. *已知一个数字列表，写程序判断这个列表是不是连续递增列表。

     例如：
     [1, 2, 3, 4, 5]   -> True
     [23, 45, 78, 90]  -> True
     [1, 3, 2, 4, 5]	-> False
     

     A=[1, 2, 3, 4, 5]
     new_A = sorted(A)
     B=[23, 45, 78, 90]  
     new_B =sorted(B)
     C=[1, 3, 2, 4, 5]
     new_C = sorted(C)
     print(A == new_A)
     print(B == new_B)
     print(C == new_C)
     ##
     True
     True
     False
     

  5. 已知两个列表，将两个列表按照下面的规律交叉合并

     A = [10, 20, 30, 40, 50]
     B = [100, 200, 300]
     结果：[10, 100, 20, 200, 30, 300, 40, 50]
     

     A = [10, 20, 30, 40, 50]
     B = [100, 200, 300]
     C=[]
     while True:
         a = A.pop(0)
         b = B.pop(0)
         if a < b:
             C.append(a)
             C.append(b)
             if A == [] or B == []:
             	break
     C += A+B
     print(C)
     ##
     [10, 100, 20, 200, 30, 300, 40, 50]
     

  6. 已知两个有序列表，将两个列表合并，合并后的新列表中元素仍然是递增列表

     A = [10, 20, 30, 40, 50]
     B = [25, 44, 60]
     结果：[10, 20, 25, 30, 40, 45, 50, 60]
     

     A = [10, 20, 30, 40, 50]
     B = [25, 44, 60]
     C = []
     while True:
         a = A.pop(0)
         b = B.pop(0)
         if a < b:
             C.append(a)
             B.insert(0, b)
         else:
             C.append(b)
             A.insert(0, a)
     
         if A == [] or B == []:
             break
     
     C += A + B
     print(C)
     ##
     [10, 20, 25, 30, 40, 44, 50, 60]