文章目錄

一、Python程式結構
二、函數的介紹和基本使用
三、列表

各位看官朋友，最近「GEEK+」原創·博主大賽TOP 50榜單投票，各位有票的捧個票場，沒票的捧個人場，點選https://tp.wjx.top/jq/91687657.aspx，投給第3個cutercorley，如下：

投出您最寶貴的一票，您的支援與鼓勵是我繼續創作、不斷努力的動力，我將繼續為大家貢獻原創文章、為您排憂解難。

一、Python程式結構

Python中，有3種常見的程式結構：

Sequence順序
從上向下依次執行。
Condition條件
滿足某個條件則執行。
Loop迴圈
重複執行某個動作。

1.if條件

判斷某個變數是否滿足某個條件時如下：

possibility_to_rain = 0.7
print(possibility_to_rain > 0.8)
print(possibility_to_rain > 0.3)
possibility_to_rain = 1
print(possibility_to_rain > 0.8)
print(possibility_to_rain > 0.3)

輸出：

False
True
True
True

如需本節同步ipynb檔案，可以直接點選加QQ群 963624318 在群資料夾商業資料分析從入門到入職中下載即可。

但是如果想在變數滿足某個條件時需要執行某個動作，則需要if條件判斷語句，如下：

possibility_to_rain = 0.7

if possibility_to_rain > 0.8:
    print("Do take your umberalla with you.") ## 這個地方標準格式是四個空格的縮排
elif possibility_to_rain > 0.3:
    print("Take your umberalla just in case. hahaha")    
else:
    print("Enjoy the sunshine!")
print('hello')

輸出：

Take your umberalla just in case. hahaha

這段程式碼的意思是：
如果possibility_to_rain > 0.8為True，則執行print("Do take your umberalla with you.")，如果不滿足前述條件，但滿足possibility_to_rain > 0.3，則執行print("Take your umberalla just in case. hahaha")，否則執行print("Enjoy the sunshine!")；
if語句執行完後，再執行後面的語句，如print('hello')；
需要注意縮排，if、elif、else語句後面的語句都應該縮排4格並保持對齊，即通過縮排控制程式碼塊和程式碼結構，而不像其他語言使用{}來控制程式碼結構，如下：
python code blocks

前面也看到，出現了很多以#開頭的程式碼和文字性說明，程式碼顏色也是和其他程式碼有所區別的，這就是Python中的單行註釋，註釋後的程式碼不會被執行，而只能起到說明作用，這段程式碼中這個地方標準格式是四個空格的縮排被#註釋，這一行前面的程式碼能正常執行，#後的文字不會執行、也不會報錯、作為解釋性語句。

除了對數值進行判斷，還能對字串進行判斷：

card_type = "debit"
account_type = "checking"

if card_type == "debit":
    if account_type == "checking":
        print("Checkings selectd.")
    else:
        print("Savings selected.")
else:
    print("Credit card.")

輸出：

Take your umberalla just in case. hahaha
hello

可以看到，使用到了條件判斷的巢狀。

2.迴圈

while迴圈

之前要是需要執行重複操作，可能如下：

count =1
print(count)
count+=1
print(count)
count+=1
print(count)
count+=1
print(count)
count+=1
print(count)
count+=1
print(count)
count+=1
print(count)
count+=1
print(count)
count+=1
print(count)
count+=1
print(count)

輸出：

顯然，程式碼很冗長，此時就可以使用迴圈進行優化。

使用while迴圈如下：

count = 1
while count <= 10:
    print(count)
    count += 1

執行效果與前面相同；
需要注意，迴圈一般要有停止的條件，當滿足count <= 10時迴圈會一直執行，直到count = 11時就會不符合、從而退出迴圈；
如果沒有停止條件，則可能陷入死迴圈、消耗記憶體。

再如：

cnt = 1
while True:
    print("cnt = %d" % cnt)
    ch = input('Do you want to continue? [y:n]: ')
    if ch == 'y':
        cnt += 1
    else:
        break

輸出如下：
python while loop break

可以看到，雖然迴圈條件為True，是恆成立的，但是迴圈內部進行了條件判斷，輸入的是y就會一直迴圈，輸入其他則執行break退出迴圈；
但是需要注意，這裡只有嚴格地輸入y才能繼續迴圈，但是輸入yes都會退出迴圈，所以要想進一步控制執行邏輯、還需要對程式碼進行完善。

