小豬的Python學習之旅 —— 1.基礎知識儲備

引言：(文章比較長，建議看目錄按需學習～)

      以前剛學程式設計的時候就對Python略有耳聞，不過學校只有C，C++，Java，C#。 和PHP有句**"PHP是最好的語言"** 這種家喻戶曉的騷話一樣，Python也有 "人生苦短，我用Python"。而接觸Python這個詞最多的場合就是在一些技術群裡， 有些大佬張嘴動不動就說什麼Py交易，作為潛伏在群裡的開發萌新的我每次都 會忍不住會發出這樣的感慨：

而真正接觸了下Python是在上家公司，當時老大讓我寫個指令碼去下載 倉庫裡最近打包的apk，當時東湊湊西湊湊最後總算拼成了一個可執行 的py檔案，因為不瞭解Python裡的資料結構，全部用的字串變數， 後面被老大教育了一番才知道有元組這種東西。因為本身做Android的， Python用到的場合不多，加之覺得Kotlin有點意思，就沒去研究Python了。

前段時間，手頭的事做得差不多了，無聊四處張望時，看到隔壁後臺 小哥迅雷瘋狂下載東西，建資料夾，貼上複製，不知道還以為他在給 小電影分類呢，後來一問才知道，運營讓他把伺服器上所有的音訊 檔案下下來，然後根據對應的類別下到對應資料夾，所以他做的事情 就是：迅雷批量下載過歌曲 -> 看mysql歌曲的分組 -> 建資料夾 -> 貼上複製歌曲到這個資料夾下，咋一看，流程挺簡單的，然而有 4700多首歌，幾百個目錄，這樣慢慢搞怕是要搞幾天，而且常時間 機械化的重複某項工作，很容易出錯。看著一臉絕望的後臺小哥：

於心不忍，決定寫個py指令碼來拯救他，腦子裡也有了程式的大概邏輯:

• 1.讓後臺匯出一份mysql建表語句，安裝mysql把表建起來；
• 2.Python連mysql，讀取表裡的資料
• 3.編寫帶limit去重的sql查詢語句，查詢得到所有分類
• 4.得到的所有分類就是要建立的資料夾，迭代批量建立資料夾；
• 5.sql查詢歌曲下載url與分類，拼接，寫入到檔案中；
• 6.讀取檔案，迭代：下載url擷取檔名與分類路徑拼接成檔案 的完整路徑，呼叫下載相關函式下載url到對應路徑即可。

邏輯挺簡單明瞭的，然而各種坑，最後折騰了一天才能弄出來 遇到了下面這些問題：

• 1.最坑的解碼問題：預設使用Python2，中文亂碼，各種網上搜， 設定編碼方式，都沒用，頭皮發麻，特別是在擷取檔名的時候。 後面換了一波Python3，很舒服，什麼問題都沒了。
• 2.沒有對異常進行捕獲，有些資源失效404，下到中途才發現.;
• 3.想弄多執行緒下載的，因為Python很多基礎不知道，後面放棄了;

當看到所有檔案都下載到了對應的位置，一種油然而生的成就感， 比起寫APP天天畫介面，請求，解析資料，顯示資料，有意思太多， 畢竟學習開發興趣很重要，索性從零開始學習下Python吧，越學越覺得：

理由上班時的閒暇時間，歷時兩週總算是把基礎知識的東西過了 一遍，遂有此文，畢竟初學者，有些地方可能理解有誤，望看到 的大佬不吝賜教，文中大部分內容摘自： 《Python 3 教程》與《小甲魚的零基礎入門學習Python》 有興趣的可以閱讀下這兩本書~ 本文不是入門教程啊，完全沒有程式設計經驗的不建議閱讀！ 完全小白可以看下這本：《程式設計小白的第一本Python入門書》

---

目錄

[TOC]

---

1.學習資源相關

API文件

• 官網：www.python.org/
• API：docs.python.org/release/3.6…
• 中文API(3.5.2)：python.usyiyi.cn/translate/p…
• awesome-python：github.com/vinta/aweso…
• awesome-python(翻譯)：github.com/jobbole/awe…

書籍

• 《Python 3 教程》：www.runoob.com/python3/pyt…
• 《老齊零基礎學Python》：www.gitbook.com/book/looly/…
• 《小甲魚的零基礎入門學習Python》：很不錯的一本入門書籍，我就是看這本~
• 《Python核心程式設計（第3版）》：也是挺有名的一本書，還沒看~

---

2.學習Python2還是Python3的問題

！！！Python 3的語法 不完全相容 Python 2的語法！！！

菜逼剛學Python沒多久，不敢大聲嗶嗶，最直接原因： Python 3預設使用utf-8，在處理中文的時候可以 減少很多編解碼的問題，而Python 2預設使用ascii。

另外的原因：與時俱進，IT行業發展那麼迅速，完全過渡只是時間問題； 舉個例子：Android Studio剛出的沒多久的時候，各種說卡啊，垃圾， 只能開一個專案等各種嫌棄，不如Eclipse好用；然而現在開發Android 還是用Eclipse的都是會被歧視一波的，另外官方已經確定Python 2.7會 在2020年退休。So：人生苦短，我用Python3。

而且Python 2.7預計會在2020年退休

更多比較的文章可見：

Python2.x與3​​.x版本區別 Python2orPython3 Python3.x和Python2.x的區別

---

3.開發環境搭建

Python下載安裝

官網下載：www.python.org/downloads/， 自己選擇需要的版本與作業系統。

• Windows

傻瓜式下一步就好，記得勾選Add Python x.x to Path！勾選 了你裝完就不用自己去配置環境變數，安裝完畢後開啟CMD輸入： python3 -V 能檢視到安裝的Python版本說明安裝成功， 如果提示錯誤：python3不是內部或外部命令之類的話，恭喜你 可以百度下：Python3環境變數配置 了~

• Mac

方法一：官網下安裝包，傻瓜下一步； 方法二：如果有裝Homebrew，終端輸入：brew install Python3 安裝即可。

• Ubuntu：一般內建，執行下述命令可檢視版本，如果想安裝自己喜歡 的版本可以鍵入：sudo apt-get install python版本號 進行安裝

PyCharm下載安裝

其實在安裝完Python後就可以進行Python程式設計了，直接命令列輸入python3， 就可以使用自帶的IDLE進行開發了；又或者直接用Sublime Text或NotePad++ 這類程式碼檢視工具直接編寫程式碼，然後儲存成字尾為.py的檔案，然後python3 執行這個py檔案就可以了。

