1、序列（sequence）

? 序列的索引其實在之前的第四篇博客的字串切片中有說到過，這里再次提一下，因為它很重要，重要，重要，很重要的事情要說3遍嘛， ( ?? ω ?? )y 博客鏈接，感興趣的朋友可以點過去看看，當然，本篇中也講述了串列的切片哦*?( ??? )?*

1.1、基本概念

• 序列是Python中最基本的一種資料結構，

? 序列用于保存一組有序的資料，所有的資料在序列當中都有一個唯一的位置（索引）并且序列中的資料會按照添加的順序來分配索引
? 序列就是名為容器的資料結構，序列（例如：串列，元組）和映射（例如：字典），序列中的每個元素都有一個編號，而映射中的每個元素都有一個名字（鍵），而集合既不是序列型別的容器也不是映射的型別，
? 序列可以一些特殊的操作：索引，分片，加，乘，檢查某個元素是否屬于序列，除此之外python還可以計算序列的長度，找出最大函式和最小函式的內建函式，

• 資料結構指計算機中資料存盤的方式

• 序列的分類：

  • 可變序列（序列中的元素可以改變）：例如 串列（list）
  • 不可變序列（序列中的元素不能改變）：例如 字串（str）元組（tuple）

1.2、索引

? 陣列索引，陣列索引機制指的是用方括號（[]）加序號的形式參考單個陣列元素，它的用處很多，比如抽取元素，選取陣列的幾個元素，甚至為其賦一個新值，
這里拿一個串列的索引展示一下，例如陣列 a=['a','b','c','d','e','f','g','h','i']

1.3、實際運用

• 以下就是陣列通過索引來獲取單個陣列的元素，

a=['a','b','c','d','e','f','g','h','i']
print(a[0])
# 運行結果 》》》a

print(a[4])
# 運行結果 》》》e

print(a[8])
# 運行結果 》》》i

print(a[-1])
# 運行結果 》》》i

2、串列(list)

2.1、 串列的概念

串列是Python中的一個物件
串列的作用:

• 串列中可以保存多個有序的資料
• 串列是用來存盤物件的物件

? 串列是由一系列按特定順序排列的元素組成的，通常包含多個元素，例如：字串，整型數值，浮點型數值，串列，None,串列，字典等，在python中，用方括號[ ] 表示串列，并用逗號分割其中的元素

2.2、 串列的使用

• 串列的創建：通過[]來創建一個空串列

a=[]
print(a)
# 運行結果 》》》[]

• 串列的創建：直接賦值

a=['a','b','c','d','e','f','g','h','i']
print(a)
# 運行結果 》》》['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

3、切片

3.1、切片的概念

? 在第四講對字串的切片中有講過字串切片的用法，其實切片不止是字串能用，串列list，元組tuple都能夠使用切片，
? 切片做的事情在已知的資料上取出想要的部分，切片是在可迭代物件的基礎上，取出任意長度的元素，同時取得范圍、頻次也是可以自定義的
總結：切片是取操作，不改變原值

• 切片是指從現有可迭代物件（串列）中獲得一個子串列
• 通過切片來獲取指定的元素

3.2、語法

• 串列[起始 : 結束 : 步長] 左閉右開區間 取頭不取尾 步長默認是1

詳細一點講就是：
1、左閉右開區間：在通過切片獲取元素時,會包括起始位置的元素,不會包括結束位置的元素
2、起始位置和結束位置的索引可以不寫

• 如果省略結束位置, 則會從當前的開始位置一直截取到最后
• 如果省略開始位置, 則會從第一個元素截取到結束的元素，但是不包括結束的元素
• 如果開始位置和結束位置都省略, 則則會從第一個元素開始截取到最后一個元素

3、步長表示每次獲取元素的間隔，默認是1(可以省略不寫)
4、 步長不能是0,但可以是是負數

3.3、 實際運用

• 個人對切片學習的心得：建議親自動手敲幾遍，概念看再多總歸還不如多去實操幾遍來的效果好，

a=['a','b','c','d','e','f','g','h','i']

