Python入門

一、為什么選擇Python？

　　1、Python 追求的是找到最好的解決方案，相比之下，其他語言追求的是多種解決方案。

　　2、Python 的最大優點，是使你能夠專注於解決問題而不是去搞明白語言本身。

二、准備工作

　　1、軟件安裝

　　　　使用 Anaconda 和 PyCharm。

　　　　使用 Anaconda 能幫你安裝好許多麻煩的東西，包括： Python 環境、pip 包管理工具、 常用的庫、配置好環境路徑等等。

　　　　使用 PyCharm 的原因是它的功能齊全，一站式解決所有問題，報錯提醒也更齊全。

　　2、Anaconda 安裝方法

　　　　進入 Anaconda 官網：https://www.anaconda.com/download/  （附百度網盤：鏈接：https://pan.baidu.com/s/1UHvGgeJ-bohPmA8zhvxH8Q 密碼：cc13），選擇適合你的電腦系統 Python 版本，下載安裝即可。

　　3、PyCharm 安裝方法

　　　　進入 PyCharm 官網：https://www.jetbrains.com/pycharm/download/ （附百度網盤：鏈接：https://pan.baidu.com/s/1W1KqsahuRcAAq038iEYvbg 密碼：eowx），初學者下載免費的 Community 社區版安裝即可。

　　4、Anaconda + PyCharm 配置方法 

　　　　打開 PyCharm，點擊 Create New Project 。

　　　　然后在 Interpreter 解釋器這一欄，選擇 anaconda3 這一項，然后點擊 Create 完成創建。如果沒有anaconda這一項的話，點擊旁邊的小齒輪圖標，選擇 add local ，然后選擇 anaconda 文件路路徑下的 python.exe。 

　　　　點擊 File - New，然后選擇文件類型，比如 Python File 。

　　　　然后就可以開始快樂的寫代碼了，在菜單欄點擊 Run 可以運行代碼。

三、變量與字符串

　　1、變量

　　　　變量是編程中最基本的存儲單位，變量會暫時性地儲存你放進去的東西。

　　　　變量的名字叫做標識符。

　　　　Python 對大小寫敏感，“a” 和 “A” 是兩個不同的變量。

　　2、print()

　　　　打印是Python 中最常用的功能。

　　　　駝峰命名法

　　　　帕斯卡命名法

　　3、字符串

　　　　單引號、雙引號、三引號,，其中單引號和雙引號完全一樣，三引號被用於過長段的文字或者是說明。

　　　　字符串的基本用法——合並　　　　

what_he_does = ' plays '
his_instrument = 'guitar'
his_name = 'Robert Johnson'
artist_intro = his_name + what_he_does + his_instrument 5 print(artist_intro) # Robert Johnson plays guitar

　　　　運行：

　　

 

　　　　type()函數查看變量的類型

　　　　　　由於中文注釋會打字報錯，所以需要在文件開頭加一行魔法注釋 # coding=utf-8 ，也可以在設置里面找到“File Encodings”設置為 UTF-8

　　　　數據類型轉換

num = 1
string = '1'
num2 = int(string) 4 print(num + num2) # 輸出2

　　　　

　　　　字符串相乘　　

words = 'words' * 3
print(words) # wordswordswords

word ='a loooooong word'
num =12
string = 'bang!'
total = string * (len(word) - num) # 這里的意思是total = 'bang' * (16 - 12)
print(total) # bang!bang!bang!bang!

　　

　　　　字符串的分片與索引

　　　　　　字符串可以通過 string[x] 的方式進行索引、分片，也就是加一個[]。

　　　　　　分片（slice）獲得的每個字符串可以看做是原字符串的一個副本。　　　　　

name = 'My name is Mike'
print(name[0])  # M
print(name[-4])  # M
print(name[11:14])  # Mik
print(name[11:15])  # Mike
print(name[5:])  # me is Mike
print(name[:5])  # My na
'''
1、:兩邊分別代表着字符串的分給是從哪里開始，並到哪里結束。 10 2、以name[11:14]為例，截取的編號從第11個字符開始，到位置為14但不包括第14個字符結束。 11 3、像name[5:]這樣的寫法代表着從編號為5的字符到結束的字符串分片。 12 4、像name[:5]代表着從編號為0的字符開始到編號為5單不包括第5個字符的字符分片 13 '''

　　

　　　　找出你朋友中的魔鬼　　

word = 'friends'
find_the_evil_in_your_friends = word[0] + word[2:4] + word[-3:-1] 3 print(find_the_evil_in_your_friends)  # fiend

　　　　　　過長的代碼段可以使用'\'來進行換行

　　　　實際項目中的應用

　　

　　　　字符串的方法

