Day 4 - 列表相关

Day 4

数字相关类型

Python中和数字相关的类型：int、 float、 bool、 complex

• 一、int - 所有整数对应的类型

  进制的转换

  进制的转换常用有4种

  (或取等值的十进制数值，直接用print打印即可；而 bin（数字）可以将二进制以外的数字转换为二进制；oct（数字）可以将八进制以外的数字转换为八进制；hex（数字）可以将十六进制以外的数字转换为十六进制)

  1.十进制：基数为0~9，在程序中直接书写

  2.二进制：基数只有0-1，表示时加前缀 0b or 0B，例如：0B1100表示十进制的12

  3.八进制：基数为0~7，表示时加前缀 0o or 0O，例如：0o1401表示十进制的769

  4.十六进制：基数为0_9和af(或A~F)，表示时加前缀 0x or 0X，例如：0x2aF表示十进制的687

  num1 = 1234
  num2 = 0b1100
  num3 = 0o1401
  num4 = 0x2aF
  print(num1, num2, num3, num4)				# 1234 12 769 687
  print(bin(num1), oct(num2), hex(num3))		# 0b10011010010 0o14 0x301
  

• 二、float - 表示小数

  支持科学计数法（XeY 表示X * 10^Y）

  没法进行精确的保存（计算机硬件影响，非程序错误与软件问题）

  print(1.2 - 1.0)							# 0.19999999999999996
  print(1.92 - 1.9199999999999999)			# 0.0
  print(1.92 == 1.919999999999999)			# False
  print(1.92 == 1.9199999999999999999999999)	# True
  

• 三、bool - 本质是一种特殊的整型，其中True为1，False为0

  print(1 + True)								# 2
  print(3 * False)							# 0
  

• 四、complex - 表示复数

  数学中虚数单位为 i（i^2 = -1）

  Python中虚数单位为 j（j^2 = -1）

  A + Bj（A表示实数，B表示虚数）

  可以直接进行数学运算

  num5 = 1 + 3j
  num6 = 2 + 1j
  print(num5)									# (1+3j)
  print(type(num6))     # 虚部为 1 时，不能省略    <class 'complex'>
  print(num5 + num6)							# (3+4j)
  print(num5 * num6)							# (-1+7j)
  print(num5 / num6)							# (1+1j)
  

列表

列表是容器型数据类型（序列） - List 标志为中括号，里面多个元素用逗号隔开

基本格式：(英语单词的复数形式或者在后面加list)

  list = [元素1， 元素2， 元素3， ……]

容器特点：

1.可变性 - 可变

  列表中元素数量可变，元素数据可变，元素顺序可变 - 质变量变

2.有序性 - 顺序

  每个元素都有其对应的编号，当然元素编号可以改变，但依然有序

元素特点：

  元素可以是任何数据，且同一列表中的不同元素的类型可以不同，且可以重复

list1 = []      # 空列表（再Python中具有意义）
list2 = [  ]        # 依然是空列表
print(bool(list1), bool(list2))					# False False
list3 = [0, '你好', True, [1, 2], 'abc']
print(list3, bool(list3))						# [0, '你好', True, [1, 2], 'abc'] True

• 一、查找 - 获取元素

  a.获取单个元素

  ​ 语法：

  ​ 列表[下标] - 获取指定位置的元素,下标不能越界

  ​ 说明：

  ​ 1.列表 - 想要获取元素对应的；列表

  ​ 2.[] - 固定写法

  ​ 3.下标 - 又叫索引；是元素在列表中位置信息对应的标号（每个元素对应的下标有两种，从左向右0~n，从右向左-1~-n）

  b.遍历列表

  ​ 语法：

  ​ for _ in list:

  ​ 说明：

  c.遍历同时获取列表元素和元素对应下标

  ​ 语法：

  ​ for 变量1， 变量2 in enumerate（list）

  ​ 说明：

  ​ 1.变量1获取每个元素下标

  ​ 2.变量2获取每个元素

  nums = [1, 32, 15, 78, 43, 98]
  print(nums)
  print(nums[1])      						# 32
  print(nums[-5])     						# 32
  
  for i in nums:
      print(i)        						# 1 32 15 78 43 98
  
  for x,y in enumerate(nums):
      print('下标', x, '元素', y)     
  # 下标 0 元素 1
  # 下标 1 元素 32
  # 下标 2 元素 15
  # 下标 3 元素 78
  # 下标 4 元素 43
  # 下标 5 元素 98
  
  for p in range(0, 6, 2):
      print(nums[p])          				# 1 15 43
      
  scores = [78, 67, 52, 78, 99, 23]
  sum = 0
  for s in scores:
      sum += s
  print(sum)                  				# 397
  