print(a[::])
# 運行結果 》》》['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
# 運行講解：起始位置、結束位置和步長都是空，既列印所有串列元素

print(a[0:3])   # 默認步長為1
# 運行結果 》》》['a', 'b', 'c']
# 運行講解：a串列從第一位a取到第4位d，d不可取，所以只能取到c，既abc這3個元素
# 也可以是如下寫法，從 0 開始就可以把初始位置省略，效果如上
print(a[:3])

print(a[0:4:2])    # 初始位置為0可省略
# 運行結果 》》》['a', 'c']
# 運行講解：a串列從第一位a取到第5位e，e不可取，步長為2,只能取到ac

print(a[-1:-4])
# 運行結果 》》》[]
# 運行講解：步長不寫默認為1，但初始和結束位置為負，但初始大于結束位置，則什么值都取不到

print(a[-4:-1:1])
# 運行結果 》》》['f', 'g', 'h']
# 運行講解：初始小于結束位置，從倒數第4位f取到最后1位i,i不可取，步長為1

print(a[-1:-4:-1])
# 運行結果 》》》['i', 'h', 'g']
# 運行講解：從倒數第一位i取到倒數第4位e（e不可取），

print(a[::-1])
# 運行結果 》》》['i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
# 運行講解：初始和結束位置都為空，步長為負，則逆序列印

4、通用操作

4.1 操作與說明

4.2 實際運用

• +的使用

a = [1, 2, 3] + [4, 5, 6]
print(a)
# 運行結果 》》》[1, 2, 3, 4, 5, 6]

• *的使用

a = [1, 2, 3] *3
print(a)
# 運行結果 》》》[1, 2, 3, 1, 2, 3, 1, 2, 3]

# 錯誤用法：串列乘串列，不用這樣使用
a = [1, 2, 3] * [4, 5, 6]
#上面這種寫法會報錯的哦，像這樣：
# TypeError: can't multiply sequence by non-int of type 'list'
# 型別錯誤:不能用“串列”型別的非整數乘序列

• in的使用

a = ['p','y','t','h','o','n']
print('y' in a)
# 運行結果 》》》True

• not in的使用

a = ['p','y','t','h','o','n']
print('y' not in a)
# 運行結果 》》》 False

• len() 的使用

a = ['p','y','t','h','o','n']
print(len(a))
# 運行結果 》》》6

• max()的使用

b = [1, 2, 3, 1]
print(max(b))
# 運行結果 》》》3

• min()的使用

b = [1, 2, 3, 1]
print(min(b))
# 運行結果 》》》1

• list.index的使用

a = ['p','y','t','h','o','n']
print(a.index('y'))
# 運行結果 》》》1
# 回傳的結果就是當前這個資料‘y’的索引

注：串列沒有find用法，使用find會報錯的

• list.count(x)

a = ['p','y','t','h','o','n','y']
print(a.count('y'))
# 運行結果 》》》2
# 查找有幾個這種元素

• list.copy(x)

a = ['p','y','t','h','o','n']
print(a.copy())
# 運行結果 》》》['p', 'y', 't', 'h', 'o', 'n']

• cmp(list1, list2)，這里用operator模塊

# cmp是python2中的函式，python3中以無法使用，可以用operator代替，效果一樣的
a = ['11','22','33']
b = ['22','33','44']
import operator
print(operator.eq(a,b))
# 運行結果 》》》False

這里有一種關于operator模塊的使用，感興趣的朋友可以了解一下

5、修改串列

通過切片來修改(起始就是給切片的內容重新賦值，但是賦值的內容必須是一個序列)
當設定了步長時,序列中元素的個數必須和切片中元素的個數保持一致
通過切片來洗掉元素

• del list[起始 : 結束]
  list = []

5.1、 直接修改

a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
a[-1] = '亞瑟'
print(a)
# 運行結果 》》》['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '亞瑟']

5.2、切片修改

a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
print(a[3:5])
# 運行結果 》》》['露娜', '安琪拉']