雖然可以，但是挺不方便的，比如縮排問題，Python通過縮排來表示程式碼塊， 程式碼一多，某一行沒有正確的使用縮排，結果可能與你預期的相差甚遠。 智慧提示，方便的依賴庫管理等，這兩個就不用說了吧，具體的還得你自己體會。

官網下載：www.jetbrains.com/pycharm/dow… 下載Professional版本，傻瓜式安裝，開啟後會彈出註冊頁面， 勾選License server，在License server address輸入註冊伺服器， 網上搜很多，然後就可以愉快的進行py開發了。

軟體的基本使用也非常簡單，Jetbrains的IDE都是差不多的~ 有一點要注意的地方是，如果你想切換專案依賴的Python版本號的話： 開啟設定(Preference或settings)，修改即可：

---

4.基本常識

1) 導包

有時專案中需要引入其他模組或者模組中的某個函式，需要用到import和 from...import，用法示例如下：

import sys  # 匯入整個模組
from sys import argv   # 匯入模組中的需要用到的部分
from urllib.error import URLError, HTTPError # 多個的時候可以用逗號隔開
from sys import *  # 匯出模組中的所有
# 另外還可以使用as關鍵字為模組設定別名，比如 import sys as s
# 呼叫的時候直接s.argv 這樣就可以了。
複製程式碼

2) 關鍵字與識別符號命名規則

在對變數或者方法名這些識別符號進行命名的時候，需要注意，不能夠 與Python中的關鍵字相同，通過keyword.kwlist可以查詢所有的關鍵字： 需要import keyword模組哦~

除了不能與與關鍵字相同外，識別符號的命名規則： 由字母，數字和下劃線組成，且首字元必須為字母或下劃線， Python對大小寫敏感；關於命名規範的問題，沒有什麼 強制規定，整個專案保持統一就好，附上網上找的一個命名規則：

• 1.專案名：首字母大寫，其餘小寫，用下劃線增加可讀性，如：Ui_test；
• 2.包名與模組名：全部小寫字母；
• 3.類名：首字母大寫，其餘小寫，多個單詞駝峰命名法；
• 4.方法(函式)名：全部小寫，多個單詞用下劃線分隔；
• 5.引數名：小寫單詞，如果與關鍵詞衝突，引數名前加上下劃線，比如_print;
• 6.變數：小寫，多個單詞用下劃線分隔；
• 7.常量：全部大寫，多個單詞用下劃線分隔；

3) 註釋

Python 使用 # 來進行 單行註釋，多行註釋 的話使用三引號，比如：

'''
這是
Python的
多行註釋
'''
複製程式碼

4) print列印輸出與input輸入函式

學習一門新的程式語言，第一個程式基本都是列印Hello world， 把結果列印到螢幕上，是驗證程式碼執行結果的最直觀體現，所以 有必要先學一波 print 和 input 的用法！

print():

• 1.可以輸出各種亂七八糟型別的資料直接轉成字串列印輸出；
• 2.print預設會換行，如果不換行可以: print(xxx, end = "")
• 3.支援 格式化輸出，和C中的printf用法類似，逗號分隔前後改成**%**：

  

 

input():

從鍵盤讀入一個字串，並自動忽略換行符，所有形式的輸入按字串處理。 可以在括號裡寫一些輸入的提示資訊，比如: input("請輸入一個字串：")

   輸出結果：   

5) help函式

這個就不用說了，很多程式語言都有的，可以用來檢視某個 內建函式(BIF) 的相關用法的，比如help(print)，會輸出這樣的結果：

6) dir函式

檢視物件內所有屬性與方法，只需要把要查詢的物件新增到括號中即可， 比如定義一個類，然後用dir可以獲取所有的屬性與方法：

   部分輸出結果：   

7) 檢視所有內建函式(BIF)

執行：print(dir(sys.modules['builtins'])) 可以列印出所有的內建函式。

8) 多個語句一行與一個語句多行

如果你想把多個語句寫到一行，可以使用**；** (分號)分隔； 有時語句可能太長，你可以使用**\** (反斜槓)來銜接， 而在**[] , {} , ()**裡的不需要使用反斜槓來銜接。

---

5.資料型別

1) 變數

Python3裡定義一個變數非常簡單粗暴，直接一個 變數名 = 初值 賦值時就決定了變數的資料型別，變數名引用了數值的同時也引用 它的型別，如果不理解的話，看下例子就知道了，**type**可以檢視 變數的資料型別(另外還要注意Python對大小寫敏感，區分大小寫！)：

   輸出結果：   

另外Python中**支援多個變數賦值**，以下這兩種賦值寫法是正確的：

a = b = c = 1
a,b,c = 1,2,"Python"
複製程式碼

對了，你還可以使用**del關鍵字刪除物件的引用**，但刪除後再呼叫 變數是會報錯的！

   輸出結果：

2) 數字(Number)

Python3中支援三種數字型別：int，float，complex(複數)

注：Python3中 int 不區分整形與長整形，整數的長度不受限制， 所以很容易進行大數計算。而除了十進位制外的進製表示如下： 二進位制0b，八進位制0o，十六進位制0x 開頭。

Python支援複數直接表示法，就是**(a+bj)的形式，complex類的例項， 可以直接運算，比如：a = 1 + 2j + 3 * 4j，輸出a，結果是：(1+14j)** 實數+虛數，除了a+bj，還可以用**complex(a,b)表示，兩個都是 浮點型，可以呼叫.real獲得實部，.imag** 獲得虛部，abs()求複數 的模(√(a^2 + b^2))。

數字型別轉換：(Python文件中，方括號[]括起來表示為可選)

函式	作用
int(x[,base])	將x轉換為一個整數，第二個引數是指定前面字串的進位制型別
float(x)	將x轉換到一個浮點數
complex(real [,imag])	建立一個複數
str(x)	將物件x轉換為字串
repr(x)	將物件x轉換為表示式字串
eval(str)	用來計算在字串中的有效Python表示式,並返回一個物件
tuple(s)	將序列s轉換為一個元組
list(s)	將序列s轉換為一個列表
chr(x)	將一個整數轉換為一個字元
unichr(x)	將一個整數轉換為Unicode字元
ord(x)	將一個字元轉換為它的整數值
hex(x)	將一個整數轉換為一個十六進位制字串
oct(x)	將一個整數轉換為一個八進位制字串
bin(x)	將一個整數轉換為一個二進位制字串

數學函式：