• 二、增添 - 添加元素

  语法1 - 添加：

  ​ list.append(元素) - 再列表最后添加元素

  语法2 - 插入：

  ​ list.insert(下标， 元素) - 在列表指定下标前插入指定元素

  hero_list = ['a', 'c', 'd', 'c']
  print(hero_list)            # ['a', 'c', 'd', 'c']
  hero_list.append('f')
  print(hero_list)            # ['a', 'c', 'd', 'c', 'f']
  hero_list.append('e')
  print(hero_list)            # ['a', 'c', 'd', 'c', 'f', 'e']
  hero_list.insert(1, 'b')
  print(hero_list)            # ['a', 'b', 'c', 'd', 'c', 'f', 'e']
  

• 三、删除 - 删除元素

  语法1：（元素直接被消灭，不存在）

  ​ del list[下标] - 删除列表中对应位置的元素

  语法2：（同上）

  ​ list.remove(元素) - 删除指定元素(如果指定元素不存在，会报错；如果指定元素重复，会删除最前的一个元素)

  语法3：（不在列表中，但元素依然存在）

  ​ list.pop() - 取出列表最后一个元素

  ​ list.pop(下标) - 取出列表中指定下标元素

  del hero_list[0]
  print(hero_list)            # ['b', 'c', 'd', 'c', 'f', 'e']
  hero_list.remove('b')
  print(hero_list)            # ['c', 'd', 'c', 'f', 'e']
  hero_list.remove('c')
  print(hero_list)            # ['d', 'c', 'f', 'e']
  x = hero_list.pop()
  print(hero_list, x)         # ['d', 'c', 'f'] e
  

• 四、修改 - 修改元素

  语法：

  ​ list[下标] = 新元素 - 将列表指定下标的元素修改成新元素

  hero_list[2] = 'w'
  print(hero_list)            # ['d', 'c', 'w']
  

• 五、列表切片 - 获取列表中部分元素

  语法：

  ​ list[开始下标：结束下标：步长] - 从开始下标开始获取到结束下标为止，每次下标值郑家步长取获取下一个元素

  说明：

  ​ 1.列表切片的结果一定时列表，结果是[]代表列表是空列表

  ​ 2.结束下标一定娶不到

  ​ 3.如果步长为正，表示从前往后取，这个时候开始下标对应的元素必须在结束下标对应的元素的前面，否则结果为空

  ​ 如果步长为负，表示从后往前取，这个时候开始下标对应的元素必须再结束下标对应的元素的后面，否则结果为空

  ​ 4.先看步长，再看开始结束

  省略语法：

  ​ 1.省略步长：

  ​ list[开始下标：结束下标] - 步长默认为1

  ​ 2.省略开始下标：

  ​ list[：结束下标：步长] - 步长为正，从最开始往后取，取到结束下标对应的元素；步长为负，从最后的元素往前取，取到结束下标对应的元素

  ​ 3.省略结束下标：

  ​ list[开始下标：：步长] - 步长为正，从开始下标对应的元素往后取，取到最后的元素；步长为负，从开始下标对应的元素往前取，取到最开始的元素

  list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
  print(list[1:7:2])              # [2, 4, 6]
  print(list[2:-1:2])             # [3, 5, 7, 9]
  print(list[-1::-1])             # [0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
  print(list[4:-8:-1])            # [5, 4]
  print(list[5:1:1])              # []
  print(list[1:6:-2])             # []
  print(list[-2:1:-2])            # [9, 7, 5, 3]
  print(list[2:5])                # [3, 4, 5]
  print(list[-3:-1])              # [8, 9]
  print(list[-1:3])               # []
  print(list[:6:1])               # [1, 2, 3, 4, 5, 6]
  print(list[:6:-1])              # [0, 9, 8]
  print(list[2:])                 # [3, 4, 5, 6, 7, 8, 9, 0]
  print(list[-3::-1])             # [8, 7, 6, 5, 4, 3, 2, 1]
  print(list[:])                  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] - 拷贝
  print(list[::-1])               # [0, 9, 8, 7, 6, 5, 4, 3, 2, 1] - 倒序
  print('hello'[1:4])             # ell
  print('hello'[::-1])            # olleh
  