在Python中，else也可以與while迴圈結合使用，如果迴圈不是因呼叫break而結束的，將執行else中的語句，這可以用於判斷迴圈是不是完全執行，例如前面第1個迴圈的例子是不是執行了10次。

如下：

count = 1
while count < 11:
    print(count)
    count = count + 1
else:
    print('Counting complete.')

    print()
count = 1
while count < 11:
    print(count)
    count = count + 1
    if count == 8:
        break
else:
    print('Counting complete.')

輸出：

1
2
3
4
5
6
7
8
9
10
Counting complete.

1
2
3
4
5
6
7

可以看到：
第一個迴圈並沒有因為break而停止迴圈，因此在執行完迴圈語句後執行了else語句；
第二個迴圈因為count為8時滿足if條件而退出迴圈、並未將回圈執行完畢，因此未執行else語句。

再如：

count=0
while count < 11:
    print("while count:",count)
    count = count + 1
    if count == 11:
        break
else:
    print("else:",count)

輸出：

while count: 0
while count: 1
while count: 2
while count: 3
while count: 4
while count: 5
while count: 6
while count: 7
while count: 8
while count: 9
while count: 10

顯然，此時因為執行最後一次迴圈時滿足if條件而執行了break語句，因此並未執行else語句塊。

for迴圈

經常與for迴圈同時出現的還有range，range(self, /, *args, **kwargs)函數有以下兩種常見的用法：

range(stop) -> range object
range(start, stop[, step]) -> range object

該函數返回一個物件，該物件以step為步長生成從start（包含）到stop（排除）的整數序列。例如range(i, j)產生i，i+1，i+2，…，j-1的序列。

輸入：

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

輸出：

再如：

for i in range(4,10):
    print(i)
    
print()
for i in range(4,10,2):
    print(i)
    
print()
for i in range(5):
    print('Corley')
    
print()
for i in range(5):
    print('Corley'[i])

輸出：

4
5
6
7
8
9

4
6
8

Corley
Corley
Corley
Corley
Corley

C
o
r
l
e

可以看到，for迴圈內也可以執行與i無關的操作；
還可以用來遍歷字串。

for迴圈中也可以使用break語句來終止迴圈，如下：

for i in range(10):
    print(i) 
    if i == 5:
        break

輸出：

再如：

result = 0

for num in range(1,100):
    if num % 2 == 0:
        result = result + num
        
print(result)

輸出：

上面的例子實現了計算從1到100（不包括）的所有偶數的和。

3.案例-王者榮耀純文字分析

目標是從以下文字提取出所有的英雄資訊連結、頭像圖片連結、英雄名稱，如herodetail/194.shtml、http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg和蘇烈：

<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="蘇烈">蘇烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守約">百里守約</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="鎧">鎧</a></li></ul>

我們可以先找出一個英雄的資訊，即使用下標進行字串切分，找下標時使用find()方法。
例如，對於連結http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg，如果找到第一個h字母和最後一個g字母的下標，就可以通過切分將該連結提取出來。

先讀入字串，如下：

page_hero = '''<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="蘇烈">蘇烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守約">百里守約</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="鎧">鎧</a></li></ul>
'''

此時再通過一步步地獲取與目標相關字元的下標和根據下標切片來獲取目標字串，如獲取圖片連結如下：

start_link = page_hero.find('<img src="')
print(start_link)
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_link = page_hero[start_quote+1:end_quote]
print(hero_link)

輸出：

81
http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg

此時再依次獲取英雄名和資訊連結如下：

# 第1個英雄
start_link = page_hero.find('<a href="')
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_info1 = page_hero[start_quote+1:end_quote]
print(hero_info1)
start_link = page_hero.find('<img src="', end_quote+1)
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_link1 = page_hero[start_quote+1:end_quote]
print(hero_link1)
end_bracket = page_hero.find('>', end_quote+1)
start_bracket = page_hero.find('<', end_bracket+1)
hero_name1 = page_hero[end_bracket+1:start_bracket]
print(hero_name1)

輸出：

herodetail/194.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg
蘇烈

顯然，已經獲取到第1個英雄的完整資訊。

此時再獲取第2個英雄的資訊，如下：