a[3:4] = '橘右京'
print(a)
# 運行結果 》》》['孫悟空', '豬八戒', '魯班', '橘', '右', '京', '安琪拉', '虞姬']

a[3:5] = '李白'
print(a)
# 運行結果 》》》['孫悟空', '豬八戒', '魯班', '李', '白', '京', '安琪拉', '虞姬']

a[0:0] = ['牛魔']
print(a)
# 運行結果 》》》['牛魔', '孫悟空', '豬八戒', '魯班', '李', '白', '京', '安琪拉', '虞姬']

a[::2] = ['凱','凱','凱','凱','凱']
print(a)
# 運行結果 》》》['凱', '孫悟空', '凱', '魯班', '凱', '白', '凱', '安琪拉', '凱']
# 取到多少個資料，替換的資料就得有多少

print(a)
print(a.index('安琪拉'))
# 運行結果 》》》7

5.3、 洗掉 關鍵字

a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
del a[-1]
# 運行結果 》》》['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉']

6、串列的方法

6.1 方法與說明

6.2 實際運用

6.2.1、添加方法

• append()

# list.append()  向類表中最后的位置插入一個元素
a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
a.append('凱')
print(a)
# 運行結果 》》》['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬', '凱']

• insert(arg1,arg2)

# list.insert() 向串列中的指定位置插入一個元素，第一個引數是要插入的位置，第二個引數是要插入的內容
a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
a.insert(4, '亞瑟')
print(a)
# 運行結果 》》》['孫悟空', '豬八戒', '魯班', '露娜', '亞瑟', '安琪拉', '虞姬']

• extend(iterable)

# list.extend() 使用新的序列來擴展當前序列，就是添加多個元素
a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
a.extend(['亞瑟', '凱'])
print(a)
# 運行結果 》》》['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬', '亞瑟', '凱']

6.2.2、洗掉方法

• pop()

# list.pop() 根據索引洗掉并回傳元素， 如果不傳遞索引，默認洗掉最后一個
a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
a = a.pop()
print(a)
運行結果 》》》虞姬

• remove()

# list.remove() 洗掉指定的元素
a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
a.remove('魯班')
print(a)
運行結果 》》》['孫悟空', '豬八戒', '露娜', '安琪拉', '虞姬']

6.2.4、反轉串列

• reverse()

a = ['孫悟空', '豬八戒', '魯班', '露娜', '安琪拉', '虞姬']
a.reverse()
print(a)
運行結果 》》》['虞姬', '安琪拉', '露娜', '魯班', '豬八戒', '孫悟空']

6.2.1、排序

• sort(key=None,reverse=False)

# list.sort()  默認是正序排序 他有一個引數reverse
a = [4,5,2,7,1,0,5,8]
a.sort(reverse=True)
print(a)
運行結果 》》》[8, 7, 5, 5, 4, 2, 1, 0]

7、對條件陳述句的補充（for回圈）

7.1、基本概念

? for 陳述句是 Python 中執行迭代的兩個陳述句之一，另一個陳述句是 while，while在之前的博客里有講過，這里我們補充介紹一下for回圈的用法，
? Python 中，for 回圈用于遍歷一個迭代物件的所有元素，回圈內的陳述句段會針對迭代物件的每一個元素專案都執行一次，這里我們用的迭代物件就是串列和range，

7.2、for 回圈語法

• 字串

for i(迭代變數) in 'Python':
	回圈體

• range

for i(迭代變數) in range(1,9):
	回圈體

• 序列

for i(迭代變數) in 序列(遍歷的規則):
	回圈體

7.2 range的用法

• for 迭代變數 in range ( i, j [,k ]):

引數說明：

這個也是左閉右開區間，所以終止值不可取
i: 初始值（默認為‘0’）
j: 終止值（默認為‘1’）
k: 步長值，即每次重復操作時比上一次操作所增長的數值，（默認為‘1’）

執行程序：

第一步：將 i 值傳遞給 ‘迭代變數’，然后執行一次內部陳述句;
第二步：在 i 的基礎上 + k 再次傳遞給 ‘迭代變數’，如果 ‘迭代變數’ 的值小于 ‘j’ 的值，則再次執行內部陳述句，否則退出for回圈，