　　　　　　Python 是面向對象進行編程的語言，而對象擁有各種功能、特性，專業術語稱之為——方法（Method）。

　　　　　　隱藏信息　　

phone_number = '1386-666-0006'
hiding_number = phone_number.replace(phone_number[:9], '*' * 9) 3 '''這里使用了新的字符串方法replace()進行“遮擋”，replace方法的括號中，第一個phone_number[:9] 代表要被替換掉的部分， 4 后面的'*' * 9 表示簡要替換成什么字符，也就是把*乘以9，顯示9個* '''
print(hiding_number)  #輸出 *********0006

　　

　　　　　　模擬手機通訊錄中的電話號碼聯想功能

search = '168'
num_a = '1386-168-0006'
num_b = '1681-222-0006'
print(search + ' is at ' + str(num_a.find(search) + 1) + ' to ' +str(num_a.find(search) + len(search)) + ' of num_a') 5 # 168 is at 6 to 8 of num_a

print(search + ' is at ' + str(num_b.find(search) + 1) + ' to ' +str(num_b.find(search) + len(search)) + ' of num_b') 8 # 168 is at 1 to 3 of num_b

 

　　　　字符串格式化符　

　　　　　　當字符串中有多個“空”需要填寫時，可以使用.format()進行批處理。

　　　　　　填空題

　　　　　　____ a word she can get what she ____ for.　　

print('{} a word she can get what she {} for.'.format('with', 'came')) 2 print('{preposition} a word she can get what she {verb} for.'.format(preposition='with', verb='came')) 3 # preposition 介詞 ， verb 動詞
print('{0} a word she can get what she {1} for.'.format('with', 'came'))

　　　　　　利用百度提供的天氣api實現客戶端天氣插件的開發的代碼片段

city = input("write down the name of city:") 2 url = "http://apistore.baidu.com/microservice/weather?citypinyin={}.format(city)"

 

四、最基本的魔法函數

　　1、重新認識函數

　　　　print 是一個放入對象就能將結果打印的函數。

　　　　input 是一個讓用戶輸入信息的函數。

　　　　len 是一個可以測量對象長度的函數。

　　　　int 是一個可以將字符串類型的數字轉換成證書類型的函數。

　　　　Python 中所謂的使用函數就是把你要處理的對象放到一個名字的括號里面就可以了。

　　　　內建函數（Bulit-int Functions），在安裝完成之后就可以使用它們，是“自帶”的。

　　2、開始創建函數

　　　　def（即 define，定義）的含義是創建函數，也就是定義一個函數。

　　　　arg（即 argument，參數），另外一種寫法是parameter 。

　　　　return 即返回結果。

　　　　咒語： Define a function named ‘function’ which has two arguments : args1 and args2, returns the result——'Something'

　　

　　注意：

　　　　1、def 和 return 是關鍵字（keyword），Python 就是靠識別這些特定的關鍵字來明白用戶的意圖，實現更為復雜的編程。

　　　　2、在閉合括號后面的冒號必不可少，而且需要使用英文輸入法進行輸入，否則報錯（SyntaxError: invalid character in identifier）。

　　　　3、在IDE中冒號后面回車（換行）會自動得到一個縮進。函數縮進后面的語法被稱為語句塊（block）。縮進是為了表明語句和邏輯的從屬關系，是 Python 最顯著的特征之一。

　　　　攝氏度轉換華氏度

def fahrenheit_converter(C): 2     fahrenheit = C * 9 / 5 + 32
    return str(fahrenheit) + '°F'  # 計算的結果類型是float，不能與字符串"°F"相合並，所以需要先用str函數進行轉換


# 把調用函數這種行為叫做“調用”（call），這里是有攝氏度（Celsius）轉換器將35攝氏度轉換成華氏度（fahrenheit），
# 將結果存儲在名為C2F的變量並打印出來
C2F = fahrenheit_converter(35) 9 print(C2F)  # 95.0°F

　　　　4、在 Python 中，return 是可選的（optional），意味着不寫 return 也可以順利地定義一個函數並使用，只不過返回值是‘None’ 。

　　　　5、在 Python 中，definition 和 declaration（聲明） 是一體的。

　　　　6、練習題

　　　　（1）初級難度：設計一個重量轉換器，輸入以‘g’為單位的數字后返回換算成'kg'的結果。

　　　參考答案：

def g2kg(g): 2     return str(g/1000) + 'kg'


print(g2kg(2000))  # 調用函數並打印結果

 　　運行結果：

　　

 

　　　　（2）中級難度：設計一個求直角三角形斜邊長的函數（兩條直角邊為參數，求最長邊），如果直角邊邊長分別為3和4，那么返回的結果應該像這樣：

　　

　　　　　參考答案：