# 第2個英雄
page_hero = page_hero[start_bracket:]
start_link = page_hero.find('<a href="')
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_info2 = page_hero[start_quote+1:end_quote]
print(hero_info2)
start_link = page_hero.find('<img src="', end_quote+1)
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_link2 = page_hero[start_quote+1:end_quote]
print(hero_link2)
end_bracket = page_hero.find('>', end_quote+1)
start_bracket = page_hero.find('<', end_bracket+1)
hero_name2 = page_hero[end_bracket+1:start_bracket]
print(hero_name2)

輸出：

herodetail/195.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg
百里玄策

需要注意：
第二次切分不需要再在原字串上進行切分、而只要從上次切分的位置開始查詢和切分即可，所以page_hero = page_hero[end_quote:]即是將上次切分之後的子字串重新賦值給page_hero作為新字串；
因為各個英雄資訊的字串形式是一樣的，所以可以直接利用查詢第一個英雄的方式即可。

查詢第3個和第4個英雄也類似如下：

# 第3個英雄
page_hero = page_hero[start_bracket:]
start_link = page_hero.find('<a href="')
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_info3 = page_hero[start_quote+1:end_quote]
print(hero_info3)
start_link = page_hero.find('<img src="', end_quote+1)
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_link3 = page_hero[start_quote+1:end_quote]
print(hero_link3)
end_bracket = page_hero.find('>', end_quote+1)
start_bracket = page_hero.find('<', end_bracket+1)
hero_name3 = page_hero[end_bracket+1:start_bracket]
print(hero_name3)

# 第4個英雄
page_hero = page_hero[start_bracket:]
start_link = page_hero.find('<a href="')
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_info4 = page_hero[start_quote+1:end_quote]
print(hero_info4)
start_link = page_hero.find('<img src="', end_quote+1)
start_quote = page_hero.find('"', start_link)
end_quote = page_hero.find('"', start_quote+1)
hero_link4 = page_hero[start_quote+1:end_quote]
print(hero_link4)
end_bracket = page_hero.find('>', end_quote+1)
start_bracket = page_hero.find('<', end_bracket+1)
hero_name4 = page_hero[end_bracket+1:start_bracket]
print(hero_name4)

輸出：

herodetail/196.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg
百里守約
herodetail/193.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg
鎧

可以看到，找4個英雄的思路都大致如下：
（1）找到第一個出現的<img src= >=>start_link；
（2）找到第一個出現的"=>start_quote；
（3）找到start_quote+1之後那個引號 end_quote；
（4）end_quote+1找到後面的>記作 end_bracket；
（5）end_bracket+1 找到 start_bracket；
（6）拋棄start_bracket之前的所有內容，再根據上面的方法找。

可以看到，3部分程式碼也有很大部分相似，因此可以使用迴圈來簡化程式碼：

# 使用迴圈簡化程式碼
page_hero = '''<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="蘇烈">蘇烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守約">百里守約</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="鎧">鎧</a></li></ul>
'''
for i in range(4):
    print('第%d個英雄：' % (i+1))
    start_link = page_hero.find('<a href="')
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_info = page_hero[start_quote+1:end_quote]
    print(hero_info)
    start_link = page_hero.find('<img src="', end_quote+1)
    start_quote = page_hero.find('"', start_link)
    end_quote = page_hero.find('"', start_quote+1)
    hero_link = page_hero[start_quote+1:end_quote]
    print(hero_link)
    end_bracket = page_hero.find('>', end_quote+1)
    start_bracket = page_hero.find('<', end_bracket+1)
    hero_name = page_hero[end_bracket+1:start_bracket]
    print(hero_name)
    page_hero = page_hero[start_bracket:]

輸出：

第1個英雄：
herodetail/194.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg
蘇烈
第2個英雄：
herodetail/195.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg
百里玄策
第3個英雄：
herodetail/196.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg
百里守約
第4個英雄：
herodetail/193.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg
鎧

顯然，程式碼精簡很多。

二、函數的介紹和基本使用

函數是一段命名的程式碼，並且獨立於所有其他程式碼。
函數可以接受任何型別的輸入引數，並返回任意數量和型別的輸出結果。
簡而言之，函數可以代替大段程式碼，在需要使用這些程式碼的時候、直接呼叫函數即可，而不再需要重複大段程式碼，很大程度上優化了程式碼的結構、提高了程式碼的可讀性。

定義一個不做任何事的函數如下：

# An empty function that does nothing
def do_nothing():
    pass