詳情如下：

for i in range(9):
    print(i)

運行結果如圖;

8、課后作業

8.1、 現在有 a = [1,2,3,4,5,6] 用多種方式實作串列的反轉([6,5,4,3,2,1]) 并寫出推導程序

# 第一種方法，使用append
a = [1,2,3,4,5,6]
b = []
for i in a:
    b.append(a[6-i])
print(b)

# 第二種方法，切片的運用
a = [1,2,3,4,5,6]
print(a[::-1])

# 第三種方法，反轉串列
a = [1,2,3,4,5,6]
a.reverse()
print(a)

# 第四種方法，排序
a = [1,2,3,4,5,6]
a.sort(reverse=True)
print(a)

• 運行結果如下：
  

• 知識點運用及撰寫思路：

? 第一種方法用到了串列方法append和for回圈的配合，每一次運行都將串列a中的值添加給b，達到逆序的效果，
? 第二種方法是切片的逆序列印，詳情可以看上面切片的介紹及運用，
? 第三種和第四張方法都是串列方法的運用，不過第三種不管里面的元素是什么型別的都可以逆序列印，但第四張只能針對像這種原本就是元素從小到大的串列，其他的就達不到逆序的效果，

8.2、給用戶9次機會 猜1 - 10 個數字隨機來猜數字，

如果隨機的數字和用戶輸入的數字一致則表示正確，如果不一致則表示錯誤，
最終結果要求用戶怎么也猜不對
# 第一種方法
list1 = [1,2,3,4,5,6,7,8,9,10]
for i in range(1,10):
    a = int(input('請輸入1 - 10中的數字：'))
    b = list1[a+1]
    print(f'你猜錯啦，應該是{b}才對哦!')
else:
    print('哈哈哈，你9次都沒猜對哦！！！')
    
# 第二種方法    
list1 = [1,2,3,4,5,6,7,8,9,10]
i=1
while i<10:
    a = int(input('請輸入1 - 10中的數字：'))
    if a in list1:
        b = list1[a+1]
        print(f'你猜錯啦，應該是{b}才對哦!')
        i += 1
    else:
        print('哎呀，要猜1到10內的數字哦！！！')
        continue
else:
    print('哈哈哈，你9次都沒猜對哦！！！')

# 第三種方法
import random
i = 1
while i<10:
    a = int(input('請輸入1 - 10中的數字：'))
    if a>=1 and a<=10:
        b = random.randint(1, 10)
        while (a == b):
            b = random.randint(1, 10)
            if (a != b):
                continue
        print(f'你猜錯啦，應該是{b}才對哦!')
        i+=1
    else:
        print('哎呀，要猜1到10內的數字哦！！！')
        continue
else:
    print('哈哈哈，你一次都沒猜對！！！')

• 運行結果如下（這里只展示第3種方法的效果，還有2種也差不多）：
  

• 知識點運用及撰寫思路：

? 我們先審一下題目，這里要求不管用戶輸入什么1~10內的數字，都讓他猜不到
? 這里我寫了3種方法，思路是循序漸進的，應該更好理解，
? 首先我們第一種方法用到的就是for回圈和串列的運用，先創建一個串列，里面的元素就是1~10的數字，然后不管用戶輸入什么數字，我這邊都加上2輸出，這里因為索引是從0開始，所以list1[a+1]就能達到這種效果，但是我發現這個方法又不足，先不說，我們輸出的數字不隨機，再有就是我不管輸入什么數字都行，缺少了一個判斷，所以我又進行了更改
? 第二種方法我就在第一種方法加上了if判斷，但是我這個時候又遇到一個問題，如果接著用for回圈，就算我輸不是1 ~ 10 內的數字，然后他總的回圈只能有9次，所以不符合我的預期效果，這個時候我想到了while回圈，并將其添加進去，這時我就限定了用戶只能輸入1 ~ 10內的數字，
? 第三種方法，是我想讓我們輸出的數字也隨機，這是我想到了random模塊，使用這個模塊不就能隨機了能生成亂數了嘛，但是我又想到這個還有一個問題，就是他有很大概率讓用戶懵中，所以我這又給他加了個回圈，使其就算猜中了也沒用，猜中我就換一個亂數就好了，最后的效果就如上圖了，

