列表的初识,列表的索引切片,列表的增删改查,列表的嵌套,元组的初识,range

1 内容总览

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

2 具体内容

1. 列表的初识

   • why：

     • str： 存储少量的数据。切片出来全都是str类型,存储的数据单一。
     • list：能储存大量的数据。包含不同类型的数据。且有顺序,有规律,可自己制作设计其中的数据,可修改

   • what：list

     • l1 = [100, 'alex',True,[1, 2, 3]] 可承载任意数据类型，存储大量的数据。

     • python常用的容器型数据类型。

     • 列表是有序的，可索引，切片（步长）。

     • 列表可+列表 ( 叫list的合并 );列表可*int

       #列表的合并
       l1 = [1,2,3,4]
       l2 = [11,22,33]
       print(l1 + l2)   #[1, 2, 3, 4, 11, 22, 33]  是放到了一个列表里
       
       #列表*数字
       print(l1 * 2)   #[1, 2, 3, 4, 1, 2, 3, 4]   是放到了一个列表里

2. 列表的索引，切片，步长

   li = [100, '太白', True, [1, 2, 3]]
   # 索引
   # print(li[0], type(li[0]))    #元素是什么类型,取出来就是什么类型(str取出来均是str)
   # 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]
   print(li[:3])
   # 通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
   print(li[3:6])
   # 通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
   print(li[1:-2:2])
   # 通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
   print(li[-3::-2])

3. 列表的增删改查

   # 1.列表的创建(3种):
   # 方式一
   # l1 = []  #空列表
   # l1 = [1, 2, 'Alex']
   
   # 方式二
   # l1 = list()  #空列表
   # l1 = list('f小白hd12jf')    #['f', '小', '白', 'h', 'd', '1', '2', 'j', 'f']
   # print(l1)
   
   # 方式三：列表推导式(后续)
   
   # 2.列表的增删改查
   # 写在前面:a.列表的增删改3种操作中,除了.pop可以打印动作外,其他均不可打印动作;
   # b.列表的查.按索引,切片查值均是直接打印动作
   
   l1 = ['太白', '女神', 'xiao','吴老师', '闫龙']
   # 增：3种
   # 写在前面:此3种,均只能print(l1),不能print(l1.append("某元素")),因为不能打印动作
   # append:追加
   # l1.append('xx')
   # print(l1.append('xx'))  # 不能打印它!!!不能打印动作!
   # print(l1)  #只能打印l1
   
   # 举例：
   # l1 = ['太白', '女神', '吴老师', 'xiao', '闫龙']
   # while 1:
   #     name = input('请输入新员工姓名：(Q或者q退出程序)')
   #     if name.upper() == 'Q': break
   #     l1.append(name)
   # print(l1)
   
   # insert 插入
   # l1.insert(索引,'wusir')  #要插入到哪个位置,索引就写谁
   # print(l1)   #只能打印l1,不能打印动作
   
   # extend 迭代着追加  #将可迭代对象迭代(拆开)着追加进去
   # 注:效率低,因为插入位置元素后面的元素全部需要后移
   # l1.extend('abcd')    #['太白', '女神', 'xiao', '吴老师', '闫龙', 'a', 'b', 'c', 'd']
   # l1.extend(['alex',])   #['太白', '女神', 'xiao', '吴老师', '闫龙', 'alex']
   # l1.extend(['alex', 22])   #['太白', '女神', 'xiao', '吴老师', '闫龙', 'alex',"22"]
   # print(l1)  #只能打印l1,不能打印动作
   # 注:[1,]只要带逗号,就是个列表
   
   # 删:4种
   # 写在前面:除了pop有返回值外(即可打印动作),其他3种均只可print(l1),不可打印动作.
   # pop 按照索引位置删除
   # l1.pop(-2)  # 按照索引删除
   # print(l1)
   # print(l1.pop(-2))   #若打印动作,返回的是删除的元素(即有返回值)
   # l1.pop()  # 不写索引,默认删除最后一个
   # print(l1)
   
   # remove  指定元素删除,如果有重名元素，默认删除从左数第一个
   # l1.remove('xiao')
   # print(l1)  #不能打印动作
   
   # clear清空 (了解)
   # l1.clear()
   # print(l1)  #不能打印动作
   
   # del
   # 按照索引删除
   # del l1[-1]
   # print(l1)  #不能打印动作
   # 按照切片(步长)删除
   # del l1[::2]
   # print(l1)   #不能打印动作
   
   # 改:1种-实则3种
   # 写在前面:按索引改值,只可print(l1),不可打印动作.无意义
   # a.按照索引改值
   # l1[0] = '男神'
   # b.按照切片改
   # 如何改?--是将可迭代对象 迭代着(拆开)放回原列表的切片处.
   # 切片:将可迭代对象单个放回原处来改值,可迭代对象里的元素个数与取出的元素个数可以不相等!可多可少
   # l1 = ['太白', '女神', 'xiao','吴老师', '闫龙']
   # l1[2:] = 'fsdafsdafsdfdsfsadfdsfdsgsfdag'     #切片:可多可少
   # print(l1)   #不能打印动作
   # c.按照切片步长改       #步长:取处几个就放回几个
   # 如何改?--是将可迭代对象 迭代着(拆开)放回原列表取出来的元素处.
   # 步长:取几个,就放几个,不能多也不能少!!!
   # l1[::2] = 'abc'
   # l1[::2] = 'abcd'  #会报错
   # print(l1)
   # 思考题:为什么正向能放开,反向放不开呢?
   l1 = [1,2,3,4,9,8,9]
   l1[:3:] = "asdqwe"
   print(l1)   #['a', 's', 'd', 'q', 'w', 'e', 4, 9, 8, 9]
   l1 = [1,2,3,4,9,8,9]
   l1[-1:-3:-1] = "asdqwe"
   print(l1)   #报错-ValueError:尝试将大小为6的序列分配给大小为2的扩展片
   # 底层原理:因为list只能向下延伸开辟新的内存空间,但不能反向(倒着)去开)
   
   # 写在最后:索引,切片,切片步长改值 放回去的可以是单个元素,也可以是个list
   # li = ["水杯",2,3,"abc",]
   # li[0:3:2] = [1,2,3],[1234]
   # print(li)
   # 输出结果:[[1, 2, 3], 2, [1234], 'abc']
   
   # 查：3种
   # 按索引，切片（步长）查
   # for i in l1:   #遍历
   #     print(i)