def Pythagorean_theorem(a, b): 2     return 'The right triangle third side\'s length is {}'.format((a**2 + b**2) ** (1/2)) 3 # 等價於a的平方與b的平方之和的1/2次方（即開根）


print(Pythagorean_theorem(3, 4))   # 調用函數並打印結果

 　　運行結果：

　　

 

　　3、傳遞參數與參數類型

 　　傳遞參數的方式有兩種：

　　　　位置參數（positional argument）

　　　　關鍵詞參數（keyword argument）

　　把函數的名稱定位trapezoid_area（梯形面積），設定參數為base_up，base_down（下底），height（高）　

　　（1）位置參數（positional argument）

def trapezoid_area(base_up, base_down, height): 2     return 1/2 * (base_up + base_down) * height

　　調用函數

trapezoid_area(1, 2, 3) 2 # 填入的參數1,2,3分別對應着參數base_up, base_down, height，這種傳入參數的方式被稱為位置參數

　　（2）關鍵詞參數（keyword argument）

trapezoid_area(base_up=1, base_down=2, height=3) 2 # 將每個參數名稱后面賦予一個我們想要傳入的值，這種以名稱作為一一對應的參數傳入方式被稱作是關鍵詞參數

 

　　4、設計自己的函數

　　認識新的函數——open

　　　　這個函數使用起來很簡單，只需要傳入兩個參數就可以正常運轉了：文件的完整路徑和名稱，打開的方式。

　　　　在E盤的根目錄下創建text.txt

file = open('E://text.txt', 'w') 2 file.write('hello World')

　　　　運行程序后

　　

　　

　　設計函數

　　　　需求：傳入參數 name 與 msg 就可以控制在E盤根目錄寫入的文件名稱和內容的函數text_create， 並且如果當E盤根目錄沒有這個可以寫入的文件時，那么就要創建一個之后，再寫入。

def text_create(name, msg):  # 定義函數的名稱和參數
    e_path = 'E:'  # 定義 open 函數要打開的路徑
    full_path = e_path + name + '.txt'  # 傳入的參數加上路徑再加上后綴就是完整的文件路徑
    file = open(full_path, 'w') 5     # 打開文件，'w'參數代表作為寫入模式，意思：如果沒有就在該路徑創建一個有該名稱文本，有則追加覆蓋文本內容。

    file.write(msg)  # 寫入傳入的參數 msg，即內容
    file.close()  # 關閉文本
    print('Done')  # 表明上面的所有語句均已執行，提示作用。

　　敏感詞過濾：

 　　　　需求：定義一個函數text_filter 的函數，傳入參數 word，cencored_word 和 changed_word 實現過濾，敏感詞cencored_word 默認為 'lame'，替換詞changed_word默認為'Awesome'

def text_filter(word, censored_word='lame', changed_word='Awesome'): 2     return word.replace(censored_word, changed_word) 3 

text_filter('Python is lame!')  # 調用函數

　　把兩個函數合並

　　　　創建一個名為text-consored_create 的函數，功能是在桌面上創建一個文本可以在其中輸入文字，但是如果信息中含有敏感詞的話將被默認過濾后寫入文件。其中，文本的文件名參數為 name，信息參數為msg

def censored_text_create(name, msg): 2     clean_msg = text_filter(msg) 3  text_create(name, clean_msg) 4 

censored_text_create('Try', 'lame!lame!lame!')  #調用函數

　　數學運算

　　　　a=10，b=20

　　　　+　　加，兩個對象相加　　a + b 輸出結果  30　　

　　　　-　　減，得到負數或是一個數減去兩外一個數　　a - b輸出結果 -10

　　　　*　　乘，兩個數相乘或是返回一個被重復若干次的字符串　　a * b 輸出結果 200

　　　　/　　除，x除以y　　b / a 輸出結果 2

　　　　%　 取模，返回除法的余數　　b % a 輸出結果 0

　　　　**　  冪，返回x的y次冪　　a**b為10的20次方，輸出結果100000000000000000000

　　　　//　   取整數，返回商的整數部分　　9//2 輸出結果 4， 9.0//2.0 輸出結果 4.0

 

五、循環與判斷　　

　　邏輯控制與循環

　　　　邏輯判斷——True & False

　　　　if-else 結構是常見的邏輯控制的手段。

　　　　邏輯判斷的最基本准則——布爾類型（Boolean Type）

　　　　布爾類型（Boolean）的數據只有兩種類型，True 和False（需要注意的是首字母大寫）。

　　　　在命令行/終端環境輸入代碼（更快展示結果）

　　　　但凡能夠產生一個布爾值的表達式為布爾表達式（Boolean Expressions）

　　比較運算（Comparison）

　　　　==　　左右兩邊等值的時候返回 True

　　　  ！=　   左右兩邊不相等時返回 True

