大家好~我是李拜天，一個希望每天都是禮拜天的程式員，
我最近在整理以前的一些東西，無意間發現我當時學Python的筆記本，翻了一下發現筆記還挺詳細，我就想分享給大家，
我根據我筆記肝出萬字Python知識點大總結！
文章篇幅有點長，能堅持看完就看完，看不完可以收藏慢慢看！
一、Python基礎必備
1、什么是Python
Python是門程式設計語言
-
自然語言：人能聽懂的語言（漢語，英語，法語…）
-
機器語言：機器能聽懂的語言（01010101）
-
程式設計語言：機器能夠聽懂，人能聽懂的語言（Python，C，C++ C# Java）
-
語法規范
高級程式設計語言：越接近于人類的語言越高級
低級程式設計語言：越接近于機器語言越低級（匯編）
2、Python 的歷史
- 創始人：Guido van Rossum --龜叔
- 時間：1989圣誕節期間，構思Python這門語言
- Python來自于《Monty Python’s Flying Circus》《蒙提·派森的飛行馬戲團》–小品
- 2020.11.12加入微軟的開發部門
3、Python的特點
- 語法簡潔（通過文本縮進的形式）
- 有著非常強大的類別庫
- 膠水語言（呼叫其他語言的類別庫）
- 代碼量較少
4、Python 運行機制
程式員：代碼（源檔案）
-
編譯型
將源檔案通過編譯器，編譯成機器碼檔案，當運行的時候直接執行機器碼檔案
缺點：不能跨平臺
優點：執行快 -
解釋型
將源檔案通過解釋器，逐行進行翻譯并運行
缺點：執行慢
優點：可以跨平臺（作業系統） -
Python的運行機制
- 解釋運行（腳本）
- 先編譯后解釋
5、Python的安裝
-
官網：www.python.org
-
勾選add Python** to PATH
-
驗證Python是否安裝成功
通過黑視窗（cmd）輸入Python測驗
6、helloworld
-
開發工具：
idle 文本編輯器，支持互動式界面
pycharm 文本編輯器
-
創建源檔案
*.py
-
編譯源檔案
print(“helloworld”)
-
運行Python檔案
點擊run run Module F5
7、print（）
輸出函式（功能）
-
print(要輸出的內容)
py2: print 要輸出的內容
py3：print(要輸出的內容) -
print()
默認有換行功能
print(輸出的內容,end='\n') #end是以...結尾 “\n” 轉義字符：換行
8、input()
輸入陳述句
input(“提示資訊”)
input(“請輸入密碼：”)
input接收到的內容全是字串
9、變數
-
就是一個名字
-
先賦值在使用
-
變數要符合識別符號(名字)的命名規范
10、識別符號的命名規范
識別符號–名字(變數名，函式名，類名…)
語法規范：硬性要求
-
合法的識別符號:字母，數字(不能開頭),下劃線
py3可以用中文（不建議）
py2不可以 -
大小寫敏感
-
不能使用關鍵字和保留字
關鍵字： if while for as import
保留字：input，print range -
沒有長度限制
-
望文生義
看到名字就知道要表達的意思 -
大小寫
1. 包名：全小寫
2. 類名：每個單詞的首字母大寫其他的小寫（駝峰命名法）大駝峰
3. 變數名/函式名:第一個單詞的首字母小寫，后面的單詞的首字母大寫(小駝峰)
4. 常量：全大寫 -
其他命名方式
hello_world
11、資料型別
-
整型：int 整數
-
浮點型： float 小數
表現形式：
小數
科學計數法 e表示乘以10幾次方
a=5e-1 b=1e10 #1*10的10次方 -
字串：str
形式：’’ “” “”“xsxs”"" ‘’’‘xxx’’’
三引號特殊功能：表示注釋：
#注釋
三引號注釋：
“”
xsx
xs
“”" -
布爾型別： bool
True: 真
False:假
1表示真
0表示假 -
None
-
串列，元組，字典，集合…
12、型別轉換
- 字串轉整型
int(str)
user = int('304200780') #字串必須是數字
- 浮點型轉整型
int(float)
f = 20.1
ff = int(f) #直接抹去小數部分
- 字串轉浮點型
float(str) #字串必須是數字和.
f = "203.4"
ff = float(f)
- 整型轉浮點型
float(int)
f=30
float(f) #30.0
- 浮點型轉字串
str(float)
f = 30.5
ff = str(f) #字串"30.5"
- 整型轉字串
str(int)
f=30
str(f) #字串"30"
13、 獲取型別資訊
-
type()
type(物件)–回傳物件的型別 -
isinstance(物件,class)
回傳布林值（True,False）
14、 運算式
運算式都有固定字面值
字面值：所有值 10+20 a+b（a=10,b=20） 10>30
10:整型int的字面值
例如：
b=“hehe”
a=“heiehi”
a+b
15、運算子
-
一般運算子
+，-，*，/（真除法）//（地板除，舍去小數部分）,%（取余數）,**（冪運算）
-
賦值運算子
=：等號右邊的值賦值等號左邊
增強賦值運算子：
+=，-=，*=，/=,%=,**=
連續賦值：
a=b=c=d=10 -
布爾運演算法
== （等于），！=（不等于） ，>= （大于等于），<= （小于等于），>， < -
邏輯運算子
not 非
and 與
or 或
and：前后都為真則為真
or：有一個為真則為真
not:非真，非假
二、流程控制
1、 條件分支流程：當達到某種條件的時候才會觸發的代碼
語法1：
if 布爾運算式: #如果為真則執行內部的代碼塊
代碼塊
語法2：
if 布爾運算式：#如果為真則執行if內部的代碼塊,如果為假則執行else內部的代碼
代碼塊
else:
代碼塊
實體： a = 10
b = 20
if a>b:
a = 30
print(a)
else:
print(1111)
語法3：
if 布爾運算式：#如果為真則執行if內部的代碼塊,如果為假則執行else內部的代碼
代碼塊
elif 布爾運算式：
代碼塊
elif 布爾運算式：
代碼塊
....
else:
代碼塊
實體：
s = int(input("請輸入分數:"))
if 80>=s>=60:
print("及格")
elif 80<s<=90:
print("優秀")
elif 90<s<=100:
print("非常優秀")
else:
print("不及格")
語法4:
嵌套使用
s = int(input("請輸入分數:"))
if 80>=s>=60:
print("及格")
elif 80<s<=90:
print("優秀")
elif 90<s<=100:
print("非常優秀")
else:
print("不及格")
if s>50:
print("你的分數在60分左右")
else:
print("你的分數低于50分")
2、回圈流程
重復運行某些代碼
1. while
語法：
while 布爾運算式: #只要條件為真就執行
代碼塊
實體：
while 4<5:
s = int(input("請輸入分數:"))
if 80>=s>=60:
print("及格")
elif 80<s<=90:
print("優秀")
elif 90<s<=100:
print("非常優秀")
else:
print("不及格")
if s>50:
print("你的分數在60分左右")
else:
print("你的分數低于50分")
解決死回圈問題：
a=3
while a<5:
s = int(input("請輸入分數:"))
if 80>=s>=60:
print("及格")
elif 80<s<=90:
print("優秀")
elif 90<s<=100:
print("非常優秀")
else:
print("不及格")
if s>50:
print("你的分數在60分左右")
else:
print("你的分數低于50分")
a+=1
print(a)
print("while執行結束了")
案例：
#請輸入一個整數，并計算各個位和 如：321=6
n = int(input("請輸入一個整數:"))#將字串轉為整型
#sums累加器：m=10 m=10+5
sums = 0
while n!=0: #32 #3
sums=sums+n%10 #sums=1+2=3+3=6
n=n//10 #32
print(sums)
2. for回圈 --計數回圈
語法：l=[3,2,1]
for 變數 in l(可迭代物件):
代碼塊
3. range()
可迭代物件
(1)range(stop)
回傳一個序列從0開始到stop-1為止
(2)range(start=0,stop,step=1)
for i in range(0,10,2):
print(i)
print("helloworld")
for i in range(10,2,-2):
print(i)
print("helloworld")
4. break
跳出回圈，后面回圈不在執行
a=5
for i in range(1,10):
if i==5:
break
print(i)
print("helloworld")
5. continue
跳過本次回圈，后面的回圈繼續執行
a=5
for i in range(1,10):
if i==5:
continue
print(i)
print("helloworld")
三、串列(List)
可以存放任何資料，整型，浮點型，字串，布爾型…
最常用的資料型別之一
1、 串列的創建
串列也是一個可迭代物件
-
普通形式
l = [1,2,3,4,5] —整型串列
l = [“a”,“b”,“c”] —字串串列
l = [True,False,1>2,5<6]—布爾串列 -
混合串列
l = [1,2.5,“a”,True]
-
空串列
l = []
2、從串列中如何獲取資料(元素)
串列是有下標的，并且下標從0開始
l = [5,4,3,2,1] 元素是指串列中每個資料
- 1.獲取當個資料(元素)
語法：
變數[下標] #獲取下標所對應的值
l = [1,2,3] #下標/索引：0開始
print(l[1])
- 串列的遍歷
for i in l:
print(i,end=" ")
- 交換資料
l = [1,2,3,4,5] #下標/索引：0開始
l[2],l[3] = l[3],l[2]
print(l)
3、添加元素
- append(物件)
向串列中添加資料，并添加到末尾
變數.append(資料)
- extend(可迭代物件)
#將可迭代物件中資料分別添加到串列中，并添加到末尾
l.extend([6,7])
print(l)
- insert(下標,物件)
l.insert(3,6)
print(l)
4、 洗掉元素
-
clear()
清空串列
-
pop([下標])
洗掉下標指定的元素，如果不加下標則洗掉最后一個元素
l.pop(3)
print(l) -
remove(value)
洗掉指定的值
l.remove(4)
print(l) -
del 陳述句
del l ： 洗掉變數I
del l[3] ： 洗掉串列中下標為3的資料
print(l)
5、修改
修改串列中元素
語法：
變數[下標]=新值
l[2]=6
print(l)
6、串列高級特性的
切片操作,分片
-
語法：
變數[起始下標:結束下標] #結束下標取不到
如果下標從0開始可以省略不寫 n = l[:4]
如果結束下標取的是最后一個元素，可以省略不寫 n = l[3:]
如果串列中的元素都要 開始和結束下標都可以省略 n = l[:]
n = l[:-1] 從0開始-到數二個元素 -
串列的進階操作
n = l[開始:結束:步長]
n = l[-9:-1:2]
n = l[-1:-9:-2]
7、串列的一些運算子
- 比較運算子
l = [1,2,3,4,5,6,7,8,9,10] #下標/索引：0開始
l2 = [2,3,4,6]
print(l < l2) #True
串列之間進行比較，以相同下標進行比較，從小到大進行比較，如果值相同則比較下一組元素，如果不同直接出結果
- 邏輯運算子
and not or - 拼接運算子
+
print(l + l2)
- 重復運算子
*
- 成員關系運算子
in not in
判斷元素是否在串列中
print(5 not in l)
8、串列的其他方法
-
copy()
淺拷貝 -
count(value)
回傳value在串列中出現的次數
n = l.count(6)
print(n) -
index(value,[開始下標],[結束下標])
元素出現的第一次下標位置，也可自定義范圍
n = l.index(6,8,9)
print(n) -
reverse()
原地翻轉
l.reverse()
print(l) -
sort（key=None，reverse=False）
快速排序
默認從小到大排序
key:演算法
9、 冒泡排序
給定一個串列
l = [5,4,3,2,1],用冒泡排序的思想從小到大排序
讓串列中兩個相鄰的元素，進行比較，如果不符合條件那么就互換位置
len():獲取串列的長度（元素）
案例：
#給定一個串列
# l = [5,4,3,2,1],用冒泡排序的思想從小到大排序
l = [6,5,4,3,2,1]
for i in range(1,len(l)): #1,5 #回圈4大次 4
for j in range(len(l)-i):
if l[j] >l[j+1]:
l[j],l[j+1] = l[j+1],l[j]
print(l)
10、選擇排序
#給定一個串列
# l = [5,4,3,2,1],用選擇排序的思想從小到大排序
選擇排序：讓串列中的元素，固定一個元素和其他元素進行比較，不符合條件互換位置
l = [6,5,4,3,2,1]
for i in range(0,len(l)-1):#0,4
for j in range(i+1,len(l)): #1,5
if l[i] >l[j]:
l[i],l[j]=l[j],l[i]
print(l)
11、二維串列
串列中的串列
l = [[1,2,3],[4,5,6],[7,8,9]]
語法：
變數[外層串列下標][內層串列的下標]
l[0][1] #2
for遍歷：
l = [[1,2,3],[4,5,6],[7,8,9]]
for i in l:
for j in i:
print(j)
四、元組（tuple）
存放任何資料型別
- 不能修改，不可變型別
- 用（）的形式
- 元組也是可迭代物件
- 元組是有序的，下標操作,支持切面操作[:]
1、元組的創建及訪問
-
創建：
直接創建： t = (1,2,3,4,5) -
訪問：
t[下標] 獲取元素 -
切片操作：
t[:] 回傳元組
2、 修改和洗掉
- 修改：
#先轉換成串列進行修改，然后再轉換回來
t = (1,2,3,4,5)
print(t[1:4])
l = list(t)
print(l)
l[2]=6
print(l)
t=tuple(l)
print(t)
- 洗掉：
del t #洗掉變數
3、元組的運算子
-
比較運算子
< > >= <= == != -
邏輯運算子
and not or -
拼接運算子
+ -
重復運算子
* -
成員關系運算子
in not in
判斷元素是否在串列中
print(5 not in l)
4、元組的方法
-
count(value)
value出現的次數
-
index(value,[start],[stop])
回傳value再元組中出現的下標位置（第一次出現的下標）
五、字串
1、 字符和字串
Python中字符和字串沒有區別
字符：單個字符
字串：一個字串物件（）
Java：
字符：單引號’a’
字串：雙引號：“abc”
2、字串的特點
-
字串不可變型別
-
字串是可迭代物件
-
字串支持索引和切片操作
-
支持運算子;
拼接：+
重復運算子：*
比較運算子： > < <= >= == !=
邏輯運算子：not and or
成員關系： in not in
3、字串的方法
-
capitalize()
把字串的第一個字符改為大寫，后面的小寫
b = a.capitalize()
print(b) -
casefold()
把整個字串都小寫
b= a.casefold()
print(b) -
encode()
編碼 str–bytes（二進制字串） -
decode()
解碼 -
count(sub,[start],[stop])
回傳字符（sub）出現的次數
n = a.count(“L”)
print(n) -
find(sub,[start],[stop])
回傳sub第一次出現的下標,查不到回傳-1 -
index(sub,[start],[stop])
回傳sub第一次出現的下標，報錯 -
upper()
將字串轉為大寫 -
lower()
將字串轉為小寫
4、 格式化
按照某種格式輸出
1.format
語法1：用數字占位（下標）
"{0} 嘿嘿".format("Python")
a=100
s = "{0}{1}{2} 嘿嘿"
s2 = s.format(a,"JAVA","C++")
print(s2)
語法2：
{} 占位
a=100
s = "{}{}{} 嘿嘿"
s2 = s.format(a,"JAVA","C++","C# ")
print(s2)
語法3：用字母占位
s = "{a}{b}{c} 嘿嘿"
s2 = s.format(b="JAVA",a="C++",c="C# ")
print(s2)
2. %s
“%s”%（值）
最常用的引數可以是任意值
九九乘法表:
for i in range(1,10):
for j in range(1,i+1):
print("%s * %s = %s"%(i,j,i*j),end="\t")
print()
5、轉義字符
- “\n” ：換行符
- “’”:單引號
- “\“”:雙引號
- “\” : \
反斜杠應用：
a= "sxsxsxsxsxsxsxs\
xsxsxsxs\
xsx"
print(a)
a= 1+2+3\
+4
print(a)
六、字典（dict）
存盤資料，以映射關系存盤
1、字典的特點
-
字典是Python中唯一的映射型別
name – “不良人” -
字典是無序的
-
字典是可迭代物件
-
字典的構成
鍵：key
值：value
映射：鍵–值
鍵-值：鍵值對（項）
2、創建字典
- 直接創建
d = {} #空字典
d = {"name":"不良人","apple":"蘋果"}
- dict()
d = dict()
- dict(可迭代物件)
d3 = dict([("one",1),("two",2)])
print(d3)
- **dict(kwargs)
d4 = dict(a=3,b=4)
print(d4)
3、字典訪問的
- 基本形式：
變數名[鍵名] #鍵所對應的值
d = {"name":"小黑"}
print(d["name "])
-
添加一個鍵值對
變數名[鍵名]=值
-
修改一個鍵值對的值
變數名[鍵名]=值
4、字典的方法
- clear()
清空字典 - copy()
淺拷貝 - fromkeys(可迭代物件，value=None)
根據可迭代物件中的元素去創建字典
d = {"name":"小黑"}
d2 = d.fromkeys([1,2,3,4],[4,5,6,7])
print(d2)
- get(key,[d])
key：鍵
d：提示資訊
d = {"name":"小黑"}
print(d.get("name2","沒有查到"))、
- items()
將字典中的鍵值對封裝成元組并放到類集合中
d2={'c': 3, 'hehe': 100, 'b': 2, 'a': 1}
s = d2.items()
print(list(s))
-
keys()
同上，取鍵 -
pop(key,[d])
根據鍵洗掉字典中的鍵值對
d:提示資訊 -
popitem()
洗掉某個鍵值對 -
values()
回傳字典中的值（類集合物件）
d2={'c': 3, 'hehe': 100, 'b': 2, 'a': 1}
c= d2.values()
print(list(c))
5、補充
- 字典可以使用for回圈
for i in d2:
print(i) #鍵，不包含值
- 輸出一個鍵值對
for i in d2.items():
print(i)
-
成員關系運算子
in/not in
只能查詢鍵
七、函式
由一組代碼組成，完成某個特定的功能
-
創建函式：
語法：
def 函式名([引數]): #引數相當于變數,引數可以為多個，逗號隔開，還可以沒有引數=無參
代碼塊（函式的實作/函式體） -
函式的呼叫
函式名(引數)
1、函式的運行機制
-
從函式呼叫開始執行
-
通過函式名字找到函式定義的位置（創建函式的位置）
-
執行函式體
-
執行完畢之后，回傳到函式的呼叫處
2、函式的使用
def fun2(a,n):
print(a*n)
#列印古詩
print("白日依山盡")
fun2("+",5)
print("黃河入海流")
fun2("-",10)
print("欲窮千里目")
fun2("*",15)
print("更上一層樓")
fun2("/",20)
3、函式的特點
-
避免了代碼的冗余
-
提高了代碼的可維護性
-
提高了代碼的可重用性
-
提高了代碼的靈活性
4、 函式的引數
-
形式引數：形參
在定義函式的時候傳遞的引數 -
實際引數：實參
在呼叫函式時傳遞的引數 -
無參
沒有任何引數
位置引數：
和位置有關系--一一對應，不能多也不能少
def fun4(a,b,c,d):
print(a,b,c)
fun4(10,20,30)
關鍵字引數：
定義關鍵字的引數--實參
def fun4(a,b,c):
print(a,b,c)
fun4(b=10,a=20,c=30)
位置引數和關鍵字引數混用：
當位置引數和關鍵字引數混用時，位置引數在前
def fun4(a,b,c):
print(a,b,c)
fun4(10,20,c=30)
默認引數：
給了默認值的引數--形參
如果傳遞了新的值，那么默認值就被覆寫了
def fun4(a=10,b=20,c=30):
print(a,b,c)
fun4()
fun4(20,30,40)
fun4(b=20,c=30,a=40)
可變成引數：
def 函式名(*a)
本質上封裝成了元組
def fun5(*a):
print(a) #元組
fun5(10,20,30)
--------------
def 函式名(**kwargs)
將引數封裝成了字典
def fun6(**a):
print(a)
fun6(b=10,c=20,d=30)
可變成引數和位置引數混用的時候：
def fun6(*a,b):
print(a,b)
fun6(10,20,b=30)
def fun6(b,*a):
print(a,b)
fun6(10,20,30)
5、 函式的檔案
檔案注釋：#，三引號
函式的檔案注釋：
函式結構的第一行
def fun6(b,*a):
"""
fun6是個函式
a:可變成引數
b:位置引數
"""
print(a,b)
fun6(10,20,30)
print(fun6.__doc__)
1. 獲取函式的檔案內容: 函式名.__doc__
2. help(函式名) #查看函式檔案
6、 函式的回傳值
關鍵字：return
回傳值誰呼叫就回傳給誰
-
任何函式都有回傳值
-
如果不寫return ，也會默認加一個return None
-
如果寫return ，不寫回傳值 也會默認加一個None
-
可以回傳任何資料型別
-
return后面的代碼不在執行，代表著函式的結束
7、函式的變數的作用域
-
區域變數
定義在函式內部的變數
先賦值在使用
從定義開始到包含他的代碼結束
在外部無法訪問 -
全域變數
定義在源檔案的開頭
作用范圍：整個檔案
區域變數和全域變數發生命名沖突時，以區域變數優先 -
global
宣告全域變數
def fun1():
global b
b=100
print(b)
fun1()
print(b)
- nonlocal
宣告的是區域變數
def fun1():
b=100
def fun2():
nonlocal b
b=300
print(b)
fun2()
print(b)
fun1()
- 函式內部不能進行a+=1,a=a+1這樣的操作（全域變數）
解決飯方式1：
b=100
def fun1():
global b
b = b+1
print(b)
fun1()
解決飯方式2：
def fun1():
b=100
def fun2():
nonlocal b
b=b+1
print(b)
fun2()
print(b)
fun1()
7、內嵌函式
內部函式
內部函式的作用范圍：從定義開始到包含給他的代碼塊結束
在內部函式中不能進行a+=1,a=a+1這樣的操作，解決方案是nonlocal
8、 閉包
閉包：是函式式編程的重要語法結構，函式式編程是一種編程范式
編程范式：對代碼進行提煉和抽象概括，使得重用性更高
如果內部函式呼叫了外部函式的區域變數，并外部函式回傳內部函式的函式物件（函式名）
def fun1():
a=100
def fun2():
print(a)
return "哈哈"
return fun2
print(fun1()())
-
作用：
可以傳遞更少的形參，可以傳遞更多的實參—更加安全
def fun1(b):
a=100
print(b)
def fun2(c):
print(c)
return "哈哈"
return fun2
print(fun1(200)(300))
間接性的訪問內部函式
-
條件
- 必須是一個內嵌函式
- 外部函式必須回傳內部函式的函式物件
- 內部函式必須使用外部函式的區域變數
9、lambda運算式
-
匿名函式
沒有名字的函式 -
使用時機：
只使用一次的時候 -
語法：
關鍵字： lambda
lambda 引數1，引數2:回傳值 -
lambda的書寫形式更加的簡潔，優雅
l = lambda x:x
print(l(100))
- lambda的優先級最低
八、機器人實戰
知識點總結完后，就來看看實體，
安裝模塊（功能）
語法:import 模塊名
pip install itchat #微信功能
pip install request #發送請求
#匯入相關模塊，功能
import itchat
import requests
#1.生成機器人進行回復訊息
KEY = "a7e21d94d4944e5ca6d4215f46a0339d"
#1. 實作機器人功能
def get_response(msg):
apiUrl = "http://www.tuling123.com/openapi/api" #要訪問的網站
#key：機器人的key，info是要發送的訊息
data = {'key':KEY,'info':msg,'userid':"WeChat-robot"}
#發送請求：
r = requests.post(apiUrl,data=data).json()
return r["text"]
#第二步：實作微信功能
#裝飾器，用于查詢哪個好友給你發訊息
@itchat.msg_register(itchat.content.TEXT) #好友的資訊
def tuling_reply(user_data):
print(user_data) #用戶的資訊包含給你發的訊息
user = user_data["Text"] #用戶發你的訊息
return_user = get_response(user_data["Text"])
print(return_user)
return return_user or user
itchat.auto_login() #掃碼登錄
itchat.run() #回圈執行上面的函式
這我總結的知識點，總結可能沒其他人的好，因為每個人的學習方法和總結方法不一樣，但是希望我的總結有一定的參考價值，給帶來你們一定的幫助!
最后祝愿所有點贊收藏的小伙伴都能順利通過學習完成人生逆襲，
想理解更多Python知識，可以關注公眾號：Python學習指南，↓↓↓
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/289871.html
標籤：python