二级标准

一、 了解与掌握如下的python编程的进阶知识，并会使用。

1. 知道如下几种数据类型：列表、元组、字典、字符串、 range、集合六大内置核心数据类型；

   • python中内置数据类型：

   

   • 其中列表、元组、字典、字符串、 range、集合是二级考试中的重点，列表、元组、字符串、 range是重点的重点

2. 理解列表类型的概念，掌握它的基础用法及操作：访问/更 新、获取元素个数、遍历、转换为列表型数据、添加和删 除、连接、排序等等；

   • 定义：是一个有序且可变的容器，在里面可以存放多个不同类型的元素

   • 基础用法及操作：访问/更 新、获取元素个数、遍历、转换为列表型数据、添加和删 除、连接、排序

     • 访问(查询)

       name_list = [1, "大白", True, '小白']
        print(name_list)
        ​
        #输出结果：[1, '大白', True, '小白']

     • 获取元素个数

       name_list = [1, "大白", True, '小白']
        print(len(name_list))
        ​
        #输出结果： 4

        

     • 转换

       name = "德玛西亚之力"
        name_list = list(name)
        print(name_list)
        ​
        #输出结果:['德', '玛', '西', '亚', '之', '力']

        

     • 遍历

       • for

         #实例1
          name = "德玛西亚之力"
          name_list = list(name)
          for data in name_list:
              print(data)
          print(name_list)
          ​
          #输出结果：
          '''
          德
          玛
          西
          亚
          之
          力
          ['德', '玛', '西', '亚', '之', '力']
          ​
          '''

         #实例2
          name_list = [1, "大白", True, '小白']
          for data in name_list:
              print(data)
          print(name_list)
          ​
          #输出结果
          '''
          1
          大白
          True
          小白
          [1, '大白', True, '小白']
          ​
          '''

          

       • while

         #实例1
          name_list = []
          while True:
              name = input("请输入参加游戏的人名：")
              if name == "王老师":
                  print("大佬来了，游戏结束")
                  break
              name_list.append(name)
          print("游戏失败名单：{}".format(name_list))
          ​
          #输出结果：
          '''
          请输入参加游戏的人名：大白
          请输入参加游戏的人名：二白
          请输入参加游戏的人名：三白
          请输入参加游戏的人名：王老师
          大佬来了，游戏结束
          游戏失败名单：['大白', '二白', '三白']
          ​
          '''

          

       • 根据需求串讲

         #需求
          '''
          设计一个不多于10人的游戏
          1.游戏开始，由玩家输入参加游戏的人数，并判断输入的是否是数字
          2.在第一个条件的基础上判断输入的数字是否大于10，如果大于10人参加游戏，提示用户"请输入小于10的数字！"
          3.如果参加游戏人数小于10人，玩家依次输入参加游戏的人名，并添加到空列表  name_list = []
          4.当输入的名字是"王老师"提示用户：王老师来了，游戏结束，输出游戏失败名单
          '''
          ​
          #答案1（不好）
          name_list = []
          n = 10
          num = input("输入参加游戏的人数：")
          if not num.isdecimal():
              print("请输入整数!")
          elif int(num) > n:
              print("请输入小于10的数字！")
          else:
              for m in range(int(num)):
                  name = input("请输入参加游戏的人名：")
                  if name == "王老师":
                      print("{}来了，游戏结束".format(name))
                      break
                  name_list.append(name)
          print("游戏失败名单：{}".format(name_list))
          ​
          #答案2
          name_list = []
          n = 10
          num = input("输入参加游戏的人数：")
          while True:
              if not num.isdecimal():
                  print("请输入整数!")
                  break
              if int(num) > n:
                  print("请输入小于10的数字！")
                  break
              for m in range(int(num)):
                  name = input("请输入参加游戏的人名：")
                  if name == "王老师":
                      print("{}来了，游戏结束".format(name))
                      break
                  name_list.append(name)
              print("游戏失败名单：{}".format(name_list))

          

     • 更新(包括增加、删除、修改)

       • append()追加：在列表的最后增加元素,只能一次追加一个元素

         name_list = [1, "大白", True, '小白']
          name_list.append("小小白")
          print(name_list)
          ​
          #输出结果：[1, '大白', True, '小白', '小小白']

       • 批量追加，将一个列表中的元素逐一添加另外一个列表

         • 列表相加(连接)

           name_list1 = [1, "大白", True, '小白']
            name_list2 = ["小小白", 2]
            print(name_list1 + name_lsit2)
            ​
            #输出结果：[1, '大白', True, '小白', '小小白', 2]

         • 列表*整数

           name_list = [1, "大白", True, '小白'] * 2
            print(name_list)
            ​
            #输出结果： [1, '大白', True, '小白', 1, '大白', True, '小白']

         • extend()

           name_list = [1, "大白", True, '小白']
            name_list.extend(["小小白", 2])
            print(name_list)
            ​
            #输出结果：[1, '大白', True, '小白', '小小白', 2]

         • insert()插入

           0    1      2      3
            name_list = [1, "大白", True, '小白']
            name_list.insert(2, "中白")
            print(name_list)
            ​
                      0     1      2      3      4
            #输出结果：[1, '大白', '中白', True, '小白']

            

       • 删除

         • remove()删除

           name_list = [1, "大白","中白", True, '小白']
            name_list.remove("中白")
            print(name_list)
            ​
            #输出结果：[1, '大白', True, '小白']

         • pop()根据索引剔除单个元素

           0    1     2      3      4
            name_list = [1, "大白","中白", True, '小白']
            name_list.pop(2)
            print(name_list)
            ​
            #输出结果：[1, '大白', True, '小白']

            

         • clear()清空列表

           name_list = [1, "大白", True, '小白']
            print(name_list)
            name_list.clear()
            print(name_list)
            ​
            #输出结果：[1, '大白', True, '小白']
            #        []

     • 排序

       • 数字排序

         num_list = [11, 22, 4, 5, 11, 99, 88]
          print(num_list)
          num_list.sort()  # 让num_list从小到大排序
          print(num_list)
          num_list.sort(reverse=True)  # # 让num_list从大到小排序
          print(num_list)
          ​
          #输出结果：
          '''
          [11, 22, 4, 5, 11, 99, 88]
          [4, 5, 11, 11, 22, 88, 99]
          [99, 88, 22, 11, 11, 5, 4]
          ​
          '''
          #注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）。

       • 反转原列表

         num_list = [11, 22, 4, 5, 11, 99, 88]
          print(num_list)
          num_list.reverse()
          print(num_list)
          ​
          #输出结果：
          '''
          [11, 22, 4, 5, 11, 99, 88]
          [88, 99, 11, 5, 4, 22, 11]
          ​
          '''

     • 嵌套

       num_list = [11, False, "大小白", [1, "大白", True, '小白']]
        print(num_list[3])
        print(numlist[3][2])
        print(numlist[-2][-2])
        num_list[3].append([22, "小小白"])
        print(num_list)
        ​
        #输出结果：
        '''
        [1, '大白', True, '小白']
        True
        小
        [11, False, '大小白', [1, '大白', True, '小白', [22, '小小白']]]
        ​
        '''

        

