Day4-Day5数字和列表

Day4-Day5数字和列表

01-python数字的类型

  1. 类型:int(整型)、float(浮点型)、bool(布尔)、complex(复数)
    • int(整型) - 所有整数对应的类型

      • python只整数支持4种写法:十进制数、二进制数、八进制数、和十六进制数
        十进制:基数是0~9,表示的时候直接写
        二进制数:基数是0和1,表示的时候加前缀0b/0B:0b1100,0B1101
        八进制数:基数是0~7,表示的时候加前缀0o/0O:0o645,0O324
        十六进制数:基数是09,af(A~F),表示的时候加前缀: 0x/0X : 0x12,0x3f,0xabc
      # 1)python如果要获取一个其他进制数对应的等值的十进制数是多少,直接用print打印就可
      print(num1, num2, num3, num4)
      
      # 2)bin(数字)   -   将其他进制的数转换成二进制形式的数
      print(bin(100))     # 0b1100100
      print(bin(0x12abc))     # 0b10010101010111100
      
      # 3)oct(数字)     -   将其他进制的数转换成八进制形式的数
      print(oct(100))
      
      # 4)hex(数字)     -   将其他进制的数转换成十六进制形式的数
      print(hex(100))
      
    • float(浮点型) - 所有小数对应的类型

    • bool(布尔) - bool类型的本质就是一种特殊的整型,其中True就是1,False就是0

    • complex(复数) - 由实部和虚部组成的数就是复数,数学中虚数单位是i,python中虚数单位是j: A+Bj

      ​ 注意:如果虚部是1,这个1不能省

      1)python中的复数直接支持数学的复数运算
      num7 = 10 + 20j
      num8 = 3 + 1j
      print(type(num7))
      print(num7 + num8)
      print(num7 * num8)
      

