Python編程學習筆記(4)

4.1 遍歷整個列表

我們我們經(jīng)常需要遍歷列表的所有元素，對每個元素執(zhí)行相同的操作。這時需要對列表中的每個元素都執(zhí)行相同的操作時，可使用Python中的for 循環(huán)。

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician)

alice
david
carolina

4.1.1 深入地研究循環(huán)

循環(huán)這種概念很重要，因為它是讓計算機自動完成重復工作的常見方式之一。

使用循環(huán)時請牢記，對列表中的每個元素，都將執(zhí)行循環(huán)指定的步驟，而不管列表包含多少個元素。如果列表包含一百萬個元素，Python就重復執(zhí)行指定的步驟一百萬次，且通常速度非常快。

對于用于存儲列表中每個值的臨時變量，可指定任何名稱。然而，選擇描述單個列表元素的有意義的名稱大有幫助。例如，對于小貓列表、小狗列表和一般性列表，像下面這樣編寫for循環(huán)的第一行代碼是不錯的選擇：

for cat in cats:

for dog in dogs:

for item in list_of_items:

這些命名約定有助于你明白for 循環(huán)中將對每個元素執(zhí)行的操作。使用單數(shù)和復數(shù)式名稱，可幫助你判斷代碼段處理的是單個列表元素還是整個列表。

4.1.2 在for循環(huán)中執(zhí)行更多的操作

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician.title() + ", that was a great trick!")

Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!

在for循環(huán)中，想包含多少行代碼都可以。在代碼行for magician in magicians后面，每個縮進代碼行都是循環(huán)的一部分，且將針對列表中的每個值都執(zhí)行一次。因此，可對列表中的每個值執(zhí)行任意次數(shù)的操作。

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician.title() + ", that was a great trick!")
    print("I can't wait to see your next trick, {} n".format(magician.title()))

Alice, that was a great trick!
I can't wait to see your next trick, Alice

David, that was a great trick!
I can't wait to see your next trick, David

Carolina, that was a great trick!
I can't wait to see your next trick, Carolina

4.1.3 在for 循環(huán)結(jié)束后執(zhí)行一些操作

在for循環(huán)后面，沒有縮進的代碼都只執(zhí)行一次，而不會重復執(zhí)行。

使用for 循環(huán)處理數(shù)據(jù)是一種對數(shù)據(jù)集執(zhí)行整體操作的不錯的方式。

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician.title() + ", that was a great trick!")
    print("I can't wait to see your next trick, " + magician.title() + ".n")

print("Thank you, everyone. That was a great magic show!")

Alice, that was a great trick!
I can't wait to see your next trick, Alice.

David, that was a great trick!
I can't wait to see your next trick, David.

Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

Thank you, everyone. That was a great magic show!

4.2 避免縮進錯誤

Python根據(jù)縮進來判斷代碼行與前一個代碼行的關系，通過使用縮進讓代碼更易讀；簡單地說，它要求你使用縮進讓代碼整潔而結(jié)構(gòu)清晰。在較長的Python程序中，你將看到縮進程度各不相同的代碼塊，這讓你對程序的組織結(jié)構(gòu)有大致的認識。

當你開始編寫必須正確縮進的代碼時，需要注意一些常見的縮進錯誤。

4.2.1 忘記縮進

對于位于for 語句后面且屬于循環(huán)組成部分的代碼行，一定要縮進。如果你忘記縮進，Python會提醒你應縮進卻沒有縮進。Python沒有找到期望縮進的代碼塊時，會讓你知道哪行代碼有問題。

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
print(magician)

File "< ipython-input-5-bc3e0c643e2b >", line 3
    print(magician)
        ^
IndentationError: expected an indented block

4.2.2 忘記縮進額外的代碼行

有時候，循環(huán)能夠運行而不會報告錯誤，但結(jié)果可能會出乎意料。試圖在循環(huán)中執(zhí)行多項任務，卻忘記縮進其中的一些代碼行時，就會出現(xiàn)這種情況。

這時產(chǎn)生的是邏輯錯誤。從語法上看，這些Python代碼是合法的，但由于存在邏輯錯誤，結(jié)果并不符合預期。如果預期某項操作將針對每個列表元素都執(zhí)行一次，但它卻只執(zhí)行了一次，請確定是否需要將一行或多行代碼縮進。