3. 理解元组类型的概念，理解元组和列表的不同，掌握它的基 础用法及操作：元组的声明与赋值、元组的访问与更新、元 组的遍历、添加、删除、排序等等；

   • 定义：是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。

     d1 = (1)  # 1  只有一个元素的时候最后没有","  得到的不是元组
      d2 = (1,) # (1,)

   • 元组和列表的区别

     元组是不可变的容器

     列表是可变的容器

   • 基础用法及操作

     • 声明

       #声明空元组
        v1 =（）
        #赋值
        v1 = (11,22,33)
        v2 = ("李杰","Alex")
        v3 = (True,123,"Alex",[11,22,33,44])
        print(v1, v2, v3)
        ​
        #输出结果：
        '''
        (11, 22, 33) ('李杰', 'Alex') (True, 123, 'Alex', [11, 22, 33, 44])
        '''

     • 元组的长度

       v3 = (True,123,"Alex",[11,22,33,44])
        print(len(v3))
        ​
        #输出结果：4

        

     • 元组的访问

       • 索引

         v3 = (True,123,"Alex",[11,22,33,44])
          print(v3[0])
          print(v3[1])
          print(v3[2])
          print(v3[3])
          ​
          #输出结果：
          '''
          True
          123
          Alex
          [11, 22, 33, 44]
          ​
          '''

       • 切片

         v3 = (True,123,"Alex",[11,22,33,44])
          print(v3[0:2])
          print(v3[:-1])
          print(v3[2:])
          ​
          #输出结果：
          '''
          (True, 123)
          (True, 123, 'Alex')
          ('Alex', [11, 22, 33, 44])
          ​
          '''

     • 元组相加

       v1 = (11,22,33)
        v2 = ("李杰","Alex")
        v3 = v1 + v2
        print(v3)
        ​
        #输出结果：
        '''
        (11, 22, 33, '李杰', 'Alex')
        相加得到的是新元组
        '''

        

     • 元组相乘

       v1 = (11,22,33)
        v2 = v1 * 2
        print(v2)
        ​
        #输出结果：
        '''
        (11, 22, 33, 11, 22, 33)
        相加得到的是新元组
        '''

        

     • 元组的更新、删除、排序：由于元组是不可变的容器，所以不能更新、删除、排序。

       更新、删除、排序也只能得到新元组，原来的元组不变

        

     • 转换

       name = "德玛西亚之力"
        name_list = tuple(name)
        for data in name_list:
            print(data)
        print(name_list)
        ​
        #输出结果：
        '''
        德
        玛
        西
        亚
        之
        力
        ('德', '玛', '西', '亚', '之', '力')
        ​
        '''
        ​
        ---------------------------------------
        v3 = [True,123,"Alex",[11,22,33,44]]
        data = tuple(v3)
        print(data)
        ​
        #输出结果：(True, 123, 'Alex', [11, 22, 33, 44])

        

     • 元组的遍历

       v3 = (True,123,"Alex",[11,22,33,44])
        for v in v3:
            print(v)
            
        #输出结果：
        '''
        True
        123
        Alex
        [11, 22, 33, 44]
        ​
        '''

     • 嵌套

       num_list = (11, False, "大小白", [1, "大白", True, '小白'])
        print(num_list[3])
        print(num_list[3][2])
        print(num_list[-2][-2])
        num_list[3].append([22, "小小白"])
        print(num_list)
        num_list[3][4][0] = 11
        print(num_list)
        ​
        ​
        #输出结果：
        '''
        [1, '大白', True, '小白']
        True
        小
        (11, False, '大小白', [1, '大白', True, '小白', [22, '小小白']])
        (11, False, '大小白', [1, '大白', True, '小白', [11, '小小白']])
        ​
        '''

       

       注意：元组是不可变的，列表是可变的，元组里嵌套列表时，列表中的元素是可以变的