函式	作用
abs(x)	返回數字的絕對值，如abs(-10) 返回 10
ceil(x)	返回數字的上入整數，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回數字的絕對值，如math.fabs(-10) 返回10.0
floor(x)	返回數字的下舍整數，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10為基數的x的對數，如math.log10(100)返回 2.0
max(x1, x2,...)	返回給定引數的最大值，引數可以為序列。
min(x1, x2,...)	返回給定引數的最小值，引數可以為序列。
modf(x)	返回x的整數部分與小數部分，兩部分的數值符號與x相同， 整數部分以浮點型表示。
pow(x, y)	x的y次方
round(x [,n])	返回浮點數x的四捨五入值，如給出n值，則代表舍入到 小數點後的位數。
sqrt(x)	返回數字x的平方根，數字可以為負數，返回型別為實數， 如math.sqrt(4)返回 2+0j

3) 布林型別(Bool)

用**True和False**來表示真假，也可以當做整數來對待，True為1， False為0，但是不建議用來參與運算！

4) 列表(List)

類似於陣列，有序，內容長度可變，使用中括號[]表示，元素間用逗號分隔， 元素的資料型別可以不一樣！用法示例如下(dir(list)可以檢視所有的屬性與方法j)： (Tip：列表可巢狀，如果想訪問列表中的列表中的某個值可以寫多個[],比如：list1[1][2])

list1 = [1,2.0,"a",True]  # 定義列表
print(list1[1])           # 通過[下標]訪問元素，從0開始，結果輸出：2.0
print(list1[1:3])         # 支援擷取，比如這裡的[1:3]，結果輸出：[2.0, 'a']
print(list1[1:3:2])       # 還可以有第三個引數，步長，預設為1，結果輸出:[2.0]
print(list1[2:])          # 輸出結果：['a', True]
print(list1[-2])          # 負數的話從後面開始訪問，結果輸出：a
print(list1.index("a"))   # 返回引數在列表中的位置，結果輸出：2    

# 修改列表元素
list1[1] = 3.0            # 直接獲得元素後進行修改，此時列表元素：[1, 3.0, 'a', True]

# 新增元素
list1.append('Jay')       # 追加一個元素，此時列表元素：[1, 2.0, 'a', True, 'Jay']
list1.insert(2,'pig')     # 插入一個元素，此時列表元素：[1, 2.0, 'pig', 'a', True]
print(list1.pop())        # 移除最後一個元素，並返回元素的值，結果輸出：True         

# 刪除元素
del list1[0]              # 刪除索引位置的值，此時列表元素：[2.0, 'a', True]
list1.remove('a')         # 刪除指定的元素值，此時列表元素：[1, 2.0, True]

# 其他(使用+號可以組合列表，*號可以重複列表)
print(list1+list1)        # 輸出結果：[1, 2.0, 'a', True, 1, 2.0, 'a', True]
print(list1*2)            # 輸出結果：[1, 2.0, 'a', True, 1, 2.0, 'a', True]
print('a' in list1)       # 判斷列表中是否有此元素，輸出結果：True
print('b' not in list1)   # 判斷原始中是不是沒有這個元素，輸出結果：True
for x in list:            # 迭代遍歷列表
print(len(list1))         # 獲得列表長度，結果輸出：4
print(list1.count(1))     # 統計某個元素在列表中出現的次數，結果輸出：2，因為True的值也是1
max(list1)                # 獲得列表中的元素最大值，列表元素型別需要為數字
min(list1)                # 獲得列表中的元素最小值，列表元素型別需要為數字
list1.sort()              # 對原列表元素進行排序，本地排序(會修改值)，返回None，
                          # 只能比較數字！預設從小到大，從大到小可以用可選引數，括號里加上：
                          # key = lambda x:-1*x
                          
list1.reverse()           # 反轉列表元素，會修改列表，返回None
list2 = list1.copy()      # 拷貝列表，重新開闢了記憶體空間！和等號賦值不一樣！
list(tuple)               # 將元組或字串轉換為列表
複製程式碼

5) 元組(tuple)

受限的列表，元組中的元素不能修改，使用小括號()表示。 有一點要注意的是：當元組中只有一個元素，需要在元素後新增逗號， 否則會當做括號運算子使用！元組可以當做不能修改的引數傳遞給函式， 而且元組所佔用的記憶體較小。使用的話，除了沒有修改元組元素的方法外， 其他的和列表的方法基本一致。

另外元組中的元素不能刪除，但是可以使用del語句來刪除整個元組， 不過比較少用，因為Python回收機制會在這個元組不再被使用時自動刪除 (和Java的gc有點像～) 還可以使用**tuple(list)**將字串或列表轉換為元組。

  輸出結果：  

6) 字典(dict)

和列表，元組通過下標序列來索引元素不同，字典使用**鍵值對的形式來儲存 資料，通過鍵來索引值**，建立字典時，鍵不能重複，重複後面的會覆蓋！ 因為鍵必須不可變，所以鍵可用數字，字串或元組，但是不能用列表！ 使用**冒號:分割鍵與值，多個鍵值對用逗號,**分隔；字典也是支援巢狀的！ 用法示例如下：

dict1 = {}                          # 定義一個空字典
dict2 = {'a': 1, 'b': 2, 3: "c"}    # 定義一個普通字典
dict4 = dict2.copy()                # 淺複製一個字典

# 可以使用fromkeys建立並返回新的字典，有兩個引數，鍵和鍵對應的值
# 值可以不提供，預設None，不過有個小細節要注意，下面的例子輸出
# 的結果是：{1: ['a', 'b', 'c'], 2: ['a', 'b', 'c'], 3: ['a', 'b', 'c']}
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
dict3 = {}
dict3 = dict3.fromkeys(list1, list2)
print(dict3)

# 通過鍵查詢對應的值，如果沒有這個鍵會報錯TypeError，這裡輸出結果：2
print(dict2['b'])    
print(dict2.get("d"))               # 通過get()方法查詢鍵對應的值，沒有的話會返回None
                                    # 還可以加上一個預設的返回引數get(x,y)
print(dict2.setdefault("d"))        # 和get()類似，如果找不到鍵的話會自動新增 鍵:None                     
print("d" in dict2)                 # 字典中是否有此鍵，這裡輸出結果：False
print("d" not in dict2)             # 字典中是否沒有此鍵，這裡輸出結果：True

print(dict2.keys())                 # 返回字典中所有的鍵，這裡輸出結果：dict_keys(['a', 3, 'b'])
print(dict2.values())               # 返回字典中所有的值，這裡輸出結果：dict_values([1, 'c', 2])
print(dict2.items())                # 返回字典中所有的鍵值對，這裡輸出結果：
                                    # dict_items([('a', 1), (3, 'c'), ('b', 2)])

