列表

• 列表是python中的一个对象

• 对象就是内存中专门来存储数据的一块区域

• 之前我们学习的对象，像数值，它只能保存单一的数据

• 列表中可以保存多个有序的数据

• 列表的使用

  • 创建列表
  • 通过定义变量 和 [] 来创建列表

    my_list = [ ]

• 列表存储的数据，称为元素

• 一个列表中可以存储多个元素，也可以在创建列表式，来制定列表中的元素

  my_list =[ 10 ] # 创建了一个包含一个元素的列表

• 当列表中添加多个元素时，多个元素之间用 逗号隔开

  my_list = [ 10,20,30,40,50 ] # 创建五个元素的列表

• 列表中可以任意保存对象

  • 可以保存，str float bool int 列表 ，函数等，
  • 列表中的对象都会按照插入顺序来储存到列表中
  • 第一个插入的对象保存到第一个位置，依次类推

• 可以通过 索引 index 来获取列表中的元素

  • 索引是元素在列表中的位置，列表中的每一个元素都有一个索引
  • 索引是从0开始的整数，列表中的第一个位置索引为0 第二个位置索引为1

• 通过索引获取列表中的元素

  • 语法 :
  • 列表名[索引位置]

```
例
my_list = [ 10,20,30,40,50 ] # 定义一个列表
my_list[ 0 ] # 获取的元素是 10
printI(my_list[4]) # 输出的信息是 50

如果使用索引超过了最大的范围，会报错 就是 列表有5个 你获取第六个元素，就会报错

```

• 获取列表的长度 列表中元素的个数

  • len() 函数，通过该函数可以获取列表的长度
  • 获取列表的长度的值是，列表的最大索引，就是列表元素的最大个数
    print(len(my_list)) # 获取的数就是 5

• 字符串是有索引下标这一说的
  kml = ‘qwertyuio’
  print(len(kml))
  # 输出的是9 这个字符串有九个
  print(kml[8])
  # 输出的是 o 最后一个
  print(kml[1:])
  # 输出 第二个到最后一个 wertyuio
  
  print(kml[3:6])
  # 输出4个到第6个 rty

切片

• 切片是指从现有列表中，获取一个子列表

• 创建一个列表，一般创建列表时，变量的名字会使用复数

• 列表的索引可以是负数

• 如果索引是负数，则从后向前获取元素，-1 表示倒数第一个， -2 表示倒数第二个 以此类推

• 通过切片来获取指定的元素

  • 语法 ：
  • 列表[起始:结束]
    • 通过切片获取元素是，会包括起始位置的元素，不会包括结束位置的元素
    • 做切片操作时，总会返回一个新的列表，不会影响原来的列表
    • 起始和结束位置的索引都可以省略不写
    • 如果省略结束位置，则会一直截取元素到最后一个
    • 如果省略起始位置，则会从第一个元素开始截取
    • 如果起始位置和结束为止全部省略，则相当于创建了一个列表的副本
      print(lmk [1:3])
      # 截取第二个
      print(lmk [:3])
      # 截取1，2个
      print(lmk [:])
      # 全部截取 相当于创建了一个列表的副本

步长

• 语法：
• 列表 [起始:结束:步长]
• 步长表示，每次获取元素的间隔，默认值是1
  print(lmk[1:11:5])
  # 意思是 获取lmk这个列表的1到10的元素,并且是每五个获取一次
• 步长不能是0 但可以是负数
• 如果是负数则会从列表后补向前获取元素 打印的值也是从后往前的

列表的通用操作

• + 和 *

• + 可以将两个列表拼接成一个列表

• * 可以将列表重复指定的次数

• in 和 not in

• in用来检查指定元素是否存在于列表中

  • 如果存在，则返回true，否则返回false

• not in 用来检查指定元素是否不在列表中

  • 如果不在，则返回true，否则返回false

• 一些函数方法

• len() 获取列表中的元素个数

• max() 获取列表中的最大值

• min() 获取列表中的最小值

• 方法