4. 理解字符串类型的概念，掌握它的基础用法及操作：字符串 的分割、结合、替换、检索、长度获取。

   • 定义：是不可变有序的，一般表示文本信息

     name = "德玛西亚之力"
      name1 = '德玛西亚之力'
      name2 = "德玛西亚'之力"
      name3 = '德玛西亚"之力'
      name4 = """
      德玛西亚之力
      德玛西亚"之力
      """
      print(name)
      print(name1)
      print(name2)
      print(name3)
      print(name4)
      ​
      #输出结果：
      '''
      德玛西亚之力
      德玛西亚之力
      德玛西亚'之力
      德玛西亚"之力
      ​
      德玛西亚之力
      德玛西亚"之力
      ​
      ​
      '''

   • 基础用法及操作

     • 加法(连接)

       name1 = "德玛西亚"
        name2 = "之力"
        print(name1 + name2)
        ​
        #输出结果：德玛西亚之力

     • 乘法(重复)

       name1 = "德玛西亚之力"
        name2 = name * 2
        print(name2)
        ​
        #输出结果：德玛西亚之力德玛西亚之力

        

     • 字符串的分割

       name = "德玛西亚|之力"
        data = name.split("|")
        print(data)
        ​
        ​
        #得到的是一个列表
        #输出结果：['德玛西亚', '之力']

     • 替换

       字符串是不可变的类型，所以替换字符串中的内容是生成新的字符串

       name = "德玛西亚之力"
        data = name.replace("之"， "大")
        print(data)
        ​
        #输出结果：
        '''
        德玛西亚之力
        德玛西亚大力
        ​
        '''

     • 格式化format()

       name = "{}可以杀了{}，但是打不过{}"
        data = name.format("德玛西亚", "李白", "貂蝉")
        print(data)
        ​
        #输出结果：德玛西亚可以杀了李白，但是打不过貂蝉
        ​
        ​
        #-----------------------------------------
        name = "{1}可以杀了{0}，但是打不过{2}"
        data = name.format("德玛西亚", "李白", "貂蝉")
        print(data)
        ​
        #输出结果：李白可以杀了德玛西亚，但是打不过貂蝉
        ​
        ​
        #-----------------------------------------
        name = "{player3}可以杀了{player1}，但是打不过{player2}"
        data = name.format(player1="德玛西亚", player2="李白", player3="貂蝉")
        print(data)
        ​
        #输出结果：貂蝉可以杀了德玛西亚，但是打不过李白
        ​

     • 长度获取

       name = "德玛西亚之力"
        print(len(name))
        ​
        #结果输出：6

        

     • 转义符 \

       要求输出：我爱玩"王者荣耀"

       正确方式

       data = "我爱玩\"王者荣耀\""
        print(data)
        ​
        #结果输出：我爱玩"王者荣耀"
        ​
        #-----------------------------
        data = '我爱玩"王者荣耀"'
        print(data)
        ​
        #结果输出：我爱玩"王者荣耀"
        ​
        #-----------------------------
        data2 = 'I\'am a teacher'
        print( data2)
        ​
        #结果输出：I'am a teacher
        ​
        #-----------------------------
        data = '我爱玩\t"王者荣耀"'
        data1 = '我爱玩\n"王者荣耀"'
        data2 = '我爱玩\r"王者荣耀"'
        data3 = '我爱玩\\"王者荣耀"'
        print(data)
        print(data1)
        print(data2)
        print(data3)
        ​
        #结果输出：
        '''
        我爱玩 "王者荣耀"
        我爱玩
        "王者荣耀"
        "王者荣耀"
        我爱玩\"王者荣耀"
        ​
        '''

       错误方式

       

        

        