#注意循環(huán)中縮進的影響
magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician.title() + ", that was a great trick!")
print("I can't wait to see your next trick, {}n".format(magician.title()))

Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!
I can't wait to see your next trick, Carolina

4.2.3 不必要的縮進

如果你不小心縮進了無需縮進的代碼行，Python將指出無需縮進，因為它并不屬于前一行代碼。

message = "Hello Python world!"
    print(message)

File "< ipython-input-7-e744c47c5d20 >", line 2
    print(message)
    ^
IndentationError: unexpected indent

4.2.4 循環(huán)后不必要的縮進

如果你縮進了應在循環(huán)結(jié)束后執(zhí)行的代碼，這些代碼將針對每個列表元素重復執(zhí)行。在有些情況下，這可能導致Python報告語法錯誤，但在大多數(shù)情況下，這只會導致邏輯錯誤。

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician.title() + ", that was a great trick!")
    print("I can't wait to see your next trick, " + magician.title() + ".n")
    #增加了不必要的縮進
    print("Thank you everyone, that was a great magic show!")

Alice, that was a great trick!
I can't wait to see your next trick, Alice.

Thank you everyone, that was a great magic show!
David, that was a great trick!
I can't wait to see your next trick, David.

Thank you everyone, that was a great magic show!
Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

Thank you everyone, that was a great magic show!

4.2.5 遺漏了冒號

for 語句末尾的冒號告訴Python，下一行是循環(huán)的第一行。如果遺漏了冒號，將導致語法錯誤，因為Python不知道你意欲何為。

magicians = ['alice', 'david', 'carolina']
for magician in magicians
    print(magician)

File "< ipython-input-9-0b84a6ab73bd >", line 2
    for magician in magicians
                             ^
SyntaxError: invalid syntax

練習： 4-1 比薩：想出至少三種你喜歡的比薩，將其名稱存儲在一個列表中，再使用for 循環(huán)將每種比薩的名稱都打印出來。

修改這個for 循環(huán)，使其打印包含比薩名稱的句子，而不僅僅是比薩的名稱。對于每種比薩，都顯示一行輸出，如“I like pepperoni pizza”。

在程序末尾添加一行代碼，它不在for 循環(huán)中，指出你有多喜歡比薩。輸出應包含針對每種比薩的消息，還有一個總結(jié)性句子，如“I really love pizza!”。

4-2 動物：想出至少三種有共同特征的動物，將這些動物的名稱存儲在一個列表中，再使用for 循環(huán)將每種動物的名稱都打印出來。

修改這個程序，使其針對每種動物都打印一個句子，如“A dog would make a great pet”。

在程序末尾添加一行代碼，指出這些動物的共同之處，如打印諸如“Any of these animals would make a great pet!”這樣的句子。

# 4-1 不知道有些什么口味的pizza，亂來
print("----------------------")
pizzas = ['pepperoni', 'chicken', 'pork']
for pizza in pizzas:
    print("I like {} pizza.".format(pizza))
print("I really love pizza!")
# 4-2
print("-----------------------")
pets = ['dog', 'cat', 'lizard']
for pet in pets:
    print("A {} would make a great pet.".format(pet))
print("Any of these animals would make a great pet!")

----------------------
I like pepperoni pizza.
I like chicken pizza.
I like pork pizza.
I really love pizza!
-----------------------
A dog would make a great pet.
A cat would make a great pet.
A lizard would make a great pet.
Any of these animals would make a great pet!

4.3 創(chuàng)建數(shù)值列表

列表非常適合用于存儲數(shù)字集合，而Python提供了很多工具

4.3.1 使用函數(shù)range()

下例中range()只是打印數(shù)字1~4，這是經(jīng)?？吹降牟钜恍袨榈慕Y(jié)果。如果要打印出1～5，我更喜歡下面的方式。

for value in range(1,5):
    print(value)

for value in range(5):
    print(value+1)

4.3.2 使用range() 創(chuàng)建數(shù)字列表

要創(chuàng)建數(shù)字列表，可使用函數(shù)list()將range() 的結(jié)果直接轉(zhuǎn)換為列表。如果將range()作為list()的參數(shù)，輸出將為一個數(shù)字列表。

使用函數(shù)range() 時，還可指定步長。第二段代碼打印1~10內(nèi)的偶數(shù)。

numbers = list(range(1,6))
print(numbers)

[1, 2, 3, 4, 5]

even_numbers = list(range(2,11,2))
print(even_numbers)

[2, 4, 6, 8, 10]