# 修改鍵對應的值，此時字典元素：{3: 'c', 'a': 1, 'b': 'HaHa'}
dict2['b'] = 'HaHa' 
dict2.update(b:'Pig')               # 使用update方法可以更新鍵對應的值，不過鍵需要為字串！

# 刪除字典元素
del(dict2['b'])                     # 刪除某個鍵值對，此時字典元素：{3: 'c', 'a': 1}
dict2.clear()                       # 移除字典中所有的鍵值對，此時剩下空字典：{}
del dict2                           # 刪除整個字典，刪除後無法再重複引用！！！
print(dict2.pop('a'))               # 根據鍵刪除對應的值，返回被刪除的值。
print(dict2.popitem())              # 刪除一個項，隨機，比如：('b', 2)

# 遍歷字典：
for d in dict2:
    print("%s:%s" % (d, dict2.get(d)))
    
for (k,v) in dict2.items():
    print("%s:%s" % (k, v))

複製程式碼

7) 集合(set)

集合中的儲存的元素無序且不重複，所以你無法去索引某個具體的元素； 使用大括號{}包裹元素，逗號分隔，如果有重複的元素會被自動剔除！ 另外有一點要注意的是，如果是建立空集合必須使用set()，而不能用{}， 通過上面我們也知道了**{}的話是直接建立一個空字典**！ 用法示例如下：

set1 = set()  # 建立空集合
set2 = {1, 2, 3, 4, 5, 1}  # 普通方式建立集合
print(set2)  # 重複元素會被自動刪除，輸出結果：{1, 2, 3, 4, 5}

set3 = set('12345')  # 字串
print(set3)  # 輸出：{'2', '5', '3', '4', '1'}，集合元素無序

print(6 in set2)  # 判斷集合中是否有此元素：輸出結果：False
print(6 not in set2)  # 判斷集合中是否有此元素：輸出結果：True

set2.add("6")  # 新增元素
print(set2)  # 輸出結果：{1, 2, 3, 4, 5, '6'}

set2.remove(2)  # 刪除元素，如果刪除的元素不存在會報錯
print(set2)  # 輸出結果：{1, 3, 4, 5, '6'}

# 遍歷集合，輸出結果： 1	3	4	5	6
for data in set2:
    print(data, end="\t")

# 使用frozenset()函式定義不可變集合
set4 = frozenset({1, 2, 3, 4, 5})
複製程式碼

8) 字串

Python裡對處理字串可是日常，熟練掌握字串的處理非常重要。 可以使用**單引號('')或者雙引號("")來修飾字串， 如果想讓字串包含換行縮排等格式時，可以使用三括號('''''')** 來修飾，一般要列印段落文字的時候可以用這個。 另外，字串定義後就不能修改元素了，比如下面str1[0] = 'x'是會報錯的， 只能通過+,*，分片等方式進行拼接，間接得到相同的字串內容，不過卻不是原來 的字元了，變數指向了新的字串，而舊的會被py的回收機制回收掉！

訪問字串：

str1 = "Hello Python"
print(str1[3])                  # 輸出結果：l
print(str1[2:])                 # 輸出結果：llo Python
print(str1[2:5])                # 輸出結果：llo
print(str1[2:10:2])             # 輸出結果：loPt
print(str1[0:8] + str1[8:])     # 輸出結果：Hello Python
str2 = str1[6:] * 3
print(str2)                     # 輸出結果：PythonPythonPython
複製程式碼

轉義字元：

轉義字元	作用	轉義字元	作用	轉義字元	作用
行尾的\	續行符	\\	反斜槓	\'	單引號
\a	響鈴	\b	退格	\e	轉義
\000	空	\n	換行	\v	縱向製表符
\t	橫向製表符	\r	回車	\f	換頁
\o	八進位制數代表字元	\x	十六進位制數代表字元

各種內建方法：

方法名	作用
capitalize()	把字串的第一個字元改為大寫
casefold()	把整個字串的所有字元改為小寫
center(width)	將字串居中，並使用空格填充至長度width的新字串
count(sub[,start[,end]])	返同sub在字元申裡邊出現的次數， start和end參數列示範圍，可選
encode(encoding= 'utf-8 ',errors='strict')	以encoding指定的編碼格式對字串進行編碼
endswith(sub[,start[,end]])	檢查字串是否以sub 子字串結束，如果是返回True， 否則返回False。start和end參數列示範圍，可選
expandtabs([tabsize= 8])	把字串中的tab符號(\t)轉換為空格，如不指定引數， 預設的空格數是tabsize=8
find(sub[,start[,end]])	檢測sub是否包含在字串中，如果有則返回索引值， 否則返回-1,start和end參數列示範圍，可選
index(sub[,start[,end]])	跟find方法一樣，不過如果sub不在string中會產生一個異常
isalnum()	如果字串中至少有一個字元，並且所有字元都是 字母或數字則返回True，否則返回False
isalpha()	如果字串至少有一個字串，並且所有字元都是 字母則返回True，否則返回False
isdecimal()	如果字串只包含十進位制數字則返回True，否則返回False
isdigit()	如果字串只包含數字則返回True，否則返回False
islower()	如果字串中至少包含一個區分大小寫的字元，並且這些字元 都是小寫，則返回True，否則返回False
isnumeric()	如果字串中只包含數字字元，則返回True，否則返回False
isspace()	如果字串中只包含空格，則返回True，否則返回False
istitle()	如果字串是標題化(所有單詞大寫開頭，其餘小寫)， 則返回True，否則返回False
isupper()	如果字串中至少包含一個區分大小寫的字元，並且這些 字元都是大寫，則返回True，否則返回False
join(sub)	以字串作為分隔符，插入到sub中所有的字元之間，使用+去拼接大量 字串的時候是很低效率的，因為加號拼接會引起記憶體賦值一級垃圾回收 操作，此時用join來拼接效率會高一些，比如: ''.join(['Hello','Python'])
ljust(width)	返回一個左對齊的字串，並使用空格填充至長度為width的新字串
lower()	轉換字串所有大寫字元為小寫
lstrip()	去除字串左邊的所有空格
partition(sub)	找到子字串sub，把字串分割成3元組(前，pre，後) 如果字串中不包含則返回('原字串','','')
replace(old, new[,count])	把字串中的old子字串替換成new，如果count指定， 則替換次數不超過count次
rfind(sub[,start[,end]])	和find()方法類似，不過是從右開始查詢
rindex(sub[,start[,end]])	和index()方法類似，不過是從右開始查詢
rjust(width)	返回一個右對齊的字串，並使用空格填充至長度為width的新字串
rpartition(sub)	類似於partition()，不過是從右邊開始查詢
rstrip()	刪除字串末尾的空格
split(sep=None,maxsplit=-1)	不帶引數預設是以空格為分隔符切片字串，如果maxspli引數t 右設定，則僅分隔maxsplit個子字串，返回切片後的子字串拼接的列表
splitlines([keepends])	按照'\n'分隔，返回一個包含各行作為元素的列表，如果keepends引數 指定，則返回前keepends行
startswith(prefix[,start[,end]])	檢查字串是否以prefix開頭，是則返回True，否則返回False。 start和end引數可以指定範圍檢查，可選
strip([chars])	刪除字串前邊和後邊所有的空格，chars引數可定製刪除的字串，可選
swapcase()	反轉字串中的大小寫
title()	返回標題化(所有的單詞都是以大寫開始，其餘字母小寫)的字串
translate(table)	按照table的規則(可由str.maketrans('a','b')定製)轉換字串中的字元
upper()	轉換字串中所有的小寫字元為大寫
zfill(width)	返回長度為width的字串，原字串右對齊，前邊用0填充

