第七章：序列

01.序列简介

序列是Python当中最基本的数据结构
数据结构是什么？计算机中数据的存储方式

序列的分类：
1.可变序列 列表
2.不可变序列 str 元组

列表 ： list
列表的作用
列表可以保存多个有序的数据

1.列表的创建

列表存储的数据，我们称之为元素

一个列表可以存多个数据，每个数据（元素）我们用逗号隔开

列表可以保存任意对象

lst = [1,2,3,4,5]    # 我们可以通过[]来创建列表  创建了一个空的列表
print(lst,type(lst))
》》》
[1, 2, 3, 4, 5] <class 'list'>

我们把元素放在序列（文具盒）里面，怎么把它取出来？

我们可以通过索引（index）来获取列表中的元素

索引是从0开始，列表第一个位置是0 第二个位置是1 。。。。。以此类推

如果超出最大索引值就会报错 ；IndexError： list index out of range

len（）函数 获取列表的长度（列表中元素的个数）

获取到的列表的长度值；是列表的最大索引值+1

lst = [10,20,30,40,50]
print(lst[4])        # 该列表的最大索引值是：4
print(len(lst))     # 该列表的长度是：5 ——>  len(lst) = 4（最大索引值） + 1
》》》
50
5

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

lst = [10,20,30,40,50]
print(lst[-1])        #  50
print(lst[-2])       #  40
print(lst[-5])       #  10

02 - 列表切片

详细解释 一：

# 从现有列表获取一个子列表
#           0        1       2        3       4        5
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
# 通过切片来获取列表当中指定的元素
# print(hero[0])   # 钢铁侠


# 语法 列表[起始：结束]
# 通过切片获取元素的时候，会包括起始位置的元素，但是不会包括结束位置的元素

# print(hero[0:3])      # ['钢铁侠', '绿巨人', '蜘蛛侠'] ----> [0,1,2]左闭右合，跟数学中的[0,2] 和 [0,3) 是一个意思


# 起始位置 和 结束位置 可不可以不写呢？
# 如果省略结束位置，则会从当前的开始位置一直截取到最后
print(hero[1:])   #  ['绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

# 如果省略开始位置，则会从第一个元素开始当前位置
print(hero[:3])  #  ['钢铁侠', '绿巨人', '蜘蛛侠']

# 如果把开始和结束位置同时省略掉，则会从第一个元素截取到最后一个元素
print(hero[:])    #  ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

算法演练二：

#         0          1        2        3       5       6
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[0:3])  # ['钢铁侠', '绿巨人', '蜘蛛侠']  [0,2]->[0,1,2]

print(hero[:3])   # ['钢铁侠', '绿巨人', '蜘蛛侠']  # [0,1,2]
print(hero[:5])    #  ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人'] [0,1,2,3,4]


print(hero[0:])    # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']
                    # [0,1,2,3,4,5,]
print(hero[1:])     # ['绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']
                    #  [1,2,3,,4,5]


print(hero[:])     # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']
                    # [0,1,2,3,4,5]

步长：

#           0        1       2        3       4        5
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']

# 步长
# 语法 列表[起始：结束：步长]
# 步长表示，每次获取元素的间隔，默认是1（可以省略不写）
print(hero[:])  # ['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']
print(hero[::2]) # ['钢铁侠', '蜘蛛侠', '蚁人']

# 步长不能为0   ValueError: slice step cannot be zero
# print(hero[::0])

# 步长可以为负数，如果是负数，则会像列表的后部向前边获取元素，也就是说从后往前取
print(hero[::-2])   #  ['美国队长', '黑寡妇', '绿巨人']

知识点补充：

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[0:6])
》》》
['钢铁侠', '绿巨人', '蜘蛛侠', '黑寡妇', '蚁人', '美国队长']

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
print(hero[0:0])
》》》
[]    # 空

03 - 通用操作

+ 和 *

加号可以将两个列表拼接成一个列表

my_list = [1,2,3] + [4,5,6] # [1,2,3,4,5,6]

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

my_list = [1,2,3] * 2 # [1,2,3,1,2,3]

in 和 not in

hero = [‘钢铁侠’,‘绿巨人’,‘蜘蛛侠’,‘黑寡妇’,‘蚁人’,‘美国队长’]

in 用来检查指定元素是否在列表当中,如果在，返回True；如果不在，返回False