　　　　>　　  左邊大於右邊的時候返回 True

　　　　<　　  左邊小於右邊的時候返回 True

　　　　<=　　左邊小於或等於右邊的時候返回 True

　　　　>=　　左邊大於或等於右邊的時候返回 True

 　　　　比較運算還支持更為復雜的表達方式，例如：

　　　　　　多條件的比較。先給變量賦值，並在多條件下比較大小：　　　　　

middle = 5
1< middle < 10  # True

　　　　　　變量的比較。將兩個運算結果儲存在不同的變量中，再進行比較：　　

two = 1+1
three = 1+3
two<three  # True

　　　　　　字符串的比較。其實就是對比左右兩邊的字符串是否完全一致，下面的代碼就是不一致的，因為在 Python 中有着嚴格的大小寫區分：

'Eddie Van Helen' == 'eddie van helen'  # False

　　　　　　兩個函數產生的結果進行比較：比較運算符兩邊會先行調用函數后再進行比較，其結果等價於10>19 ：

abs(-10) > len('length of this word')  # false,其中abs() 是一個會返回輸入參數的絕對值的函數

 

　　比較運算的一些小問題

　　　　不同類型的對象不能使用“<，>，<=，>=”進行比較，卻可以使用‘==’和‘！=’，例如字符串和數字：　

42 > 'the answer'  # 無法比較
42 == 'the answer'  # False
42 != 'the answer'  # True

　　　　需要注意的是，浮點和整數雖是不同類型，但是不影響到比較運算：

5.0 == 5  # True
3.0 > 1  # True

　　　　“=”在 Python 中代表着賦值，並非是“等於”，使用“==”這種表達方式，可以理解成是表達兩個對象的值是相等的。

　　　　True 和 False 對於計算機就像是1和0一樣，如果在命令行中敲入True + True +False 實際上等價於1+1+0

　　　　類似 1<>3這種表達式，與 1!=3 是等價的。

 

　　成員運算符和身份運算符（Membership & Identify Operators）

　　　　成員運算符和身份運算符的關鍵詞是 in 和 is 。把 in 放在兩個對象中間的含義是，測試前者是否存在於 in 后面的集合中。

　　　　簡單易懂的集合類型——列表（list）

　　　　字符串、浮點、整數、布爾類型、變量甚至是另一個列表都可以存儲在列表中，列表是非常實用的數據結構。

# album = [] # 此時列表是空的
album = ['Black Star', 'David Bowie', 25, True]  # 創建了一個非空的列表
album.append('new song')  # 使用列表的 append 方法可以向列表中添加新的元素，且自動排列到列表的尾部
print(album[0], album[-1])  # 列表的索引，這里是打印列表中的第一個和最后一個元素
print('Black Start' in album)  # 使用in來測試字符串'Black Start'是否在列表 album 中，在則顯示 True，不在則顯示 False

　　　　is 和 is not ，它們是表示身份鑒別（Identify Operator）的布爾運算符，in 和 not in 則是表示歸屬關系的布爾運算符號（Membership Operator）。

　　　　在 Python 中，任何一個對象都要滿足身份（Identify）、類型（Type）、值（Value）這三個點，缺一不可。is 操作符號就是用來進行身份的對比的。

　　　　在 Python 中，任何對象都可判斷其布爾值，除了 0 、None 和所有空的序列與集合（列表，字典，集合）布爾值為 False 之外，其他為 True ，我們可以使用函數 bool()進行判別。

　　

　　布爾運算符（Boolean Operators）

　　　　and 、or 用於布爾值之間的運算，具體規則如下：

　　　　　　not x　　如果 x 是True，則返回 False，否則返回 True

　　　　　　x and y　　and 表示“並且”，如果 x 和 y 都是True，則返回 True；如果x 和 y 有一個 False，則返回 False

　　　　　　x or y　　or 表示“或者”，如果 x 或 y 有其中一個是 True，則返回 True；如果 x 和 y 都是 False ，則返回 False

　　　　and 和 or 經常用於處理復合條件，類似於1 < n <3，也就是兩個條件同時滿足。

 

　　條件控制

　　　　條件控制其實就是if …else 的使用。

　　　　用一句話概括 if…else 的作用：如果…條件是成立的，就做…；反之，就做…

　　　　所謂條件（condition）指的是成立的條件，即是返回值為 True 的布爾表達式。　　　

def account_login():  # 定義函數，並不需要參數
    password = input('Password:')  # 使用 input 獲得用戶輸入的字符串並存儲在變量 password 中
    if password == '12345':  # 設置條件，如果用戶輸入的字符串和預設的密碼12345相等時，就執行打印文本'Login success!'
        print('Login success!')  5     else:  6         print('Wrong password or invalid input!')  # 一切不等於預設密碼的輸入結果，全部會執行打印錯誤提示
        account_login()  # 再次調用函數，讓用戶再次輸入密碼