使用函數(shù)range() 幾乎能夠創(chuàng)建任何需要的數(shù)字集，例如，創(chuàng)建一個列表，其中包含前10個整數(shù)（即1~10）的平方：

squares=[]
for value in range(1,11):
    square = value**2
    squares.append(square)
print(squares)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#更簡潔的一種方法
squares = []
for value in range(1,11):
    squares.append(value**2)
print(squares)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

創(chuàng)建更復雜的列表時，可使用上述兩種方法中的任何一種。有時候，使用臨時變量會讓代碼更易讀；而在其他情況下，這樣做只會讓代碼無謂地變長。

首先應該考慮的是，編寫清晰易懂且能完成所需功能的代碼；等到審核代碼時，再考慮采用更高效的方法。

回想一下之前的python之禪（zen of python）。

4.3.3 對數(shù)字列表執(zhí)行簡單的統(tǒng)計計算

有幾個專門用于處理數(shù)字列表的Python函數(shù)。例如，找出數(shù)字列表的最大值、最小值和總和。

#更復雜、專業(yè)的統(tǒng)計可以通過numpy和pandas庫來實現(xiàn)。
digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(min(digits))
print(max(digits))
print(sum(digits))

0
9
45

4.3.4 列表解析

使用列表解析創(chuàng)建你在前面看到的平方數(shù)列表。使用這種語法，首先指定一個描述性的列表名，如squares；然后，指定一個左方括號，并定義一個表達式，用于生成你要存儲到列表中的值。在這個示例中，表達式為，它計算平方值。接下來，編寫一個for循環(huán)，用于給表達式提供值，再加上右方括號。在這個示例中，for 循環(huán)為for value in range(1,11) ，它將值1~10提供給表達式。

這里的for 語句末尾沒有冒號。

squares = [value**2for value in range(1,11)]
print(squares)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

練習： 4-3 數(shù)到20 ：使用一個for 循環(huán)打印數(shù)字1~20（含）。

4-4 一百萬：創(chuàng)建一個列表，其中包含數(shù)字1~1 000 000，再使用一個for 循環(huán)將這些數(shù)字打印出來（如果輸出的時間太長，按Ctrl + C停止輸出，或關閉輸出窗口）。

4-5 計算1~~1 000 000的總和：創(chuàng)建一個列表，其中包含數(shù)字1~~1 000 000，再使用min() 和max() 核實該列表確實是從1開始，到1 000 000結(jié)束的。另外，對這個列表調(diào)用函數(shù)sum() ，看看Python將一百萬個數(shù)字相加需要多長時間。

4-6 奇數(shù) ：通過給函數(shù)range() 指定第三個參數(shù)來創(chuàng)建一個列表，其中包含1~20的奇數(shù)；再使用一個for 循環(huán)將這些數(shù)字都打印出來。

4-7 3的倍數(shù) ：創(chuàng)建一個列表，其中包含3~30內(nèi)能被3整除的數(shù)字；再使用一個for 循環(huán)將這個列表中的數(shù)字都打印出來。

4-8 立方：將同一個數(shù)字乘三次稱為立方。例如，在Python中，2的立方用表示。請創(chuàng)建一個列表，其中包含前10個整數(shù)（即1~10）的立方，再使用一個for 循環(huán)將這些立方數(shù)都打印出來。

4-9 立方解析：使用列表解析生成一個列表，其中包含前10個整數(shù)的立方。

%time
# 4-3
print("-----4-3-----")
for value in range(1,21):
    print(value,end='t')
print("n")
# 4-4
print("-----4-4-----")
values = list(range(1,101))
for value in values:
    print(value,end='t')
print("n")
# 4-5
print("-----4-5-----")
values = list(range(1,1000001))
print(min(values),max(values))
print(sum(values))
# 4-6
print("-----4-6-----")
for odd in range(1,21,2):
    print(odd,end='t')
print("n")
# 4-7
print("-----4-7-----")
for value in range(3,31,3):
    print(value,end='t')
print("n")
# 4-8
print("-----4-8-----")
cubics = [value**3for value in range(1,11)]
for cubic in cubics:
    print(cubic,end='t')
print("n")
# 4-9
print("-----4-9-----")
cubics = [value**3for value in range(1,11)]
print(cubics)

CPU times: user 7 μs, sys: 1 μs, total: 8 μs
Wall time: 15 μs
-----4-3-----
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	

