Day 04 ：列表的初始：列表切片索引：列表增删改查：列表嵌套：元组初识：元组简单应用：range

1 今日内容大纲

• 列表的初识
• 列表的索引切片
• 列表的增删改查
• 列表的嵌套
• 元组的初识（了解）
• 元组的简单应用（了解）
• range

2 昨日内容回顾以及作业讲解

• int str bool

• str：s1 = '太白123abc'

  • 索引：

    • s1[0]
    • s1[-1]
    • s1[:3]
    • s1[:5:2]
    • s1[-1:-4:-1]
    • s1[-1:-6:-2]

  • 常用操作方法：

    • .upper() .lower()

    • .startswith() .endswith()

    • spilt 分割： str ----- > list

      • 默认按照空格分割
      • 可以指定分隔符,指定分割数量 .spilt('+',1)

    • .strip()：默认去除字符串两边的空格，换行符，制表符

    • isdecimal（是否全部十进制） isalpha（是否全部字母） isalnum（是否由字母数字组合）

    • format 格式化输出 '倒计时{}秒'.format(i)

    • count 某个元素出现的次数

    • join 连接

      li = ["alex", "wusir", "taibai"]
      li = '_'.join(li)
      print(li)
      
      #结果：alex_wusir_taibai
      

    • replace 替换

    • len()获取数据元素的个数

  • for 循环

3 具体内容

1. 如何学习python

   1. 上午认真听
   2. 下午不要看视频，抓紧把时间放在练习上，写作业。 251行
   3. 讨论

2. 列表的初识

   • why： int bool str：'123 TRUE 太白'

     • str：存储少量的数据。
     • str： 切片还是对其进行任何操作，获取的内容全都是str类型。存储的数据类型单一。

   • what：list

     • l1 = [100,'alex',True,[1,2,3]] 可以承载任意数据类型，存储大量的数据。
     • Python常用的容器型数据类型。 list 列表，其他语言：java：数组
     • 列表是有序的，可索引的，切片（步长）

   • 列表的创建

     #方式一
     l1 = [1,2,'alex']
     
     #方式二
     l1 = list()
     l1 = list('asdasdasd')
     print(l1)
     
     #方式三
     #列表推导式，后面讲
     

     ​

3. 索引，切片，步长

   li = [100, '太白', True, [1, 2, 3]]
   print(li[0],type(li[0]))
   print(li[1],type(li[1]))
   print(li[-1])
   print(li[:2])   #切片（顾头不顾腚）
   

   相关练习题

   li = [1, 3, 2, "a", 4, "b", 5,"c"]
   # 通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
   l1 = li[:3]
   print(l1)
   # 通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
   l2 = li[3:-2]
   print(l2)
   # 通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
   l4 = li[1:-2:2]
   print(l4)
   # 通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
   l6 = li[-3:0:-2]
   print(l6)
   
   

4. 列表的增删改查

   1. 增

      • append：追加

        l1 = ['太白', '女神', 'xiao','吴老师', '闫龙']
        
        l1.append('xx')
        # print(l1.append('xx'))      #不能打印他
        print（l1）
        
        #举例：
        #向列表添加新员工姓名，按Q或q退出程序,并打印
        l1 = ['太白', '女神', '吴老师', 'xiao', '闫龙']
        while 1:#常用
        	name = input('请输入新员工姓名：（Q或q退出程序）')
            if name.upper() == 'Q':
            	break
            l1.append(name)
        print(l1)					
        

        ​

      • insert 插入

        #在'吴老师'之后添加'wusir'
        l1 = ['太白', '女神', '吴老师', 'xiao', '闫龙']
        l1.insert(2,'wusir')
        

      • extend 迭代着追加

        l1 = ['太白', '女神', '吴老师', 'xiao', '闫龙']
        l1.extend('abc')	   #'abc'字符串分成a，b，c添加到列表
        l1.extend(['alex',])   #列表中的元素分别叠加
        l1.extend(['alex',1,3])#列表中的元素分别叠加
        print(l1)
        
        
        #['太白', '女神', 'wusir', '吴老师', 'xiao', '闫龙', 'a', 'b', 'c', 'd']
        ['太白', '女神', '吴老师', 'xiao', '闫龙', 'alex']
        #['太白', '女神', '吴老师', 'xiao', '闫龙', 'alex', 1, 3]
        
        

   2. 删

      • pop 按照索引位置删除

        l1 = ['太白', '女神', '吴老师', 'xiao', '闫龙']
        l1.pop(-2)	#按索引删除    ['太白', '女神', '吴老师', '闫龙']
        print(l1.pop(-2))	#xiao  （可以返回删除的元素）
        l1.pop()  # 默认删除最后一个
        print(l1) #['太白', '女神', '吴老师', 'xiao']
        

      • remove 指定元素去除，如果有重名元素，默认删除从左数第一个

        l1.remove('xiao')
        print(l1)
        

      • clear（了解）

        l1.clear()
        print(l1)   #[]  不删除列表，只删除内容
        
        

      • del

        • 按照索引删除

        • 按照切片切除

          #按照索引删除
          del l1[-1]
          print(l1)
          
          #按照切片切除
          del l1[::2]
          print(l1)
          

   3. 改

      • 按照索引改值

      • 按照切片改值（了解）

      • 按照步长改值（了解）

        l1 = ['太白', '女神', '吴老师', 'xiao', '闫龙']
        
        按照索引改值
        l1[0] = '男神'        #['男神', '女神', '吴老师', 'xiao', '闫龙']
        print(l1)
        按照切片改值（了解）
        l1[2:] = 'asdasd'   #['太白', '女神', 'a', 's', 'd', 'a', 's', 'd']
        print(l1)
        按照步长改值（了解）
        l1[::2] = 'aaa'    #一一对应，要不然就报错，例如'a'
        print(l1)
        
        

   4. 查：

      • 索引，切片（步长）

      • for

        l1 = ['太白', '女神', '吴老师', 'xiao', '闫龙']
        for i in l1:
        	print(i)
        