4. 列表的嵌套

   l1 = [1, 2, 'taibai', [1, 'alex', 3,]]
   # 1,将l1中的'taibai'变成大写并放回原处。
   l1[2] = l1[2].upper()
   print(l1)
   # 2，给小列表[1,'alex',3,]追加一个元素,'老男孩教育'。
   l1[-1].append("老男孩教育")
   print(l1)   #不能打印动作
   # 3，将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'
   l1[-1][1] = l1[-1][1] + "sb"
   print(l1)

5. 元组的初识(了解)

   • 只读列表,不可改。存大量的数据，可以索引，切片（步长）;可存储多种数据类型
   • 格式: (100, '太白', True, [1, 2, 3])
   • where:储存一些重要数据如用户名,密码,个人信息等不想让外部环境修改的一些数据

6. 元组的简单应用(了解)

   • 元组的索引,切片

     tu = (100, '太白', True, [1, 2, 3])
     print(tu[0])
     print(tu[:3]) 

   • 遍历元组里的每个元素

     tu = (100, '太白', True, [1, 2, 3])
     for i in tu:
         print(i)

   • len:有效长度(元素个数)

     print(len(tu))   #打印元组tu的有效长度

   • .append(谁) : 只有当元组里的元素是list时,才可追加

     tu = (100, '太白', True, [1, 2, 3])
     tu[-1].append(666)   #给tu[-1]追加
     print(tu)   #不能打印动作
     

   • del: #元组tuple 里的东西不可删

     del tu[2]
     print(tu)  #报错
     # 应用：
     # 重要数据，用户名，密码，个人信息，不想让别人改动的一些数据，存在元组中。
     

   • 元组的拆包。即分别赋值。

     a, b = (1, 2)  # 多一个少一个都不行   #与一行代码交换a,b的值区分开!a,b = b,a,见下
     print(a,b)
     #输出结果: 1 2
     
     c = (1,2)
     a,b = c
     print(a,b)
     #输出结果: 1 2
     
     #注:tu(1)  int(没有逗号就是它本身)
     #tu(1,)   tuple  #有逗号就是元组
     

     #题目:一行代码交换a,b的值----2种方法实现
     a = 1
     b = 2
     a,b = b,a
     print(a,b)   #2  1    #注:a,b = [1,23],[3,45]也可  #输出结果:[1, 23] [3, 45]
     
     #元组的拆包:
     a = 1
     b = 2
     a,b = (2,1) #分别赋值
     print(a,b)   #2  1
     
     #小结:虽然2者都能实现,但原理不同??
     

7. range：

   • 看作: 一个可以自己控制范围的数字列表; #看作一个列表！！！,实则不是列表.

   • "顾头不顾腚": range(10)只能打印到数字9,[0,1,2,3,4,5,6,7,8,9];另,首不写,默认0

   • 通常和for循环结合使用

     • 利用for循环,和range遍历1-100之间的数字

       for i in range(1,101):  #"顾头不顾腚",格式:range(首,尾+1),若不写首,默认首是0.
        print(i)
       

     • 利用for循环,和range遍历1-100之间所有的偶数

       for i in range(2,101,2):     #range(首,尾+1,步长)
           print(i)
       

     • 利用for循环,和range倒序打印1-100之间所有的数字

       for i in range(100,0,-1)    #倒序,尾向尾的方向(向左)顺延1位
        print(i)
       

     • 利用for循环，利用range将l1列表的所有索引依次打印出来 ***

       l1 = ['asd', 1, 3, 'asd']
       for i in range(len(l1)):  #range(0,4)打印出来是[0,1,2,3](不顾腚).即l1各元素的索引!!!
        print(i)   #再for一下遍历出来.
       

     ​ 注: len代表元素个数,range代表一可控范围的数字列表;range(len(l1))即用元素个数去控制range的范 围.
     ​ 注: range打印出来的元素索引,要比len小1.(因为range不顾腚)

     • 坑:

       for i in range(3):        #range(3)代表[0,1,2]
           pass
       print(i)   #此行与for平齐,故执行完for语句,再执行它;故最后只是2,不是遍历[0,1,2]
       

       结果: 2