0 環境搭建
1。安裝python 2。安裝pycharm 3。安裝anaconda
1 基本程式要素
Python 程式示例：猜數字
我們來看一個完整的 Python 程式，它是一個和使用者玩猜數字的遊戲的程式。 計算機要求使用者輸入數值範圍的最小值和最大值。計算機隨後“思考”出在這個範圍之內的一個隨機數，並且重複地要求使用者猜測這個數，直到使用者猜對了。在使用者每次進行猜測之後，計算機都會給出一個提示，並且會在這個過程的最後顯示出總的猜測次數。這個程式包含了幾種型別的 Python 語句，例如，輸入語句、輸出語句、賦值語句、迴圈和條件語句，我們將在本章的後面介紹它們。這個程式還包含了一個函式的定義。
如下是該程式的程式碼，程式碼位於檔案 numberguess。py 之中：
“”“Author： Ken LambertPlays a game of guess the number with the user。”“”import randomdef main（）： “”“Inputs the bounds of the range of numbers， and lets the user guess the computer‘s number until the guess is correct。”“” smaller = int（input（“Enter the smaller number： ”）） larger = int（input（“Enter the larger number： ”）） myNumber = random。randint（smaller， larger） count = 0 while True： count += 1 userNumber = int（input（“Enter your guess： ”）） if userNumber < myNumber： print（“Too small”） elif userNumber > myNumber： print（“Too large”） else： print（“You’ve got it in”， count， “tries！”） breakif __name__ == “__main__”： main（）
如下是一個使用者和該程式的互動記錄：
Enter the smaller number： 1Enter the larger number： 32Enter your guess： 16Too smallEnter your guess： 24Too largeEnter your guess： 20You’ve got it in 3 tries！
你可以在一個終端視窗中輸入一條命令，來執行整個 Python 程式。要執行 numberguess。py 檔案中包含的程式，在大多數的終端視窗中，只要輸入如下的命令就可以了：
python numberguess。py
程式註釋
# This is an end-of-line comment。
語法元素
一種語言的語法元素是由詞法元素組成的語句（表示式、語句和其他結構）的型別。和大多數的高階語言不同，Python 使用空白（空格、製表符和換行）來標記多種型別的語句的語法。這意味著，在 Python 程式碼中，縮排和換行是很重要的。我使用 4 個空格寬度的縮排。
字面值
數字（整數或浮點數）的寫法和在其他程式語言中的寫法都是一樣的。布林值 True 和False 都是關鍵字。一些資料結構，例如字串、元組、列表和字典，也擁有字面值，稍後我們將會看到這一點
字串字面值
可以用單引號、雙引號，或者成對的三個雙引號或三個單引號將字串括起來。最後的這種表示方法，對於包含多行文字的字串來說，是很有用的。字元值是單字元的字串。\字元用於將非圖形化的字元（例如，換行\n 和製表符\t，或者\字元本身）進行轉義。下面的程式碼段及其輸出，展示了各種可能性：
print（“Using double quotes”）print（’Using single quotes’）print（“Mentioning the word ’Python’ by quoting it”）print（“Embedding a\nline break with \\n”）print（“”“Embedding aline break with triple quotes”“”）
輸出
Using double quotesUsing single quotesMentioning the word ’Python’ by quoting itEmbedding aline break with \nEmbedding aline break with triple quotes
運算子和表示式
算術表示式使用標準的運算子（+、–、*和/）和中綴表示法。/運算子對於任何數字運算數，都會生成一個浮點數的結果，而//運算子則會產生一個整數的商。當+運算子用於集合（例如，字串和列表）的時候，它表示連線。**運算子用於指數運算。
比較運算子（<、<=、>、>=、和！=）用於數字和字串。運算子比較資料結構內部的內容（例如，兩個列表）在結構上的相等性。is 運算子比較物件實體的兩個值。比較會返回 True 或 False。
邏輯運算子 and、or 和 not 會將幾個值（例如 0、None、空字串和空列表）作為False 對待。相反，它們會將大多數其他的 Python 值當作 True 對待。
下標運算子［］和集合一起使用，稍後將會介紹它。 選擇器運算子。用於引用一個模組、類或物件中的一個具名的項。
函式呼叫
函式呼叫的通常形式是函式名後面跟著用括號括起來的引數列表。例如：
min（5， 2） # Returns 2
Python 包含了一些標準的函式，例如 abs 和 round。很多其他的函式，可以透過匯入模組的方式而變得可用，稍後你將會看到這一點。
print 函式（輸出）
標準輸出函式 print 會將其引數顯示到控制檯。這個函式允許不同個數的引數。Python自動在每個引數上執行 str 函式，以獲取其字串表示，並且在輸出之前用一個空格將每一個字串隔開。預設情況下，輸出結束的時候會使用一個換行。
input 函式（輸入）
標準輸入函式 input 會等待使用者透過鍵盤輸入文字。當用戶按下回車鍵的時候，該函式返回了包含所輸入的字元的一個字串。這個函式接受一個可選的字串作為其引數，並且會不換行地打印出這個字串，以提示使用者進行輸入。
name = input（“Enter the smaller number： ”）
型別轉換函式和混合模式運算
可以將一些資料型別名稱當作型別轉換函式來使用。例如，當用戶輸入一個數字的時候，input 函式返回數字組成的一個字串，而不是一個數字值。程式必須先把這個字串轉換為 int 型別或 float 型別，然後才能夠進行數字處理。下面的程式碼段輸入了一個圓的半徑，將這個字串轉換為 float 型，然後計算並輸出了這個圓形的面積：
radius = float（input（“Radius： ”））print（“The area is”， 3。14 * radius ** 2）
變數和賦值語句
一個 Python 變數是透過一條賦值語句來引入的。例如： PI = 3。1416 將 PI 的值設為 3。1416。一條簡單的賦值語句的語法是：
minValue， maxValue = 1， 100
要交換變數 a 和變數 b 的值，可以像下面這樣編寫程式碼：
a， b=b，a
Python 資料型別
在 Python 中，任何變數都可以指定任何型別的一個值。變數不會宣告為某一個型別，這和很多其他語言中的情況不同，變數會被直接賦一個值。 因此，資料型別名稱不會出現在 Python 程式中。然而，所有的值和物件都是有型別的。 表示式中的運算數的型別會在執行時檢查，因此，型別錯誤一定會進行檢查；然而，在編寫程式碼的時候，程式設計師不必關心資料型別。
import 語句
import 語句使得另一個模組中的識別符號可以被一個程式所見到。這些識別符號可能是物件名、函式名或類名。有幾種方式可以表示一條 import 語句。最簡單的方式是，匯入一個模組名稱，例如：
import math
這使得在 math 模組中定義的任何名稱，在當前的模組中都可以透過 math。
from math import sqrtprint（sqrt（2））
可以透過列出幾個單獨的名稱來匯入它們：
from math import pi， sqrtprint（sqrt（2） * pi）
可以使用*運算子匯入一個模組中所有的名稱，但是，我們並不認為這是好的做法。
2 控制語句
Python 包含了針對序列、條件式執行和迭代等情況的、常見的各種控制語句。語句的序列是一條接著一條編寫的一組語句。一個序列中的每一條語句，都必須以相同的縮排開始。本節將會介紹條件式執行和迭代的控制語句。
條件語句
Python 的條件式語句的結構和其他語言中的條件式語句類似。關鍵詞 if、elif 和else 是很重要的，冒號和縮排也同樣重要。 單向的 if 語句的語法如下：
if
正如前面提到的，布林表示式（Boolean expression）可以是任何的 Python 值，其中的一些值被當作是 False，另一些值被當作是 True。如果布林表示式為 True，就執行該語句序列，否則，什麼也不會發生。語句序列（一條或多條語句）必須至少按照一個空格或制 表符（通常一個製表符是 4 個空格）來縮排或對齊。冒號是唯一的分隔符，如果序列中只有一條語句，它可以緊跟在同一行的冒號之後。
雙向的 if 語句的語法如下：
if
注意關鍵詞 else 後面的冒號和縮排。這兩個語句序列中，只有一個序列會執行。如果布林表示式為 True，將會執行第 1 個序列；如果布林表示式為 False，將會執行第 2個序列。 多向的 if 語句的語法如下：
if
多向的 if 語句也只會執行一個語句序列。多向的 if 語句包含了一個或多個可選的布林表示式，其中的每一個布林表示式都跟在關鍵字 elif 後面。你可以忽略掉最後一個 else：子句。下面的示例是比較兩個數的大小的問題，並輸出正確的答案：
if x > y： print（“x is greater than y”）elif x < y： print（“x is less than y”）else： print（“x is equal to y”）
使用 if
name
== “
main
”
前面討論的 numberguess 程式包含了一個 main 函式的定義和如下的 if 語句：
if __name__ == “__main__”： main（）
這條 if 語句的作用是，允許程式設計師要麼將模組當作一個獨立的程式執行，要麼從 shell或另一個模組中匯入它。其工作方式如下。每個 Python 模組都包含一組內建的模組變數，當載入該模組的時候，Python 虛擬機器會自動為這些變數賦值。 如果該模組是作為一個獨立的程式載入（要麼透過從一個終端提示符來執行它，要麼從一個 IDLE 視窗載入它），該模組的
name
變數會設定為字串“
main
”。否則，這個變數會設定為模組的名稱，在這個例子中，也就是“numberguess”。不管怎麼樣，該變數的賦值都會在模組中的任何程式碼載入之前完成。因此，當執行到了模組末尾的 if 語句的時候，只有當模組是作為一個獨立的程式啟動的時候，才會呼叫模組的 main 函式。
迴圈語句
Python 的 while 迴圈語句的結構，類似於其他語言中的迴圈結構。其語法如下：
while
下面的示例是計算從 1 到 10 的乘積並輸出結果：
product = 1value = 1while value <= 10： product *= value value += 1print（product）
注意，這裡使用了擴充套件的賦值運算子*=。該行程式碼等價於如下的程式碼：
product = product * value
Python 包含了一個for 迴圈語句，以便更簡潔地遍歷值的一個序列。這條語句的語法如下：
for
當執行這個迴圈的時候，它將可迭代的物件（iterable object）中包含的每一個值都賦值給迴圈變數，並且在每一個賦值上下文中執行語句的序列。可迭代物件的示例是字串和列表。下面的程式碼段使用了 Python 的 range 函式返回整數的一個可迭代的序列，從而計算 前面展示的乘積。
product = 1for value in range（1， 11）： product *= valueprint（product）
Python 程式設計師通常更喜歡使用一個 for 迴圈來遍歷確定的範圍的值或值的序列。當繼續迴圈的條件是一個任意的布林表示式的時候，程式設計師則使用 while 迴圈。
3字串及其運算
和其他語言一樣，Python 字串也是一個複合物件，它包含了其他物件，也就是字元。然而，Python 中的每個字元，本身也是一個單個的字元的字串，並且在字面上也採用了和字串相似的方式來表示。Python 的字串型別名為 str，其中包含了很多的運算，本節將會介紹其中的一些。
運算子
當使用比較運算子來比較字串的時候，將會使用 ASCII 的順序來比較兩個字串中的每一個位置的成對的字元。因此，“a”小於“b”，而“A”小於“a”。
+運算子構建並返回一個新的字串，它包含了兩個運算數中的字元。
在下標運算子的最簡單的形式中，它期待範圍是從0到字串的長度減去1的一個整數。該運算子返回在字串中該位置的字元。因此：
“greater”［0］ # Returns “g”
儘管字串索引不能超過其長度減去 1，但是，負的索引是允許的。 當索引為負值的時候，Python 會將這個值和字串的長度相加，以確定要返回的字元的位置。在這種情況下，所提供的負的索引值，不能夠比字串長度的負值還要小。
字串是不可變的，也就是說，一旦建立了字串，不能更改其內部的內容。因此，不能使用下標來替換字串中一個給定位置的字元。 下標的一種變體，叫作切片（slice）運算子，可以用它來獲取一個字串的子字串。 切片的語法如下：
如果給出了
“greater”［：］ # Returns “greater”“greater”［2：］ # Returns “eater”“greater”［：2］ # Returns “gr”“greater”［2：5］ # Returns “eat”
物件和方法呼叫
除了標準的運算子和函式，Python 還包含了大量的可以操作物件的方法。方法和函式類似，方法也接受引數，執行一項任務並且返回一個值。然而，方法總是在相關聯的物件之上呼叫。呼叫一個方法的語法如下所示：
如下是在字串上呼叫方法的一些示例：
“greater”。isupper（） # Returns False“greater”。upper（） # Returns “GREATER”“greater”。startswith（“great”） # Returns True
如果你試圖執行一個物件所不識別的方法，Python 會丟擲一個異常並且終止程式。想搞清楚在物件上能夠識別一組什麼樣的方法，可以在 Python shell 中以該物件型別為引數來執行 Python 的 dir 函式。例如，dir（str）返回了字串物件所識別的方法的一個列表。執行 help（str。upper）則會輸出和 str。upper 方法用法相關的文件。 有些方法名，例如
add
和
len
，當 Python 看到一個物件和某種運算子或函式 一起使用的時候，就會執行這些方法。例如：
len（“greater”） # Is equivalent to “greater”。__len__（）“great” + “er” # Is equivalent to “great”。__add__（“er”）“e” in “great” # Is equivalent to “great”。__contains__（“e”）
4內建 Python 集合及其操作
列表
列表（list）是零個或多個 Python 物件的一個序列，這些物件通常稱為項（item）。列表有一個字面的表示法，就是使用方括號將用逗號隔開的項括起來。下面是列表的一些示例：
［］ # An empty list［“greater”］ # A list of one string［“greater”， “less”］ # A list of two strings［“greater”， “less”， 10］ # A list of two strings and an int［“greater”， ［“less”， 10］］ # A list with a nested list
和字串一樣，可以使用標準運算子對列表進行切片和連線。然而，在這種情況下，返回的結果也是列表。和字串不同，列表是可變的，這意味著，可以替換、插入或刪除列表中所包含的項。這一功能帶來兩個後果。首先，切片和連線運算子所返回的列表是新的列表，而不是最初列表的一部分。其次，列表型別包含了幾個叫作修改器（mutator）的方法，它們的作用是修改一個列表的結構。可以在 Python shell 中輸入 dir（list）來檢視這些方法。 最常用的列表修改器方法是 append、insert、pop、remove 和 sort。如下是使用 這些方法的一些示例：
testList = ［］ # testList is ［］testList。append（34） # testList is ［34］testList。append（22） # testList is ［34， 22］testList。sort（） # testList is ［22， 34］testList。pop（） # Returns 22； testList is ［34］testList。insert（0， 22） # testList is ［22， 34］testList。insert（1， 55） # testList is ［22， 55， 34］testList。pop（1） # Returns 55； testList is ［22， 34］testList。remove（22） # testList is ［34］testList。remove（55） # raises ValueError
字串方法 split 和 join 分別從一個字串中提取單詞的一個列表並將單詞列表組合到一起以形成一個字串：
“Python is cool”。split（） #Returns［’Python’，’is’，’cool’］“ ”。join（［“Python”，“is”，“cool”］） #Returns’Python is cool’
元組
元組（tuple）是項的一個不可變的序列。元組字面值用圓括號將各項括起來，並且元組必須至少包含兩個項。元組實際上就像列表一樣，只不過它沒有修改器方法。要了解元組的可用方法，在 Python shell 中執行 dir（tuple）。
遍歷序列
for 迴圈用來遍歷一個序列（如字串、列表或元組）中的項。例如，如下的程式碼段輸出一個列表中的項：
testList = ［67， 100， 22］for item in testList： print（item）
如下的程式碼是基於索引的遍歷方法，顯然上面的程式碼與其等價但是更簡單一些：
testList = ［67， 100， 22］for index in range（len（testList））： print（testList［index］）
字典
字典（dictionary）包含零個或多個條目。每個條目（entry）都將一個唯一的鍵和一個值相關聯。鍵通常是字串或整數，而值是任何的 Python 物件。 字典字面值將鍵—值條目包含到一對花括號中，如下面的示例所示：
{} # An empty dictionary{“name”：“Ken”} # One entry{“name”：“Ken”， “age”：61} # Two entries{“hobbies”：［“reading”， “running”］} # One entry， value is a listdic = {“name”：“Ken”， “age”：61}for key，value in dic。items（）： print（key， value）
我們使用下標運算子來訪問一個給定鍵的值，給一個新鍵新增一個值，以及替換給定鍵的值。pop 方法刪除條目，並且返回給定鍵的值。keys 方法返回鍵的一個可迭代的物件，而 values 方法返回值的一個可迭代的物件。for 迴圈可以遍歷一個字典的鍵。
搜尋一個值
程式設計師可以對值和集合使用 in 運算子，從而在字串、列表、元組或字典中搜索一個值。這個運算子返回 True 或 False。字典搜尋的目標值應該是一個潛在的鍵。當獲知給定的值在一個序列（字串、列表、元組）中時，index 方法將會返回第一次搜尋到的這個值的位置。對於字典來說，get 和 pop 方法可以接受兩個引數，一個鍵和一個預設值。搜尋失敗的話，將會返回該預設值；搜尋成功的話，將會返回和該鍵相關聯的值。
#5 函式
函式定義
Python 函式的定義語法是：
def ）：
命名函式和引數的規則和慣例，與命名變數的是相同的。必需引數的列表可以為空，或者可以包含用逗號隔開的名稱。和其他的程式語言不同，這裡沒有和引數名稱或函式名自身相關聯的資料型別。 如下是一個簡單的函式，它計算並返回一個數字的平方：
def square（n）： “”“Returns the square of n。”“” result = n ** 2 return result
注意，在函式頭的下方使用了帶有 3 個引號的字串。這是一個文件字串（docstring）。這個字串就像是函式中的註釋一樣，當用戶在Python shell提示符視窗輸入help（square）的時候，將會顯示這個字串。你所定義的每一個函式，都應該包含一個文件字串，以說明這個函式做什麼，並且給出與引數或返回值相關的任何資訊。
函式可以引入新的變數，叫作臨時變數（temporary variable）。在 square 函式中，n 是引數，result 是一個臨時變數。函式的引數和臨時變數，只有在函式呼叫的生命週期中存在，並且對其他的函式或外圍程式是不可見的。因此，幾個不同的函式可以使用相同的引數和變數名而不會導致衝突。
當一個函式並不包含 return 語句的時候，它在執行完最後一條語句的時候，會自動地返回一個 None 值。在模組中，可以按照任意的順序來定義函式，只要在函式的定義被編譯之前，不會真正地去執行函式就可以了。下面的示例展示了在模組開始處的一個非法的函式呼叫：
first（） # Raises a NameError （function undefined yet）def first（）： second（） # Not an error， because not actually print（“Calling first。”） # called until after second is defineddef second（）： print（“Calling second。”）first（） # Here is where the call should go
當 Python 執行第一行程式碼的時候，函式 first 還沒有定義，因此，會丟擲一個異常。如果在這行程式碼的開始處放置一個註釋符號#，並且再次執行這段程式碼，程式將會執行並正常結束。在這個例子中，即便函式 second 似乎在定義它之前就呼叫了，但實際上直到呼叫函式 first 的時候，才真正地呼叫了 second，而這個時候，這兩個函式都已經定義過了。 可以使用
遞迴函式
遞迴函式是呼叫自身的函式。為了防止函式無限次地重複呼叫自己，它必須至少包含一條選擇語句。這條語句檢查一個叫作基本條件（base case）的條件，來判斷是停止還是繼續遞迴的步驟。 我們來看看如何把一個迭代演算法轉換為一個遞迴函式。如下是一個名為 displayRange的遞迴函式的定義，它輸出從下邊界到上邊界的數字：
def displayRange（lower， upper）：“”“Outputs the numbers from lower to upper。”“”while lower <= upper： print（lower） lower = lower + 1
如何將這個函式轉換為遞迴函式呢？首先，需要注意兩點重要的情況：
當 lower<=upper 的時候，迴圈體繼續執行；
當函式執行的時候，lower 增加 1，但是 upper 不變。 等價的遞迴函式可以執行類似的基本操作，但是，用一條 if 語句替代了迴圈，用函式的遞迴呼叫替代了賦值語句。如下是做出這些修改後的程式碼：
def displayRange（lower， upper）：“”“Outputs the numbers from lower to upper。”“”if lower <= upper： print（lower） displayRange（lower + 1， upper）
儘管兩個函式的語法和設計是不同的，但它們所執行的演算法過程是相同的。遞迴函式的每次呼叫，都會按照順序訪問下一個數，這和函式的迭代版本中的迴圈所做的事情是一樣的。
大多數遞迴函式都至少接受一個引數。這個資料值測試結束遞迴過程的基本條件。在每一個遞迴步驟之前，也會以某種方式修改這個值。每次對資料值的修改，都應該會產生一個新的資料值，以允許函式最終達到基本條件。在 displayRange 的例子中，也就是在每一次遞迴呼叫之前，將引數 lower 的值增加 1，以使得其最終能夠超過引數 upper 的值。
下面是遞迴函式的另一個示例，它生成並返回一個值。Python 的 sum 函式接受數字的一個集合，並且返回它們的加和。這個函式應該會返回從下界到上界的數字的加和。如果lower 超過了 upper（基本條件），遞迴函式 ourSum 會返回 0。否則的話，該函式會把lower 和針對 lower+1 與 upper 執行 ourSum 的結果相加，並且返回最終的結果：
def ourSum（lower， upper）：“”“Returns the sum of the numbers from lower thru upper。”“” if lower > upper： return 0 else： return lower + ourSum（lower + 1， upper）
對 ourSum 的遞迴呼叫，會將數字從 lower+1 一直加到 upper。然後，這個函式把lower 和結果相加，並將其返回。
類和物件
類描述了資料以及和一組物件相關的方法。類提供了一個藍圖，可以用來建立物件以及在這些物件上呼叫方法的時候所執行的程式碼。Python 中所有的資料型別都是類。
定義 Python 類的語法如下：
def
按照慣例，類名是要大寫的。類定義的程式碼通常放在模組中，該模組的檔名和類名一樣，但是是小寫的。相關的類也可以出現在同一模組中。父類名是可選的，在這種情況下，會假設它是 object。所有的 Python 類都位於層級之中，object 在這個層級的根部。有幾個方法如
str
和
eq
均定義於 object 中並且是所有的子類會自動繼承的。例項方法在類的物件之上執行，它們包含了訪問或修改例項變數的程式碼。例項變數引用了單個物件所擁有的儲存。類變數引用了類的所有物件共同擁有的儲存。 為了說明這些思路，本節現在將定義一個 Counter 類的程式碼。正如其名，Counter 物件用來記錄整數。計數器的值最初為 0，並且可以隨時將其重新設定為 0。我們可以遞增或遞減一個計數器，獲取其當前的整數值，獲取其字串表示，或者比較兩個計數器是否相等。 該類的程式碼如下：
“”“File： counter。pyDefines a Counter class for counting。”“”class Counter（object）： “”“Models a counter。”“” # Class variable instances = 0 #Constructor def __init__（self）： “”“Sets up the counter。”“” Counter。instances += 1 self。reset（） # Mutator methods def reset（self）： “”“Sets the counter to 0。”“” self。_value = 0 def increment（self， amount = 1）： “”“Adds amount to the counter。”“” self。_value += amount def decrement（self， amount = 1）： “”“Subtracts amount from the counter。”“” self。_value -= amount # Accessor methods def getValue（self）： “”“Returns the counter‘s value。”“” return self。_value def __str__（self）： “”“Returns the string representation of the counter。”“” return str（self。_value） def __eq__（self， other）： “”“Returns True if self equals other or False otherwise。”“” if self is other： return True if type（self） ！= type（other）： return False return self。_value == other。_value
如下是在 Python shell 中和一些 Counter 物件的互動程式碼：
>>>from counter import Counter>>>c1=Counter（）>>>print（c1）0>>>c1。getValue（）0>>>str（c1）’0’>>>c1。increment（）>>>print（c1）1>>>c1。increment（5）>>>print（c1）6>>>c1。reset（）>>>print（c1）0>>>c2=Counter（）>>>Counter。instances2>>>c1==c1True>>>c1==0False>>>c1==c2True>>>c2。increment（）>>>c1==c2False>>>
現在我們來簡單介紹一下，Counter 類是 object 的一個子類。 類變數 instances 記錄了所建立的 Counter 物件的數目。除了最初在透過賦值引入類變數的時候之外，在其他時候，類變數必須有一個類名作為其字首。定義例項方法的語法，和定義函式的語法是相同的。然而，有一個叫作 self 的、額外的引數，它總是出現在引數列表的開始處。在一個方法定義的上下文中，self 引用的是在其上執行該方法的那個物件。 例項方法
init
也叫作構造方法，當建立 Counter 的例項的時候，會自動執行其構造方法。該方法初始化了例項變數並且更新了類變數。注意，
init
使用了 self。reset（）的語法，呼叫了例項方法 reset，以初始化單個的例項變數。其他的例項方法分為兩類：修改器（mutator）方法和訪問器（accessor）方法。修改器方法透過修改物件的例項變數，來修改或改變物件的內部狀態。訪問器方法直接檢視或使用物件的例項變數的值，而不會修改它們。
在初次呼叫例項方法 reset 的時候，它引入了例項變數 self。value。隨後，對該方法的任何其他的呼叫，都會將這個例項變數的值修改為 0。一個例項變數總是有一個 self字首。與引數或臨時變數不同，例項變數在類的任何方法之中都是可見的。一些類的例項變數拼寫為帶有一個字元字首。這個慣例有助於讀者將其與引數以及臨時變數 區分開來，並且這也不鼓勵程式碼編寫者在類定義之外訪問例項變數。 increment 和 decrement 方法使用預設的引數，這允許程式設計師來選擇指定還是不指定這個量。Counter 類中的
str
方法覆蓋了 object 類中的相同的方法。當把物件作為引數傳遞給 str 函式的時候，python 在該物件上執行
str
。當在一個物件上執行一個方法的時候，Python 首先在該物件自己的類中查詢該方法的程式碼。如果沒有在那裡找到這個方法，Python 會在其父類中查詢，依次類推。如果最終沒有找到該方法的程式碼（在 object類中查詢完了之後），Python 會丟擲一個異常。 當 Python 的 print 函式接受引數的時候，會自動執行該引數的
str
方法，獲取其字串表示以用於輸出。我們鼓勵程式設計師為每一個自定義的類都包含一個
str
方法，以幫助進行除錯。 當 Python 看到的時候，它會執行
eq
方法。該方法預設地定義在 object 類中，它執行 is 運算子，該運算子會比較兩個運算數的物件相等性。正如你所看到的，只要兩個不同的 counter 物件擁有相同的值，我們就讓視作它們是相等的。因為的第二個運算數 可以是任何的物件，
eq
方法在訪問它們的例項變數之前，會詢問運算數的型別是否是相同的。注意，我們在物件上使用了點表示法來訪問例項變數。
檔案操作
文字檔案的輸出
根據文字檔案的格式和資料的用途，我們可以將文字檔案中的資料看做是字元、單詞、數字或者文字行。當把這些資料當作整數或浮點數的時候，必須用空白字元（空格、製表符和換行符）將其分隔開。例如，當使用一個文字編輯器檢視包含 6 個浮點數的一個文字檔案的時候，如下所示：
34。6 22。33 66。7577。12 21。44 99。01
注意，該格式用空格或換行作為文字中的各項的分隔符。文字檔案的所有資料輸出或資料輸入都必須是字串。因此，在輸出之前，這些數字必須先轉換為字串，並且在輸入之後，這些字串必須再轉換為數字。可以使用檔案物件將資料輸出到文字檔案中。Python 的 open 函式接受檔案的路徑名稱和模式字串作為引數，它開啟到磁碟上的檔案的一個連線，並且返回檔案物件。模式字串’r’表示輸入檔案，’w’表示輸出檔案。因此，如下的程式碼在名為 myfile。txt的文 件上開啟一個檔案物件以進行輸出：
>>>f=open（“myfile。txt”，’w’）
如果該檔案並不存在，會使用給定的路徑名稱來建立它。如果該檔案已經存在，Python 會開啟它。當資料寫入到檔案並且檔案關閉的時候，檔案中之前存在的任何資料都將會被擦除。我們使用 write 方法和檔案物件，將字串資料寫入（或輸出）到一個檔案之中。write 方接受單個的字串引數。如果你想要輸出文字並且以換行來結束，必須在字串中包含跳脫字元\n。下面的語句將兩行文字寫入到了檔案中：
>>> f。write（“First line。\nSecond line。\n”）
當所有的輸出完成之後，應該使用 close 方法來關閉檔案，如下所示：
>>> f。close（）
如果沒有能夠成功地關閉輸出的檔案，將會導致資料丟失。
將數字寫入到一個文字檔案
檔案方法 write 接受字串作為引數。因此，其他型別的資料，例如整數或浮點數，必須先轉換成字串，然後才能寫入到輸出檔案中。在 Python 中，大多數資料型別的值都可以使用 str 函式來轉換為字串。然後，使用空格或換行作為分隔符字元，將所得到的字串寫入到檔案中。 下面的程式碼段展示瞭如何將整數輸出到文字檔案中。生成 1 到 500 之間的 500 個隨機的整數，並將其寫入到名為 integers。txt 的文字檔案中。換行字元作為分隔符。
import randomf=open（“integers。txt”，’w‘）for count in range（500）： number = random。randint（1， 500） f。write（str（number） + “\n”）f。close（）
從文字檔案讀取文字
開啟一個檔案進行輸入的方式，和開啟一個檔案進行輸出的方式相同。唯一的變化在於模式字串。在開啟檔案進行輸入的情況下，使用’r’字串。然而，如果路徑名是從當前的工作目錄無法訪問的，Python 會產生錯誤。開啟 myfile。txt 檔案進行輸入的程式碼如下：
>>>f=open（“myfile。txt”，’r’）
有幾種方法可以實現從輸入檔案讀取資料。最簡單的方法是使用檔案方法 read 來將整個檔案的內容作為一個單獨的字串輸入。如果檔案包含了多行文字的話，換行字元將會嵌入到這個字串中。下面的這個 shell 會話展示瞭如何使用 read 方法：
>>> text=f。read（）>>> text’First line。 \nSecond line。 \n’>>>print（text）First line。Second line。>>>
在輸入完成後，再次呼叫 read 將會返回一個空的字串，表明已經到達了檔案的末尾。要重複輸入，必須再次開啟檔案。這樣的話，就不必關閉該檔案了。此外，一個應用程式可能每次只讀取和處理一行文字。一個 for 迴圈就可以很好地完成這一任務。這個 for 迴圈將一個檔案物件當作是文字行的一個序列。在每次透過迴圈的時候，迴圈變數都跳到序列中的下一行文字。如下的會話重新開啟示例檔案並訪問其中的每一行文字：
>>>f=open（“myfile。txt”，’r’）>>>for line in f：print（line）First line。Second line。>>>
注意，print 似乎輸出了一個額外的換行。這是因為從檔案輸入的每一行文字，都包含一個換行字元。當你想要從一個檔案讀取特定數目的行的時候（例如，只讀取第 1 行），可以使用檔案方法 readline。readline 方法只讀取一行的輸入並且返回該字串，包括換行符。如果 readline 遇到了檔案的末尾，它會返回空字串。下面的程式碼段使用一個 while True迴圈並用 readline 輸入所有的文字行：
>>>f=open（“myfile。txt”，’r’）>>> while True： line = f。readline（） if line == “”： break print（line）First line。Second line。>>>
python程式設計練習題
1。有一分數序列：2/1，3/2，5/3，8/5，13/8，21/13…求出這個數列的前20項之和。
from functools import reducedef cal_sum（）： fenzi = 2 fenmu = 1 lst = ［2］ for i in range（1，20）： fenmu，fenzi= fenzi，fenmu+fenzi lst。append（fenzi / fenmu） return reduce（lambda x，y：x+y，lst）print（cal_sum（））
2。給一個不多於5位的正整數，要求：一、求它是幾位數，二、逆序打印出各位數字。
def num_reverse（num）： print（’ ‘。join（str（num））） numLen = len（str（num）） print（numLen） for i in range（numLen）： toPrint = num % 10 num = int（（num - toPrint）/10） print（toPrint，end=’ ‘）num_reverse（9523684）
有n個人圍成一圈，順序排號。從第一個人開始報數（從1到3報數），凡報到3的人退出圈子，問最後留下的是原來第幾號的那位。
def who_remain（n）： lst = list（range（1， n+1）） while n > 2： lst。pop（2） before = lst［：2］ lst = lst［2：］ lst。extend（before） n = len（lst） return lst［-1］print（who_remain（29））
4。題：編寫一個程式，根據控制檯輸入的事務日誌計算銀行帳戶的淨金額。 事務日誌格式如下所示： D 100 W 200
D表示存款，而W表示提款。 假設為程式提供了以下輸入： D 300 D 300 W 200 D 100 然後，輸出應該是： 500
netAmount = 0while True： print（“請輸入：”） s = input（） if not s： break values = s。split（“ ”） operation = values［0］ amount = int（values［1］） if operation==“D”： netAmount+=amount elif operation==“W”： netAmount-=amount else： passprint （netAmount）
5。機器人從原點（0，0）開始在平面中移動。 機器人可以透過給定的步驟向上，向下，向左和向右移動。 機器人運動的痕跡如下所示： UP 5 DOWN 3 LETF 3 RIGHT 2 方向之後的數字是步驟。 請編寫一個程式來計算一系列運動和原點之後距當前位置的距離。如果距離是浮點數，則只打印最接近的整數。 例：如果給出以下元組作為程式的輸入： UP 5 DOWN 3 LETF 3 RIGHT 2 然後，程式的輸出應該是：2
import mathpos = ［0， 0］print（“請輸入：”）while True： s = input（） if not s： break movement = s。split（“ ”） direction = movement［0］ steps = int（movement［1］） if direction == “UP”： pos［0］ += steps elif direction == “DOWN”： pos［0］ -= steps elif direction == “LEFT”： pos［1］ -= steps elif direction == “RIGHT”： pos［1］ += steps else： passprint（int（round（math。sqrt（pos［1］ ** 2 + pos［0］ ** 2））））
python字串練習題
1。判斷使用者輸入的變數名是否合法： 1。變數名可以由字母，數字或者下劃線組成 2。變數名只能以字母或者下劃線開頭
分析： 1。判斷變數名的第一個元素是否為字母或者下劃線 s［0］ 2。如果第一個元素符合條件，判斷除了第一個元素之外的其他元素s［1：］
while True： s = input（’變數名：‘） if s == ’q‘： exit（） # 判斷首字母是否符合變數名要求 if s［0］ == ’_‘ or s［0］。isalpha（）： # 依次判斷剩餘的所有字元 for i in s［1：］： # 只要有一個字元不符合，便不是合法的變數；alnum表示字母或數字 if not （i。isalnum（） or i == ’_‘）： print（’%s不是一個合法的變數名‘ % s） break else： print（’%s是一個合法的變數名‘ % s） else： print（’%s不是一個合法的變數名‘ % s）
2。給定一個字串來代表一個學生的出勤紀錄，這個紀錄僅包含以下三個 字元： ’A‘ ： Absent，缺勤 ’L‘ ： Late，遲到 ’P‘ ： Present，到場 如果一個學生的出勤紀錄中不超過一個’A‘（缺勤）並且不超過兩個連續的’L‘（遲到）， 那麼這個學生會被獎賞。 你需要根據這個學生的出勤紀錄判斷他是否會被獎賞。 示例 1： 輸入： “PPALLP” 輸出： True 示例 2： 輸入： “PPALLL” 輸出： False
print（“”“ 出勤記錄規則 ’A‘ ： Absent 缺勤 ’L‘ ： Late 遲到 ’P‘ ： Present 到場”“”）while True： c = input（’請輸入考勤記錄：‘） # count（） 表示指定字元出現的次數 if c。count（’A‘） <= 1 and c。count（’LLL‘） == 0 and c ！= ’q‘： print（’True‘） elif c == ’q‘： exit（） else： print（’False‘）
3。輸入兩個字串，從第一字串中刪除第二個字串中所有的字元。例 如，輸入”They are students。”和”aeiou”， 則刪除之後的第一個字串變成”Thy r stdnts。”
輸入描述： 每個測試輸入包含2個字串
輸出描述： 輸出刪除後的字串
示例1：
輸入 They are students。 aeiou 輸出 Thy r stdnts。
s1 = input（’s1：‘）s2 = input（’s2：‘）# 遍歷字串s1for i in s1： # 依次判斷s1中的每個字元是否在s2中 if i in s2： # replace 表示替換； # 將s1中與s2中相同的所有字元，替換為空字元 s1 = s1。replace（i，’‘）print（s1）
python集合綜合練習
1。地鐵站編號和站名對應關係如下： 1=朱辛莊 2=育知路 3=平西府 4=回龍觀東大街 5=霍營 //。。。。
遍歷列印（可以不按順序列印）： 第10站： 森林公園南門 第6站： 育新 第12站： 奧體中心 第13站： 北土城 //。。。
2。計算地鐵票價規則： 總行程 3站內（包含3站）收費3元， 3站以上但不超過5站（包含5站）的收費4元， 5站以上的，在4元的基礎上，每多1站增加2元， 10元封頂；
3。列印格式（需要對鍵盤錄入的上車站和到達站進行判斷，如果沒有該站，提示重新輸入，直到站名存在為止）： 注意：每站需要2分鐘 請輸入上車站： 沙河 您輸入的上車站：沙河不存在，請重新輸入上車站： 上地 您輸入的上車站：上地不存在，請重新輸入上車站： 朱辛莊 請輸入到達站： 沙河 您輸入的到達站：沙河不存在，請重新輸入到達站： 西二旗 您輸入的到達站：西二旗不存在，請重新輸入到達站： 西小口 從朱辛莊到西小口共經過6站收費6元，大約需要 12分鐘
st = “”“十三號街站 05：30 23：00 —— ——中央大街站 05：31 23：01 06：28 23：47七號街站 05：33 23：03 06：26 23：45四號街站 05：36 23：06 06：24 23：42張士站 05：38 23：08 06：21 23：40開發大道站 05：41 23：11 06：19 23：37於洪廣場站 05：43 23：13 06：16 23：35迎賓路站 05：46 23：16 06：14 23：33重工街站 05：48 23：18 06：11 23：30啟工街站 05：51 23：21 06：09 23：28保工街站 05：53 23：23 06：07 23：26鐵西廣場站 05：55 23：25 06：04 23：23雲峰北街站 05：58 23：28 06：02 23：21瀋陽站 06：01 23：31 06：00 23：18太原街站 06：03 23：33 06：16 23：16南市場站 06：05 23：35 06：13 23：13青年大街站 06：07 23：37 06：11 23：11懷遠門站 06：10 23：40 06：09 23：09中街站 06：13 23：43 06：06 23：06東中街站 06：15 23：45 06：04 23：04滂江街站 06：17 23：47 06：01 23：01黎明廣場站 —— —— 06：00 23：00”“”lst = st。split（）llsstt = list（filter（lambda x ： ’站‘ in x，lst））print（llsstt）while True： upstation = input（’請輸入上車站：‘） if upstation not in llsstt： print（f’您輸入的上車站：{upstation}不存在，請重新輸入上車站‘） upstation_idx = llsstt。index（upstation） downstation = input（’請輸入下車站：‘） if downstation not in llsstt： print（f’您輸入的下車站：{upstation}不存在，請重新輸入下車站‘） else： downstation_idx = llsstt。index（downstation） if downstation_idx < upstation_idx： print（’下車站必須在上車站之後‘） else： breakdiff = downstation_idx - upstation_idxprice = 0if diff <= 3： price = 3elif diff <= 5： price = 4else： price = 4 + （diff - 5）*2if price > 10： price = 10print（f’從{upstation}到{downstation}共經過{diff}站收費{price}元，大約需要{diff*2}分鐘‘）
python函式綜合練習
1。編寫一個函式cacluate， 可以接收任意多個數，返回的是一個元組。 元組的第一個值為所有引數的平均值， 第二個值是大於平均值的所有數。
執行結果：
# 1。定義函式； *args：可變引數def cacluate（*args）： # 2。計算平均值； args的資料型別為元組，sum求和 average = sum（args） / len（args） # 3。將所有大於平均值數的值存入列表 list=［］ for i in args： if i > average： list。append（i） # 4。將平均值和列表元素存入元組 tuple=（average，list） return tupleprint（cacluate（1，1，2，3，4））
2。編寫一個函式， 接收字串引數， 返回一個元組， 元組的第一個值為大寫字母的個數， 第二個值為小寫字母個數。 例如 輸入：’hello WORLD‘ 輸出：（5，5）
# 直接在函數里print輸出，在呼叫函式時只能列印不能使用# 如果想要使用函數里的變數值，此時需要在定義函式時用return返回函式值def fun（c）： # 記錄大寫字母個數 upper = 0 # 記錄小寫字母個數 lower = 0 # 統計大小寫字母的個數 for i in c： if i。isupper（）： upper += 1 # 注意：不能用else，因為字串之間有空格 if i。islower（）： lower += 1 tuple = （upper，lower） # 函式返回值 return tuple# 此時直接呼叫函式將不會有輸出值，必須用print輸出print（fun（input（’請輸入字串：‘）））
3。編寫函式， 接收一個列表（包含30個1~100之間的隨機整形數） 和一個整形數k， 返回一個新列表。
函式需求： - 將列表下標k之前對應（不包含k）的元素逆序； - 將下標k及之後的元素逆序；
# 匯入生成隨機數的包import random# 定義空列表list = ［］# 生成30個隨機數for i in range（30）： num = random。randint（1，100） # 將生成的隨機數新增到列表中 list。append（num）# 列印原始列表print（list）# 定義函式def fun（list，k）： # k表示下標 if k < 0 or k >= len（list）： print（’error key‘） else： # ［：k］ k之前的元素 ［：：-1］ 逆序 + 連線 return list［：k］［：：-1］ + list［k：］［：：-1］print（fun（list，3））
4。模擬輪盤抽獎遊戲 輪盤分為三部分： 一等獎， 二等獎和三等獎； 輪盤轉的時候是隨機的， 如果範圍在［0，0。08）之間，代表一等獎， 如果範圍在［0。08，0。3）之間，代表2等獎， 如果範圍在［0。3， 1。0）之間，代表3等獎，
模擬本次活動1000人參加， 模擬遊戲時需要準備各等級獎品的個數。
import random# 定義（得獎情況）字典rewardDict ={’一等獎‘：（0，0。08），’二等獎‘：（0。08，0。3），’三等獎‘：（0。3，1。0）}# 判斷使用者是否得獎def rewardfun（）： num = random。random（） # 遍歷key-value for k，v in rewardDict。items（）： if num >= v［0］ and num < v［1］： return k# 定義空字典resultDict = {}# 將得獎記錄新增到字典中，記錄1000人玩遊戲的得獎情況for i in range（1000）： # 將函式的返回值賦給reskey reskey = rewardfun（） # print（reskey） if reskey not in resultDict： # 增加元素 resultDict［reskey］ = 1 else： resultDict［reskey］ += 1# 遍歷輸出字典的 key-value值for k，v in resultDict。items（）： print（k，’——>‘，v）
5。題目需求： 對於一個十進位制的正整數， 定義f（n）為其各位數字的平方和，如： f（13） = 1
2 + 3
2 = 10 f（207） = 2
2 + 0
2 + 7
2 = 53 下面給出三個正整數k，a, b,你需要計算有多少個正整數n滿足a<=n<=b, 且k*f(n)=n 輸入: 第一行包含3個正整數k，a, b, k>=1, a,b<=10
18， a<=b； 輸出： 輸出對應的答案；
範例： 輸入： 51 5000 10000 輸出： 3
k=51a=5000b=100007293 1437854 1547905 1553
# 1。接收使用者輸入k = int（input（’k=‘））a = int（input（’a=‘））b = int（input（’b=‘））# 2。定義函式，計算fdef fun（c）： f = 0 for i in str（c）： f += int（i）**2 return f# fun（207）# 定義計數器count = 0# 3。統計滿足條件的n的個數for n in range（a，b+1）： if k * fun（n） == n： print（n，fun（n）） count += 1# 列印個數print（count）