• 调用方法，和函数基本上式一样的，只不过方法必须通过 对象.方法()的形式调用方法 实际上就是和对象关系紧密相连的函数

  • 第一个方法

    s.index() 获取指定元素在列表中第一次出现的索引 s 写变量名
    例
    print(lmk.index(‘lmk’))
    # 获取lmk列表中 lmk第一次出现的索引数
    # 后面可以写参数
    print(lmk.index(‘lmk’,3,7))
    # 3 代表查找的起始位置，7代表查找的结束位置

  • 第二个方法

    s.count() 指定元素在列表中出现的次数 s 写变量名
    例
    print(lmk.count(‘lmk’))
    # 这是查询 lmk列表中，lmk出现的次数

序列

• 序列是python中的基本的一种数据结构

• 数据结构指的是计算机中数据的存储方式

• 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置，这个位置就是索引下标，并且序列中的数据会按照添加的顺序来分配索引

• 序列的分类

• 可变序列

  列表 list

• 不可变序列

  字符串 str
  元组 tuple

• 可变序列

• 修改列表元素
  # 通过索引修改
  lmk [0] = ‘kml’
  # 把索引为零的值改为kml
  
  # 通过del 删除元素
  del lmk[2]
  # 删除索引为2的元素
  
  # 通过切片修改
  # 再给切片进行赋值时，只能使用序列，不能是其他
  lmk[0:2] = [‘123’,’456’] # 把 列标配中 0 到2 的索引值替换为 等号后面的值，也可以传多个元素
  
  lmk[0:0] = [‘123’,’456’] # 索引为零的元素是相当于在最前面插入等号后面的值
  
  lmk[: : 2] =[‘123’,’456’,’789’] # 从第一个开始，每两个替换为=号后面的值
  # 当设置步长时，序列中元素的个数，必须和切片中元素的个数一致
  
  # 通过切片删除元素
  lmk[0:2] # 删除0到2索引的值
  
  del lmk[: : 2] # 从0开始每两个值删除一次
  
  lmk [1 : 3 ] = [] # 把lmk 中 1 到 3的索引值 替换为空列表，就相当于删除
  
  # 如果要修改字符串的某一个值的话可以先把字符串转化为列表，再进行修改
  s = ‘hello’
  print(s[::-1])
  # str 反转 [::-1]就反转字符串了
  # 字符串也是可以和列表一样有索引值的

列表方法(总)

• 第一个方法

  s.index() 获取指定元素在列表中第一次出现的索引 s 写变量名
  例
  print(lmk.index(‘lmk’)) # 获取lmk列表中 lmk第一次出现的索引数 ,后面可以写参数
  print(lmk.index(‘lmk’,3,7)) # 3 代表查找的起始位置，7代表查找的结束位置

• 第二个方法

  s.count() 指定元素在列表中出现的次数 s 写变量名
  例
  print(lmk.count(‘lmk’)) # 这是查询 lmk列表中，lmk出现的次数

• 第三个方法

  s.append() 向列表的最后添加一个元素
  例
  lmk.append(‘lmk’) # 在列表最后添加一个lmk元素

• 第四个方法

  s.insert() 向列表的指定位置插入一个元素
  参数
  1.要插入的位置
  2.要插入的元素
  例 ：
  lmk.insert(2,’kml’) # 在第二个索引插入kml这个元素
  # 这个操作不会影响其他的元素 如果直接用索引插入，则会替换掉原来的元素

• 第五个方法

  s.extend() 使用新的序列来扩展当前序列
  需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
  例 ：
  lmk.extend([‘111’,’222’]) # 这两个元素会在lmk这个列表的后面被添加
  # 和 lmk += [‘111’,’222’] 效果一样

• 第六个方法

  clear() 清空序列
  lmk.clear() # 后这个列表中的元素都会被清空

• 第七个方法

  s.pop() 根据索引删除并返回被删除的元素
  这个是删除元素的
  例：
  name = lmk.pop(2) # 删除索引为2的元素
  print(name) # 这里会打印被删除的元素 pop这个方法会返回被删除的参数值
  # 如果括号里什么也不写
  name = lmk.pop() # 括号内不写元素则是删除最后一个元素

• 第八个方法

  s.remove() 删除指定值的元素，如果相同值的元素有多个，值会删除第一个元素
  例 ：
  lmk.remove(‘lmk’) # 删除这个元素，如果这个元素在lmk这个列表有多个，则只会删除第一次出现的，其他的不删