二、 会编写较为复杂的Python程序，掌握Python编程的控制语句

1. 理解选择结构语句的功能和写法，能够完成简单选择结构的程序；

   • if else :如果条件成立或者不成立，执行代码段1，否则执行代码段2

     条件最终是布尔类型的值

     if 条件成立：
          代码段1
      else:
          代码段2

     #实例1
      print("开始")
      if True:
        print("123")
      else:
        print("456")
      print("结束")
      ​
      # 输出结果
      开始
      123
      结束
      ​
      #实例2
      #-----------------------------
      num = 19
      if num > 10:
          print("num变量对应值大于10")
      else:
          print("num变量对应值不大于10")
          
      #实例3    
      #-----------------------------
      number = input("请输入数字：")
      if int(number)%2 == 1:
          print("{}是奇数".format(number))
      else:
          print("{}是偶数".format(number))    
          
      #实例4    
      #-----------------------------
      name = input("请输入用户名：")
      passwd = input("请输入密码：")
      if name == "teacher" and passwd == "123":
          print("登录成功！")
      else:
          print("登录失败！")
          
      #实例5  
      #-----------------------------   
      num = input("请输入数字：")
      if int(num) > 10:
          print("猜错了！")
      else:
          print("猜对了！")

      

2. 掌握程序的单分支结构，理解二分支、多分支结构语句；

   • 单分支结构

     name = input("请输入用户名：")
      passwd = input("请输入密码：")
      print("你输入的用户名是：{}".format(name))
      print("你输入的密码是：{}".format(passwd))
      ​
      #输出结果：
      请输入用户名：1
      请输入密码：2
      你输入的用户名是：1
      你输入的密码是：2

     

   • 二分支结构

     name = input("请输入用户名：")
      passwd = input("请输入密码：")
      if name == "teacher" and passwd == "123":
          print("登录成功！")
      else:
          print("登录失败！")

     

   • 多分支结构语句

     if 条件A:
        A成立，执行此缩进中的所有代码
        ...
      elif 条件B:
        B成立，执行此缩进中的所有代码
        ...
      elif 条件C:
        C成立，执行此缩进中的所有代码
        ...
      else:
        上述ABC都不成立。

      

     num = input("请输入数字")
      data = int(num)
      if data>6:
        print("太大了")
      elif data == 6:
        print("刚刚好")
      else:
        print("太小了")

     

      