account_login()  # 調用函數

 　　　　如果 if 后面的布爾表達式過長或者難以理解，可以采取給變量賦值的方法來存儲布爾表達式返回的布爾值 True 或 False

def account_login(): 2     password = input('Password:') 3     password_correct = password == '12345'
    # 如果 if 后面的布爾表達式過長或者難以理解，可以采取給變量賦值的方法來存儲布爾表達式返回的布爾值 True 或 False
    if password_correct: 6         print('Login success!') 7     else: 8         print('Wrong password or invalid input!') 9         account_login()

　　　　一般情況下，設計程序的時候需要考慮到邏輯的完備性，並對用戶可能會產生困擾的情況進行預防性設計，這時候會有多條件判斷。多條件判斷只需要在 if 和 else 之間加上elif ，用法和 if 是一致的。而且條件的判斷也是依次進行的，首先看條件是否成立，如果成立那么就進行下面的代碼，如果不成立就接着順次地看下面的條件是否成立，如果都不成立則運行 else 對應的語句。　　

password_list = ['*#*#', '12345']  # 創建一個列表，用於儲存用戶的密碼、初始密碼和其他數據（對實際數據庫的簡化模擬）


def account_login():  # 定義函數
    password = input('Password:')  # 使用input 獲得用戶輸入的字符串並存儲在變量 password 中

    # 當用戶輸入的密碼等於密碼列表最后一個元素的時候（即用戶最新設定的密碼，登錄成功）
    password_correct = password == password_list[-1]  9     password_reset =password == password_list[0] 10     if password_correct: 11         print('Login success!') 12 
    # 當用戶輸入的密碼等於密碼列表中第一個元素的時候（即重置密碼的“口令”）觸發密碼變更，並將變呢狗的密碼存儲至列表的最后一個，稱為最新的用戶密碼
    elif password_reset: 15         new_password = input('Enter a new password:') 16  password_list.append(new_password) 17         print('Your password has changed successfully!') 18  account_login() 19         
    # 一切不等於預設密碼的輸入結果，全部會執行打印錯誤提示，並且再次調用函數，讓用戶輸入密碼 
    else: 22         print('Wrong password or invalid input!') 23  account_login() 24 

account_login()  # 調用函數

　　　　代碼塊（Code Block），代碼塊的產生是由於縮進，具有相同縮進量的代碼實際上實在共同完成相同層面的事情。

 

　　循環（Loop）

　　　　for循環　　

for every_letter in 'Hello world': 2     print(every_letter)  # 使用 for 循環打印出"hello world" 這段字符串中的每一個字符。

　　　　把 for 循環所做的事情概括成一句話就是：於…其中的每一個元素，做…事情。

for num in range(1, 11):  # 不包括11，因此實際范圍是1-10
    print(str(num) + ' + 1 = ', num + 1) 3     # 將1-10范圍內的每一個數字依次裝入變量 num 中，每次展示一個 num +1 的結果。在這個過程中，變量 num 被循環賦值10次。

　　　　

　　嵌套循環（Nested Loop）

　　　　嵌套循環實現“九九乘法表”

for i in range(1, 10): 2     for j in range(1, 10): 3         print('{} × {} = {}'.format(i, j, i*j))

 

　　while 循環

　　　　for 循環會在可迭代的序列被窮盡的時候停止，while 則是在條件不成立的時候停止，因此 while 的作用概括成一句話就是：只要…條件成立，就一直做…　

while 1 < 3: 2     print('1 is smaller that 3') 3     # 在終端或者命令行中按 Ctrl + C 停止運行，在 PyCharm 中則點擊紅色的 X 停止
    # 一定要及時停止運行代碼，因為在 while 后面的表達式是永遠成立的，所以 print 會一直進行下去直到你的CPU過熱。
    # 這種條件永遠為 True 的循環，我們稱之為死循環（Infinite Loop）

　　　　讓 while 循環停下來的方法：

　　　　　　（1）在循環過程中制造某種可以使循環停下來的條件

count = 0 2 while True: 3     print('Repeat this line！') 4     count = count + 1
    if count == 5: 6         break

　　　　　　（2）改變使循環成立的條件

password_list = ['*#*#', '12345']  # 創建一個列表，用於儲存用戶的密碼、初始密碼和其他數據（對實際數據庫的簡化模擬）