print('绿巨人’in hero) # True

not in 用来检查制定元素是否不在列表当中，如果不在，返回True，如果在，返回False

print('葫芦娃’not in hero) # True

min() 和 max()

min()函数是获取列表当中的最小值
max()函数是获取列表当中的最大值
len()函数是获取列表当中元素个数的值

a = [10,2,3,4,55]
print(min(a),max(a)) # 2 55
print(len(a)) # 5

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长','蜘蛛侠','蜘蛛侠','蜘蛛侠']
# s.index()     **获取指定元素在列表当中的位置**
print(hero.index('蜘蛛侠'))   #  2

# s.count()  统计指定元素在列表当中出现的次数
print(hero.count('蜘蛛侠'))   #  4
print(hero.count('葫芦娃'))   #  0

04 - 修改列表

04-修改列表
hero = [‘钢铁侠’,‘绿巨人’,‘蜘蛛侠’,‘黑寡妇’,‘蚁人’,‘美国队长’]

hero[0] = [‘雷神’]
print(hero)

通过del来删除元素
del hero[2]
print(hero)

通过切片来修改元素
hero[0:3] = ‘abcde’ # [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘黑寡妇’, ‘蚁人’, ‘美国队长’]
hero[0:3] = ‘123’ # [‘1’, ‘2’, ‘3’, ‘黑寡妇’, ‘蚁人’, ‘美国队长’]

hero[0:3] = 123 # TypeError: can only assign an iterable 给切片进行复制的时候必须传递一个序列

hero[0:3] = [‘黑豹’,‘灭霸’] # [‘黑豹’, ‘灭霸’, ‘黑寡妇’, ‘蚁人’, ‘美国队长’]
hero[0:6] = [‘黑豹’,‘灭霸’] #
print(hero)

l = hero[0:0]
print(l) # []

hero[0:0] = [‘雷神’] # 向索引值为0的位置插入元素
print(hero)
》》》
[‘雷神’, ‘钢铁侠’, ‘绿巨人’, ‘蜘蛛侠’, ‘黑寡妇’, ‘蚁人’, ‘美国队长’]

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇','蚁人','美国队长']
# print(hero[::2])   #  ['钢铁侠', '蜘蛛侠', '蚁人']

# 当设置了步长，序列中元素的个数必须和切片重元素的个数保持一致
# hero[::2] = ['雷神','黑豹','灭霸']   #  ['雷神', '绿巨人', '黑豹', '黑寡妇', '灭霸', '美国队长']

# 通过切片来删除元素
# del hero[::2]   #   ['绿巨人', '黑寡妇', '美国队长']
# hero[1:3] = []  # ['钢铁侠', '黑寡妇', '蚁人', '美国队长']

# s = 'python'
# s[1] = 'j'
# print(s)  # 报错，改不了  # TypeError: 'str' object does not support item assignment

s = 'python'
s = list(s)
s[1] = 'j'
print(s)  #  ['p', 'j', 't', 'h', 'o', 'n']

05 - 列表的方法

hero = [‘钢铁侠’,‘绿巨人’,‘蜘蛛侠’]

1. s.append()

s.append() 向列表的最后添加一个元素
hero.append(‘黑寡妇’)
print() # [‘钢铁侠’, ‘绿巨人’, ‘蜘蛛侠’, ‘黑寡妇’]

2. s.insert()

s.insert() 向列表指定位置插入一个元素 参数 1.要插入的位置 2.要插入的元素
hero.insert(2,‘黑寡妇’)
print(hero) # [‘钢铁侠’, ‘绿巨人’, ‘黑寡妇’, ‘蜘蛛侠’]

3. s.extend()

s.extend 使用新的序列来扩展当前的序列
需要一个序列作为参数，它会将该序列中的元素添加到当前的序列当中
hero.extend([‘黑寡妇’,‘蚁人’]) # 相当于 hero += [‘黑寡妇’,‘蚁人’]
print(hero) # [‘钢铁侠’, ‘绿巨人’, ‘蜘蛛侠’, ‘黑寡妇’, ‘蚁人’]

4. s.append() 和 s.extend的区别

s.append 和 s.extend 看起来有些相似，但是区别在于 s.append 只能添加一个元素，而 s.extend 能添加一个序列

5. s.clear()

s.clear() 清空序列
hero.clear()
print(hero) # 打印出来是： []

6. s.pop()

s.pop() 可以根据索引值删除并返回指定的元素
a = hero.pop(1)
print(a) # 蜘蛛侠
print(hero) # [‘钢铁侠’, ‘绿巨人’]

如果不传递索引值就是删除最后一个元素
b = hero.pop()
print(b) # 蜘蛛侠
print(hero) # [‘钢铁侠’, ‘绿巨人’]

7. s.remove()

s.remove 删除指定值的元素
hero.remove(‘绿巨人’)
print(hero) # [‘钢铁侠’, ‘蜘蛛侠’]

8. s.reverse()

s.reverse() 用来翻转列表
hero.reverse()
print(hero) # [‘蜘蛛侠’, ‘绿巨人’, ‘钢铁侠’]

9. s.sort()

s.sort() 可以用来对列表当中的元素进行排序 (默认是升序的)
一般python中排序只会对数字字符串进行排序，对英文字符串进行排序的一般比较少，对中文基本上不进行排序
s.sort()是根据ASCII码表来进行排序的
（1）这个是排 ‘顺’ 序
my_list = list(‘ansdbasdat’)
my_list.sort() # [‘a’, ‘a’, ‘a’, ‘b’, ‘d’, ‘d’, ‘n’, ‘s’, ‘s’, ‘t’]
print(my_list)
（2） 这个是排 ’倒‘ 序
my_list = list(‘ansdbasdat’)
my_list.sort(reverse=True) # [‘t’, ‘s’, ‘s’, ‘n’, ‘d’, ‘d’, ‘b’, ‘a’, ‘a’, ‘a’]
print(my_list)

06. - 遍历列表

遍历列表 指的是将列表当中的元素取出来

hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇']

（1）
print(hero[0])      # 钢铁侠
print(hero[1])      # 绿巨人
print(hero[2])		#  蜘蛛侠
print(hero[3])		#  黑寡妇

 一般不这么写 （1）（2）
 （2)
i = 0
while i < len(hero):   # 用len（）的好处是不管这个列表当中有多少个元素，我们都可                          
    print(hero[i])             以获取到，
    i += 1
》》》
钢铁侠
绿巨人
蜘蛛侠
黑寡妇

一般情况下我们是不通过while循环来遍历列表中的元素，我们通常使用的是 for 循环
语法： for 变量 in 序列（遍历的规则）
                代码块              
每执行一次就会将序列当中的一个元素赋值给变量 s
所以我们可以通过变量，来获取列表中的元素


 该列表中有几个元素，循环就会执行几次
hero = ['钢铁侠','绿巨人','蜘蛛侠','黑寡妇']
for s in hero:
    print(1)  # hero列表中有4个元素，这个循环就会执行4次


for s in hero:
    print(s)
    >>>
 钢铁侠
绿巨人
蜘蛛侠
黑寡妇

07. - range()函数

（1）start - stop：

range()函数 可以用来生成一个自然数的序列
start： 开始 默认从0开始（0可以省略）
stop: 结束 但是不包括结束 例如： range(0,5) ——> [0,1,2,3,4] 没有5

r = range(5) # 相当于 range(0,5)
print(list®) # [0,1,2,3,4]

（2）step：

step: 步长 默认为1 跟列表中的 步长 差不多
r = range(0,5,1)
print(list®) # [0, 1, 2, 3, 4]
r = range(0,10,2)
print(list®) # [0, 2, 4, 6, 8]

（3）for循环在range()函数-步长中的应用：

如果我想让一个 for 循环中的代码块执行指定的次数，那么我们就可以在range（）函数里面的参数传递指定的次数

lst = [1,2,3,4,5,6,7,8,9]

for i in range(0,9,2):

    print(lst[i])
    》》》
    1
3
5
7
9

08. - 练习

08 练习一 获取列表中所有的奇数

lst = [1,2,3,4,5,6,7,8,9]

for i in range(0,9,2):

    print(lst[i])


练习二 找出100以内所有可以被3整除的数
方案一：
1. 定义一个空的列表  来接受结果
lst = []

# 2. 循环100个数
for i in range(1,101):

    # 3. 判断 可以被3整除的数：
    if i % 3 == 0:
        # 可以被3整除的数添加到列表中
        lst.append(i)

print(lst)
》》》
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]

# 方案二：
print(list(range(3,101,3)))
》》》
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]

练习三：不通过函数的形式让列表实现翻转，并写出推导过程

练习三  现在有一列表 a = [1,2,3,4,5,6]  那么现在的要求是  不通过函数的形式让列表实现翻转，并写出推导过程

a = [1,2,3,4,5,6]

考点：对切片的另一种操作
a[::-1]  结论
a[0:4] [1,2,3,4]      切片
a[0:4:1] [1,2,3,4]   加上步长
a[0:4:2] [1.3]       步长为2

以上操作都是从左往右开始，步长为负就是从右往左开始
a[4:1:-1] [5,4,3]   步长为负
a[::-1] [6,5,4,3,2,1]  不使用切片  省略开始值  省略结束值