8.3、有兩個串列 lst1 = [11, 22, 33] lst2 = [22, 33, 44]獲取內容相同的元素

# 第一種方法 while回圈
lst1 = [11, 22, 33]
lst2 = [22, 33, 44]
a = 0
c = '相同的元素為：'
while a<3:
    b=0
    while b<3:
        if lst1[a]==lst2[b]:
            c+=f' {lst1[a]}'
        b +=1
    a +=1
print(c)

# 第二種方法 for回圈
lst1 = [11, 22, 33]
lst2 = [22, 33, 44]
c = '相同的元素為：'
for i in range(0,3):
    for j in range(0,3):
        if lst1[i]==lst2[j]:
            c+=f' {lst1[i]}'
print(c)

• 運行結果如下：
  
• 知識點運用及撰寫思路：

? 這題比較容易，獲取2個串列相同的元素，我們只要用一下回圈嵌套就好了，外回圈和內回圈都是回圈3次，外回圈就是lst1的元素數量，內回圈是lst2的元素數量，之后那list1的每一個元素都與list2的元素一一對比判斷就行了，相同的復制給c,最后直接輸出c即可，

8.4、現在有8位老師，3個辦公室，要求將8位老師隨機的分配到三個辦公室中

# 第一種方法 while回圈
import random
a = 1
while a<9:
    b = random.randint(1,3)
    print(f'第{a}老師分配的辦公室為：第{b}間辦公室')
    a+=1
    
# 第二種方法 for回圈
import random
for i in range (1,9):
    b = random.randint(1,3)
    print(f'第{i}老師分配的辦公室為：第{b}間辦公室')

• 運行結果如下：
  

• 知識點運用及撰寫思路：

? 這題說白了就是random模塊與回圈之間的使用，將老師的數量作為迭代變數，也就是回圈的次數，然后使用random模塊生產隨機的1~3之間的數字，然后就是輸出啦，

9、附加（個人代碼練習）

9.1、求1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100的值

# 求1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100的值
# while回圈
i=1
sum=0
while i<101:
    if i%2==0:
        sum-=1/i
    elif i%2!=0:
        sum+=1/i
    i+=1
print(sum)

# for回圈
sum=0
for i in range(1,101):
    if i%2==0:
        sum-=1/i
    elif i%2!=0:
        sum+=1/i
print(sum)

運行結果：

9.2、計算下面數列的和值， 1/3+3/5+5/7+…+97/99

# 計算下面數列的和值， 1/3+3/5+5/7+....+97/99
# while回圈
i,j,sum = 1,3,0
while i<98:
    sum+=i/j
    j+=2
    i+=2
print(sum)
# for回圈
j,sum=3,0
for i in range(1,98,2):
    sum += i / j
    j+=2
print(sum)

運行結果：

9.3、 輸入2個數值，判斷之間有多少個素數，并輸出所有素數

# 輸入2個數值，判斷之間有多少個素數，并輸出所有素數
c=[int(input('輸入第一個數:')),int(input('輸入第二個數:'))]
c.sort(reverse=False)  #保證2個數以升序方式排列
a,b=c[0],c[1]
while a <= b:
    i = 2
    if a % 2 == 0:
        n = a / 2
    else:
        n = (a - 1) / 2
    while i <= n:
        if a % i == 0:
            break
        i += 1
    else:
        print(a, '是素數')
    a += 1

運行結果：

旺仔注：

? 時間就像一條前進的火車，不管你在干什么，它都會悄悄的流逝，所以要善用每一分每一秒，當覺得為時已晚的時候，恰恰是最早的時候；只要開始，永遠都不晚，希望每一位讀者都能在刷到我這篇文章的時候能學到一些東西，如果感覺我寫的還行，請給點個贊吧！！！O(∩_∩)O、