3. 理解循环结构语句的功能和写法，能够完成简单循环结构的 程序；理解for循环、while循环、break和continue循环控制 结构语句；

   • while循环

     #死循环
      while True:
          print(1)
      print(2)
      ​
      #输出结果
      '''
      1
      1
      1
      1
      1
      1
      1
      1
      ....
      '''

     while 1 > 2:
          print(1)
      print(2)
      #输出结果

     print("开始")
     num = 1
     while num < 3:
     	print("滚滚黄河，滔滔长江。")
     	num = 5
     print("结束")
     
     # 输出：
     '''
     开始
     滚滚黄河，滔滔长江。
     结束
     '''

     print("游戏开始!!!!")
     
     flag = True
     while flag:
         num = input("请输入数字")
         data = int(num)
         if data > 6:
             print("太大了")
         elif data == 6:
             print("刚刚好")
             flag = False
         else:
             print("太小了")
     print("游戏结束!!!!")

   • break

     print("开始")
     while True:
     	print("1")
       break
     	print("2")
     print("结束")
     
     #输出结果：
     '''
     开始
     1
     结束
     
     '''

      

     游戏猜数字：

     1.提示用户输入数字，循环比较输入的数字与6的大小，如果大于6，输出“太大了”;小于6输出“太小了”；直到等于6，输出“刚刚好”，并退出循环。

     print("游戏开始!!!!")
     
     num = 0
     flag = True
     while True:
         num = input("请输入数字")
         data = int(num)
         if data > 6:
             print("太大了")
         elif data == 6:
             print("刚刚好")
             flag = False
             break
         else:
             print("太小了")
     print("游戏结束!!!!")

     2.提示用户输入数字，循环比较输入的数字与6的大小，如果大于6，输出“太大了”;小于6输出“太小了”；等于6，输出“刚刚好”，并退出循环。限制用户输入次数不能大于5次

     print("游戏开始!!!!")
     flag = True
     for i in range(5):
         num = input("请输入数字")
         i += 1
         data = int(num)
         if data > 6:
             print("太大了")
         elif data == 6:
             print("刚刚好")
             flag = False
         else:
             print("太小了")
     
     print("游戏结束!!!!")

     上述实例可以得出：一般while循环用于不知道循环的次数，而for循环一般用于已知循环次数

   • continue

     print("开始")
      i = 1
      while True:
          if i == 7:
              i = i + 1
              continue
          print(i)
          i = i + 1
          if i == 10:
              break
      print("结束")
      ​
      #输出结果：
      '''
      开始
      1
      2
      3
      4
      5
      6
      8
      9
      结束
      ​
      '''

   • 总结：对于break和continue都是放在循环语句中用于控制循环过程的，一旦遇到break就停止所有循环，一旦遇到continue就停止本次循环，开始下次循环。

4. 理解range类型的概念，掌握它的基础用法及操作。

   • range返回的是一个整数序列的对象

     print(list(range(10)))
      print("*"*20)
      print(list(range(1, 10)))
      print("*"*20)
      print(list(range(0, -10, -1)))
      ​
      #输出结果：
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      ********************
      [1, 2, 3, 4, 5, 6, 7, 8, 9]
      ********************
      [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

      

     for i in range(5):
          print(i)
          
      #输出结果：
      '''
      0
      1
      2
      3
      4
      ​
      '''
      ​
      ​
      ****************************************
      for i in range(2, 5):
          print(i)
      ​
          #输出结果：
      '''
      2
      3
      4
      ​
      '''
      ​
      ****************************************
      for i in range(10, 1, -1):
          print(i)
          
          #输出结果：
      '''
      10
      8
      6
      4
      2
      ​
      '''   
      ​
      ****************************************
      for i in range(10, 2, -2):
          print(i)
      #输出结果是？
      ​
      ****************************************
      for i in range(-3, -10, -2):
          print(i)
          
          #输出结果：
      '''
      -3
      -5
      -7
      -9
      ​
      '''

range取前不取后