Python 3 入門基礎知識，小白的福利，讓你0基礎入門
關注頭條號，私信回覆資料會有意外驚喜呦………………最後一張照片有資料呦。
簡介
Python 是一種高層次的結合瞭解釋性、編譯性、互動性和麵向物件的指令碼語言。
Python 由 Guido van Rossum 於 1989 年底在荷蘭國家數學和計算機科學研究所發明，第一個公開發行版發行於 1991 年。
特點
易於學習
：Python 有相對較少的關鍵字，結構簡單，和一個明確定義的語法，學習起來更加簡單。
易於閱讀
：Python 程式碼定義的更清晰。
易於維護
：Python 的成功在於它的原始碼是相當容易維護的。
一個廣泛的標準庫
：Python 的最大的優勢之一是豐富的庫，跨平臺的，在 UNIX，Windows 和 macOS 相容很好。
互動模式
：互動模式的支援，您可以從終端輸入執行程式碼並獲得結果的語言，互動的測試和除錯程式碼片斷。
可移植
：基於其開放原始碼的特性，Python 已經被移植（也就是使其工作）到許多平臺。
可擴充套件
：如果你需要一段執行很快的關鍵程式碼，或者是想要編寫一些不願開放的演算法，你可以使用 C 或 C++ 完成那部分程式，然後從你的 Python 程式中呼叫。
資料庫
：Python 提供所有主要的商業資料庫的介面。
GUI 程式設計
：Python 支援 GUI 可以建立和移植到許多系統呼叫。
可嵌入
：你可以將 Python 嵌入到 C/C++ 程式，讓你的程式的使用者獲得”指令碼化”的能力。
面向物件
：Python 是強面向物件的語言，程式中任何內容統稱為物件，包括數字、字串、函式等。
基礎語法
執行 Python
互動式直譯器
在命令列視窗執行python後，進入 Python 的互動式直譯器。
exit（） 或 Ctrl + D 組合鍵退出互動式直譯器。
命令列指令碼
在命令列視窗執行python script-file。py，以執行 Python 指令碼檔案。
指定直譯器
如果在 Python 指令碼檔案首行輸入#！/usr/bin/env python，那麼可以在命令列視窗中執行/path/to/script-file。py以執行該指令碼檔案。
注：該方法不支援 Windows 環境。
編碼
預設情況下，3。x 原始碼檔案都是 UTF-8 編碼，字串都是 Unicode 字元。
也可以手動指定檔案編碼：
# -*- coding： utf-8 -*-
或者
# encoding： utf-8
注意
： 該行標註必須位於檔案第一行。
識別符號
第一個字元必須是英文字母或下劃線 _ 。
識別符號的其他的部分由字母、數字和下劃線組成。
識別符號對大小寫敏感。
注：從 3。x 開始，非 ASCII 識別符號也是允許的，但不建議。
保留字
保留字即關鍵字，我們不能把它們用作任何識別符號名稱。
Python 的標準庫提供了一個 keyword 模組，可以輸出當前版本的所有關鍵字：
>>> import keyword
>>> keyword。kwlist
［‘False’， ‘None’， ‘True’， ‘and’， ‘as’， ‘assert’， ‘break’， ‘class’， ‘continue’， ‘def’， ‘del’， ‘elif’， ‘else’， ‘except’， ‘finally’， ‘for’， ‘from’， ‘global’， ‘if’， ‘import’， ‘in’， ‘is’， ‘lambda’， ‘nonlocal’， ‘not’， ‘or’， ‘pass’， ‘raise’， ‘return’， ‘try’， ‘while’， ‘with’， ‘yield’］
註釋
單行註釋採用#，多行註釋採用‘’‘或“”“。
# 這是單行註釋
’‘’
這是多行註釋
這是多行註釋
‘’‘
”“”
這也是多行註釋
這也是多行註釋
“”“
行與縮排
Python 最具特色的就是使用縮排來表示程式碼塊，不需要使用大括號 {}。
縮排的空格數是可變的，但是同一個程式碼塊的語句必須包含相同的縮排空格數，縮排不一致，會導致執行錯誤。
多行語句
Python 通常是一行寫完一條語句。
但如果語句很長，我們可以使用反斜槓\來實現多行語句。
total = item_one + \
item_two + \
item_three
在 ［］， {}， 或 （） 中的多行語句，不需要使用反斜槓\。
空行
函式之間或類的方法之間用空行分隔，表示一段新的程式碼的開始。
類和函式入口之間也用一行空行分隔，以突出函式入口的開始。
空行與程式碼縮排不同，空行並不是 Python 語法的一部分。
書寫時不插入空行，Python 直譯器執行也不會出錯。
但是空行的作用在於分隔兩段不同功能或含義的程式碼，便於日後程式碼的維護或重構。
記住
：空行也是程式程式碼的一部分。
等待使用者輸入
input函式
可以實現等待並接收命令列中的使用者輸入。
content = input（”\n\n請輸入點東西並按 Enter 鍵\n“）
print（content）
同一行寫多條語句
Python 可以在同一行中使用多條語句，語句之間使用分號；分割。
import sys； x = ’hello world‘； sys。stdout。write（x + ’\n‘）
多個語句構成程式碼組
縮排相同的一組語句構成一個程式碼塊，我們稱之程式碼組。
像
if、while、def
和
class
這樣的複合語句，首行以關鍵字開始，以冒號：結束，該行之後的一行或多行程式碼構成程式碼組。
我們將首行及後面的程式碼組
稱為
一個子句（clause）。
print 輸出
print 預設輸出是換行的，如果要實現不換行需要在變數末尾加上
end=""
或別的非換行符字串：
print（’123‘） # 預設換行
print（’123‘， end = ”“） # 不換行
import 與 from…import
在 Python 用
import
或者
from...import
來匯入相應的模組。
將整個模組匯入，格式為：
import module_name
從某個模組中匯入某個函式，格式為：
from module_name import func1
從某個模組中匯入多個函式，格式為：
from module_name import func1, func2, func3
將某個模組中的全部函式匯入，格式為：
from module_name import *
運算子
算術運算子
運算子描述+加-減*乘/除%取模**冪//取整除
比較運算子
運算子描述==等於！=不等於>大於<小於>=大於等於<=小於等於
賦值運算子
運算子描述=簡單的賦值運算子+=加法賦值運算子-=減法賦值運算子*=乘法賦值運算子/=除法賦值運算子%=取模賦值運算子**=冪賦值運算子//=取整除賦值運算子
位運算子
邏輯運算子
成員運算子
身份運算子
運算子優先順序
具有相同優先順序的運算子將從左至右的方式依次進行，用小括號（）可以改變運算順序。
變數
變數在使用前必須先”定義”（即賦予變數一個值），否則會報錯：
>>> name
Traceback （most recent call last）：
File ”
NameError： name ’name‘ is not defined
資料型別
布林(bool)
只有
True
和
False
兩個值，表示真或假。
數字(number)
整型(int)
整數值，可正數亦可複數，無小數。
3。x 整型是沒有限制大小的，可以當作 Long 型別使用，所以 3。x 沒有 2。x 的 Long 型別。
浮點型(float)
浮點型由整數部分與小數部分組成。
浮點型也可以使用科學計數法表示（2。5e2 = 2。5 x 10^2 = 250）
複數(complex)
複數由實數部分和虛數部分構成，可以用a + bj，或者complex（a，b）表示。
複數的實部 a 和虛部 b 都是浮點型。
數字運算
不同型別的數字混合運算時會將整數轉換為浮點數
在不同的機器上浮點運算的結果可能會不一樣
在整數除法中，除法 / 總是返回一個浮點數。
如果只想得到整數的結果，丟棄可能的分數部分，可以使用運算子 //。
// 得到的並不一定是整數型別的數，它與分母分子的資料型別有關係。
在互動模式中，最後被輸出的表示式結果被賦值給變數 _，_ 是個只讀變數
字串(string)
單引號和雙引號使用完全相同。
使用三引號（’‘’或”“”）可以指定一個多行字串。
轉義符（反斜槓\）可以用來轉義，使用r可以讓反斜槓不發生轉義。
如r“this is a line with \n”，則\n會顯示，並不是換行。
按字面意義級聯字串。
如“this ” “is ” “string”會被自動轉換為this is string。
字串可以用 + 運算子連線在一起，用 * 運算子重複。
字串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始。
字串不能改變。
沒有單獨的字元型別，一個字元就是長度為 1 的字串。
字串的擷取的語法格式如下：變數［頭下標：尾下標］。
跳脫字元
字串運算子
多行字串
用三引號（‘’‘ 或 “”“）包裹字串內容
多行字串內容支援轉義符，用法與單雙引號一樣
三引號包裹的內容，有變數接收或操作即字串，否則就是多行註釋
例項：
string = ’‘’
print（\tmath。fabs（-10））
print（\nrandom。choice（li））
‘’‘
print（string）
輸出：
print（ math。fabs（-10））
print（
random。choice（li））
Unicode
在 2。x 中，普通字串是以 8 位 ASCII 碼進行儲存的。
而 Unicode 字串則儲存為 16 位 Unicode 字串，這樣能夠表示更多的字符集。
使用的語法是在字串前面加上字首 u。
在 3。x 中，所有的字串都是 Unicode 字串。
位元組(bytes)
在 3。x 中，字串和二進位制資料完全區分開。
文字總是 Unicode，由 str 型別表示，二進位制資料則由 bytes 型別表示。
Python 3 不會以任意隱式的方式混用 str 和 bytes，你不能拼接字串和位元組流，也無法在位元組流裡搜尋字串（反之亦然），也不能將字串傳入引數為位元組流的函式（反之亦然）。
bytes 型別與 str 型別，二者的方法僅有 encode（） 和 decode（） 不同。
bytes 型別資料需在常規的 str 型別前加個 b 以示區分，例如 b’abc‘。
只有在需要將 str 編碼（encode）成 bytes 的時候。
比如：透過網路傳輸資料；或者需要將 bytes 解碼（decode）成 str 的時候， 我們才會關注 str 和 bytes 的區別。
bytes 轉 str：
b’abc‘。decode（）
str（b’abc‘）
str（b’abc‘， encoding=’utf-8‘）
str 轉 bytes：
’中國‘。encode（）
bytes（’中國‘， encoding=’utf-8‘）
列表(list)
列表是一種無序的、可重複的資料序列，可以隨時新增、刪除其中的元素。
列表頁的每個元素都分配一個數字索引，從 0 開始。
列表使用方括號建立，使用逗號分隔元素。
列表元素值可以是任意型別，包括變數。
使用方括號對列表進行元素訪問、切片、修改、刪除等操作，開閉合區間為［）形式。
列表的元素訪問可以巢狀。
方括號內可以是任意表達式。
建立列表
hello = （1， 2， 3）
li = ［1， ”2“， ［3， ’a‘］， （1， 3）， hello］
訪問元素
li = ［1， ”2“， ［3， ’a‘］， （1， 3）］
print（li［3］） # （1， 3）
print（li［-2］） # ［3， ’a‘］
切片訪問
格式： list_name［begin：end：step］ begin 表示起始位置（預設為0），end 表示結束位置（預設為最後一個元素），step 表示步長（預設為1）。
hello = （1， 2， 3）
li = ［1， ”2“， ［3， ’a‘］， （1， 3）， hello］
print（li） # ［1， ’2‘， ［3， ’a‘］， （1， 3）， （1， 2， 3）］
print（li［1：2］） # ［’2‘］
print（li［：2］） # ［1， ’2‘］
print（li［：］） # ［1， ’2‘， ［3， ’a‘］， （1， 3）， （1， 2， 3）］
print（li［2：］） # ［［3， ’a‘］， （1， 3）， （1， 2， 3）］
print（li［1：-1：2］） # ［’2‘， （1， 3）］
訪問內嵌 list 的元素：
li = ［0， 1， 2， 3， 4， 5， 6， 7， 8， 9， ［’a‘， ’b‘， ’c‘］］
print（li［1：-1：2］［1：3］） # （3， 5）
print（li［-1］［1：3］） # ［’b‘， ’c‘］
print（li［-1］［1］） # b
修改列表
透過使用方括號，可以非常靈活的對列表的元素進行修改、替換、刪除等操作。
li = ［0， 1， 2， 3， 4， 5］
li［len（li） - 2］ = 22 # 修改 ［0， 1， 2， 22， 4， 5］
li［3］ = 33 # 修改 ［0， 1， 2， 33， 4， 5］
li［1：-1］ = ［9， 9］ # 替換 ［0， 9， 9， 5］
li［1：-1］ = ［］ # 刪除 ［0， 5］
刪除元素
可以用 del 語句來刪除列表的指定範圍的元素。
li = ［0， 1， 2， 3， 4， 5］
del li［3］ # ［0， 1， 2， 4， 5］
del li［2：-1］ # ［0， 1， 5］
列表運算子
+ 用於合併列表。
* 用於重複列表元素。
in 用於判斷元素是否存在於列表中。
for 。。。 in 。。。 用於遍歷列表元素。
［1， 2， 3］ + ［3， 4， 5］ # ［1， 2， 3， 3， 4， 5］
［1， 2， 3］ * 2 # ［1， 2， 3， 1， 2， 3］
3 in ［1， 2， 3］ # True
for x in ［1， 2， 3］： print（x） # 1 2 3
列表函式
len(list)
列表元素個數
max(list)
列表元素中的最大值
min(list)
列表元素中的最小值
list(seq)
將元組轉換為列表
li = ［0， 1， 5］
max（li） # 5
len（li） # 3
注:
對列表使用 max/min 函式，2。x 中對元素值型別無要求，3。x 則要求元素值型別必須一致。
列表方法
list.append(obj)
在列表末尾新增新的物件
list.count(obj)
返回元素在列表中出現的次數
list.extend(seq)
在列表末尾一次性追加另一個序列中的多個值
list.index(obj)
返回查詢物件的索引位置，如果沒有找到物件則丟擲異常
list.insert(index, obj)
將指定物件插入列表的指定位置
list.pop([index=-1]])
移除列表中的一個元素（預設最後一個元素），並且返回該元素的值
list.remove(obj)
移除列表中某個值的第一個匹配項
list.reverse()
反向排序列表的元素
list.sort(cmp=None, key=None, reverse=False)
對原列表進行排序，如果指定引數，則使用比較函式指定的比較函式
list.clear()
清空列表 還可以使用 del list［：］、li = ［］ 等方式實現
list.copy()
複製列表 預設使用等號賦值給另一個變數，實際上是引用列表變數。如果要實現
列表推導式
列表推導式提供了從序列建立列表的簡單途徑。
通常應用程式將一些操作應用於某個序列的每個元素，用其獲得的結果作為生成新列表的元素，或者根據確定的判定條件建立子序列。
每個列表推導式都在 for 之後跟一個表示式，然後有零到多個 for 或 if 子句。
返回結果是一個根據表達從其後的 for 和 if 上下文環境中生成出來的列表。
如果希望表示式推匯出一個元組，就必須使用括號。
將列表中每個數值乘三，獲得一個新的列表：
vec = ［2， 4， 6］
［（x， x**2） for x in vec］
# ［（2， 4）， （4， 16）， （6， 36）］
對序列裡每一個元素逐個呼叫某方法：
freshfruit = ［’ banana‘， ’ loganberry ‘， ’passion fruit ‘］
［weapon。strip（） for weapon in freshfruit］
# ［’banana‘， ’loganberry‘， ’passion fruit‘］
用 if 子句作為過濾器：
vec = ［2， 4， 6］
［3*x for x in vec if x > 3］
# ［12， 18］
vec1 = ［2， 4， 6］
vec2 = ［4， 3， -9］
［x*y for x in vec1 for y in vec2］
# ［8， 6， -18， 16， 12， -36， 24， 18， -54］
［vec1［i］*vec2［i］ for i in range（len（vec1））］
# ［8， 12， -54］
列表巢狀解析：
matrix = ［
［1， 2， 3］，
［4， 5， 6］，
［7， 8， 9］，
］
new_matrix = ［［row［i］ for row in matrix］ for i in range（len（matrix［0］））］
print（new_matrix）
# ［［1， 4， 7］， ［2， 5， 8］， ［3， 6， 9］］
元組(tuple)
元組與列表類似，不同之處在於元組的元素不能修改
元組使用小括號，列表使用方括號
元組建立很簡單，只需要在括號中新增元素，並使用逗號隔開即可
沒有 append（），insert（） 這樣進行修改的方法，其他方法都與列表一樣
字典中的鍵必須是唯一的同時不可變的，值則沒有限制
元組中只包含一個元素時，需要在元素後面新增逗號，否則括號會被當作運算子使用
訪問元組
訪問元組的方式與列表是一致的。
元組的元素可以直接賦值給多個變數，但變數數必須與元素數量一致。
a， b， c = （1， 2， 3）
print（a， b， c）
組合元組
元組中的元素值是不允許修改的，但我們可以對元組進行連線組合。
tup1 = （12， 34。56）；
tup2 = （’abc‘， ’xyz‘）
tup3 = tup1 + tup2；
print （tup3）
# （12， 34。56， ’abc‘， ’xyz‘）
刪除元組
元組中的元素值是不允許刪除的，但我們可以使用 del 語句來刪除整個元組
元組函式
len（tuple） 元組元素個數
max（tuple） 元組元素中的最大值
min（tuple） 元組元素中的最小值
tuple（tuple） 將列表轉換為元組
元組推導式
t = 1， 2， 3
print（t）
# （1， 2， 3）
u = t， （3， 4， 5）
print（u）
# （（1， 2， 3）， （3， 4， 5））
字典(dict)
字典是另一種可變容器模型，可儲存任意型別物件
字典的每個鍵值（key=>value）對用冒號（：）分割，每個對之間用逗號（，）分割，整個字典包括在花括號（{}）中
鍵必須是唯一的，但值則不必
值可以是任意資料型別
鍵必須是不可變的，例如：數字、字串、元組可以，但列表就不行
如果用字典裡沒有的鍵訪問資料，會報錯
字典的元素沒有順序，不能透過下標引用元素，透過鍵來引用
字典內部存放的順序和 key 放入的順序是沒有關係的
格式如下：
d = {key1 ： value1， key2 ： value2 }
訪問字典
dis = {’a‘： 1， ’b‘： ［1， 2， 3］}
print（dis［’b‘］［2］）
修改字典
dis = {’a‘： 1， ’b‘： ［1， 2， 3］， 9： {’name‘： ’hello‘}}
dis［9］［’name‘］ = 999
print（dis）
# {’a‘： 1， 9： {’name‘： 999}， ’b‘： ［1， 2， 3］}
刪除字典
用 del 語句刪除字典或字典的元素。
dis = {’a‘： 1， ’b‘： ［1， 2， 3］， 9： {’name‘： ’hello‘}}
del dis［9］［’name‘］
print（dis）
del dis # 刪除字典
# {’a‘： 1， 9： {}， ’b‘： ［1， 2， 3］}
字典函式
len（dict） 計算字典元素個數，即鍵的總數
str（dict） 輸出字典，以可列印的字串表示
type（variable） 返回輸入的變數型別，如果變數是字典就返回字典型別
key in dict 判斷鍵是否存在於字典中
字典方法
dict。clear（）
刪除字典內所有元素
dict。copy（）
返回一個字典的淺複製
dict。fromkeys（seq［， value］）
建立一個新字典，以序列 seq 中元素做字典的鍵，value 為字典所有鍵對應的初始值
dict。get（key， default=None）
返回指定鍵的值，如果值不在字典中返回預設值
dict。items（）
以列表形式返回可遍歷的（鍵， 值）元組陣列
dict。keys（）
以列表返回一個字典所有的鍵
dict。values（）
以列表返回字典中的所有值
dict。setdefault（key， default=None）
如果 key 在字典中，返回對應的值。
如果不在字典中，則插入 key 及設定的預設值 default，並返回 default ，default 預設值為 None。
dict。update（dict2）
把字典引數 dict2 的鍵/值對更新到字典 dict 裡
dic1 = {’a‘： ’a‘}
dic2 = {9： 9， ’a‘： ’b‘}
dic1。update（dic2）
print（dic1）
# {’a‘： ’b‘， 9： 9}
dict。pop（key［，default］）
刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key 值必須給出，否則返回 default 值。
dict。popitem（）
隨機返回並刪除字典中的一對鍵和值（一般刪除末尾對）
字典推導式
建構函式 dict（） 直接從鍵值對元組列表中構建字典。如果有固定的模式，列表推導式指定特定的鍵值對：
>>> dict（［（’sape‘， 4139）， （’guido‘， 4127）， （’jack‘， 4098）］）
{’sape‘： 4139， ’jack‘： 4098， ’guido‘： 4127}
此外，字典推導可以用來建立任意鍵和值的表示式詞典：
>>> {x： x**2 for x in （2， 4， 6）}
{2： 4， 4： 16， 6： 36}
如果關鍵字只是簡單的字串，使用關鍵字引數指定鍵值對有時候更方便：
>>> dict（sape=4139， guido=4127， jack=4098）
{’sape‘： 4139， ’jack‘： 4098， ’guido‘： 4127}
很多人在問，學習Python讀什麼書，這其實是一個非常通用的問題，學習分為三種方式：看書、上課，而讀書學習是最實惠也是最高效的一種，小編整理了一些Python高分書籍給大家，從0基礎到高階適合不同學習階段，希望大家學習愉快。獲取方式：點選小編頭像，關注後私信回覆“資料”即可下載。