def account_login():  # 定義函數
    tries = 3
    while tries > 0:  # 如果 tries > 0 這個條件成立，那么便可輸入密碼，從而執行辨別密碼是否正確的邏輯判斷
        password = input('Password:')  # 使用input 獲得用戶輸入的字符串並存儲在變量 password 中

    # 當用戶輸入的密碼等於密碼列表最后一個元素的時候（即用戶最新設定的密碼，登錄成功）
        password_correct = password == password_list[-1] 11         password_reset = password == password_list[0] 12         if password_correct: 13             print('Login success!') 14 
    # 當用戶輸入的密碼等於密碼列表中第一個元素的時候（即重置密碼的“口令”）觸發密碼變更，並將變呢狗的密碼存儲至列表的最后一個，稱為最新的用戶密碼
        elif password_reset: 17             new_password = input('Enter a new password:') 18  password_list.append(new_password) 19             print('Your password has changed successfully!') 20  account_login() 21 
    # 一切不等於預設密碼的輸入結果，全部會執行打印錯誤提示，並且再次調用函數，讓用戶輸入密碼
        else: 24             print('Wrong password or invalid input!') 25             tries = tries - 1  # 當密碼輸入錯誤時，可嘗試的次數 tries 減少 1
            print(tries, 'times left') 27     else: 28         print('Your account has been suspended')  # while 循環的條件不成立時，就意味着嘗試次數用完，通知用戶賬號被鎖。


account_login()  # 調用函數

 

　　練習題

　　1、設計這樣一個函數，在桌面的d文件夾上創建10個文本，以數字給它們命名。

# 在桌面的d文件夾上創建10個文本，以數字給它們命名
def text_creation():
    # 創建文本的路徑
    path = 'C://Users//Lamfai//Desktop//d//'
    for name in range(1, 11):
        with open(path + str(name) + '.txt', 'w') as text:
            text.write(str(name))
            text.close()
            print('Done')


# 函數調用
text_creation()

 

　　運行結果：

　　

 

　　2、復利是一件神奇的事情，正如富蘭克林所說：“復利是能夠將所有鉛塊變成金塊的石頭”。設計一個復利計算函數 invest()，它包含三個參數：amount（資金），rate（利率），time（投資時間）。 輸入每個參數后調用函數，應該返回每一年的資金總額。它看起來就應該像這樣（假設利率為5%）。

# 復利公式
def invest(amount, rate, time):
    print("principal amount:{}".format(amount))
    for t in range(1, time + 1):
        amount = amount * (1 + rate)
        print("year {} :${}".format(t, amount))


# 本金為100美元，利率為5%的8年的本息和
invest(100, .05, 8)

　　運行結果：　

 

　　3、打印100以內的偶數。

# 打印100以內的偶數
def even_print():
    for i in range(1, 101):
        if i % 2 == 0:
            print(i)


even_print()

 

　　綜合練習

 

六、數據結構

　　數據結構（Data Structure）

　　　　儲存大量數據的容器，在 Python 中被稱為內置數據結構（Built-in Data Structure）

　　　　Python 有四種數據結構，分別是：列表、字典、元組、集合。

　　　　list =  [val1,val2,val3,val4]

　　　　dict = {key1:val1,key2:val2}

　　　　tuple = (val1,val2,val3,val4)

　　　　set = {val1,val2,val3,val4}

　　列表（list）

　　　　列表中的每一個元素都是可變的，這意味着我們可以在列表中添加、刪除和修改元素。

　　　　列表中的元素是有序的，也就是說每一個元素都有一個位置，我們通過輸入位置而查詢該位置所對應的值，試着輸入：

Weekday = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] 2 print(Weekday[0])  # 輸出Monday

　　　　列表可以容納 Python 中的任何對象。

　　列表的增刪改查

　　　　1、列表的插入。在使用 insert 方法的時候，必須指定在列表中要插入新的元素的位置，插入元素的實際位置是在指定元素之前的位置，如果指定插入的位置在列表中不存在（實際上是超出指定列表長度），那么這個元素一定會被放在列表的最后位置。　　　　

fruit = ['pineapple', 'pear'] 2 fruit.insert(1, 'grape') 3 print(fruit)  # 輸出['pineapple', 'grape', 'pear']

　　　　另外一種插入的方法

fruit = ['pineapple', 'pear'] 2 fruit[0:0] = ['Orange'] 3 print(fruit)# 輸出['Orange', 'pineapple', 'pear']

　　　　2、刪除列表中元素的方法是使用 remove()

fruit = ['pineapple', 'pear', 'grape'] 2 fruit.remove('grape') 3 print(fruit)  # 輸出['pineapple', 'pear']

　　　　另外一種刪除的方法，使用 del 關鍵字來聲明

fruit = ['pineapple', 'pear', 'grape'] 2 del fruit[0:2] 3 print(fruit)  # 輸出['grape']

　　　　3、替換修改其中的元素

fruit = ['pineapple', 'pear', 'grape'] 2 fruit[0] = 'Grapefruit'
print(fruit)  # 輸出['Grapefruit', 'pear', 'grape']