-----4-4-----
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31	32	33	34	35	36	37	38	39	40	41	42	43	44	45	46	47	48	49	50	51	52	53	54	55	56	57	58	59	60	61	62	63	64	65	66	67	68	69	70	71	72	73	74	75	76	77	78	79	80	81	82	83	84	85	86	87	88	89	90	91	92	93	94	95	96	97	98	99	100	

-----4-5-----
1 1000000
500000500000
-----4-6-----
1	3	5	7	9	11	13	15	17	19	

-----4-7-----
3	6	9	12	15	18	21	24	27	30	

-----4-8-----
1	8	27	64	125	216	343	512	729	1000	

-----4-9-----
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

4.4 使用列表的一部分

除了處理列表的所有元素，還可以處理列表的部分元素——Python稱之為切片。

4.4.1 切片

要創(chuàng)建切片，可指定要使用的第一個元素和最后一個元素的索引。與函數(shù)range() 一樣，Python在到達你指定的第二個索引前面的元素后停止。要輸出列表中的前三個元素，需要指定索引0~3，這將輸出分別為0 、1 和2 的元素。

使用[]進行切片操作；
如果沒有指定第一個索引，Python將自動從列表開頭開始；
如果要讓切片終止于列表末尾，也可使用類似的語法；
負數(shù)索引返回離列表末尾相應距離的元素，因此你可以輸出列表末尾的任何切片。

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])
print(players[1:4])
print(players[:2])
print(players[3:])
print(players[-3:])

['charles', 'martina', 'michael']
['martina', 'michael', 'florence']
['charles', 'martina']
['florence', 'eli']
['michael', 'florence', 'eli']

4.4.2 遍歷切片

如果要遍歷列表的部分元素，可在for 循環(huán)中使用切片。

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("Here are the first three players on my team:")
for player in players[:3]:
    print(player.title())

Here are the first three players on my team:
Charles
Martina
Michael

4.4.3 復制列表

要復制列表，可創(chuàng)建一個包含整個列表的切片，方法是同時省略起始索引和終止索引（[:] ）。這讓Python創(chuàng)建一個始于第一個元素，終止于最后一個元素的切片，即復制整個列表。

注意：這里與直接賦值不同，直接賦值類似于指針，指向的是同一段內(nèi)存地址。

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]

print("My favorite foods are:")
print(my_foods)

print("My friend's favorite foods are:")
print(friend_foods)

My favorite foods are:
['pizza', 'falafel', 'carrot cake']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake']

#這里的my_foods和friend_foods是兩個不同的列表
my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
my_foods.append('cannoli')
friend_foods.append('ice cream')

print("My favorite foods are:")
print(my_foods)

print("My friend's favorite foods are:")
print(friend_foods)

My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'ice cream']

my_foods = ['pizza', 'falafel', 'carrot cake']

#這里則類似于指針，指向同一個內(nèi)存地址
friend_foods = my_foods

my_foods.append('cannoli')
friend_foods.append('ice cream')

print("My favorite foods are:")
print(my_foods)

print("My friend's favorite foods are:")
print(friend_foods)

My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

練習： 4-10 切片：選擇你在本章編寫的一個程序，在末尾添加幾行代碼，以完成如下任務。

打印消息“The first three items in the list are:”，再使用切片來打印列表的前三個元素。

打印消息“Three items from the middle of the list are:”，再使用切片來打印列表中間的三個元素。

打印消息“The last three items in the list are:”，再使用切片來打印列表末尾的三個元素。

4-11 你的比薩和我的比薩：在你為完成練習4-1而編寫的程序中，創(chuàng)建比薩列表的副本，并將其存儲到變量friend_pizzas 中，再完成如下任務。

在原來的比薩列表中添加一種比薩。

在列表friend_pizzas 中添加另一種比薩。

核實你有兩個不同的列表。為此，打印消息“My favorite pizzas are:”，再使用一個for 循環(huán)來打印第一個列表；打印消息“My friend's favorite pizzas are:”，再使用一個for 循環(huán)來打印第二個列表。核實新增的比薩被添加到了正確的列表中。

4-12 使用多個循環(huán) ：在本節(jié)中，為節(jié)省篇幅，程序foods.py的每個版本都沒有使用for 循環(huán)來打印列表。請選擇一個版本的foods.py，在其中編寫兩個for 循環(huán)，將各個食品列表都打印出來。