5. 列表的嵌套

   l1 = [1, 2, 'taibai', [1, 'alex', 3,]]
   
   # 1, 将l1中的'taibai'变成大写并放回原处。
   l1[2] = l1[2].upper()
   print(l1)
   
   # 2，给小列表[1,'alex',3,]追加一个元素,'老男孩教育'。
   l1[-1].append('老男孩')   #直接给大列表的元素加.append就可以了。
   print(l1)
   
   # 3，将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'
   l1[-1][1] =l1[-1][1]+'sb'   #等价于 l1[-1][1] += 'sb'
   print(l1)
   
   
   
   lis = [2, 30, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
   
   # 将列表lis中的"tt"变成大写
   lis[-3][2][-1][0] = lis[-3][2][-1][0].upper()
   print(lis)
   # 将列表中的数字3变成字符串"100"
   lis[-3][2][-1][1] = 100
   print(lis)
   # 将列表中的字符串"1"变成数字101
   lis[-3][2][-1][-1] = lis[-3][2][-1][-1]+'01'
   print(lis)
   

   ​

6. 元组 tuple（了解）

   • 只读列表。存储大量的数据，可以索引，切片（步长），（100,'太白',True,[1,2,3]）

   • 应用：只读，存储重要数据，用户名，密码，个人信息，不想让别人改动的数据

   • 元组的拆包 分别赋值

     tu = (100, '太白', True, [1, 2, 3])
     print(tu[0])    #索引
     print(tu[:3])   #切片
     
     #查看
     for i in tu:
         print(i)
     
     # print(len(tu))  #元素个数
     tu[-1].append(777)  #只有元组中的列表可以.append()
     print(tu)
     
     del tu[2]   #元组中内容不可删,报错
     print(tu)
     
     #元组的拆包
     a,b = (1,2) #多一个少一个都不行
     print(a,b)
     
     

     ​

7. range：类似与列表，自定制数字范围的数字列表

   r = range(10)  # [0,1,2,3,4,5,6,7,8,9]
   # 顾头不顾腚
   print(r)
   for i in r:
       print(i)
   
   #索引（了解）
   print(r[1])
   
   for i in  range(1,101):   #顾头不顾腚  #1，2，3，，，，100
       print(i)
   #步长
   for i in  range(2,101,2):   #步长   #2，4，6，，，，100
       print(i)
   
   for i in range(100,0,-1): #顾头不顾腚 #100，99，98，，，，1
       print(i)
   
   
   l1 = [1, 2, 3, 'alex', '太白', 2, 3, 4, 66,]
   # 利用for循环，利用range将l1列表的所有索引依次打印出来
   '''
   0
   1
   2
   3
   4
   '''
   for i in range(1,len(l1)):
       print(l1[i])
   
   

   ​

4.今日总结

1. 列表的所有方法都要记住，append insert extend pop remove del clear
2. 列表的嵌套一定要会。
3. range 与 for循环结合

5.课后预习

1. 字典。