字串格式化：

其實就是format方法的使用而已，示例如下：

# 位置引數
str1 = "{0}生{1}，{2}{3}！".format("人","苦短","我用","Python")
print(str1) # 輸出結果：人生苦短，我用Python！

# 關鍵字引數
str1 = "{a}生{c}，{b}{d}！".format(a = "人", c = "苦短",b = "我用",d = "Python")
print(str1) # 輸出結果：人生苦短，我用Python！

# 位置引數可以與關鍵字引數一起使用，不過位置引數需要在關鍵字引數前，否則會報錯！

# 另外還有個叫替換域的東西，冒號代表格式化符號開始，比如下面的例子：
str1 = "{0}:{1:.4}".format("圓周率", 3.1415926)
print(str1) # 輸出結果：圓周率:3.142
複製程式碼

格式化操作符：%，這個就不說了，和上面print()那裡的一致！

9) 運算子

算術操作符：(+ - * / % **(冪，次方) //(地板除法，捨棄小數))

print("3 + 7 = %d" % (3 + 7))   # 輸出結果： 3 + 7 = 10
print("3 - 7 = %d" % (3 - 7))   # 輸出結果： 3 - 7 = -4
print("3 * 7 = %d" % (3 * 7))   # 輸出結果： 3 * 7 = 21
print("7 / 3 = %f" % (7 / 3))   # 輸出結果： 7 / 3 = 2.333333
print("7 %% 3 = %d" % (7 % 3))  # 輸出結果： 7 % 3 = 1
print("3 ** 6 = %d" % (7 ** 3)) # 輸出結果： 3 ** 6 = 343
print("3 // 6 = %f" % (7 // 3)) # 輸出結果： 3 // 6 = 2.000000

複製程式碼

比較運算子：(== != > < >= <=)

賦值運算子：(== += -= *= /= %= **= //=)

位運算子：(&(按位與) |(按位或) ^(異或，不同為1) ~(取反) << >>)

邏輯運算子：(and or not)

成員運算子：(in not in)

身份運算子(判斷是否引用同一個物件)：(is is not)

運算子優先順序：

**(指數)   >   ~ + -(取反，正負號)   >   * / % //(乘除，求餘，地板除)   >   << >>(左右移) >    &(按位與)   >  ^ |(異或，按位或)  >   < <= > >=(比較運算子)   >  等於運算子  >   賦值運算子   >  身份運算子  >  成員運算子  >  邏輯運算子

10) 日期時間

日期時間並不屬於資料結構，只是覺得很常用，索性也在這裡把用法mark下～ 以來的兩個模組是：time 和 datetime，詳細用法示例如下：

import time, datetime

# 獲取當前時間
moment = time.localtime()   
print("年：%s" % moment[0])
print("月：%s" % moment[1])
print("日：%s" % moment[2])
print("時：%s" % moment[3])
print("分：%s" % moment[4])
print("秒：%s" % (moment[5] + 1))
print("周幾：%s" % (moment[6] + 1))
print("一年第幾天：%s" % moment[7])
print("是否為夏令時：%s" % moment[8]) 

# 格式化時間(這裡要注意strftime和strptime是不一樣的！！！)
moment1 = time.strftime('%Y-%m-%d %H:%M:%S')
moment2 = time.strftime('%a %b %d %H:%M:%S %Y', time.localtime())
moment3 = time.mktime(time.strptime(moment2, '%a %b %d %H:%M:%S %Y'))
print(moment1)  # 輸出結果：2017-12-02 11:08:02
print(moment2)  # 輸出結果：Sat Dec 02 11:08:02 2017
print(moment3)  # 輸出結果：1512184082.0   日期轉換為時間戳

# 獲得當前時間戳
print(time.time())  # 輸出結果：1512185208.0942981

# 獲得當前時間(時間陣列，還需strftime格式化下)
print(datetime.datetime.now())  # 輸出結果：2017-12-02 11:34:44.726843

# 時間戳轉換為時間
# 方法一：(輸出結果：2017-12-02 11:08:02)
moment4 = 1512184082
moment5 = time.localtime(moment4)  # 轉換成時間陣列
print(time.strftime('%Y-%m-%d %H:%M:%S', moment5))  # 格式化
# 方法二：
moment6 = datetime.datetime.utcfromtimestamp(moment4)
print(moment6)  # 直接輸出：2017-12-02 03:08:02
moment7 = moment6.strftime('%a %b %d %H:%M:%S %Y')
print(moment7)  # 格式化後輸出：Sat Dec 02 03:08:02 2017

# 延遲執行
time.sleep(秒)

複製程式碼

---

6.流程控制

1) if條件判斷

python中沒有switch-case，另外使用了 elif 代替了else if 每個條件後需要跟一個**冒號(:)，通過縮放**來劃分程式碼塊， 巢狀的時候要注意！使用示例如下：

   輸出結果：

另外，如果條件成立，你又不想做任何事情，可以直接使用**pass空語句**

2) while迴圈

python中沒有do-while，同樣要注意冒號和縮放！ 可以搭配**else使用，還有無限迴圈這種東西：while True:** 使用下面的**break關鍵字可以跳出迴圈**。 使用示例如下：

   輸出結果：

3) for迴圈

和C或者Java那種for迴圈不同，並不能直接寫 for(int a = 0;a < 100;a++) 使用示例如下：

   

輸出結果：

4) break，continue，else