　　　　4、查詢元素

　　　　　　列表的索引與字符串的分片十分相似，同樣是正反兩種索引方式，只要輸入對應的位置就會返回給你這個位置上的值。

periodic_table = ['H', 'He', 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ne'] 2 print(periodic_table[0])    # H
print(periodic_table[-2])   # F
print(periodic_table[0:3])  # ['H', 'He', 'Li']
print(periodic_table[-10:-7])   # ['H', 'He', 'Li']
print(periodic_table[-10:])  # ['H', 'He', 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ne']
print(periodic_table[:9])   # ['H', 'He', 'Li', 'Be', 'B', 'C', 'N', 'O', 'F']

 

　　字典（Dictionary）

　　　　使用名稱 — 內容進行數據的構建，在 Python 中分別對應着鍵（key） — 值（value），習慣上稱之為鍵值對。

　　　　字典的特征總結如下：

　　　　　　1、字典中數據必須是以鍵值對的形式出現的。

　　　　　　2、邏輯上講，鍵是不能重復的，而值可以重復。

　　　　　　3、字典中的鍵（key）是不可變的，也就是無法修改的；而值（value）是可變的，可修改的，可以使任何對象。

NASDAQ_code = { 2     'BIDU':'Baidu', 3     'SINA':'Sina', 4     'YOKU':'Youku'
}

　　　　字典的增刪改查

　　　　　　1、按照映射關系創建一個字典

NASDAQ_code = { 'BIDU': 'Baidu',   'SINA': 'Sina'}

　　　　　　2、添加

NASDAQ_code['YOUKU'] = 'Youku'
print(NASDAQ_code)

　　　　　　添加多個元素的方法 update()

NASDAQ_code = { 'BIDU': 'Baidu',   'SINA': 'Sina'} 2 NASDAQ_code.update({'FB': 'Facebook', 'TSLA': 'Tesla'}) 3 print(NASDAQ_code)

　　　　　　3、刪除使用 del 方法

del NASDAQ_code['FB']

　　　　　　

　　元組（Tuple）

　　　　元組其實可以理解成一個穩固版的列表，因為元組是不可修改的，因此在列表中的存在的方法均不可以使用在元組上，但是元組是可以被查看索引的，方式就和列表一樣。

letters = ('a', 'b', 'c', 'd', 'e', 'f', 'g') 2 print(letters[0])

 

　　集合（Set）

　　　　集合更接近數學上集合的概念。每一個集合中的元素是無序的、不重復的任意對象，我們可以通過集合去判斷數據的從屬關系，有時還可以通過集合把數據結構中重復的元素減掉。

　　　　集合不能被切片也不能被索引，除了做集合運算之外，集合元素可以被添加還有刪除。

a_set = {1, 2, 3, 4} 2 a_set.add(5) 3 print(a_set)    # {1, 2, 3, 4, 5}
a_set.discard(5) 5 print(a_set)    # {1, 2, 3, 4}

 

　　數據結構的一些技巧

　　　　多重循環

　　　　　　sorted 函數按照長短、大小、英文字母的順序給每個列表中的元素進行排序。這個函數會經常在數據的展示中石油，其中有一個非常重要的地方，storted 函數並不會改變列表本身（先將列表進行復制，然后再進行順序的整理）。

num_list = [6, 2, 7, 4, 1, 3, 5] 2 print(sorted(num_list))  # [1, 2, 3, 4, 5, 6, 7]

　　　　　　在使用默認參數 reverse 后，列表可以被按照逆序整理。

num_list = [6, 2, 7, 4, 1, 3, 5] 2 print(sorted(num_list))  # [1, 2, 3, 4, 5, 6, 7]
print(sorted(num_list, reverse=True))  # [7, 6, 5, 4, 3, 2, 1]

　　　　推導式（List comprehension）

　　　　　　數據結構中的推導式，也叫列表的解析式。

import time  2 
# 普通寫法
a = []  5 t0 = time.clock()  6 for i in range(1, 20000):  7  a.append(i)  8 print(time.clock() - t0, "seconds process time")  9 
# 列表解析式，不僅非常方便，並且在執行效率上要遠遠勝於前者
t0 = time.clock() 12 b = [i for i in range(1, 20000)] 13 print(time.clock() - t0, "seconds process time")

 

　　　　循環列表時獲取元素的索引

letters = ('a', 'b', 'c', 'd', 'e', 'f', 'g') 2 for num, letters in enumerate(letters): 3     print(letters, 'is', num+1)

 

　　綜合項目

　　　　詞頻統計　　

import string  2 path = 'E:\\Walden.txt'
with open(path, 'r') as text:  4     words = text.read().split()  5     print(words)  6     for word in words:  7         print('{}-{} times'.format(word, words.count(word)))  8 '''
 這個代碼的缺點： 10  1、有一些帶標點符號的單詞背單獨統計了次數 11  2、有些單詞不止一次地展示了出現的次數 12  3、由於 Python 對大小寫敏感，開頭大寫的單詞背單獨統計了 13 '''

　　　　根據上面代碼的缺點進行調整，對單詞進行預處理

import string  # 引入了一個新的模塊 string，里面靜靜是包含了所有的標點符號——!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

path = 'E:\\Walden.txt'  # 文本路徑

with open(path, 'r') as text:  6     words = [raw_word.strip(string.punctuation).lower() for raw_word in text.read().split()]  7     # 在文字的首位去掉了連在一起的標點符號，並把首字母大寫的單詞轉化為小寫

    words_index = set(words) 10     # 將列表用 set 函數轉換成集合，自動去掉了其中所有重復的元素

    counts_dict = {index: words.count(index) for index in words_index} 13     # 創建了一個以單詞為鍵（key）出現頻率為值（value）的字典

for word in sorted(counts_dict, key=lambda x: counts_dict[x], reverse=True): 16     print('{} -- {} times'.format(word, counts_dict[word])) 17     # 打印整理后的函數，其中 key=lambda x: counts_dict[x] 叫做lambda 表達式，可以暫且理解為以字典中的值為排序的參數

 

七、類

　　定義一個類

　　　　類是有一些系列有共同特征和行為事物的抽象概念的總和。　　　

class Cococola: 2     formula = ['caffeine', 'sugar', 'water', 'soda']

　　

　　類的實例化

class Cocacola:  2     formula = ['caffeine', 'sugar', 'water', 'soda']  3 

coke_for_me = Cocacola()  6 coke_for_you = Cocacola()  7 
print(Cocacola.formula)  9 print(coke_for_me.formula) 10 print(coke_for_you.formula)

　

　　類屬性引用

　　　　在類的名字后面輸入 . ，IDE 就會自動聯想出我們之前在定義類的時候寫在里面的屬性，而這就是類屬性的引用（attribute reference）。

　　　　類的屬性會被所有類的實例共享。

　　　　類的屬性和正常的變量並無區別。

　　

　　實例屬性　　　　　　

class Cococola: 2     formula = ['caffeine', 'sugar', 'water', 'soda'] 3 

coke_for_China = Cococola() 6 coke_for_China.local_logo = '可口可樂'  # 創建實例屬性

print(coke_for_China.local_logo)  # 打印實例屬性引用結果

 

　　實例方法　　　　

class CocaCola: 2     formula = ['caffeine', 'sugar', 'water', 'soda'] 3 
    def drink(self):  # self 這個參數是可以隨意修改名稱的，編譯器不會因此而報錯，按照 Python 的規矩，統一使用 self
        print('Energy!') 6 

coke = CocaCola() 9 coke.drink()  # 相當於 CocaCola.drink(coke)

　　類的方法也能有屬於自己的參數。

class CocaCola:  2     formula = ['caffeine', 'sugar', 'water', 'soda']  3 
    def drink(self, how_much):  5         if how_much == 'a sip':  6             print('Cool')  7         elif how_much == 'whole bottle':  8             print('Headache')  9 

ice_coke = CocaCola() 12 ice_coke.drink('a sip')

 

　　魔術方法

　　　　Python 的類中存在一些方法，被稱為“魔術方法”，_init_()_ 就是其中之一。

　　　　_init()_ 的神奇之處在於，如果你在類里定義了它，在創建實例的時候它就能幫你自動地處理很多事情 —— 比如新增實例屬性。

　　　　_init()_ 是 initialize （初始化）的縮寫，這意味着即使我們在創建實例的時候不去引用 init()方法，其中的命令也會被自動地執行。

class Cocacola:  2     formula = ['caffeine', 'sugar', 'water', 'soda']  3 
    def __init__(self):  5         for element in self.formula:  6             print('Coke has {}!'.format(element))  7 
    def drink(self):  9         print('Energy！') 10 

coke = Cocacola()

 

　　類的繼承（Inheritance）

　　　　類中的變量和方法可以完全被子類繼承，但如需要特殊的改動也可以進行覆蓋（Override）。

八、第三方庫

　　1、在 PyCharm 中安裝第三方庫

　　（1）在 PyChram 的菜單中選擇：File > Default Settings ；

　　（2）搜索 Project Interpreter，選擇當前版本 Python 環境，，點擊 “+” 添加庫；

　　（3）輸入庫的名稱，勾選並點擊 Install Package。

　　2、使用第三方庫

　　在 Python 中輸入庫的名字，就會自動提示補全了。