第七章：序列

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]  不使用切片  省略開始值  省略結束值