break跳出迴圈；continue跳過餘下操作直接進入下一次迴圈； else也可以使用在迴圈，for迴圈條件不成立時執行，如果先break的話不會執行！

5) 條件表示式(簡化版的if-else)

a = x if 條件 else y

6) 斷言

當**assert關鍵字後面的判斷條件為假的時候，程式自動崩潰並丟擲AssertionErro異常**， 一般在測試程式的時候才會用到，要確保某個條件為真程式才能正常工作的時候使用～

7) 迭代器與生成器

迭代器：用於訪問集合，是一種可以記住遍歷位置的物件，會從第一個元素 開始訪問，直到結束，兩個基本的方法：iter()和next()

   

輸出結果：

生成器

應該叫**生成器函式吧，一種特別的函式，用yield來返回值， 呼叫時會返回一個生成器物件，本質上還是迭代器，只是更加簡潔， yield對應的值在函式呼叫的時候不會立即返回**，只有去呼叫next() 方法的時候才會返回，使用for x in xxx的時候其實呼叫的還是next()方法， 最簡單的使用示例如下：

   輸出結果：   

如果你用type()方法查下，會發現返回的物件型別是：<class 'generator'> 相比起迭代器，生成器更加簡潔優雅，最經典的例子就是實現斐波那契數列：

def func(n):
    a, b = 0, 1
    while n > 0:
        n -= 1
        yield b
        a, b = b, a + b

for i in func(10):
    print(i, end="\t")

# 輸出結果：1 1 2 3 5 8 13 21 34 55 
    
複製程式碼

---

7.函式

對於一些重複使用的程式碼塊，我們可以把他抽取出來寫成一個函式。

1) 函式定義

使用 def關鍵字 修飾，後接函式名與圓括號(傳入引數)， 使用 return關鍵字 返回值，不寫的話預設返回 None值， Python可以動態確定函式型別，返回不同的型別的值，可以利用 列表打包多種型別的值一次性返回，也可以直接用元組返回多個值； 另外函式引數如果有多個的話，可以用**逗號隔開。 還有一個建議是：在函式第一行語句可以選擇性地使用文件字串用於存放 函式說明，直接用三引號註釋**包括即可，通過help方法可以拿到！

2) 形參與實參

定義函式時的引數是形參，呼叫時傳入的是實參；

3) 關鍵字引數

引數有多個的時候，怕引數混淆傳錯，可以在傳入的時候 指定形參的引數名，比如: **show(a = "a", b = "b")**這樣。

4) 預設引數

定義的形參時候賦予預設初值，呼叫時就可以不帶 引數去呼叫函式，比如：def sub(a = "1", b = "2")，呼叫時直接 什麼都傳sub()或者傳入一個引數sub(3)都可以，還可以配合 關鍵字引數指定傳入的是哪個引數。

5) 可變引數

有時傳入的函式引數數目可能是不固定的，比如，要你 計算一組值的和，具體有多少個數字不知道，此時就可以用可變引數了。 只需要在引數前加上***號(其實是把資料打包成了元組)，就代表這個 引數是可變引數；如果有多個引數，寫在可變引數後的引數要用 關鍵字引數指定**，否則會加入可變引數的範疇！！！有打包自然有 解包，如果想把列表或元組當做可變引數傳入，需要在傳入的時候 在實參前加上***號！另外，如果想把引數打包成元組的方式的話， 可以使用兩個星號(****)修飾～

6) 全域性變數與區域性變數

全域性變數就是定義為在最外部的，可以在函式內部進行訪問但不能直接修改； 區域性變數就是定義在函式內部的，而在函式外部無法訪問的引數或變數；

區域性變數無法在外部訪問的原因： Python在執行函式時，會利用棧(Stack)來儲存資料，執行完 函式後，所有資料會被自動刪除。

函式中無法修改全域性變數的原因： 當試圖在函式裡修改全域性變數的值時，Python會自動在函式內部新建一個 名字一樣的區域性變數代替。如果硬是要修改，可以在函式內部使用 global關鍵字 修飾全域性變數，但是不建議這樣做，會使得程式 維護成本的提高。

7) 內部函式

其實就是函式巢狀，一個函式裡巢狀另一個函式，需要注意一點： 內部函式的作用域只在內部函式的直接外部函式內，外部是 無法呼叫的，如果呼叫會報錯的。

8) 閉包

Python中的閉包：如果在一個外部函式中，對外部作用域(非全域性)的變數 進行引用，那麼內部函式就被認為是閉包。簡單的例子如下：

    輸出結果：   

不能在外部函式以外的地方呼叫內部函式，會報方法名未定義。 另外，內部函式也不能直接修改外部函式裡的變數，會報UnboundLocalError錯誤！ 和前面函式裡修改全域性變數的情況一樣，如果硬是要修改的話 可以把外部函式中的變數間接通過容器型別來存放，或者使用 Python3 中提供的**nolocal關鍵字**修飾修改的變數。例子如下：

    輸出結果：    400

9) lambda表示式

在Python中可以使用**lambda關鍵字**來建立匿名函式，直接返回一個函式物件， 不用去糾結起什麼名字，省了定義函式的步驟，從而簡化程式碼的可讀性！ 簡單的對比大小lambda表示式例子如下：

big = lambda x, y: x > y
print("第一個引數比第二個引數大：%s" % big(1, 2))
# 輸出結果：第一個引數比第二個引數大：False
複製程式碼

10) 遞迴

其實就是函式呼叫自身，最簡單的遞迴求和例子如下：

def sum(n):
    if n == 1:
        return 1
    else:
        return n + sum(n - 1)

print("1到100的求和結果是: %d" % sum(100))

# 輸出結果：1到100的求和結果是: 5050
複製程式碼

---

8.異常處理

1) 語法錯誤與執行異常區分

語法錯誤是連編譯器那關都過不了的錯誤，比如if後漏掉:冒號，跑都跑不起來； 執行異常則是程式跑起來後，因為程式的業務邏輯問題引起的程式崩潰，比如除以0；

2) Python中的常見異常

異常	描述資訊
AssertionError	斷言語句失敗
AttributeError	嘗試訪問未知的物件屬性
IndexError	索引超出序列的範圍
keyError	字典中查詢一個不存在的Key
NameError	嘗試訪問一個不存在的變數
OSError	作業系統產生的異常，比如FileNotFoundError
SyntaxError	Python語法錯誤
TypeError	不同型別間的無效操作
ZeroDivisionError	除數為0
IOError	輸入輸出錯誤
ValueError	函式傳參型別錯誤

3) 異常捕獲

