Pyhton學習的基礎

函數->功能, 如print(),input(),range(),

方法->功能, 如index()(儘可能不用此方法),find(),
類裏面的函數就叫作方法

容器->列表，字符串，元組，字典,set集合.

模塊-是能夠調用的

appearance->通用的意思

標識符 ->變量，函數，類，文件等的名字

def->定義(define)

百分比轉換 print("%.2f %%"(變量名 * 100))

import 導入
類中的方法-->行爲,功能

-------------------------------------------------------------------------------------------------------
學習方法

總結知識點 寫，分析代碼
將知識點引用到做業
至少2遍做業
-------------------------------------------------------------------------------------------------------
計算機

內存 隨機存儲器，電信號表示數據（電路的狀態）讀寫速度快，只讀存儲器 主板上的半導體，開機時的數據
硬盤使用磁表示數據，之因此慢是由於多一步轉換過程

-------------------------------------------------------------------------------------------------------

驅動程序由硬件廠商開發
os經過驅動程序來管理軟硬件資源

-------------------------------------------------------------------------------------------------------
計算機只能識別和執行01的機器指令（機器語言（二進制數據））內存裏的數據既是01

語言處理程序=編譯器（如python解釋器）將程序翻譯爲01的機器語言讓計算機能夠識別執行
將軟件讀取到內存——將文件讀取到內存——cpu中的控制器調用聲卡顯卡驅動——驅動程序調用硬件處理數據

-------------------------------------------------------------------------------------------------------

編程語言->人與計算機交流的語言

劉峯說了Python是世界上最牛逼的語言
-------------------------------------------------------------------------------------------------------
Python的縮進很須要注意
-------------------------------------------------------------------------------------------------------
Python特色

-標準庫功能強大，
框架確立，將功能添加到程序中，
-語法優美，簡單，易學，免費，開源
-擴展性強
-縮進以致於整潔優美規範
-------------------------------------------------------------------------------------------------------
Python的缺點

執行效率比較慢，更適用於高性能計算機
-------------------------------------------------------------------------------------------------------
Python學習方向
web開發
操做系統管理，服務器運維的自動化腳本
網絡爬蟲
大數據挖掘分析，科學計算（人工智能）
桌面軟件
服務器軟件
遊戲
-------------------------------------------------------------------------------------------------------
Python解釋器
將程序轉換爲01機器可執行的數據
給Python提供豐富的類庫使python更增強大
能夠提升開發效率
-------------------------------------------------------------------------------------------------------
Pycharm
create Project用來創捷一個存放代碼文件的文件夾
version control版本控制工具 整合代碼
pure python 純python工程
-------------------------------------------------------------------------------------------------------
輸入法中文時使用英文標點（實用技巧）
一個語句一行，行爲單位
-------------------------------------------------------------------------------------------------------
註釋的分類

註釋最好加在上邊
單行註釋-註釋的文字只能在同一行，不能寫成多行 # 開頭
快捷鍵 選中註釋掉的行 CTRL+/（左斜線，句號後邊）
-------------------------------------------------------------------------------------------------------
多行註釋-使用三對引號引中註釋文字（單雙引號均可以）
使用雙引號時不能嵌套
-------------------------------------------------------------------------------------------------------

何時添加註釋
開發的功能比較複雜時
開發的功能是核心功能
-------------------------------------------------------------------------------------------------------
變量-就是內存中的一塊區域

數據讀取到內存後使用變量臨時存儲，
在程序中給變量起個別名即爲變量名，經過變量名來使用變

定義變量的格式-->變量名=數據值 =是賦值，數據值賦值給變量名

不是第一給變量賦值，表示修改變量值