02-列表

  1. 什么是列表(list):

    列表是容器型数据类型(序列),将[]作为容器的标志,里面多个元素用逗号隔开:[元素1,元素2,元素3,…]
    列表是可变(元素的个数和值可变);列表是有序的(元素在容器中的顺序)
    任何类型的数据都可以作为列表的元素

    • 空列表:[]

    • 元素是任何类型的数据

      list2 = [19, 'abc', True, [1, 2], 'abs']
      print(list2)
      
    • 列表的命名规范:英语单词的复数形式或者在后面加list

      scores = [89, 82, 78, 88, 78, 98]
      score_list = [99, 78, 89]
      
  2. 列表元素的增删改查

    • 查 - 获取元素

      • 获取单个元素

        列表[下标] - 获取指定下标对应的元素

        movies = ['八佰', '花木兰', '信条', '星际穿越', '肖申克的救赎', '霸王别姬']
        print(movies[1])
        
      • 遍历 - 将列表中的元素一个一个全部取出来

        """
        for 变量 in 列表:
            循环体
        """
        movies = ['八佰', '花木兰', '信条', '星际穿越', '肖申克的救赎', '霸王别姬']
        for x in movies:
            print(x)
        
      • 遍历同时获取列表元素和元素对应的下标

        """
        for 变量1,变量2 in enumerate(列表):
            循环体
        
        变量1获取到的是每个元素的下标,变量2获取到的是每个元素
        """
        movies = ['八佰', '花木兰', '信条', '星际穿越', '肖申克的救赎', '霸王别姬']
        for x, y in enumerate(movies):
            print('x:', x, 'y:', y)
        
      • 通过遍历列表中每个元素的下标来间接的遍历元素

        movies = ['八佰', '花木兰', '信条', '星际穿越', '肖申克的救赎', '霸王别姬']
        for x in range(0, 6, 2):
            print(movies[x])
        
        print('==========遍历2=========')
        for x in range(-1, -7, -1):
            print(movies[x])
        
    • 增 - 添加元素

      • 列表.append(元素) - 在指定的列表的最后添加指定元素

        hero_list = ['卢仙', '亚索', '永恩']
        print(hero_list)
        hero_list.append('阿狸')
        print(hero_list)
        hero_list.append('瑞兹')
        
      • 列表.insert(下标, 元素) - 在列表指定下标前插入指定元素

        hero_list = ['卢仙', '亚索', '永恩']
        hero_list.insert(1, '劫')
        print(hero_list)
        hero_list.insert(0, '劲夫劲夫,全场欢呼!')
        print(hero_list)
        
    • 删 - 删除元素

      • del 列表[下标] - 删除列表中指定下标的元素
      heroes = ['劲夫劲夫,全场欢呼!', '卢仙', '劫', '亚索', '永恩', '阿狸', '瑞兹']
      del heroes[0]
      print(heroes)
      
      • 列表.remove(元素) - 删除指定元素
      heroes = ['劲夫劲夫,全场欢呼!', '卢仙', '劫', '亚索', '永恩', '阿狸', '瑞兹']
      heroes.remove('卢仙')
      print(heroes)
      

      ​ 注意:如果元素不存在不会报错

      ​ 注意:如果被删除的元素有多个,只删除最前面的那一个

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

        列表.pop(下标) - 取出列表中指定下标对应的元素

    • 改 - 修改元素

      # 列表[下标] = 新值   -   将列表指定下标对应的元素修改成新的值
      teleplays = ['人民的名义', '甄嬛传', '纸牌屋', '绝命毒师', '请回答1988']
      teleplays[0] = '隐秘的角落'
      print(teleplays)
      teleplays[-2] = '生活大爆炸'
      print(teleplays)
      teleplays[1] = '德鲁纳酒店'
      print(teleplays)
      
  3. 列表删除

   # 练习:删除指定分数列表中所有低于60分的成绩
   scores = [98, 45, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   scores1 = []
   for i in scores:
       if i >= 60:
           scores1.append(i)
   print(scores1)
   # 坑一:直接遍历用remove删除元素 - 删不干净(因为遍历的时候没有把所有元素都遍历)
   for i in scores:
       if i < 60:
           scores.remove(i)
   print(scores)
   """
   scores = [98, 45, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   
   i = 98 : 98<60 -> False
   i = 45 : 45<60 -> True:scores = [98, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   i = 89 : 89<60 -> False
   """
   # 解决坑一:创建一个和原列表一样的新列表,遍历新列表,删除原列表
   scores = [98, 45, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   # scores2 = [98, 45, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   for s in scores.copy():     # scores2 = scores[:]/scores.copy/scores*1/scores + []
       if s < 60:
           scores.remove(s)
   print(scores)
   
   # 坑二: 报错(下标越界)
   scores = [98, 45, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   # len(列表) - 列表的元素
   for index in range(len(scores)-1, -1, -1):
       if scores[index] < 60:
           del scores[index]
   print(scores)
   # 解决坑二:
   scores = [98, 45, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   index = 0
   while index < len(scores):
       s = scores[index]
       if s < 60:
           del scores[index]
       else:
           index += 1
   print(scores)
   """
   scores = [98, 45, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   index in range(11) -> index: 0~10
   index = 0 if 98<60
   index = 1:45<60 -> del scores[1] -> scores = [98, 34, 89, 23, 67, 23, 9, 54, 100, 78]
   index = 2: if 89<60
   
   """
  1. 列表的切片 - 获取列表中部分元素(一次性获得多个元素)

    • 基本语法:列表[开始下标:结束下标:步长] - 从开始下标开始获取到结束下标前为止,每次增加步长

      • 列表切片的结果一定是列表
      • 结束下标对应的元素一定取不到
      • a.如果步长为正,表示从前往后取(从开始下标到结束下标),这个时候开始下标对应的元素必须在结束下标对应的元素的前面,否则结果为空
        b.如果步长为负,表示从后往前取(从开始下标到结束下标),这个时候开始下标对应的元素必须在结束下标对应的元素的后面,否则结果是空
      list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      print(list1[1:4:1])  # [2, 3, 4]
      print(list1[0:6:2])  # [1, 3, 5]
      print(list1[3:3:1])  # []
      print(list1[1:4:-1])  # []
      print(list1[1:-1:-1])  # []
      print(list1[-1:-4:-1])
      print(list1[1:-1:1])
      print(list1[-2:1:-2])
      
    • 切片省略

      """
      1)省略步长
      列表[开始下标:结束下标]   -   省略步长,步长就是1
      
      """
      fruits = ['apple', 'banana', 'peach', 'orange', 'pomegranate', 'grape']
      print(fruits[1:4])
      print(fruits[-3:-1])
      
      """
      2)省略开始下标
      列表[:结束下标:步长]
      
      步长为正:从第一个元素开始往后取
      步长为负:从最后一个元素开始往前取
      """
      print(fruits[:1:-1])    # ['grape', 'pomegranate', 'orange', 'peach']
      print(fruits[:-1])  # ['apple', 'banana', 'peach', 'orange', 'pomegranate']
      """
      3)省略结束下标
      列表[开始下标::步长]
      
      步长为正:取到最后一个元素为止
      步长为负:取到第一个元素为止
      """
      fruits = ['apple', 'banana', 'peach', 'orange', 'pomegranate', 'grape']
      print(fruits[2:])   # ['peach', 'orange', 'pomegranate', 'grape']
      print(fruits[-3::-1])   # ['orange', 'peach', 'banana', 'apple']
      print(fruits[3::-2])    # ['orange', 'banana']
      
      
      print(fruits[:])    # ['apple', 'banana', 'peach', 'orange', 'pomegranate', 'grape']
      print(fruits[::-1])  # ['grape', 'pomegranate', 'orange', 'peach', 'banana', 'apple']
      print('hello'[1:4])
      print('hello'[::-1])
      
      
  2. 列表的相关操作

    • 加法运算和乘法运算

      • 加法:列表1+列表2 - 合并两个列表产生一个新的列表(列表只能和列表相加)

        list1 = [10, 20, 30]
        list2 = [100, 200]
        list3 = list1 + list2
        print(list3)  # [10, 20, 30, 100, 200]
        
        • 乘法 :列表*N/N*列表 - 将列表中的元素重复N次产生一个新的列表
        list1 = [10, 20, 30]
        print(list1 * 2)
        
    • 比较运算

      • 两个列表比较大小 - 比较第一对不相等的元素的大小,谁大对应的列表就大
      list11 = [10, 20, 3, 4, 5]
      list22 = [10, 20]
      print(list11 > list22)
      
      • 比较相等
      # 元素顺序不同的两个列表不相等
      print([1, 2, 3] == [1, 2, 3])   # True
      print([1, 2, 3] == 'abc')     # False
      
    • in 和 not in

      # 元素 in 列表  -   判断列表中是否存在指定的'元素'
      # 元素 not in 列表  -   判断列表中是否不存在指定的'元素'
      print(10 in [1, 20, 10, 4])     # True
      print([1, 2] in [1, 2, 3, 4])   # False
      
    • 练习:获取两个列表中公共元素

      A = [1, 2, 5, 10, 3, 2]
      B = [5, 2, 10, 20, 32, 2]
      C = []
      for i in B:
          if i in A and i not in C:
              C.append(i)
      print(C)
      
    • 列表相关函数

      sum、max、 min、 sorted、 len、 list

      • sum(数字列表) - 求列表中所有元素的和

      • max(列表)/min(列表) - 求列表中元素的最大/最小值(注意:列表中元素的类型必须一致,并且本身支持比较运算)

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

        sorted(列表, reverse = True) - 将列表中的元素从打到小排序(降序)

        scores = [34, 89, 90, 78, 65, 78, 60]
        new_scores = sorted(scores)
        print(new_scores)
        print(sorted(scores, reverse=True))
        
      • len(列表) - 获取列表长度(列表中元素的个数)

      • list(数据) - 将指定类型转换成列表(数据必须是序列;转换的时候直接将序列中的元素转化成列表中的元素

        print(list('abc'))  # ['a', 'b', 'c']
        print(list(range(4)))   # [0, 1, 2, 3]
        
  3. 列表的相关操作

    • 列表.clear() - 清空指定列表

      names = ['犬夜叉', '火影忍者', '海贼王']
      names.clear()
      print(names)
      
    • 列表.copy() - 复制指定列表,产生一个一模一样的新列表,地址和原列表不同

      这是浅拷贝

      names = ['犬夜叉', '火影忍者', '海贼王']
      new_names = names.copy()
      print(new_names)
      print(id(names), id(new_names))
      
    • 列表.count(元素) - 统计指定元素在列表中出现的次数

      nums = [23, 342, 23, 334, 242, 2343, 123, 123]
      print(nums.count(23))
      
    • 列表.extend(序列) - 将序列中所有的元素全部添加到列表里面

      names = ['犬夜叉', '火影忍者', '海贼王']
      names.extend(['从零开始的异世界生活', '鬼灭之刃'])
      print(names)
      names.extend('abc')
      print(names)
      
    • 列表.index(元素) - 获取指定元素在列表中的下标(返回的是0开始的下标值)

      如果元素有多个,只取第一个元素下标值

      print(names.index('鬼灭之刃'))
      
    • 列表.reverse() - 列表倒序

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

      num2_list = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3]
      print(num2_list.count(1))
      

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值