• 第九个方法

  s.reverse() 用来反转列表

       lmk.reverse()                  # 会将lmk这个列表里元素反转，先从最后一个开始输出
  

• 第十个方法

  s.sort() 用来对列表中的元素进行排序，默认是升序（从小到大排序）
  如果需要降序排列，则需要传递一个reverse=true作为参数
  mylist [‘2’,’3’,’1’]
  mylist.sort()
  print(mylist) # 则会输出 [‘1’,’2’,’3’] 从小到大排序
  # 降序排列
  mylist.sort(reverse=true) # 在里面传递一个参数，就是降序排列了 就相当于排好序后反转一下

遍历列表

• 遍历列表指就是将列表中的所有元素都取出来 就是遍历

• 最简单的方式就是把列表中的所有元素都打印出来

• while循环遍历

   例 ：
   i = 0
   while i < len(lmk) :
   print(lmk[i])
   i += 1
  

• for循环遍历

  • 语法 ：
    for 变量 in 序列 ：
    代码块
    # for循环每循环一次就会把值赋值给变量
    
    
    例 ：
    for s in lmk :
    print(s)

• for循环中的 range函数
  range()是一个函数，可以用来生成一个自然的序列
  该函数需要三个参数
  1.起始位置（可以省略）
2.结束位置
3.步长（可以省略，默认为1）
  例：
  r = range(5) 生成一个序列 （列表） [0,1,2,3,4]
  
  r = range(0,10,2) 生成 0到9 之前的数，并且0到9每两个生成一次 就是 [0, 2, 4, 6, 8]
  print(list(r)) 输出结果就是 [0, 2, 4, 6, 8] ,如果想看数字输出的结果，就要先把range 函数的值转化为列表，就可以清楚地查看了

• 通过range()可以创建一个执行指定次数的for循环

• for()循环除了创建方式以外，其余都和while相同
  包括else break continue 都可以在for循环使用
  并且for循环也更加简单
  例：
  for s In range(30): # 这个循环是循环30次 是从0到29
  print(s)

元组 tuple

• 元组是一个不可改变的序列
• 它的操作方式基本上和列表式一致的
• 所以在操作元组是就把元组当成一个不可变的列表就可以
• 一般我们希望数据不可改变时，就使用元组，其余情况下都使用列表

创建元组

• 使用 () 来创建元组
  my_tuple =() 这是创建一个空元组
  my_tuple =(1,2,3.4) 创建了4个元素的元组
  元组是不可改变的对象，不能尝试为元组中的元素重新赋值
当元组不是空元组是，括号可以省略，如果只有一个元素必须有一个 "," 号
  例 ：
  my_tuple = 10,20,30
  my_tuple = 1,

元组的解包（解构）

• 解包就是将元组当中每一个元素都赋值给一个变量
  例 ：
  my_tuple = (1,2,3,4)
  a,b,c,d = my_tuple
  print(a,b,c,d) # 结果就是 1，2，3，4
  # 这就是把元组的元素赋值给这4个变量了

• 解包的另外一种用法
  例 ：
  a = 100
  b = 200
  a,b = b,a
  这样a和b的值就互换了

• 解包用法再加一
  在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致，如果不一致就会报错
这样就可以在变量前添加一个 * 这样这个变量就会获取元组中的剩余元素
  例 ：
  # 星号在最后时
  my_tuple = (1,2,3,4,”此处省略多个数字”,100)
  a,b,*c = my_tuple
  print(a,b,c) # 输出的值为 1，2，3 [4—100]
  # 其余的值会以列表的形式输出
  
  # 星号在中间时
  my_tuple = (1,2,3,4,”此处省略多个数字”,100)
  a,*b,c = my_tuple
  print(a,b,c) # 输出的值为 1，[2-99],100 星号在中间就是这样
  
  # 星号在前面时
  my_tuple = (1,2,3,4 。。。。。100)
  *a,b,c = my_tuple
  print(a,b,c) # 输出的值为 [1-98],99,100 星号在前面就输出前面的留两个元素赋值给后面两个变量
  * 在哪个变量前面都可以，但是不可以出现两个星号