-------------------------------------------------------------------------------------------------------
變量以及類型
數據分類-根據數據的計算規則對數據進行分類
整數-int 小數-float 字符串-str使用引號引發來的內容 布爾類型-bool(ean）只有兩個數據值True，False
列表-list 元組tuple 字典-dict set集合-set
-------------------------------------------------------------------------------------------------------
定義變量時不須要指定變量類型python解釋器會自動推導
查看數據類型 type（數據）

-------------------------------------------------------------------------------------------------------
標識符的命名規則
1.字母，下劃線，數字組成，不能以數字開頭,不能是關鍵字(在python中事先預留出來的單詞,已有特殊含義)import keyword-keyword.kwlist而後打印出來
2.必須見名知意
3.下劃線鏈接單詞,都是小寫

-------------------------------------------------------------------------------------------------------
print()打印出來在控制檯裏面
-------------------------------------------------------------------------------------------------------
格式化操做符
若是輸出的內容有相應的類型,先用格式化操做符佔位,而後再替換
string->%s
整數->%d
保留幾位數字 %nd (n+d是總位數)
float類型保留小數位數- %.nf(n就是要保留的位數)
-------------------------------------------------------------------------------------------------------
若是輸出的字符串中包含多個變量值,用小括號括住變量,使用逗號隔開,且順序必須對應
print(" xxx%s ,xxx%d" % (a,b) )
輸出一個%是 "%% %d"
-------------------------------------------------------------------------------------------------------
使用float()等 對input()錄入的string類型的數據進行數據轉換
-------------------------------------------------------------------------------------------------------
算術運算符
% 取餘,取模
// 取整,捨去餘數
** 取冪
-------------------------------------------------------------------------------------------------------
字符串與整數只能相乘,不能作其餘操做,字符串的倍數.
字符串與字符串相加表示 鏈接兩個字符串
-------------------------------------------------------------------------------------------------------
數據類型轉換
使用float()對input()錄入的string類型的數據進行數據轉換
-------------------------------------------------------------------------------------------------------
複合賦值運算符
+= 左邊的變量與右邊的數據相加再賦值給左邊的變量
-------------------------------------------------------------------------------------------------------
輸入
input()在控制檯錄入數據,在程序中獲得該數據
獲得的數據是必定是字符串

-------------------------------------------------------------------------------------------------------

數據類型轉換

格式: 目標數據類型(數據) 如a=9--> int(a),str(b)
bool類型非零都爲True,0爲False
str(9.0)沒法轉換爲int類型

-------------------------------------------------------------------------------------------------------
Debug調試程序
在懷疑出錯的位置添加斷點
以debug方式運行程序
在debugger中點擊向下的箭頭逐行測試
點擊向上的箭頭執行兩個斷電之間的全部行
-------------------------------------------------------------------------------------------------------
關係運算符的結果是bool類型,結果要麼是True要麼是False
-------------------------------------------------------------------------------------------------------

關係運算符中==是判斷是否相等
-------------------------------------------------------------------------------------------------------
if條件語句的格式
if關係表達式:
語句體

語句體能夠是一行
也能夠是多行
-------------------------------------------------------------------------------------------------------
執行流程:

if..else..

if關係表達式:
語句體1-->(條件知足關係表達式,就執行這個)
else:
語句體2-->(條件不知足關係表達式就執行這個)

-------------------------------------------------------------------------------------------------------
if...elif...else...-->適合用於判斷3種及以上條件

if 條件判斷語句1:
語句體1
elif 條件判斷語句2:
語句體2
...
else
語句體 n+1
-------------------------------------------------------------------------------------------------------

三目運算(用來簡化 if....else..語句)
a if a>b else b
若是(a>b)的條件成立,結果是a,不然就是b(a,b是值!)

關係表達式後面這個地方必定要注意 : (冒號)
-------------------------------------------------------------------------------------------------------
邏輯運算符

結果是bool類型

and 和 兩邊的條件都知足爲True
or 或 兩邊條件有一個知足爲True
not 非 取相反
-------------------------------------------------------------------------------------------------------
得到隨機數
導入工具包(通常寫在程序的最上邊)
調用工具包裏的功能,得到一個隨機數
random.randint(始,終)
-------------------------------------------------------------------------------------------------------
break 中斷循環,再也不執行循環!
continue 結束本次循環,繼續下次循環(在while循環使用continue時須要使計數器避免死循環!!!)
只對所在的的循環起做用,不對外面的循環起做用

-------------------------------------------------------------------------------------------------------
while循環語法格式

定義變量並賦值 1
while 條件判斷語句: 2
重複執行的代碼語句 3
修改條件的語句 4 執行流程 1-->2-->3-->4 -->2-->3--4 -->2-->3-->4--

若是2的值爲 False 時,循環結束(條件判斷語句不成立時,循環結束)

while循環嵌套時在內循環裏要從新定義計數器

-------------------------------------------------------------------------------------------------------

\n 換行符 \t製表符(一個縮進) \\目錄分割符(如:path= "D:\\視頻\\123.flv")

-------------------------------------------------------------------------------------------------------

for循環語法格式

for 變量 in range() 或者 可迭代的容器:
重複執行的代碼塊

-------------------------------------------------------------------------------------------------------
range() 能夠獲得 一個 數據區間
range(開始數字,結束數字)!!!不包含結束的數字
如[1,2,3,4,5]==range(1,6)
-------------------------------------------------------------------------------------------------------

流程判斷語句

順序結構語句(從上往下按順序執行的語句)
判斷語句
循環語句

-------------------------------------------------------------------------------------------------------

字符串:
使用一對單引號或者一對雙引號或者三隊單引號引住的任何內容都是字符串

索引的做用
1.能夠根據索引查找某個元素
2.根據索引截取字符串
-------------------------------------------------------------------------------------------------------
遍歷
一個一個地獲得
-------------------------------------------------------------------------------------------------------
切片
就是截取一段(截取索引超出範圍表示截取到最後一個元素)
-------------------------------------------------------------------------------------------------------
列表中的元素能夠是任何類型的

定義列表的格式
列表名 =["元素1","元素2".....](方括號!!)

-------------------------------------------------------------------------------------------------------
增長列表元素的方法
append()
列表1.extend(列表2) 將列表2 的內容添加到列表1的後面,元素能夠重複

-------------------------------------------------------------------------------------------------------
修改列表元素的方法
列表名[索引]=新的元素值
-------------------------------------------------------------------------------------------------------
刪除列表中的元素
列表名.remove("元素")若是 這個元素在列表中不存在會報錯
列表名.pop()默認刪除列表中最後一個元素
列表名.pop(索引)刪除指定索引值的元素
列表名.clear()清空列表
-------------------------------------------------------------------------------------------------------
列表的排序
列表內的元素須要是同一類型的數據,不一樣類型沒法排序
列表名.sort()默認按照升序排序
列表名.sort(reverse=True)按照倒序排序
-------------------------------------------------------------------------------------------------------
列表推導式:
定義列表並向列表中添加數據的簡化代碼
x 是 從容器中遍歷出來的數據,for 前面的數據添加到列表中
列表名 = [x for x in 可迭代的函數或者range()函數]
加if條件判斷語句
列表名 = [x for x in 可迭代的函數或者range()函數 if 條件判斷語句]
遍歷出來的數據知足條件判斷語句纔將數據添加到列表中

-------------------------------------------------------------------------------------------------------
Tuple
元組就是一個不能修改的列表

格式:
元組名=("元素1","元素2",....)(小括號!!!)

只有一個元素的元組
元組名=(元素1,)沒有,的的話就不是元組

-------------------------------------------------------------------------------------------------------
字典也是一個容器
數據時成對出現時就使用字典來存儲

key 是不能夠修改的!!
key是惟一的,不可重複!!
-------------------------------------------------------------------------------------------------------

格式:
字典名 = {"key1: value1","key2: value2", ....}
-------------------------------------------------------------------------------------------------------
存儲數據時一存一對,查詢時的效率高
-------------------------------------------------------------------------------------------------------
要想獲得值必須經過鍵來查找--> 字典名["key"]是其value,key不存在的話會報錯
-->字典名.get(key)查找 空的key並不會報錯儘可能使用此方法
-------------------------------------------------------------------------------------------------------
修改value須要經過key來修改
字典名[key]=新的value
-------------------------------------------------------------------------------------------------------
添加一個鍵值對
字典名["key"]="value"
這個key必須是字典中還沒有存在
-------------------------------------------------------------------------------------------------------
刪除一個鍵值對
字典名.pop(key)-->刪除key對應的鍵值對
字典名.popitem()-->刪除最後一個鍵值對
字典名.clear()-->清空字典裏的鍵值對
-------------------------------------------------------------------------------------------------------
字典中鍵值對的key不能是列表或者字典,這兩個是可變類型的,關鍵字key不能變,變了就不是這個keyle
-------------------------------------------------------------------------------------------------------
字典的遍歷
方式1 先獲得全部的key對應的列表 字典名.keys()獲得一個列表,定義爲key_list
遍歷列表獲得key for key in key_list
從字典的get()方法,經過key獲得value value=字典名.get(key)
print("%s:%s" % (key,value))

-------------------------------------------------------------------------------------------------------
方式2 先獲得全部的鍵值對對應的列表 kv_list=dict.item()
遍歷鍵值對的列表 for key_value in kv_list:

從鍵值對中獲得key和value
key= key_value[0]
value = key_value[1]
print('%s: %s" % (key,value))
-------------------------------------------------------------------------------------------------------
遍歷列表中的字典,實質上遍歷出來的是這個字典對應的地址,在修改改完字典的內容後其地址沒有改變,因此不須要從新
再把字典追加到列表中

-------------------------------------------------------------------------------------------------------
set 集合
-------------------------------------------------------------------------------------------------------
set集合(使用{}裝的內容不能重複,且單個出內容,的列表)
與列表相似,可是set集合中的元素是惟一的不能重複
定義格式

set集合名 = {元素1,元素2,.....}

空set集合的定義格式
set集合名 = set()

set集合添加元素
set集合名.add()

set集合更新元素
set集合名.updata((新的set集合))

set集合修改元素
先刪除要修改的,而後再添加要添加的元素

set集合刪除元素
set集合名.remove(要刪除的元素)
set集合名.pop()刪除隨意一個元素
set集合名.clear()清理空set集合

set集合查找元素
for e in set集合名:
print(e)

set,tuple,list之間能夠相互轉換
set= set([list])

-------------------------------------------------------------------------------------------------------

函數 ---->具備一個獨立功能的代碼塊

可讓代碼變得更加簡潔
儘可能避免代碼重複
提升函數體代碼的使用率

-------------------------------------------------------------------------------------------------------

定義函數的格式
def 函數名():
函數體 (就是一個語句體)

調用函數的格式
函數名()
-------------------------------------------------------------------------------------------------------
若是隻定義了函數而沒有調用,函數裏的代碼是不執行的
-------------------------------------------------------------------------------------------------------
將鼠標放在函數名上按 CTRL+Q 鍵查看函數文檔註釋
-------------------------------------------------------------------------------------------------------

帶參數的函數及其調用格式
def 函數名(形參1,形參2, ....)
函數體
函數名(實參1, 實參2, ....)
-------------------------------------------------------------------------------------------------------
函數返回值
若是調用完一個函數以後,函數交給了調用者一個結果數據
這個數據就是返回值

調用者想在後續的代碼中使用這個數據
須要在函數的最後使用return語句返回一個數據
-------------------------------------------------------------------------------------------------------

定義帶有返回值的函數語法格式

def 函數名(形參1,形參2, ...):
函數體
return 數據
函數名(實參1, 實參2, ...)<---return就是吧數據返回到這裏

這樣的函數調用後return會吧獲得的數據交給調用者
-------------------------------------------------------------------------------------------------------

函數的六個細節
1.保存函數的返回值--> 其實就是把這個返回值賦值給一個變量
2.直接打印函數的返回值 --> 直接使用print()函數打印
3.函數能夠沒有返回值--> 沒有返回值就是None,表示什麼都沒返回
4.函數中連續寫了多個return語句--> 只會執行第一個return語句,執行完return語句就表示函數調用結束了
5.return語句後不跟返回的數據--> 表示沒有返回值
6.同一個程序文件中函數不能重名--> 會使用後定義的函數覆蓋以前定義的函數

-------------------------------------------------------------------------------------------------------

函數的嵌套的格式

def function1 ():
...

def function2():
...
function1()
-------------------------------------------------------------------------------------------------------
局部變量
在函數裏面定義的變量(做用域,有效範圍-->只能在函數裏面使用)
形參是在函數內部,因此也是局部變量

全局變量
在函數外面定義的變量(做用域,有效範圍-->整個程序文件,必須先定義後使用)
使用global聲明全局變量
在函數內部對全局變量賦值,實質上並非在修改全局變量的值,而是在函數內定義了一個重名的局部變量
-------------------------------------------------------------------------------------------------------

要想在函數內部修改全局變量的值,必須使用global聲明全局變量
格式: global 全局變量名
-------------------------------------------------------------------------------------------------------
函數裏面儘可能不要定義與全局變量重名的變量
-------------------------------------------------------------------------------------------------------
要想在多個函數中使用同一個數據須要用一個全局變量來存儲這數據
-------------------------------------------------------------------------------------------------------
return 返回多個數據
把多個數據都寫在return後面,使用逗號隔開
return 數據1, 數據2,數據3, .....(python解釋器會把這些數據組包到一個元組中並返回,因此返回的值得類型是元組)
-------------------------------------------------------------------------------------------------------
參數的分類
默認參數(缺省參數)
默認參數必須在形參列表的最後
默認參數-->在定義函數時,給形參指定了默認的值,這個形參就叫作默認參數,也叫作缺省參數
調用函數的時候傳值了就使用傳的值,若沒有傳值,就使用默認值

關鍵字參數
關鍵字參數必須在實參列表的最後
再調用函數的時候按照形參的名字給形參傳
在調用函數是,不須要按照形參的順序傳值

可變參數(不定長參數)
可變參數(不定長參數)只能位於形參列表的最後
在形參前面加上一個"*"號(表示任意多個參數)
def sum (* args)

sum()
調用傳值時候把 多個實參放進一個元組,把這個元組傳遞給*args

函數變得更加靈活,提升了函數的擴展性

-------------------------------------------------------------------------------------------------------
在形參前面加兩個**這樣的可變參數只能接收一個字典類型的值

def sun (** kwargs)
print(kwargs)

sun(m=10,n=20,h=30)
調用傳值時候把 關鍵字實參放進一個字典,把這個字典傳遞給可變參數**kwargs

-------------------------------------------------------------------------------------------------------
混合參數使用的規範
沒有固定順序,按照報錯進行修改
-------------------------------------------------------------------------------------------------------
傳參的時候在實參前加*能夠將元組實參拆開
傳參的時候在實參前加**能夠將字典實參拆開
-------------------------------------------------------------------------------------------------------
組包和解包
組包-->把多個數據組裝到一個容器中
如:a=10,20那麼print(a)爲(10,20)的tuple類型的元組
解包-->把容器中的元素拆解出來
如;i, j=(10,20)那麼print(i)爲int類型的10,print(j)爲int類型的20

-------------------------------------------------------------------------------------------------------
a=10
b=20
自動解包交換a,b的值
a,b = b,a

-------------------------------------------------------------------------------------------------------
內功修煉大法

引用-->數據在內存中對應的地址
修改變量的值實質上就是在修改變量的引用

小數字:-5--256的數字
短字符串:長度小於20的字符串
這倆個也叫緩存池

可變類型與不可變類型
改變數據就改變地址的變量是不可變類型(如int,tuple,bool,str,float)
改變數據可是不改變地址的變量就是可改變類型(如 list,dict,set)

引用做爲參數傳遞

不可變類型引用傳遞
不可變類型的數據是沒法更改的 好比a=10,就是10,無法改變
參數傳遞都是引用傳遞,傳參的時候傳的是地址(id),並非數值
可變類型引用傳遞
可變類型的數據是能夠更改的 好比list1[]加數據減數據它仍是list1[]

-------------------------------------------------------------------------------------------------------
可變類型的影響
定義函數的時候建立一次,之後調用就再也不從新建立

+= 和 =+的區別
若是定義的變量 是不可變類型+=和=+是同樣的

若是定義的變量是列表
+=是追加,=+是經過建立第三個列表來存儲新的列表
-------------------------------------------------------------------------------------------------------
匿名函數
定義的函數沒有函數名
lambda 形參1,形參2,...:單行的表達式 或者 調用其它函數的語句
如; lambda a, b:a + b --> a,b是形參,a+b是返回值
若是調用的其它函數沒有返回值,那麼匿名函數就沒有返回值

調用匿名函數的格式
先把匿名函數賦值給一個變量-->變量名=lambda a,b;a+b
而後使用變量名進行調用-->變量名(實參1,實參2,...)-->sum(10,20)

匿名函數與普通函數的區別
匿名函數後只能寫一行條件表達語句不能使用if,for,while,返回值是不須要使用return,條件判斷語句的結果就是返回結果

應用場景
簡化簡單的普通函數
若是一個函數的功能只使用一次就可使用匿名單數進行定義
做爲函數的參數傳遞
-------------------------------------------------------------------------------------------------------
遞歸函數(在定義函數時,在函數裏面本身調用本身)
遞歸 :一步一步的推導,一步一步的迴歸

在函數中本身調用本身,而且須要設置終止遞歸的條件

python中遞歸的層次(深度)不能超過1000次

應用場景
總功能分解出來的小功能的計算邏輯與總功能的計算邏輯類似
-------------------------------------------------------------------------------------------------------

 

-------------------------------------------------------------------------------------------------------
模塊
一個.py文件就是一個模塊

導入模塊步驟
import 模塊名(.py文件名)
經過模塊名調用變量,函數或者類
模塊名.(變量` 函數` 類)

-------------------------------------------------------------------------------------------------------
文件
把一些數據存儲起來,永久保存

操做文件的步驟
打開問文件-->寫數據-->關閉文件(釋放文件所佔用的內存資源)
f = open("文件的路徑","操做模式")-->f.write("內容")-->f.close()

打開問文件-->寫數據-->關閉文件

操做模式: write()存在的話就覆蓋寫入, 不存在就建立
讀取文件的四種方式

一次讀取幾個字符
f.read(n) (返回一個字符串)

一次讀取一行
f.readline() (返回一個字符串)

一次讀取全部字符
f.read() (沒有傳遞參數,默認讀取全部字符,返回的是一個字符串)

一次讀取全部行
f.readlines() (把全部內容打在一行,返回一個列表,列表裏的每一個元素是一個字符串)
-------------------------------------------------------------------------------------------------------
製做文件副本
打開源文件->截取源文件中文件的路徑及其擴展名與 -副本 組成副本文件的名字->以只寫的方式打開副本文件->從原文件中讀取數據->把讀到的數據寫道副本中->關閉兩個文件
獲得最後一個.對應的索引,切片
index = 文件名.name.rfind(".")
-------------------------------------------------------------------------------------------------------
文件和文件夾的操做
import os

os.rename("舊路徑+舊名字","新路徑+新名字")重命名文件
os.remove("路徑+文件名")刪除文件

os.mkdir("文件夾名")--默認當前的工做目錄
os.getcwd()-->get current work dirctiry
os.chdir("新的工做目錄")
os.listdir("目標的目錄路徑")默認當前工做目錄的文件和文件夾列表
os.rmdir("目標文件夾的路徑")-->只能刪除空的文件夾
-------------------------------------------------------------------------------------------------------
批量修改文件名
獲得指定目錄下的列表
遍歷文件列表,每一個元素都是文件的名字(字符串類型的)
文件名.replace()

-------------------------------------------------------------------------------------------------------
面向對象

面向--面對,看重
對象--經過類找到能夠幫助你的對象

好處
開發效率高
可維護性強
可拓展行強

類與對象的關係
對象是經過類找到的
類: 描述現實世界中的某一類事物功能同樣的事物,共同的信息,

把那一類事物的共同信息抽取出來,寫到類中
屬性:從靜的一方面描述的信息. 如(顏色,年齡,體重)

行爲:從動的一方面描述的信息,這一類事物可以作的事情.如(吃飯,睡覺,敲代碼)

類 是從屬性和行爲兩方面來描述 那一類事物的
在類中 屬性:變量 行爲:方法(函數)

對象
那一類事物中的任意一個個體
對象是經過類建立出開的,先有類,後有對象

面向對象必須按照步驟開發
定義類
建立對象
經過對象調用方法(調用方法時,不須要給self形參傳值)

類的構成
類的名稱:類名
類的屬性:一組數據(變量)
類的方法:容許對類進行操做的方法(行爲就是函數)

類的命名規則按照"大駝峯命名法"

當對象在調用這個方法 時會將對象的的引用(在內存中的地址)做爲參數傳遞給self,經過self的值來肯定是誰在調用這個方法
抽象---抽取類似的東西
-------------------------------------------------------------------------------------------------------
給對象添加屬性

__init__(self)方法: 初始化對象,給對象添加屬性-->經過self添加:
格式:self.屬性名 = 屬性值 如:self.name="張三
當對象建立時當即就添加了__init__()方法中的屬性
經過對象訪問屬性
對象名.屬性名
-------------------------------------------------------------------------------------------------------
經過對象名添加
對象名.屬性=值(很是不建議使用須要添加屬性,才能調用)
二次給屬性賦值就是在修改屬性的值

在其它方法中添加
對象.屬性=值(很是不建議使用須要先調用才能添加屬性)
-------------------------------------------------------------------------------------------------------
__str__(self)方法: 查看對象中自定義 的數據(屬性值),打印對象可查看對象的數據
打印對象打印出來的是對象調用的方法的返回值 必須有一個字符串類型的返回值
若是不是字符串類型的數據須要使用str(),把對象轉成字符串是獲得對象中的數據
查看對象的屬性時不用給str設置形參,調用對象時會將對象的屬性經過self做爲形參傳遞過去
打印對象時杯python解釋器自動調用
-------------------------------------------------------------------------------------------------------
__del__(self)方法: 作臨終遺言的事情 如:驗證對象是否杯銷燬,對象已杯釋放(刪除)

對象不被銷燬就不會調用這個方法
對象即將被銷燬但尚未被銷燬的時候被python解釋器自動調用
對象在沒有被引用時才能被銷燬
-------------------------------------------------------------------------------------------------------

對象能夠做爲參數傳遞,減小調用時形參的數量

-------------------------------------------------------------------------------------------------------

私有屬性
不能在類的外面直接訪問,只能在類的裏面訪問,經過self訪問(在類的裏面訪問和訪問公共屬性格式同樣)

定義格式
在屬性名的前面加兩個下劃線
如 self.__屬性名=屬性值
在類外面訪問屬性,須要在類的裏面使用set方法給私有屬性賦值
在類的外面使用後get方法獲得私有屬性的值
能夠在類裏面設置過濾條件來保護私有屬性

私有方法
只能在類的裏面訪問
定義格式
def __方法名(self,形參..):
方法體

-------------------------------------------------------------------------------------------------------
封裝: 把不須要 對外暴露的代碼隱藏起來就是封裝
定義一個類,把屬性和方法封裝到一個類中(建立出來的對象就有這些屬性和方法)
方法(函數)自己就是封裝(把代碼塊寫道一個函數或者是方法中)(直接使用函數或者方法)
把屬性或者方法定義成私有的也是 封裝(保護私有屬性和私有方法)

對外只暴露功能,隱藏實現細節

-------------------------------------------------------------------------------------------------------

描述的是什麼就定義他的類,長得什麼樣就定義什麼屬性 有哪些行爲就定義哪些方法

-------------------------------------------------------------------------------------------------------

繼承 (不存在爺爺類,都是叫父類,基類)
繼承是描述多個類之間的所屬關係
子類一旦繼承了父類,子類中就擁有了父類中全部的非私有方法
定義格式

class 子類名(父類名)
子類中定義的方法列表
-------------------------------------------------------------------------------------------------------
object類 -->是全部類的父類(基類)
定義類時若是沒有直接繼承其餘父類,默認就是繼承了object類

-------------------------------------------------------------------------------------------------------
子類不能繼承父類的私有屬性和方法

__屬性名= 屬性值(私有屬性)
def __方法名(self):
方法體
-------------------------------------------------------------------------------------------------------
子類重寫父類中的方法
在子類中定義一個和父類名字同樣的方法,以此來知足子類的須要
使用對象調用這個方法時就會調用子類中的修改過的方法
-------------------------------------------------------------------------------------------------------
在在類中調用父類被重寫的方法

先重寫父類中的方法
在重寫的方法中使用 super().方法名(實參1, 實參2..)

父類名.方法名(self,實參1, 實參2...)
super(子類名,self).方法名(實參1, 實參2..)
-------------------------------------------------------------------------------------------------------
子類如何調用父類中的私有屬性和方法

能夠在父類中定義一個公共方法來訪問私有屬性私有方法
而後再子類中調用這個公共方法

若是父類和子類中都使用init方法添加了屬性(至關因而重寫了父類中的init方法),子類如何繼承父類中的屬性
須要使用super().方法名(實參1,實參2)來使用父類中的屬性
-------------------------------------------------------------------------------------------------------
多層繼承

A-->B-->C 使用super往基類繼承

-------------------------------------------------------------------------------------------------------
多繼承
子類同時繼承了多個父類
定義格式:
class (父類1,父類2,...)
子類中的代碼
子類的親父類是離他最近的那個,就是括號裏最左的,父類1
父類都有的方法及屬性只會繼承父類1的

想要調用其餘父類中的方法能夠經過父類名來調用父類名.方法名(self,實參1, 實參2...)
-------------------------------------------------------------------------------------------------------
實例就是對象 實例化就是建立對象
經過類名建立的對象都是實例對象
給實例對象添加的屬性就是實例屬性
實例屬性是存儲在實例對象裏面的屬於實例對象的屬性

實例方法 第一個形參是self的方法就是實例方法
實例方法是屬於實例對象
-------------------------------------------------------------------------------------------------------
類對象
定義的任何一個類都是一個類對象(類就是類對象)
對象的名字就是類名
元類:type類是用來描述全部的類的類對象的類型是type類型

類屬性
類對象名.類屬性 = 類屬性值
定義在類的裏面方法的外面

類屬性是屬於類對象的
類屬性是全部實例對象共享公用的數據,每個實例對象均可以使用這個類屬性,不專屬與某一個實例對象的

類屬性的訪問方式
實例對象名.類屬性名
類對象名.類屬性名(推薦! 能夠節省實例對象佔用的內存空間)

類屬性能夠定義成私有的,類屬性名前面加__

類屬性只能經過類對象修改,實例對象沒法修改
類對象名.類屬性 = 新的類屬性值
-------------------------------------------------------------------------------------------------------
類方法
定義格式
在方法定義的上面使用裝飾器 @classmethod 把下面的方法定義爲類方法
如
@classmethod
def 方法名.(cls, 形參,形參):
方法體

第一形參必須是 cls(類對象)

訪問方式
實例對象名.類方法名()
類對象名.類方法名()

-------------------------------------------------------------------------------------------------------
靜態方法

特色
定義的時候須要用到裝飾器:@staticmethod這個裝飾器用來表示下邊的方法是靜態方法
靜態方法中沒法訪問實例屬性實例方法(得不到self)
能夠訪問類屬性.類方法

定義格式
在定義方法的上面一行使用裝飾器@staticmethod
第一個形參是普通參數,不能是self 或cls

 

調用方式
實例對象.靜態方法名(實參1,實參2..)
類對象.靜態方法名(實參1,實參2..)(推薦!!)

 

由來

工具類裏面定義的方法通常都是靜態方法

-------------------------------------------------------------------------------------------------------
多態
多態只是一種寫法
在調用父類方法的地方也能夠調用子類的方法的狀況就叫多態

使用多態的步驟
子類繼承父類
子類重寫父類的方法
經過子類對象調用這個重寫過的方法

提升函數/方法的拓展性,可維護性

-------------------------------------------------------------------------------------------------------
異常
程序中報出來的錯誤信息
異常類
用來描述某一類異常,python解釋器自帶了不少個異常類

異常若是不處理python解釋器會在控制檯打印錯誤信息,並終止程序運行!

處理異常的目的
保證後續的代碼可以正常運行

python解釋器處理異常的原理
python解釋器在出錯的那一行代碼的地方根據錯誤緣由選擇異常類建立對象而後向外拋出,拋給她的調用者
調用者沒法處理而後一層一層繼續向外拋出
最後拋向python解釋器
python 解釋器最後在控制檯打印錯誤信息,而且終止程序運行!
-------------------------------------------------------------------------------------------------------
處理異常的基本格式
try:
可能出現異常的代碼塊

except:
處理異常的代碼塊

except後面跟上你以爲會出現的異常的類型(若是不肯定異常類型就是用Exception),而後as給一個變量,能夠打印變量獲得異常的類型
先執行try裏面的代碼,看是否出現異常
若是出錯就會執行except裏面的代碼,若是沒有出現異常就不會執行except裏面的代碼
-------------------------------------------------------------------------------------------------------
懷疑哪些代碼會出現異常,就用try...except..將它們包起來
-------------------------------------------------------------------------------------------------------
處理異常的三種方式
一次性所有捕獲,一次性所有處理(不智能,須要人爲再取分析,except後面跟上你以爲會出現的異常的類型,而後as給一個變量,能夠打印變量獲得異常的類型)
分別捕獲,分別處理(每一行都使用try...except..進行捕獲,也能夠打印錯誤類型,不建議使用)

一次捕獲,分別處理()
try
可能出現異常的代碼塊
except 異常類型名 as 異常變量名:
打印異常變量名
except 異常類型名 as 異常變量名:
打印異常變量名
except 異常 類型名 as 異常變量名:
打印異常變量名
....
-------------------------------------------------------------------------------------------------------
處理異常的格式

基本格式:
try:
可能出現異常的代碼塊
except:
處理異常的代碼塊

else格式
try:
可能出現異常的代碼塊
except:
處理異常的代碼塊
else:
沒有出現異常時必定會執行的代碼(用來驗證懷疑的代碼是否有異常)

若是出現異常就會執行except裏面的代碼,不會執行else裏面的代碼
若是沒有出現異常,就會執行else裏面的代碼,不會執行except裏面的代碼

finally格式
try:
可能出現異常的代碼塊
except:
處理異常的代碼塊
finally:
無論有沒有出現異常,也無論異常有沒有被捕獲住一,定會執行的代碼
(一般用來作釋放資源的事情,好比關閉文件,關閉數據庫鏈接)
-------------------------------------------------------------------------------------------------------
異常的跨函數傳遞

python解釋器在出錯的那一行代碼的地方根據錯誤緣由選擇異常類建立對象而後向外拋出,拋給她的調用者
調用者沒法處理而後一層一層繼續向外拋出
最後拋向python解釋器
python 解釋器最後在控制檯打印錯誤信息,而且終止程序運行!

異常被捕獲主以後,後續的try就沒法捕獲住這個異常了

 

-------------------------------------------------------------------------------------------------------
自定義異常類
當python解釋器提供的異常類不能知足足本身的需求時

自定義異常類步驟:
本身定義一個類,繼承任意一個異常類
在自定義類中添加一個初始化方法
class AgeError(Exception):
def __init__(delf,msg):
self.msg = msg

拋出異常對象
先建立一個異常對象,而後使用raise關鍵字向外拋出
raise AgeError("msg的內容如提示信息等")
-------------------------------------------------------------------------------------------------------
模塊
一個.py文件就是一個模塊
能夠在模塊中定義全局變量,函數.類
使用import導入
使用模塊名.全局變量名
模塊名.函數名
模塊名.類名
調用
好處就是能夠一一對應進行調用

其它導入方式
import 模塊名 as 別名
能夠將模塊名進行縮短,使用別名調用,寫少些字

from...import....
from 模塊名import 全局變量名, 函數名, 類名 -->也可使用as取別名
須要使用 啥就導入啥

from 模塊名 import *
使用時須要在模塊文件中使用__all__變量定義但願以這種方式導入的東西 格式爲__all__ = ["全局變量名","函數名","類名等"]
-------------------------------------------------------------------------------------------------------
__name__變量
若是文件時主動執行文件,__name__變量的 值就是main
若是文件時被動執行文件,__name__變量的 值就是文件名(模塊名)

在模塊文件中使用,不但願測試代碼在調用時被執行顯示
if __name__ == "__main__":
測試代碼塊
-------------------------------------------------------------------------------------------------------
包
工程目錄下面的一個文件夾
建立包就是建立文件夾

用來分類管理工程文件,

常常按照功能來管理功能模塊

包的命名規則與變量的命名相似

多層包命名格式
com.項目名.包名

項目名按照大駝峯命名規則
英文單詞的縮寫,取首字母大寫

導包是爲了導入模塊文件
訪問包裏面的模塊文件時須要把包名的路徑寫全

導包的方法

import 包名
在init文件名中使用 from.import文件名 肯定須要導入的文件
在調用的時候配合 import包名 使用

import 包名.模塊名
import 包名.模塊名 as 別名
from 包名.模塊名import ...
from 父包名.子包名.模塊名 import ...

from 包名 import *
在__init__文件中必須使用__all__指定須要導入的模塊名
格式: __all__ = ["模塊名1". "模塊名2", ....]

-------------------------------------------------------------------------------------------------------

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

enumerate()
enumerate()函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合爲一個索引序列，同時列出數據和數據下標，通常用在 for 循環當中。

 

vim -ON 文件1 文件2 文件3 ---> vim同時打開多個文件

GIL 全局解釋器鎖

保證了同一時刻只有一個線程可使用cpu 一個進程只有一個GIL鎖
線程搶到GIL鎖就可使用cpu 併發交替執行任務
也有可能各搶到一半,時間片極短,資源監控沒法監控到這麼短的時間 其實在這個時間段此線程是100%佔用cpu

GIL 對進程不會形成影響

GIL鎖會釋放的狀況
1 線程超時
2 線程遇到阻塞
3 線程執行完成

sudo apt-get install lrzsz -y 安裝Xshell上傳下載文件
rz 上傳 sz下載
sudo apt-get install rar
安裝rar

cpu檢測工具 ps aux靜態顯示 top動態查看cpu後臺使用狀況 htop更加清晰地查看cpu後臺使用狀況

python 解釋器默認是cpython 解釋器 天生存在GIL鎖-->全局解釋器鎖

多線程爬取網絡比單線程性能高 由於遇到IO阻塞 會自動釋放GIL鎖
IO 密集型 使用cpu過程當中cpu有空閒 網絡地收發 文件地讀寫

解決GIL的三種方式
1 換成非Cpython解釋器
2 使用多進程
2 使用其它語言

用C語言實現
將c代碼編譯成動態庫
gcc xxx.c -shared -o libxxx.so
在python文件中導入並調用c的動態庫
多線程任務使用c的函數 用以解決GIL鎖的問題

 

深拷貝 淺拷貝

淺拷貝
copy 模塊的copy函數 copy.copy()
變量之間的賦值 本質上就是 引用的傳遞
優勢 1節省有限的空間 2 節省時間 節省建立的時間
缺點 沒法保證數據的獨立性 解決方式 使用深拷貝

a = [元素1的地址,元素2的地址]-->列表a的地址
|^等於^| |^等於^| |不等|
b = [元素1的地址,元素2的地址]-->列表b的地址

淺拷貝copy.copy()對於可變數據類型對象拷貝時,僅僅是拷貝頂層對象(子元素指向引用),不考慮元素的類型
淺拷貝copy.copy()對於不可變數據類型對象拷貝時,引用指向 不考慮子元素數據類型

深拷貝
copy模塊的deepcopy()函數 copy.deepcopy()
深拷貝copy.deepcopy()對於可變數據類型,要作頂層拷貝,子元素是否拷貝要看數據類型(不可變數據類型引用指向,可變數據類型拷貝)

深拷貝copy.deepcopy()對於不可變數據類型對象拷貝時,子元素都是不可變數據類型,不拷貝引用指向,
深拷貝copy.deepcopy()對於不可變數據類型對象拷貝時,若是子元素存在可變數據類型,要拷貝頂層對象,而且拷貝元素

import 模塊 和 from 模塊 import * 的區別

sys模塊 中的變量path
sys.path 表示 解釋器尋找模塊要掃描的路徑
path 的返回值是一個列表
[
第一行''表示當前路徑
]

能夠將要添加的模塊文件路徑添加到sys.path中
sys.append("要/添加/的模塊/的路徑) 而後再使用import 導入模塊文件名
臨時性添加,環境關閉後就消失了

sys.path.insert(位置索引,"要/添加/的模塊/的路徑") 而後再使用import 導入模塊文件名
臨時性添加,環境關閉後就消失了
+----------------------------------------------------------------------------+
| 將模塊文件的路徑添加到 系統環境變量的配置文件(.bashrc)中 在文件末尾添加 |
| vim .bashrc 打開 |
+ export PYTHONPATH=$PYTHONPATH:要/添加/的模塊/的路徑 +
| 保存退出 |
| 刷新文件 source.bashrc |
| 永久添加模塊文件的路徑 (能夠用來添加第三方模塊) |
+----------------------------------------------------------------------------+
修改模塊文件內容後須要從新加載模塊文件
import 導入模塊只有第一次導入生效,以防止重複導入
如須要修改模塊文件內容,須要從新加載模塊
from imp import reload
reload(模塊文件名)

前單置下劃線的變量在使用 "from 模塊名 import *" 時 禁止導入, 在使用import * 時能夠導入
如_name = "XX"

python源.py文件命名並無特殊限制,可是要將源.py文件做爲模塊文件名的話就必須遵循變量名命名規範(數字,字母,下劃線組成,且不能以數字開頭),也不能與系統模塊名同名 如(socket,re,os,random...等)

 

多模塊開發的注意點

import 模塊名 調用模塊中的函數,變量 -->模塊名.函數名()/變量名
from 模塊名 import * 調用模塊中的函數,變量 -->直接調用 函數名()/變量名

from 模塊名 import * 導入的數據時導入全部-->把變量的值也導入 如變量值是不可變類型,那修改變量的值就失敗 調用的時變量的值依然是原值

封裝繼承多態進階
封裝
將代碼放進類裏面便於代碼的維護升級
繼承
減小代碼的重用 直接繼承父類的方法
多態
繼承父類
重寫父類的方法 添加本身的需求
將子類的實例對象做爲的參數傳到平臺中
再調用父類的方法

 

實例對象 不能直接訪問私有屬性
可是能夠經過 "實例對象._類名__私有屬性" 名字重整將私有屬性封裝起來 間接進行訪問 可是最好不用要自覺

正則表達式
從雜亂無序的數據中按照某種規則查找,匹配或者替換爲需求的數據.

導入 re 模塊 re(正則表達式模塊)
match() 匹配
變量 = re.match(正則表達式,要匹配的字符串) -->match 只顧頭不顧尾
匹配失敗返回None
經過group()方法獲取匹配成功的數據

元字符 : 具備匹配單個字符的特殊符號
. 匹配任意一個字符(除了\n)
[] 匹配[]中列舉的字符 [123]就是1 2 3 三個字符 [1-8]就是1到8
\d 匹配數字0-9
\D 匹配非數字
\s 匹配空格. tab鍵-->(\t)
\S 匹配非空格
\w 匹配非特殊字符,字母數字下劃線漢字
\W 匹配非字母數字下劃線漢字,特殊字符
* *前面的的一個字符出現任意屢次
+ +前面的一個字符至少出現一次
? ?前面的一個字符出現1次或者0次
{m}前面的一個字符出現m次 m能夠是個區間{2,5}-->2,3,4,5次均可以 {m,}m次到無限屢次

^ 匹配以什麼開頭 ^[xy]-->表示以什麼或什麼開頭 [^xy]-->表示不以什什麼均可以
$ 匹配以什麼結尾 從後往前找和開始將字符夾在在中間$

匹配分組
| 匹配左右任意一個表達式 --- 把多個字符放到分組中-->(a|b|c|d)括起來!
分組默認是從1開始的
(ab) 將括號裏的字符做爲一個分組
\num 引用分組num的數據 \1就是分組1
(?P<別名>正則表達式)

re模塊的高級用法
import re

search() 查找 返回一個對象
默認只查找一次,不是從頭開始查找

findall() 返回一個匹配成功的列表

sub("正則表達式","替換後的數據","要替換的數據,count=替換的次數,默認爲零所有替換") 替換
返回一個字符串--

split("正則表達式","要切割的的數據",maxsplit=最大切割次數) 切割

貪婪 和 非貪婪
貪婪 在知足正則表達式的條件的狀況下,取得越多越好
python 正則表達式默認是貪婪的
非貪婪 ?
?前面的正則表達式不能匹配?後面的數據

正則表達式前面加r就不用使用\進行轉義

1個進程最多打開1024個文件

多繼承 鑽石繼承--菱形繼承

多繼承單獨調用父類的方法
class Parent()
class Son1(Parent)
父類名.方法名
class Son2(Parent)
父類名.方法名(self,參數)
class Grandson(Son1.Son2)
父類名.方法名
父類名.方法名
GrandSon類的實例對象
致使頂層父類被調用兩次

解決方法 使用super()調用父類方法 -- MRO順序
定義方法(self,參數,不定長參數組包接受多餘參數)
super().方法名(參數,不定長參數解包)-->參數不須要self
查看MRO順序表(當前類名.__mro__)
調用順序由MRO順序表決定
當前類去MRO順序表中查找當前的類,若是相等,就調用當前類在MRO順序表中的的下一個類的重寫的方法

super() 能夠指定要調用的父類
super(指定父類名,self).方法名(參數,不定長參數解包)
再去MRO順序表中找指定的父類名,調用指定的父類的下一個類的重寫的方法

MRO順序表是由python解釋器中的C3算法產生的

 

不定長參數拆包
*args 在定義函數時做爲參數的功能是組包
**kwargs 在定義函數時做爲參數的功能是組包

*args 在調用時做爲函數參數 的功能是拆包
**kwargs 在調用時做爲函數參數 的功能是拆包

property 屬性
在定義時像函數同樣 在使用時像屬性同樣 的特殊屬性
把方法封裝成屬性,簡化調用流程

建立的兩種方式
1 裝飾器
@property 建立屬性--------->使用實例對象調用
@方法名.setter設置屬性值 -->使用實例對象賦值調用
@方法名.deleter刪除屬性值-->使用del 調用

2 類屬性
建立類:
def __init__(self): 初始化
def get(self): 獲取值
def set(self,參數): 設置值
def del(self): 刪除值
類屬性 = property(get,set,del,"description...")-->四個參數
建立實例對象
實例對象.類屬性 獲取實例對象值
實例對象.類屬性=值 設置實例對象值
del 實例對象.類屬性 刪除實例對象值

type 建立 -->類對象建立 -->實例對象
type類是全部類的祖宗類 type類由type類本身自己建立type類是造物主 object類也是由type類建立的

魔法屬性/魔法方法
__doc__
類的描述信息,就是類的註釋

__module__():
當前操做對象在哪一個模塊
__class__():
當前操做對象的類是什麼

__new__():---+
開闢內存 |
__init__():--+
初始化方法,建立類時自動觸發執行
__del__():
對象在內存中即將被釋放時自動觸發執行 釋放實例對象佔用的內存

__call__():
實例對象後面加括號自動觸發執行

__str__():
打印對象的屬性信息時返回該對象的信息

__dict__
類和對象裏的全部屬性

__getitem__():
__setitem__():
__delitem__():
把實例對象看成字典使用

實例對象能夠訪問實例方法,類方法,靜態方法
類對象能夠訪問類方法,靜態方法,不能夠訪問實例方法,實例方法屬於實例對象

hasattr(對象,"要查看的屬性")
查看對象有沒有這個屬性 有True 無 False
getattr(對象,"要獲取值的屬性")
獲取對象指定的屬性的屬性值
setattr(對象,"屬性","值")
設置對象的屬性值

with 與 上下文管理器
with open("文件的路徑","方式") as f:
f.write("數據")

上下文管理器
本質上就是可以支持with操做
任何實現了__enter__()和__exit__()方法的對象均可以稱之爲上下文管理器,上下文管理器對象可使用with方法
定義一個類:
初始化
文件名
操做方式
__enter__()方法返回資源對象,就是你將要打開的那個文件對象-->上文 完成一些相關的操做
self.f = open (self.文件名 ,self.模式)
return self.f
__exit__()方法處理一些資源清楚工做------------------------>下文 釋放資源的操做
self.f.close()
使用上下文管理器
with 類名 ("文件路徑", "模式") as f:
f.write("數據")

open()方法裏面已經實現了上下文管理器,因此打開操做文件時能夠直接使用 with open()...

 

使用contextmanager 實現上下文管理器
from contextlib import contextmanager

@contextmanager
def 函數(參數,參數):
上文
文件對象 = 打開文件
yield 文件對象
下文
關閉文件

使用上下文管理器
with 函數名 ("文件路徑", "模式") as f:
f.write("數據")

 

函數名就是一個變量 指向引用的函數體的空間
函數名之間的賦值本質就是引用的傳遞
函數名能夠做爲函數參數進行傳遞

類對象就是類模板

 

閉包
就是一種節省內存資源的特殊語法 相比於面向對象佔用更少的資源空間-->輕量級的面向對象
缺點:不能開發大程序,只能實現小的功能

閉包的三要素
1函數的嵌套定義
2內層函數使用了外層函數的變量或參數
3外層函數要返回內層函數的引用

定義閉包
def 外層函數(參數):
def 內層函數(參數):
內層函數的處理過程
return 內層函數的引用

實現 y = k*x + b
def func(k,b):
def create_y(x):
print(k*x + b)
return create_y

建立閉包
f1 = func(1,2)
f1(0)
f1(1)
f1(2)

修改閉包中的變量或者參數
定義閉包
建立閉包
閉包變量名() 調用的是內層函數

在內層函數中使用外層函數的變量 須要使用 nonlocal 變量名 進行聲明

斜率? 拮据? 方程? 是什麼?

匿名函數->a = lambda x ,y:x + y 完成最簡單的功能 做爲函數參數傳遞時完成的是 功能
函數----->完成較爲複雜的功能 做爲函數參數傳遞時完成的是 功能
閉包----->能夠完成比函數更爲複雜的功能 做爲函數參數傳遞時完成的是 功能+數據(外層函數給的)
實例對象->能夠完成最爲複雜的功能 做爲函數參數傳遞時完成的是 不少的功能+不少的數據

裝飾器
做用 :在不修改函數的源代碼的狀況下對函數的功能實現拓展 要麼在函數調用以前要麼在函數調用以後添加
裝飾器做用的對象就是: 函數或者方法

裝飾器基於 閉包 常常用到的功能基礎功能

裝飾器的實現
定義 一個閉包
定義外層函數
定義內層函數
實現功能使用外層函數的變量或者參數
返回內層函數的引用

@外層函數名
定義一個函~數
函數體

函~數()-->調用內層函數

@外層函數名(裝飾器的靈魂代碼) 至關於 函~數 = 外層函數(函~數) 下面緊接着的是函數才進行裝飾 不然不裝飾
裝飾器在函數調用以前就開始裝飾了

裝飾的順序最靠近函數的先裝飾
函數調用的順序是從上往下

 

使用類做爲裝飾器

先定義一個類(繼承自object):
初始化(形參)
self.形參 = xx

定義__call__方法():
return self.func()

@類名
定義一個函數:
函數體
return "----"
函數名()

使用同一個裝飾器對不一樣的函數進行裝飾時完成不一樣的裝飾功能

真正實現
在裝飾器@外層函數(參數)時傳參
在定義閉包時添加一層外層函數
在內層函數中對參數進行判斷

裝飾器 遵循開放封閉原則--->不能對原來的函數進行修改,傳參

 

miniweb 框架

框架的概念
靜態資源 通常是不須要進行修改的資源 如圖片(png,jpg,img)js資源,css資源,字體庫等不須要常常修改的資源
動態資源 根據用戶不一樣的需求返回不一樣的結果數據,通常就是從數據庫中查詢出來的數據
模板 具備必定格式的空網頁

常見的web服務器
nginx apache lighttpd IIS

常見的web框架 flask django tornado web.py aiohttp sanic bottle vibora
web服務器 --WSGI協議-->web框架

sys模塊的sys.argv 會獲取命令行的參數以列表的方式保存

瀏覽器回車一次服務器端接受到屢次請求 是由於 瀏覽器檢查當前網頁中還有新的鏈接請求會再次向服務器發送連接請求

format 格式化輸出
---->>>{}<<<---.format(字符串)

服務端send數據發送不完整可使用sendall()發送

html 能夠做爲靜態資源文件也能夠做爲動態資源文件
做爲靜態資源文件時不須要修改html文件中的內容
做爲動態資源時就是一個模板(具備必定格式的空網頁),須要從數據庫中查詢出數據填充網頁返回給瀏覽器

pycharm 遇到模塊導入報紅須要 刷新source 設置 -->項目-->選中當前文件夾

本身定義的包要想給別人使用須要在在包中建立__init__.py

WSFI協議框架 規定了服務器如何調用web框架,web框架如何將數據返回給web服務器 字典存儲數據

打開模板文件 讀取
with open("模板文件路徑","r") as f
file_content= f.read()
模擬從數據庫中查詢數據
data_from_mydql = "have func"
將數據庫中查到的數據替換模板中的{{content}}
html_content= file_content.replace("{{content}}",data_from_mysql)
返回替換後的數據
return ytml_content

路由

Django定義路由的方式 定一個路由表
route_list = [("頁面路徑",對應函數名),("頁面路徑",對應的函數名),("頁面路徑",對應的函數名),...]
添加路由 瀏覽器請求的路徑在路由列表中存在遍歷列表就能夠了,免去繁雜的判斷語句

flask 使用的是帶有參數的裝飾器
定義一個路由列表 route_list = []

定義一個閉包函數
def route(path):
def func(func):
route_list.append((path,func))
def inner();
pass
return inner
return func

@route("頁面路徑.html")
def 處理頁面數據對應的函數():
pass

...

使用上下文管理器的方式操做數據庫
class MySql(object):
def __init__(self):
self.conn=connect(host="localhost",port=3306,user="",password="",database=""cahrset="utf8")
self.cur=self.conn.cursor()
def __enter__(self):
return self.cru
def __exit__(self):
self.cur.close()
self.conn.close()

獲取遊標對象的數據 cur.fetchall()

a = ((1,2,3,4,5),(6,7,8,9,0))for value in a: print("%s:%s:%s:%s:%s" % value)每一個小元組中的元素會在自動填充佔位符%s-->元組的格式化拼接