• 六、列表的相关操作

  1.加法

  ​ 语法：

  ​ list1 + list2

  ​ 说明：

  ​ 合并两个列表

  ​ 列表只能和列表相加，不能和字符串、数字等进行加法运算

  2.乘法

  ​ 语法：

  ​ list * n or n * list

  ​ 说明：

  ​ 列表乘一个整数

  ​ 将列表中的元素重复n次，产生一个新的列表

  3.比较运算

  ​ 比较大小：比较下标相同的第一对不相等的元素的大小,且元素的数据类型要一致

  ​ 比较相等：列表中元素必须个数相同，大小相等，顺序一致

  4.in , not in

  ​ 语法：

  ​ 元素 in list

  ​ 元素 not in list

  ​ 说明：

  ​ 判断元素是否在列表中

  ​ 不能判断包含关系

  list1 = [1, 2, 3]
  list2 = [4, 5]
  list3 = [6, 7, 8, 9]
  print(list1 + list2)            # [1, 2, 3, 4, 5]
  print(list3 * 3)                # [6, 7, 8, 9, 6, 7, 8, 9, 6, 7, 8, 9]
  list4 = list1 * 1
  list5 = list1
  print(list4)                    # [1, 2, 3]
  print(list5)                    # [1, 2, 3]
  print(id(list1), id(list4), id(list5))          # 2265638879496 2265639048328 2265638879496
  print(list1 > list2)            # False
  print(list2 < list2*3)          # True
  list6 = [1, 2, 3, -1]
  print(list1 > list6)            # False
  list7 = [2, 1, 3]
  print(list7 == list1)           # False
  print(2 in list1)               # True
  print(5 in list1)               # False
  print(10 in [1, 2, [10, 20]])   # False
  print([1, 2, 3] in list1)       # False
  

• 七、列表的相关函数

  1.sum（list）- 求列表中所有元素的和

  2.max（list）- 求列表中元素的最大值，注意：列表中元素类型必须一致，并且可以比较大小

  3.min（list）- 求列表中元素的最小值

  4.sorted（list）- 将列表中的元素从小到大排序（升序），产生一个新的列表,注意：不会修改原列表

  sorted（列表，reverse=True）- 将列表中的元素从大到小排序（降序），产生一个新列表

  5.len（list）- 获取列表长度（元素个数）

  6.list（数据）- 将指定数据转换为列表（数据必须时序列，转换时直接将序列中的元素作为新的列表的元素）

  a = [3, 2, 1, 4, 7, 6, 5]
  # print(sum(a)
  print(max(a), min(a))           # 7 1
  new_a = sorted(a)               
  print(new_a)                    # [1, 2, 3, 4, 5, 6, 7]
  New_a = sorted(a, reverse=True)
  print(New_a)                    # [7, 6, 5, 4, 3, 2, 1]
  print(len(a))                   # 7
  

• 八、列表的相关方法

  1.list.clear() - 清空指定列表

  A = [1, 2, 3, 4]
  A.clear()
  print(A)						# []
  

  2.list.copy() - 复制一个指定列表（浅拷贝，地址不同）

  B = [1, 2, 3, 4]
  new_B = B.copy()
  print(new_B)					# [1, 2, 3, 4]
  

  3.list.count(元素) - 统计指定元素在列表中出现的次数

  C = [1, 2, 2, 3, 2, 5, 3]
  print(C.count(2))				# 3
  

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

  D = []
  D.extend('abcd')
  print(D)						# ['a', 'b', 'c', 'd']
  

  5.list.index(元素) - 获取指定元素在列表中的位置信息（即下标值），注意：如果元素不存在会报错，如果元素有多个只会取首次出现的元素下标值

  E = [1, 2, 3, 4]
  print(E.index(2))				# 1
  

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

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

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