do_nothing()
type(do_nothing)

輸出：

function

其中，do_nothing()是呼叫函數，即函數名()。

定義一個不帶引數和返回值的函數如下：

# A function without parameters and returns values
def greeting():
    print("Hello Python")

# Call the function
a = greeting()

輸出：

Hello Python

以後需要列印Hello Python的地方，就不用再使用print("Hello Python")語句，直接呼叫greeting()即可。

還可以定義帶引數、但是不帶返回值的函數：

# A function with a parameter that returns nothing
def greeting(name):
    print("Hello %s" % name)

# Call the function
greeting('Corley')

輸出：

Hello Corley

此時在呼叫函數時，傳入了引數'Corley'，會在函數內部使用，如果引數值變化，在函數內部被使用的變數也會同步變化，導致結果也可能變化。

但是此時：

print(a)

輸出：

None

即返回為空，這是因為在函數內部並未定義返回值。
在需要時可以在函數內部定義返回值，以便用於下一步的運算。

如下：

# A function with a parameter and return a string
def greeting_str(name):
    return "Hello again " + name

# Use the function
s = greeting_str("Corley")
print(s)

輸出：

Hello again Corley

像許多程式語言一樣，Python支援位置引數，其值按順序複製到相應的引數中。即可以給函數傳遞多個引數，如下：

# A function with 3 parameters
def menu(wine, entree, dessert):
    return "wine:{},entree:{},dessert:{}".format(wine,entree,dessert)

# Get a menu
menu('chardonnay', 'chicken', 'cake')

輸出：

'wine:chardonnay,entree:chicken,dessert:cake'

為了避免位置引數混淆，可以通過引數對應的名稱來指定引數，甚至可以使用與函數中定義不同的順序來指定引數，即關鍵字引數。
如下：

menu(entree='beef', dessert='cake', wine='bordeaux')

輸出：

'wine:bordeaux,entree:beef,dessert:cake'

顯然，此時不按照順序也可以實現傳參。

甚至可以混合使用位置引數和關鍵字引數；
但是需要注意，在輸入任何關鍵字引數之前，必須提供所有位置引數。

如果函數呼叫者未提供任何引數的預設值，則可以為引數設定預設值。
如下：

# default dessert is pudding
def menu(wine, entree, dessert='pudding'):
    return "wine:{},entree:{},dessert:{}".format(wine,entree,dessert)


# Call menu without providing dessert
menu('chardonnay', 'chicken')

輸出：

'wine:chardonnay,entree:chicken,dessert:pudding'

可以看到，此時也可以不給dessert引數傳值也能正常執行，因為在定義函數時已經提供了預設值。

當然，也可以給dessert引數傳值，此時就會使用傳遞的值代替預設值，如下：

# Default value will be overwritten if caller provide a value
menu('chardonnay', 'chicken', 'doughnut')

輸出：

'wine:chardonnay,entree:chicken,dessert:doughnut'

在函數中，存在作用域，即變數在函數內外是否有效。
如下：

x = 1
def new_x():
    x = 5
    print(x)
    
    
def old_x():
    print(x)
    
new_x()
old_x()

輸出：

5
1

顯然，第一個函數中的x在函數內部，屬於區域性變數，區域性變數只能在當前函數內部使用；
第二個函數使用的x函數內部並未定義，因此使用函數外部的x，即全域性變數，全域性變數可以在函數內部使用，也可以在函數外部使用；
函數內部定義了與全域性變數同名的區域性變數後，不會改變全域性變數的值。

要想在函數內部使用全域性變數並進行修改，需要使用global關鍵字進行宣告。
如下：

x = 1

def change_x():
    global x
    print('before changing inside,', x)
    x = 3
    print('after changing inside,', x)
    
print('before changing outside,', x)
change_x()
print('after changing outside,', x)

輸出：

before changing outside, 1
before changing inside, 1
after changing inside, 3
after changing outside, 3

可以看到，此時在函數內部對變數進行修改後，函數外部也發生改變。

此時可以對之前王者榮耀純文字分析案例進一步優化：