try-expect-else語句，try-finally語句

# 1.最簡單的，try捕獲了任何異常，直接丟給except後的程式碼塊處理：
try:
    result = 1 / 0
except:
    print("捕獲到異常了!")  # 輸出：捕獲到異常了!
    
    
# 2.捕獲特定型別：
try:
    result = 1 / 0
except ZeroDivisionError:
    print("捕獲到除數為零的錯誤")   # 輸出：捕獲到除數為零的錯誤
    
    
# 3.針對不同的異常設定多個except
try:
    sum = 1 + '2'
    result = 1 / 0
except TypeError as reason:
    print("型別出錯：" + str(reason))
except ZeroDivisionError as reason:
    print("除數為0：" + str(reason))    
# 輸出：型別出錯：unsupported operand type(s) for +: 'int' and 'str'


# 4.對多個異常統一處理
try:
    result = 1 / 0
    sum = 1 + '2'
except (TypeError, ZeroDivisionError) as reason:
    print(str(reason))  # 輸出：division by zero


# 5.當沒有檢測到異常時才執行的程式碼塊，可以用else
try:
    result = 4 / 2
except ZeroDivisionError as reason:
    print(str(reason))
else:
    print("沒有發生異常，輸出結果：%d" % result)
# 輸出：沒有發生異常，輸出結果：2


# 6.無論是否發生異常都會執行的一段程式碼塊，比如io流關閉，
# 可以使用finally子句，如果發生異常先走except子句，後走finally子句。
try:
    result = 4 / 2
except ZeroDivisionError as reason:
    print(str(reason))
else:
    print("沒有發生異常，輸出結果：%d" % result)
finally:
    print("無論是否發生異常都會執行～")
# 輸出結果：
# 沒有發生異常，輸出結果：2
# 無論是否發生異常都會執行～

複製程式碼

4) 丟擲異常

使用**raise語句可以直接丟擲異常，比如raise TypeError(異常解釋，可選)**

5) 上下文管理-with語句

當你的異常捕獲程式碼僅僅是為了保證共享資源(檔案，資料等)的唯一分配， 並在任務結束後釋放掉它，那麼可以使用**with語句**，例子如下：

try:
    with open('123.txt', "w") as f:
        for line in f:
            print(line)
except OSError as reason:
    print("發生異常：" + str(reason))

# 輸出結果：發生異常：not readable
複製程式碼

6) sys.exc_info 函式

除了上面獲取異常資訊的方式外，還可以通過sys模組的exc_info() 函式獲得： 示例如下：

# 輸出結果依次是：異常類，類示例，跟蹤記錄物件
try:
    result = 1 / 0
except:
    import sys
    tuple_exception = sys.exc_info()
    
for i in tuple_exception:
    print(i)
    
# 輸出結果：
# <class 'ZeroDivisionError'>
# division by zero
# <traceback object at 0x7f3560c05808>

複製程式碼

---

9.檔案儲存

1) open函式與檔案開啟模式

Python中讀寫檔案非常簡單，通過**open()函式** 可以開啟檔案並 返回檔案物件使用help命令可以知道，open函式有好幾個引數：

作為初學者，暫時瞭解前兩個引數就夠了： file引數：檔名，不帶路徑的話會在當前資料夾中查詢； mode：開啟模式，有以下幾種開啟方式：

模式	作用
r	只讀模式開啟，預設
w	寫模式開啟，若檔案存在，先刪除，然後重新建立
a	追加模式開啟，追加到檔案末尾，seek()指向其他地方也沒用，檔案不存在，自動建立
b	二進位制模式開啟
t	文字模式開啟，預設
+	可讀寫模式，可配合其他模式使用，比如r+，w+
x	如果檔案已存在，用此模式開啟會引發異常
U	通用換行符支援

2) 檔案物件的方法

函式	作用
close()	關閉檔案，關閉後檔案不能再進行讀寫操作
read(size=-1)	從檔案讀取指定的位元組數，如果未設定或為負數，讀取所有
next()	返回檔案下一行
readline()	讀取整行，包括換行符'\n'
seek(offset, from)	設定當前檔案指標的位置，從from(0檔案起始位置，1當前位置， 2檔案末尾)偏移offset個位元組
tell()	返回檔案的當前位置
write(str)	將字串寫入檔案
writelines(seq)	寫入一個序列字串列表，如果要換行，需要自己加入每行的換行符

3) 使用例子

# 讀取123.txt檔案裡的內容列印，同時寫入到321.txt中
try:
    f1 = open("321.txt", "w")
    with open("123.txt", "r") as f2:
        for line in f2:
            print(line, end="")
            f1.write(line)

except OSError as reason:
    print("發生異常" + str(reason))
finally:
    f1.close()  # 用完要關閉檔案，f2不用是因為用了with
複製程式碼

輸出結果：

    

4) OS模組中關於檔案/目錄的常用函式

需要匯入os模組，使用的時候需加上模組引用，比如os.getcwd()

函式	作用
getcwd()	返回當前工作目錄
chdir(path)	改變當前工作目錄
listdir(path='.')	不寫引數預設列舉當前目錄下所有檔案和資料夾，'.'當前目錄，'..'上一層目錄
mkdir(path)	建立資料夾，若存在會丟擲FileExistsError異常
mkdirs(path)	可用於建立多層目錄
remove(path)	刪除指定檔案
rmdir(path)	刪除目錄
removedirs(path)	刪除多層目錄
rename(old,new)	重新命名檔案或資料夾
system(command)	呼叫系統提供的小工具，比如計算器
walk(top)	遍歷top引數指定路徑下所有子目錄，返回一個三元組(路徑，[包含目錄]，[包含檔案])
curdir	當前目錄(.)
pardir	上一節目錄(..)
sep	路徑分隔符，Win下是'\'，Linux下是'/'
linesep	當前平臺使用的行終止符，win下是'\r\n'，Linux下是'\n'
name	當前使用的作業系統

os.path模組(檔案路徑相關)

函式	作用
dirname(path)	獲得路徑名
basename(path)	獲得檔名
join(path1[,path2[,...]])	將路徑名與檔名拼接成一個完整路徑
split(path)	分割路徑與檔名，返回元組(f_path, f_name)，如果完全使用目錄， 它也會將最後一個目錄作為檔名分離，且不會判斷檔案或目錄是否存在
splitext(path)	分隔檔名與副檔名
getsize(file)	獲得檔案大小，單位是位元組
getatime(file)	獲得檔案最近訪問時間，返回的是浮點型秒數
getctime(file)	獲得檔案的建立時間，返回的是浮點型秒數
getmtime(file)	獲得檔案的修改時間，返回的是浮點型秒數
exists(path)	判斷路徑(檔案或目錄)是否存在
isabs(path)	判斷是否為決定路徑
isdir(path)	判斷是否存在且是一個目錄
isfile(path)	判斷是否存在且是一個檔案
islink(path)	判斷是否存在且是一個符號連結
ismount(path)	判斷是否存在且是一個掛載點
samefile(path1,path2)	判斷兩個路徑是否指向同一個檔案