# 4-10
print("-----4-10-----")
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("The first three items in the list are: {}".format(players[:3]))
print("Three items from the middle of the list are: {}".format(players[int(len(players)/2)-1:int(len(players)/2)+2]))
print("The last three items in the list are: {}".format(players[-3:]))
# 4-11
print("-----4-11-----")
my_pizzas = ['pepperoni', 'chicken', 'pork']
friend_pizzas = my_pizzas[:]
my_pizzas.append('beacon')
friend_pizzas.append('cheese')
print("My favorite pizzas are: {}".format(my_pizzas))
print("My friend's favorite pizzas are: {}".format(friend_pizzas))
# 4-12
print("-----4-12-----")
for pizza in my_pizzas:
    print(pizza,end='t')

-----4-10-----
The first three items in the list are: ['charles', 'martina', 'michael']
Three items from the middle of the list are: ['martina', 'michael', 'florence']
The last three items in the list are: ['michael', 'florence', 'eli']
-----4-11-----
My favorite pizzas are: ['pepperoni', 'chicken', 'pork', 'beacon']
My friend's favorite pizzas are: ['pepperoni', 'chicken', 'pork', 'cheese']
-----4-12-----
pepperoni	chicken	pork	beacon

4.5 元組

列表是可以修改的，然而，有時候需要創(chuàng)建一系列不可修改的元素，元組可以滿足這種需求。

Python將不能修改的值稱為不可變的，而不可變的列表被稱為元組。

4.5.1 定義元組

元組看起來猶如列表，但使用圓括號()而不是方括號來標識。定義元組后，就可以使用索引來訪問其元素，就像訪問列表元素一樣。

dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

200
50

#嘗試修改內(nèi)容，將會報錯
dimensions = (200, 50)
dimensions[0] = 250

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

< ipython-input-27-8d3115351a22 > in < module >()
      1 #嘗試修改內(nèi)容，將會報錯
      2 dimensions = (200, 50)
---- > 3 dimensions[0] = 250


TypeError: 'tuple' object does not support item assignment

4.5.2 遍歷元組中的所有值

和列表一樣，也可以使用for 循環(huán)來遍歷元組中的所有值。

dimensions = (200, 50)
for dimension in dimensions:
    print(dimension)

200
50

4.5.3 修改元組變量

雖然不能修改元組的元素，但可以給儲元組的變量賦值。因此，如果要修改前述變量的大小，可重新定義整個元組。

相比于列表，元組是更簡單的數(shù)據(jù)結(jié)構(gòu)。如果需要存儲的一組值在程序的整個生命周期內(nèi)都不變，可使用元組。

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)

dimensions = (400, 100, 20)
print("Modified dimensions:")
for dimension in dimensions:
    print(dimension)

Original dimensions:
200
50
Modified dimensions:
400
100
20

練習： 4-13 自助餐：有一家自助式餐館，只提供五種簡單的食品。請想出五種簡單的食品，并將其存儲在一個元組中。

使用一個for 循環(huán)將該餐館提供的五種食品都打印出來。

嘗試修改其中的一個元素，核實Python確實會拒絕你這樣做。

餐館調(diào)整了菜單，替換了它提供的其中兩種食品。請編寫一個這樣的代碼塊：給元組變量賦值，并使用一個for 循環(huán)將新元組的每個元素都打印出來。

# 4-13
print("-----4-13-----")
foods = ('milk', 'cola', 'coffee', 'egg', 'noodles')
for food in foods:
    print(food, end="t")
print("n")
foods = ('water', 'cola', 'tea', 'egg', 'noodles')
for food in foods:
    print(food, end="t")
foods[0]='cake'

-----4-13-----
milk	cola	coffee	egg	noodles	

water	cola	tea	egg	noodles	


---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

< ipython-input-30-445179e5af1a > in < module >()
      8 for food in foods:
      9     print(food, end="t")
--- > 10 foods[0]='cake'


TypeError: 'tuple' object does not support item assignment

4.6 設置代碼格式

隨著程序越來越長，有必要了解一些代碼格式設置約定?；〞r間讓代碼盡可能易于閱讀；讓代碼易于閱讀有助于你掌握程序是做什么的，也可以幫助他人理解你編寫的代碼。

為確保所有人編寫的代碼的結(jié)構(gòu)都大致一致，Python程序員都遵循一些格式設置約定。學會編寫整潔的Python后，就能明白他人編寫的Python代碼的整體結(jié)構(gòu)——只要他們和你遵循相同的指南。要成為專業(yè)程序員，應從現(xiàn)在開始就遵循這些指南，以養(yǎng)成良好的習慣。