# 使用函數實現
def extract_info(current_page):
    start_link = current_page.find('<a href="')
    start_quote = current_page.find('"', start_link)
    end_quote = current_page.find('"', start_quote+1)
    hero_info = current_page[start_quote+1:end_quote]
    print(hero_info)
    start_link = current_page.find('<img src="', end_quote+1)
    start_quote = current_page.find('"', start_link)
    end_quote = current_page.find('"', start_quote+1)
    hero_link = current_page[start_quote+1:end_quote]
    print(hero_link)
    end_bracket = current_page.find('>', end_quote+1)
    start_bracket = current_page.find('<', end_bracket+1)
    hero_name = current_page[end_bracket+1:start_bracket]
    print(hero_name)
    return start_bracket


start_bracket = 0
page_hero = '''<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="蘇烈">蘇烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守約">百里守約</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="鎧">鎧</a></li></ul>
'''
for i in range(4):
    print('第%d個英雄：' % (i+1))
    page_hero = page_hero[start_bracket:]
    start_bracket = extract_info(page_hero)

輸出：

第1個英雄：
herodetail/194.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg
蘇烈
第2個英雄：
herodetail/195.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg
百里玄策
第3個英雄：
herodetail/196.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg
百里守約
第4個英雄：
herodetail/193.shtml
http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg
鎧

顯然，迴圈和函數結合使用，實現了功能，並且進一步簡化程式碼。

除了使用for迴圈，還可以使用while迴圈，如下：

# 使用函數實現
def extract_info(i, current_page):
    start_link = current_page.find('<a href="')
    start_quote = current_page.find('"', start_link)
    end_quote = current_page.find('"', start_quote+1)
    hero_info = current_page[start_quote+1:end_quote]    
    start_link = current_page.find('<img src="', end_quote+1)
    start_quote = current_page.find('"', start_link)
    end_quote = current_page.find('"', start_quote+1)
    hero_link = current_page[start_quote+1:end_quote]    
    end_bracket = current_page.find('>', end_quote+1)
    start_bracket = current_page.find('<', end_bracket+1)
    hero_name = current_page[end_bracket+1:start_bracket]    
    if hero_info.startswith('hero'):
        print('第%d個英雄：' % i)
        print(hero_info)
        print(hero_link)
        print(hero_name)
        return start_bracket
    else:
        return -1


start_bracket = 0
i = 1
page_hero = '''<ul class="herolist clearfix"><li><a href="herodetail/194.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/194/194.jpg" width="91px" alt="蘇烈">蘇烈</a></li><li><a href="herodetail/195.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/195/195.jpg" width="91px" alt="百里玄策">百里玄策</a></li><li><a href="herodetail/196.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/196/196.jpg" width="91px" alt="百里守約">百里守約</a></li><li><a href="herodetail/193.shtml" target="_blank"><img src="http://game.gtimg.cn/images/yxzj/img201606/heroimg/193/193.jpg" width="91px" alt="鎧">鎧</a></li></ul>
'''
while True:    
    page_hero = page_hero[start_bracket:]
    start_bracket = extract_info(i, page_hero)
    i += 1
    if start_bracket == -1:
        break

效果與前面一樣。

還有額外的程式碼結構的練習，如有需要，可以直接點選加QQ群 963624318 在群資料夾商業資料分析從入門到入職中下載即可。

三、列表

之前的資料型別一般都是單個值，而不能再儲存像矩陣、陣列這種結構儲存多個元素，要是需要達到這樣的目標、需要使用新的資料型別，Python中提供了4種資料結構來儲存多個物件，稱它們為容器型別（Container Types），包括如下幾種型別：

列表List
元組Tuple
字典Dictionary
集合Set

1.建立列表

其實，字串其實也是一種序列，是由字元組成的序列。

字串可以通過切片存取部分元素：

# sequence of characters
s="Corley!"
s[2:4]

輸出：

'rl'

字串是一個字元序列，列表是一個物件的序列。當物件的順序很重要時就會使用列表。
建立和存取列表如下：

#sequence of anything
p = ['C','o','r','l','e','y','!']
p[2:4]

輸出：

['r', 'l']

可以看到，列表是用[]定義的，元素放入其中，用,隔開。

再如：

def how_many_days(month):
    days_in_month=[31,28,31,30,31,30,31,31,30,31,30,31]
    return days_in_month[month-1]

display(how_many_days(2), how_many_days(5), how_many_days(10))

輸出：

可以看到，直接獲取到了2、5、8月的天數。

還可以直接建立空列表，如下：

empty_list = []
another_empty_list = list()
display(empty_list,another_empty_list)

輸出：