---

10.類與物件

1) 最簡單的例子

PS：Python中沒有像其他語言一樣有public或者private的關鍵字 來區分公有還是私有，預設公有，如果你想定義私有屬性或者函式， 命名的時候在前面加上兩下劃線__即可，其實是偽私有，內部 採用的是名字改編技術，改成了**_類名__私有屬性/方法名，比如 下面呼叫people._Person__skill**，是可以訪問到私有成員的！ 類中的屬性是靜態變數。

輸出結果：

2) __init__(self) 構造方法

例項化物件的時候會自動呼叫，當你想傳參的時候可以用它～

輸出結果：

3) 繼承

規則如下：

• 1.繼承寫法: class 子類(父類):
• 2.子類可以繼承父類的所有屬性與方法；
• 3.子類定義與父類同名的屬性與方法會自動覆蓋;
• 4.重寫時如果想呼叫父類的同名方法可以使用**super()函式.** 方法名呼叫;

Python支援多繼承，多個父類用逗號隔開，子類可同時繼承多個父類的 屬性與方法多繼承的時候如果父類們中有相同的方法，呼叫的順序是 誰在前面先呼叫那個父類中的方法，比如有class Person(Name, Sex，Age)， 三個父類裡都有一個show的方法，那麼子類呼叫的是Name裡的show()! 如果不是得用多繼承不可的話，應該儘量避免使用它，有時會出現 一些不可遇見的BUG。

還有一種叫組合的套路，就是在把需要用到的類丟到組合類中 例項化，然後使用，比如把Book，Phone，Wallet放到Bag裡：

輸出結果：

4) 與物件相關的一些內建函式

函式	作用
issubclass(class, classinfo)	如果第一個引數是第二個引數的子類，返回True，否則返回False
isinstance(object, classinfo)	如果第一個引數是第二個引數的例項物件，返回True，否則返回False
hasattr(object, name)	測試一個物件中是否有指定的屬性，屬性名要用引號括著！
getattr(object, name, [,default])	返回物件的指定屬性值，不存在返回default值，沒設會報ArttributeError異常
setattr(object, name, value)	設定物件中指定屬性的值，屬性不存在會新建並賦值
delattr(object, name)	刪除物件中的指定屬性的值，不存在會報報ArttributeError異常
property(fget,fset,fdel,doc)	返回一個可以設定屬性的屬性

---

11.模組

1) 匯入模組

儲存為**.py字尾的檔案都是一個獨立的模組，比如有a.py和b.py檔案， 你可以在a中import b，然後就可以使用b.py中的函式了。 模組匯入規則4.1 導包**處就寫得詳細了，此處就不重複描述了。

2) 指定模組

匯入其他模組的時候，測試部分的程式碼也會執行，可以通過 __name__告訴Python該模組是作為程式執行還是匯入到其他程式中。 作為程式執行時該屬性的值是__main__，只有單獨執行的時候才會執行。 比如:

if __name__ == '__main__':
    test()
複製程式碼

3) 搜尋路徑

Python模組的匯入會有一個路徑搜尋的過程，如果這些搜尋路徑都找不到的話， 會報ImportError，可以通過列印sys.path可以看到這些搜尋路徑，比如我的：

如果你的模組都不在這些路徑裡，就會報錯，當然也可以通過 sys.path.append("路徑") 把路徑新增到搜尋路徑中！

4) 下載安裝第三方庫

方法一：Pycharm直接安裝

File -> Default Settings -> Project Interpreter -> 選擇當前Python版本 可以看到當前安裝的所有第三庫，點+號進入庫搜尋，在搜尋頁找到想要的 庫後勾選點選Install Package即可，點-號可以解除安裝不需要的庫。

方法二：命令列使用pip命令安裝

pip在Python3裡就自帶了，在Python安裝目錄的Scripts資料夾下， win上需要配置下環境變數才能使用：

Path後面加上這個路徑即可：

pip install 庫名                # 安裝
python3 -m pip install 庫名     # 作用同上，可以區分python2和python3而已
pip install --upgrade pip      # 更新pip
pip uninstall 庫名             # 解除安裝庫
pip list                      # 檢視已安裝庫列表
複製程式碼

5) 讓別人使用你的模組

當你開始學爬蟲，電腦會慢慢多很多妹子圖，別問我為什麼... 一些小夥伴看到會問你拿U盤拷，授之以魚不如授之以漁，直接把 自己寫的爬小姐姐的Py檔案讓他自己跑，不更好～讓他裝玩Python3 配置好環境變數，直接命令列執行Python xxx.py是會報模組找 不到的，你的小夥伴僅僅是對小姐姐有興趣，對Py學習沒什麼 興趣，你不可能讓他pip命令一個個裝，可不可以匯出一個依賴 檔案的東西，執行以下自動安裝模組呢？答案肯定是可以的：

先pip命令安裝一波：pipreqs：pip install pipreqs 安裝完後開啟終端，cd到需要匯出的專案，鍵入：

pipreqs 匯出到哪個目錄
複製程式碼

就可以匯出一個requirements.txt檔案了，檔案裡就是你專案 用到的需要另外安裝的Py庫了，把這個檔案發給你的小夥伴，讓他 命令列執行：

pip install -r requirements.txt
複製程式碼

執行後把庫裝上就基本：

另外，如果是你想把自己Python環境裡的所有包都遷移到另一臺電腦 可以使用：

pip freeze > requirements.txt
複製程式碼

---

結語

呼，歷時兩週，總算把Python的基礎知識過了一遍，當然肯定是會有遺漏的 後面想到再補上吧，擼基本知識是挺乏味的，期待後續爬蟲學習～

---

來啊，Py交易啊

想加群一起學習Py的可以加下，智障機器人小Pig，驗證資訊裡包含： Python，python，py，Py，加群，交易，屁眼 中的一個關鍵詞即可通過；

驗證通過後回覆 加群 即可獲得加群連結(不要把機器人玩壞了！！！)～～～ 歡迎各種像我一樣的Py初學者，Py大神加入，一起愉快地交流學♂習，van♂轉py。

---