初识python05

序列

1.列表（list）

• 列表是python中的一个对象

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

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

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

• 列表的使用
  1.创建列表

  my_list = [] # 空列表，在列表中存储的数据称为元素
  ```
  列表中存储的数据，我们称之为元素。
  一个列表中可以存储多个元素，也可以在创建列表时来指定列表中的元素
  ```
  my_list2 = [8]
  print(my_list2,type(my_list2)) #输出结果是[8] <class 'list'>
  
  ```
  列表中可以存储不同种类的元素
  ```
  my_list3 = [8,'hello',True]
  ```
  2.列表的存储
  列表中的对象都会按照插入的顺序存储到列表中。
  第一个插入的对象保存到第一个位置，第二个保存到第二个位置。
  我们可以通过索引（index）来获取列表中的元素
  索引是元素在列表中的位置，列表中的每一个元素都有对应的一个索引
  索引是**从0开始的整数**，列表第一个位置的索引是0，第二个位置的索引为1，第三个位置的索引是2，以此类推
  3.通过列表索引获取对应的元素
  ```
  my_list3 = [8,'hello',True]  
  print(my_list3[1])  #通过索引查询列表中的某个元素,查询索引为1的元素（即列表中的第二个元素）
  ```
  4.获取列表的长度==》获取列表中元素的个数 :len()函数
  ```
  my_list3 = [8,'hello',True]
  print(len(my_list3))
  ```
  

2.切片

 切片是指从现有列表中获取一个子列表
  创建一个列表，一般创建列表时，变量的名字会使用复数
  ```
  stus = ['hello','hi','good','luckly']
  print(stus[2])
  ```

  列表的索引可以是负数
  如果列表的索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个，以此类推
  ```
  stus = ['hello','hi','good','luckly']
  print(stus[-1])
  ```
  **切片的语法格式：**
  **列表名[起始：结束]**
  注意：通过切片获取元素时，会包括起始位置的元素，**不会包括结束位置的元素**
  做切片操作时，总会返回一个新的列表，并且不会对原来的列表产生影响！
  ```
  stus = ['hello','hi','good','luckly']
  print(stus[-1]) # 输出luckly
  print(stus[0:3]) # 输出['hello', 'hi', 'good']
  print(stus)  #输出 ['hello', 'hi', 'good', 'luckly']
  ```
  用切片的方式来获取元素时，起始位置和结束位置的索引都可以省略不写
  如果省略结束位置，则会一直截取到最后
  如果省略开始位置则会从第一个元素开始截取
  ```
  stus = ['hello','hi','good','luckly']
  print(stus[1:]) #输出['hi', 'good', 'luckly']  
  print(stus[:3]) #输出 ['hello', 'hi', 'good']
  ```
  如果起始位置和结束位置都省略【：这个符号要记得写】，则相当于创建了我们原来的列表的副本
  ```
  stus = ['hello','hi','good','luckly']
  print(stus[:]) #['hello', 'hi', 'good', 'luckly']
  ```
  切片的另一种语法：列表名[起始：结束：步长]
  步长指的是每次获取元素的间隔，默认是1，步长可以是0，不能是负数，如果步长是负数，那么从后面向前面取

3.列表中的 + 和 *

  + 可以将两个列表拼接成一个列表
  ```
  my_list4 = [1,2,3]+['hello','world']
  print(my_list4) #输出[1, 2, 3, 'hello', 'world']
  ```
  * 可以将列表重复指定的次数
  ```
  my_list5 = [7,8,9] * 2
  print(my_list5)  #输出[7, 8, 9, 7, 8, 9]
  ```

4.列表中的in 和 not in

  in 用来检查指定元素是否存在于列表中，如果存在返回True,否则返回False
  ```
  my_list6 = ['o','p','q','u','v','w']
  print('o' in my_list6)
  print('b' in my_list6)
  ```
  not in用来检查指定元素不在列表中，若是不在，返回True,如果在，返回False
  ```
  my_list6 = ['o','p','q','u','v','w']
  print('b' not in my_list6)
  print('o' not in my_list6)
  ```

5.获取列表中的最小值min()和列表中的最大值max()

  ```
  my_list7 = [10,3,4,5,6]
  print(max(my_list7)) # 10
  print(min(my_list7)) # 3
  ```

6.列表名.index()& 列表名.count()

  1.index（要查找的目标元素，查找范围的开始位置，查找范围的结束位置）：用来获取指定元素在列表中第一次出现时的索引，注意范围包括开始位置，不包括结束位置
  ```
  my_list7 = [10,3,4,5,6]
  print(my_list7.index(3)) # 输出列表中元素3的索引，它在第二个位置，索引输出的索引是1
  ```
  index（）的第二个参数，表示的是查找的起始位置，即指定从第几个位置（索引）找我们要的元素
  ```
  my_list7 = [10,3,4,5,6]
  print(my_list7.index(3,4)) # 报错ValueError: 3 is not in list，因为我们这里指定从索引为4的地方找元素3，在指定范围内它找不到3，所以报错
  ```
  2.列表名.count（目标元素）用来统计目标元素在列表中出现的次数

序列sequence

• 序列是python中最基本的一种数据结构
• 数据结构指计算机中数据存储的方式
• 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引
• 序列的分类：
  可变序列（序列中的元组可以改变）：
  列表（list）
  不可变序列（序列中的元素不可以改变）【不可变序列无法通过索引来修改】：
  字符串（str）
  元组（tuple）

修改列表中的元素

  1.通过索引的方式来修改
  ```
  my_list7 = [10,3,4,5,6]
  my_list7[1]=9
  print(my_list7) # 输出 [10, 9, 4, 5, 6]
  ```
  2.通过切片的方式修改【在给切片进行赋值时，**只能使用序列**！】
  ```
  my_list7 = [10,3,4,5,6]
  my_list7[0:3]=[18,7,2]
  print(my_list7) # [18, 7, 2, 5, 6]
  ```

通过索引删除指定元素

  格式： **del  列表名[索引号]**
  ```
  my_list7 = [10,3,4,5,6]
  del my_list7[0]
  print(my_list7) #输出 [7, 2, 5, 6]
  ```

列表方法

• 1.append（）

stus1 = ['he','she','it','them','your','my']
print("原列表：",stus1) # 原列表： ['he', 'she', 'it', 'them', 'your', 'my']
stus1.append('our')
print("修改后：",stus1) # 修改后： ['he', 'she', 'it', 'them', 'your', 'my', 'our']

• 2.insert()
  向列表的指定位置插入一个元素
  参数：第一个参数是要插入的位置（索引），第二个参数是要插入的元素

stus1 = ['he','she','it','them','your','my']
stus1.insert(4,'their')
print(stus1) # ['he', 'she', 'it', 'them', 'their', 'your', 'my', 'our']

• 3.extend()
  需要以一个序列作为参数，它会将该序列中的元素添加到当前的列表中去，实现一次性添加多个元素的效果

stus1 = ['he','she','it','them','your','my']
stus1.extend(['hi','hello'])
print(stus1) # ['he', 'she', 'it', 'them', 'their', 'your', 'my', 'our', 'hi', 'hello']

• 4.clear()
  用于清空序列

stus1 = ['he','she','it','them','your','my']
stus1.clear()
print(stus1) # []

• 5.pop（）
  根据索引删除并返回被删除的元素

print(stus1) # ['hi', 'hello']
rel = stus1.pop(1)
print("被删除的元素是：",rel) # 被删除的元素是： hello
print(stus1) # ['hi']

• 6.remove（要删除的元素）
  用于删除指定值的元素，如果相同值的元素有多个，则智慧删除第一个

print(stus1) # ['hi', 'good', 'lucky']
stus1.remove('hi')
print(stus1) # ['good', 'lucky']

• 7.reverse（）用来反转列表

print(stus1) # ['good', 'lucky']
stus1.reverse()
print(stus1) # ['lucky', 'good']

• 8.sort()
  用来对列表中的元素进行排序，默认是升序排列

my_list1 = list('cabbghkhde')
print("修改前：",my_list1) # 修改前： ['c', 'a', 'b', 'b', 'g', 'h', 'k', 'h', 'd', 'e']
my_list1.sort()
print("修改后：",my_list1) # 修改后： ['a', 'b', 'b', 'c', 'd', 'e', 'g', 'h', 'h', 'k']

如果需要将排序结果是降序排序，不要使用默认的升序排序，那么用sort(reverse=True)

my_list2 = [8,6,5,3,7,9,14,10]
print("修改前：",my_list2)  # 修改前： [8, 6, 5, 3, 7, 9, 14, 10]
my_list2.sort()
print("修改后（升序排列）：",my_list2) # 修改后（升序排列）： [3, 5, 6, 7, 8, 9, 10, 14]
my_list2.sort(reverse=True)
print("修改后（降序排列）：",my_list2) # 修改后（降序排列）： [14, 10, 9, 8, 7, 6, 5, 3]