[]

[]

可以看到，輸出了兩個空列表。

還可以從字串中分割出列表，如下：

weekday_str = 'Monday,Tuesday,Wednesday,Thursday,Friday'
weekdays = weekday_str.split(',')
weekdays

輸出：

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

以列表作為元素建立列表如下：

obj_list = ["string", 1, True, 3.14]
list_of_list = [empty_list, weekdays, obj_list]
list_of_list

輸出：

[[],
 ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'],
 ['string', 1, True, 3.14]]

此即列表的巢狀。
再如：

dal_memeber= [['Corley',18],['Jack',18],['Shirely',48],['Tom',18]]
print(dal_memeber)
print(dal_memeber[0])
print(dal_memeber[0][1])

輸出：

[['Corley', 18], ['Jack', 18], ['Shirely', 48], ['Tom', 18]]
['Corley', 18]
18

列表可以定位和切片如下：

display(weekdays[0],weekdays[1:3])

輸出：

'Monday'

['Tuesday', 'Wednesday']

還可以通過賦值改變列表中的元素，如下：

weekdays[0] = "Sunday"
weekdays

輸出：

['Sunday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

顯然，第一個元素已經改變。

2.刪除元素

還可以刪除列表中的元素。
一種方式是使用del關鍵字，基於下標刪除，如下：

del weekdays[0]
weekdays

輸出：

['Tuesday', 'Wednesday', 'Thursday', 'Friday']

顯然，第一個元素被刪除。

再如：

al = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
del al[3:]
al

輸出：

['A', 'B', 'C']

一次性刪除多個元素。

還有一種方式是使用update()方法，基於元素刪除。
如下：

weekdays.remove('Friday')
weekdays

輸出：

['Tuesday', 'Wednesday', 'Thursday']

但是如果列表中不存在這個元素時，會報錯，如下：

weekdays.remove('Friday')
weekdays

報錯：

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-20-b508ecb8e563> in <module>
----> 1 weekdays.remove('Friday')
      2 weekdays

ValueError: list.remove(x): x not in list

因為weekdays中沒有元素'Friday'，因此會報錯。
此時可以先進行判斷，如果元素存在於列表中則刪除，否則不刪除；
判斷一個元素是否存在於列表中可以用in關鍵字，存在則返回True，否則返回False。
如下：

if 'Friday' in weekdays:
    weekdays.remove('Friday')
else:
    print('element not exists')

輸出：

element not exists

in的用法再如：

weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
'Friday' in weekdays

輸出：

True

還可以判斷某個元素是否不在列表中，如下：

'Fri' not in weekdays

輸出：

4

5

除了使用del和remove()刪除元素，也可以使用pop()彈出元素，該方法不僅可以彈出元素，還能返回被彈出的元素，如果未傳遞引數，則預設彈出並返回最後一個元素，傳遞了下標引數則彈出並返回相應的元素。
如下：

seasons = ['spring', 'summmer', 'autumn', 'winter']
last_season = seasons.pop()
print("last_season = ", last_season, "\nseasons = ", seasons)

輸出：

last_season =  winter 
seasons =  ['spring', 'summmer', 'autumn']

再如：

first_season = seasons.pop(0)
print("first_season = ", first_season, "\nseasons = ", seasons)

輸出：

first_season =  spring 
seasons =  ['summmer', 'autumn']

3.新增元素

向列表中新增元素也有多種方式：
一種是使用append()方法，該方法是將元素新增到列表末尾。
如下：

weekdays.append('Friday')
weekdays

輸出：

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Friday']

可以看到，列表中允許出現重複元素。

一種是insert()方法，可以指定位置新增元素。
如下：

weekdays.insert(0, 'Monday')
weekdays

輸出：

['Monday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Friday']

兩個列表也可以直接相加、形成新的列表。
如下：

weekend = ['Saturday', 'Sunday']
weekdays = weekdays + weekend
weekdays

輸出：

['Monday',
 'Monday',
 'Tuesday',
 'Wednesday',
 'Thursday',
 'Friday',
 'Friday',
 'Saturday',
 'Sunday']

還可以根據元素獲取其再在列表中的下標位置：

display(weekdays.index('Thursday'),weekdays.index('Friday'))

輸出：

4

5

可以看到，有重複元素時，會返回第一個下標。

商業資料分析從入門到入職（6）Python程式結構和函數