4.6.1 格式設置指南

若要提出Python語言修改建議，需要編寫Python改進提案（Python Enhancement Proposal，PEP）。PEP 8是最古老的PEP之一，它向Python程序員提供了代碼格式設置指南。PEP 8的篇幅很長，但大都與復雜的編碼結(jié)構(gòu)相關。

Python格式設置指南的編寫者深知，代碼被閱讀的次數(shù)比編寫的次數(shù)多。代碼編寫出來后，調(diào)試時你需要閱讀它；給程序添加新功能時，需要花很長的時間閱讀代碼；與其他程序員分享代碼時，這些程序員也將閱讀它們。

如果一定要在讓代碼易于編寫和易于閱讀之間做出選擇，Python程序員幾乎總是會選擇后者。下面的指南可幫助你從一開始就編寫出清晰的代碼。

4.6.2 縮進

PEP 8建議每級縮進都使用四個空格，這既可提高可讀性，又留下了足夠的多級縮進空間。

在字處理文檔中，大家常常使用制表符而不是空格來縮進。對于字處理文檔來說，這樣做的效果很好，但混合使用制表符和空格會讓Python解釋器感到迷惑。每款文本編輯器都提供了一種設置，可將輸入的制表符轉(zhuǎn)換為指定數(shù)量的空格。在編寫代碼時應該使用制表符鍵，但一定要對編輯器進行設置，使其在文檔中插入空格而不是制表符。

在程序中混合使用制表符和空格可能導致極難解決的問題。如果你混合使用了制表符和空格，可將文件中所有的制表符轉(zhuǎn)換為空格，大多數(shù)編輯器都提供了這樣的功能。

4.6.3 行長

很多Python程序員都建議每行不超過80字符。最初制定這樣的指南時，在大多數(shù)計算機中，終端窗口每行只能容納79字符；當前，計算機屏幕每行可容納的字符數(shù)多得多，為何還要使用79字符的標準行長呢？這里有別的原因。專業(yè)程序員通常會在同一個屏幕上打開多個文件，使用標準行長可以讓他們在屏幕上并排打開兩三個文件時能同時看到各個文件的完整行。PEP 8還建議注釋的行長都不超過72字符，因為有些工具為大型項目自動生成文檔時，會在每行注釋開頭添加格式化字符。

PEP 8中有關行長的指南并非不可逾越的紅線，有些小組將最大行長設置為99字符。在學習期間，你不用過多地考慮代碼的行長，但別忘了，協(xié)作編寫程序時，大家?guī)缀醵甲袷豍EP 8指南。在大多數(shù)編輯器中，都可設置一個視覺標志——通常是一條豎線，讓你知道不能越過的界線在什么地方。

附錄B介紹了如何配置文本編輯器，以使其：在你按制表符鍵時插入四個空格；顯示一條垂直參考線，幫助你遵守行長不能超過79字符的約定。

4.6.4 空行

要將程序的不同部分分開，可使用空行。你應該使用空行來組織程序文件，但也不能濫用。

空行不會影響代碼的運行，但會影響代碼的可讀性。Python解釋器根據(jù)水平縮進情況來解讀代碼，但不關心垂直間距。

4.6.5 其他格式設置指南

PEP 8還有很多其他的格式設置建議，但這些指南針對的程序大都比目前為止本書提到的程序復雜。等介紹更復雜的Python結(jié)構(gòu)時，我們再來分享相關的PEP 8指南。

練習： 4-14 PEP 8 ：請訪問https://python.org/dev/peps/pep-0008/ ，閱讀PEP 8格式設置指南。當前，這些指南適用的不多，但你可以大致瀏覽一下。

閱讀全文

函數(shù)(67076) 函數(shù)(67076)
循環(huán)(16631) 循環(huán)(16631)
代碼(73405) 代碼(73405)
python(89757) python(89757)

91欧美超碰AV自拍|国产成年人性爱视频免费看|亚洲日韩欧美一厂二区入|人人看人人爽人人操aV|丝袜美腿视频一区二区在线看|人人操人人爽人人爱|婷婷五月天超碰|97色色欧美亚州A√|另类A√无码精品一级av|欧美特级日韩特级

搜索歷史

Python編程學習筆記(4)

評論