Python的重要知識點匯總1

python字典的鍵值對輸出次序問題:

在2.7-3.5的python版本中，字典的鍵值對是按照哈希表的存儲順序排列輸出的，

而在3.6及以上版本中， 字典的鍵值對是按照初始化時的排列順序輸出的。

python 中 可變類型 和 不可變類型：

將python中的類型分為 兩個大類，可變 和 不可變，

可變：list dict set 

不可變：str,int(float),bool,tuple  

python 中的緩存  和 小數據池：

 

 

小數據池 指的是 不同代碼塊下的 緩存機制，只是 縮小了 數字 的范圍， 和 少的字符串，  都是為了提升性能，   

python 中 深淺copy：

對於一個 嵌套的列表，

淺copy 是只新 copy 一個列表外殼，

深copy 除了copy 一個新的列表外殼，內部的也會copy新的內存，  

def func():
    #1, 賦值 不 創建新內存空間
    '''
        a = [1,2,3 ,[4,5,6]]
        b = a
        print(id(a),id(b))
        print(id(a[-1]),id(b[-1]))
    '''

    # copy 指的就是要創建新的 內存空間
    #2,淺copy
    '''
    c = [1, 2, 3, [4, 5, 6]]
    d = c.copy() # 這是淺copy
    print(id(c),id(d))
    print(id(c[-1]),id(d[-1]))
    # 所以淺copy 只是copy 一個外殼 
    '''

    #3,深copy 創建新的內存空間最多
    '''
    from copy import deepcopy
    e = [1, 2, 3, [4, 5, 6]]
    f = deepcopy(e)
    print(id(e),id(f))
    print(id(e[-1]),id(f[-1]))
    '''
    # 所以，深copy 不只是新創建了一個殼子，而且也新創建了 里面的小殼子
    
if __name__ == '__main__':
    func()

 

注： python 對深copy 也不是一味的開辟新內存，它是有條件的，對於不可變類型是不會 開辟的，例如：str,int ,float ,tuple! 

還有，切片操作是 淺copy ,

    l1 = [1,2,3,[11,22,33]]
    l2 = l1[:] (淺copy ) 3     l1.append(666)
    print(l1)
    print(l2)

 

Python中 可以給數據  組合加上 索引的enumerate 函數：

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

def func():
    '''
    l = ["tom","a","b"]

    ret = enumerate(l)
    print(ret) # <enumerate object at 0x0371E198> #該對象 可迭代
    for item in ret:
        print(item)
    '''

    '''
    s = "abcdefg"
    ret = enumerate(s)
    print(ret)
    for item in ret:
        print(item)
    '''

    s = "woqu"
    # 多用於 for in 結構
    for item in enumerate(s):
        print(item)
        



if __name__ == '__main__':
    func()

 

Python中 編碼 Unicode 和  utf-8/gbk  相關：

def func():

    s = "hello 世界"  #s 是在內存中，它是Unicode 編碼，（必須要轉為 非unicode 才可以用於 網絡傳輸 或 保存到硬盤 ）
    print(s,type(s))
    
    #Python 中 所有的數據類型里，只有 字節類型(bytes) 的編碼方式 是 非unicode
    
    b = s.encode() # 默認編碼 utf8 一個漢字 3個字節 # b此時在內存 是utf8 編碼 b數據類型是bytes  
    print(b,type(b))

    c = s.encode(encoding="gbk") #gbk 一個漢字2個字節 # c 此時在內存中是  gbk編碼 c數據類型是 bytes
    print(c,type(c))

    # 如何將c （gbk）: hello \xca\xc0\xbd\xe7   轉為 b(utf8) :hello \xe4\xb8\x96\xe7\x95\x8c  呢？
    # 這要通過 unicode 中間 轉化，  因此需要通過 str 類型 （unicode）  轉化，  
    '''
    # d = c.decode(encoding="utf8") # 這肯定不行，c 是以 gbk編碼的，必須以 gbk解碼
    d = c.decode(encoding="gbk")
    print(d,type(d))    

    # 然后 再將 d 轉為 utf8
    e = d.encode(encoding="utf8")
    print(e,type(e))

    '''
    
    # 總結： 
    # 1,內存中的數據類型 除了bytes 都是 Unicode ，
    # 2,要想保存硬盤 或網絡傳輸 必須要是 非Unicode ( utf8 / gbk), 所以，保存 或 傳輸 要轉為 bytes 類型  
    # 3,非 Unicode 之間 如果想互轉 要通過Unicode 來轉

if __name__ == '__main__':
    func()

 

bytes 的使用： 

 

 

 不過，以后不會直接用 str 中轉  ，因為如果字典 沒辦法直接 變為 str ，和 從str 再變回來， 一般使用json 模塊 的loads()  和 dumps() ，

如下：

import json
def func():
    d = {'name':'a'}

    # 將字典 變為 utf8 用於傳輸 
    ret = json.dumps(d).encode("utf8")
    print(ret,type(ret) )

    # loads 直接可以轉為 程序中使用的字典  
    ret2 = json.loads(ret)
    print(ret2,type(ret2))

if __name__ == '__main__':
    func()

 

Python  中的 *args 和 **kwargs  :  

def func(a,*args,b=0,**kwargs):  #位置參數  和 關鍵字參數  和 args 和 kwargs  的順序 
    print(a)
    print(b)
    print(args)
    print(kwargs)

if __name__ == '__main__':
    func(1,2,1,2,b=10,d=1)

 

注：形參位置 *  和 ** 代表的都是聚合，  *代表把位置參數聚合成一個元祖，  ** 代表把關鍵字參數聚合成一個 字典  。

　　實參位置的*  和 ** 代表 的是打散， 

'''
def func():
    a= [1,2,3]
    print(a)
    print(*a)  # 在實參位置 * 代表打散
'''
def func2(a,b,c):
    print(a)
    print(b)
    print(c)

def func3(name,age):
    print(name)
    print(age)


if __name__ == '__main__':
    # func()

    temp = [1,2,3]
    func2(*temp) # * 在實參位置 處代表 打散 --> func2(1,2,3)

    temp = {"name":"tom","age":18}
    func3(**temp) # ** 在實參位置 代表 打散 --> func3(name='tom',age=18)

    # 注： 實參位置要求 只要是可迭代對象 都可以被* 或 ** 打散
    # 例如
    '''
    temp = "abc"
    def func4(a,b,c):
        print(a)
        print(b)
        print(c)

    func4(*temp)
    '''

 

*的其他用法：

* 除了可以 聚合  和 打散之外，還可以用於 處理剩下的元素：

def func():
    a,*b = range(1,10)
    print(a)  #1
    print(b)  #[2, 3, 4, 5, 6, 7, 8, 9]

if __name__ == '__main__':
    func()

 

Python  中的 命名空間  :  

總共有 三個命名空間：  內置 命名空間，  全局命名空間，局部命名空間， 

它的加載順序是 ： 內置命名空間 -->  全局命名空間 --> 局部命名空間。  

 

查找變量順序 符合 就近原則 ！  

 

Python  中的 作用域:  

總共兩個 作用域：

全局作用域：  內置命名空間  和  全局命名空間 

局部作用域： 局部命名空間 

 

局部作用域 里  只可以使用（不可修改）全局作用域里的 變量，   

 

 

 此時會報錯，為什么？

因為 當我們在局部作用域中修改一個 變量的時候，解釋器會認為我們已經在局部作用域定義了這個變量，所以報錯，

UnboundLocalError: local variable 'num' referenced before assignment 

 

解決方法：可以使用global 關鍵字 把num 聲明為 全局作用域中  的變量num ,此時就可以更改了。

 

 

除了，局部 和 全局， 如果局部中又有 局部，也是如此~  

Python  中的 高階函數 :  

高階函數：一個函數可以作為參數傳給另外一個函數，或者作為一個函數的返回值，滿足其一則為高階函數。

def test():
    print("I am test")

def func(f):
    print("I am func")
    f()
    return f

if __name__ == '__main__':
    ret = func(test) # func() 函數的參數為 一個函數， 故func() 為高階函數
    
    # func() 函數的 返回值 為一個函數，故func() 為高階函數 
    ret() 

常見的高階函數： map() reduce() filter()  它們也都是內置函數  

 

def add(x):
    return x+1

def test():
    l = [1, 2, 3, 4, 5]
    ret = map(add,l)  # 因為 內置函數map 的參數 有一個為函數，故為高階函數
    print(ret)
    print(list(ret))


if __name__ == '__main__':
    test()

def isTrue(x):
    if x>20:
        return True

def func():
    l = [17,18,19,20,21,22,23]
    ret = filter(isTrue,l)
    print(ret)
    print(list(ret))


if __name__ == '__main__':
    func()

 

from functools import reduce   # reduce 使用的時候要先導入

def test(x,y): # 定義 reduce 的方式
    return 2*x + y

def func():
    l = [17,18,19,20,21,22]
    ret = reduce(test,l) # 整個過程等同於： 2*(2*(2*(2*(2*17 + 18)+19)+20)+21)+22
    print(ret)
    print(2*(2*(2*(2*(2*17 + 18)+19)+20)+21)+22)

if __name__ == '__main__':
    func()

注：reduce 使用前要導入  

總結： map 和  filter 是迭代的時候 不管前后元素，   reduce 迭代的時候 是前后元素一起來的，  

Python  中的 globals（） 和  locals() 兩個內置函數  :  

    globals() 返回一個字典：包含全局作用域（內置+全局） 中的所有內容 
    locals()  返回一個字典：包含當前作用域 中的所有內容  

name = "tom"
age = 18
def func():
    a = 1
    b = 'jack'

    print(globals())
    print(locals())


if __name__ == '__main__':
    print(globals())
    print(locals())
    func()
'''
    總結： 
    globals() 返回一個字典：包含全局作用域（內置+全局） 中的所有內容 
    locals()  返回一個字典：包含當前作用域 中的所有內容  
'''

  

Python 函數的 默認參數的坑：

默認參數針對的是形參，

def func(a,l=[]): # 默認參數的 坑 （只針對 可變數據類型  ）
    l.append(a)
    return l

if __name__ == '__main__':
    ret = func('tom')
    print(ret)  # ['tom']
    ret2 = func('jack')
    print(ret2) # ['tom', 'jack']  按理說應該是 ['jack'] 
    #總結： 對於默認參數，如果是可變數據類型，那么為了 提高性能 也是不會重復創建的 

def func(a,l=[]):
    l.append(a)
    return l

if __name__ == '__main__':
    ret1 = func(1)
    print(ret1)
    ret2 = func(2,[])
    print(ret2)
    ret3 = func(3)
    print(ret3)
    # 其中 ret1 和 ret3 是同一個內存地址  ret2 是另一個內存地址  

 

對於 默認參數，如果是可變類型，如果不傳入的話，沿用的還是同一個，如果傳入 的話，是新的一個 。

Python 中的 偏函數： 

它的作用是：將函數  和 實參 存起來，執行時一起執行，

from functools import partial  # 偏函數

def sumTwo(a,b):
    return a+b

new_sum = partial(sumTwo,1,2)

# print(new_sum)
print(new_sum())

 

它在flask 的源碼中可以看到，

 

 

Python  中  global 和 nonlocal 關鍵字： 

 1，global 關鍵字 是在 “局部” 作用域 聲明一個全局變量 。  

def func():
    global num 3     num = 10

if __name__ == '__main__':
    func()
    print(num)

在局部的局部也可用 global 聲明一個全局變量，

def func():
    def test():
        global num
        num = 10
    test()


if __name__ == '__main__':
    func()
    print(num)

global 關鍵字也可以修改全局變量，   

 

2，nonlocal 關鍵字 

（1）不能操作全局變量 

（2）它主要是 內層函數  對 外層函數  變量 進行修改   

def func():
    num = 1
    def a():
        def test():
            nonlocal num
            num = 10
        test()
    print(num)
    a()
    print(num)

if __name__ == '__main__':
    func()

Python  中 獲取一個對象的所有方法名字 返回一個列表  dir() 內置函數：

l = [1,2,3,4]

if __name__ == '__main__':
    print(dir(l)) 
    '''
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    '''
    #因為 __iter__ 在里面，__next__ 不在里面，所以列表對象是 可迭代對象， 但是不是迭代器對象  

 

Python 中 dir()  和 __dict__() 的區別： 

在python中__dict__與dir()都可以返回一個對象的屬性，區別在於：

1，__dict__是對象的一個屬性，而dir()是一個內置函數  

2，__dict__返回一個對象的屬性名和值，即dict類型，而dir()返回一個屬性名的list；

3，__dict__不是每一個對象都有，而dir()對各種類型對象都起作用，如module, type, class, object；

4，_dict__只返回對象的可寫屬性（writable attributes），而dir()返回各種相關（relavent）屬性，且對於不同類型對象，作用不同。

 

Python  中 可迭代對象 和  迭代器對象： 

可迭代對象： 對象所對應類 的中 有 __iter__() 保留方法，  

迭代器對象：對象所對應的類 中有 __iter__() 並且 也有 __next__() 保留方法， 

因此，一個對象如果是迭代器對象，那么必是可迭代對象，但是是可迭代對象 不一定是迭代器對象 。  

 

from _collections_abc import Iterable,Iterator 2 l = [1,2,3,4]
if __name__ == '__main__':
    print(issubclass(type(l), Iterable)) # Iterable 內部是驗證 是否有 __iter__ 保留方法
    print(issubclass(type(l), Iterator)) # Iterator 內部是驗證 是否有 __iter__ 和 __next__ 保留方法
    

Iterable 用來檢查是否是 可迭代對象，

Iterator 用來檢查是否是 迭代器對象 ，

 

可迭代對象 不可以直接遍歷， 迭代器才可以遍歷，  

Python  中如何將  可迭代對象 轉化為  迭代器對象： 

通過 iter() 內置函數  / .__Iter__()  進行轉換

from _collections_abc import Iterator
l = [1,2,3,4]

if __name__ == '__main__':
    # 已知 l 是可迭代對象，但不是 迭代器對象
    ret = iter(l)
    print(type(ret),issubclass(type(ret),Iterator))

可迭代對象 是不可以直接取值的，（之所以 for 循環可以取值，是for in 結構內部做了轉換 ，已經轉換為了 迭代器對象，  ）

Python  中如何 使用  迭代器對象： 

通過next() 內置函數，或者 .__next__()  方法來取 迭代器對象中的值， 

 

 

 

 

 

使用  迭代器對象 的特點： 

優點：

　　1，節省內存

　　2，惰性機制，next()一次，取一個值

缺點：

　　1，速度慢

　　2，只能遍歷一次 

Python  中 生成器 對象： 

生成器對象 是迭代器對象 的一種，

 

構建  生成器對象  的方法：

1，生成器函數   的返回值，

什么是生成器函數呢？ 函數中有 yield  關鍵字 即為生成器函數  

def func():
    print('a')
    print('a')
    yield 3

print(func) # func 仍然是個 函數 <function func at 0x10E8EFA8>
ret = func()
print(ret) # ret 是個生成器對象  <generator object func at 0x0362F150>

2，生成器表達式  的返回值  

ret = (i for i in range(10))
print(ret)  #<generator object <genexpr> at 0x0362F120>

 

1，生成器 函數：

在 Python 中，有 yield 的 函數   被稱為生成器函數 ，

生成器每次到  調用yield時 會暫停，而可以使用next()函數和send()函數恢復生成器。

def func():
    print('a')
    a = yield 3   #暫停點
    print("=======")
    print(a)
    print('b')
    yield 2

ret = func()
# ret 為一個生成器對象
ret1 = next(ret)
print(ret1)

ret2 = next(ret)
print(ret2)

'''
a
3
=======
None 22 b
2

'''

def func():
    print('a')
    a = yield 3
    print("=======")
    print(a)
    print('b')
    yield 2

ret = func()
# ret 為一個生成器對象
ret1 = next(ret)
print(ret1)

ret2 = ret.send({'name':'tom'})
print(ret2)
'''
a
3
=======
{'name': 'tom'}
b
2
'''

def func():
    print('a')
    a = yield 3
    print("b")
    return 1
    yield 2
ret = func()
# ret 為生成器
ret1 = next(ret) # 第一次沒問題
ret2 = next(ret) # 第二次 return 就終止了生成器

 

yield from :

def func():
    yield [1,2,3,4]

ret = func()
# ret 為生成器
ret1 = next(ret)
print(ret1)
# ===========================================
def func():
    yield from [1,2,3,4]
ret2 = func()
# ret2 為生成器
ret3 = next(ret2)
print(ret3)

def func01():
    l1 = ['a','b','c']
    l2 = ['d','e','f']
    yield l1
    yield l2
ret = func01()
# ret 為生成器
ret2 = next(ret)
print(ret2)

ret3 = next(ret)
print(ret3)
print('======')

#====================================================================================
def func02():
    l1 = ['a','b','c']
    l2 = ['d','e','f']
    yield from l1
    yield from l2

ret = func02()
# ret 為生成過期
ret2 = next(ret)
print(ret2)

ret3 = next(ret)
print(ret3)

ret4 = next(ret)
print(ret4)

ret5 = next(ret)
print(ret5)

'''
['a', 'b', 'c']
['d', 'e', 'f']
======
a
b
c
d
'''

yield from 作用： 

優化了內層循環， 下例：

def func01():
    for i in [1,2,3]:
        for j in [4,5,6]:
            yield j
ret = func01() 
###############二者相比 少了一層循環##################
def func02():
    for i in [1,2,3]:
        yield [4,5,6]
ret = func02() 

 

 

 

2，生成器 表達式 ：

它只是把 列表 表達式  的[ ]  換成  （ ） 即可， 表達式的返回值 也是生成器對象 ， 

但是，列表 表達式 費內存，  生成器表達式 則是很省內存，   

 

Python 的 for in 結構： 

Python 中使用迭代器對象，生成器對象不用 一步一步 next()  ,

可以直接用 for in  結構  來遍歷，而且遍歷完 也不會 報錯，  

 

Python 68個內置函數：

一帶而過：

all()  any()  bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int()  iter() locals() next()  oct()  ord()  pow()    repr()  round()

 

repr() 原型畢露 函數 :

# 正常打印 一個字符串
print("hello") # 看不到引號

print(repr("hello"))

all()：

判斷一個可迭代對象 中   所有的元素都是真，才返回 True 

 

any(): 

判斷一個可迭代對象 中    有一個元素都是真，即返回 True 

 

 

 

重點：

abs() enumerate() filter()  map() max()  min() open()  range() print()  len()  list()  dict() str()  float() reversed()  set()  sorted()  sum()    tuple()  type()  zip()  dir() 

classmethod()  delattr() getattr() hasattr()  issubclass()  isinstance()  object() property()  setattr()  staticmethod()  super()

 

reversed():
它返回的是一個 迭代器對象，  它不會修改原來的數據 

 

Python  中 匿名函數 ： 

所謂的匿名 指的是定義函數的時候 沒有函數名，但是調用的時候，還是得用函數名調用。 

f = lambda x,y:x+y
  ret = f(1,6)  # 7 

 

Python  中 閉包： 

閉包：  在一個外函數中定義了一個內函數，內函數里 用了外函數作用域  的變量，並且   外函數的返回值是內函數的引用。

def outter():
    a = 10
    def innter():
        print(a)
    return innter
outter()()

一般情況下，如果一個函數結束，函數的內部所有東西都會釋放掉，還給內存，局部變量都會消失。

但是閉包是一種特殊情況，如果外函數在結束的時候發現有自己作用域的  變量將來會在內部函數中用到，就把這個 變量綁定給了內部函數，然后自己再結束。

這個變量會一直存在在內存中，啥時候 調用內函數，啥時候用它  。 

 

def outter():
    l = [1,2,3,4,5]
    def innter():
        l.append(6)  # 可變類型 l 是可以不用 nonlocal 的
        print(l)
        return l
    return innter
ret = outter()
# 此時outter() 已經結束了
for i in ret():
    print(i)

Python  中 裝飾器 ： 

當多個裝飾器的時候，執行是從下往上執行，

裝飾器 本質就是一個函數，這個函數的參數是 要被裝飾的函數名字，

python裝飾器（fuctional decorators）就是用於拓展原來函數功能的一種函數，目的是在不改變原函數名(或類名)的情況下，給函數增加新的功能。 

這個函數的特殊之處在於它的返回值也是一個函數，這個函數是內嵌“原“”函數。 

 

1， 被裝飾的函數 無參數  無返回值  ：

　　 a, 內函數 無返回值：

import time
def func():
    print("hello world")
    time.sleep(1)  # 模擬代碼執行

# 為了能不改func() 代碼的前提下 測量func執行時間，要使用裝飾器了

def dec(f): # 裝飾器函數的參數f 是個要被裝飾的 函數
    def inner():
        t1 = time.time()
        f()
        t = time.time() - t1
        print("耗時：",t)
    return inner
# 此時 dec 就是個裝飾器函數
dec(func)()

　　b, 內函數 有返回值：

import time
def func():
    print("hello world")
    time.sleep(1)  # 模擬代碼執行
    print("hello world")

# 為了能不改func() 代碼的前提下 測量func執行時間，要使用裝飾器了

def dec(f): # 裝飾器函數的參數 f 是個要被裝飾的 函數
    def inner():
        t1 = time.time()
        f()
        t = time.time() - t1
        return t
    return inner
# 此時 dec 就是個裝飾器函數
ret = dec(func)()
print("總耗時： ",ret)

2， 被裝飾的函數 有參數  有返回值  ：

內函數也有返回值：

import time
def func(name,age):
    print("hello I am ",name)
    time.sleep(1)  # 模擬代碼執行
    return age

def dec(f): # 裝飾器函數的參數f 是個要被裝飾的 函數
    def inner(name,age):
        t1 = time.time()
        ret = f(name,age)
        t = time.time() - t1
        print("func 函數的返回值： ",age)
        return t
    return inner

ret = dec(func)("tom",18)
print("總耗時： ",ret)

 

 

但是，上面的調用方式太麻煩，Python 提供了一個語法糖  即@ + 裝飾器名字  ，

語法糖（Syntactic sugar）是英國計算機科學家彼得·約翰·蘭達發明的一個術語，指計算機語言中添加的某種語法，這些語法沒有給程序增加新功能，但是對於程序員更“甜蜜”。語法糖提供了更易讀的編碼方式，可以提高開發效率。

import time

def dec(f): # 裝飾器函數的參數f 是個要被裝飾的 函數
    def inner(name,age):
        t1 = time.time()
        ret = f(name,age)
        t = time.time() - t1
        print("func 函數的返回值： ",age)
        return t
    return inner

@dec  # -->  func = dec(func)
def func(name,age):
    print("hello I am ",name)
    time.sleep(1)  # 模擬代碼執行
    return age

ret = func("tom",18)
print("總耗時： ",ret)

 

@ 后接的是個函數，不是直接的函數名， 

import time
def test():
    def dec(f): # 裝飾器函數的參數f 是個要被裝飾的 函數
        def inner(name,age):
            t1 = time.time()
            ret = f(name,age)
            t = time.time() - t1
            print("func 函數的返回值： ",age)
            return t
        return inner
    return dec

@test()  # 這里是先執行 test() 函數，這個函數返回dec 裝飾器
def func(name,age):
    print("hello I am ",name)
    time.sleep(1)  # 模擬代碼執行
    return age

ret = func("tom",18)
print("總耗時： ",ret)

 

多個裝飾器 裝飾同一個函數：

import time

def dec(f): # 裝飾器函數的參數f 是個要被裝飾的 函數
    def inner(name,age):
        t1 = time.time()
        ret = f(name,age)
        t = time.time() - t1
        print("func 函數的返回值： ",age)
        return t
    return inner

def dec2(f):
    def inner(name,age):
        f(name,age)
        print("你好,",name,"我再次裝飾一下")
    return inner
@dec
@dec2  # -->   func = dec(dec2(func))
def func(name,age):
    print("hello I am ",name)
    time.sleep(1)  # 模擬代碼執行
    return age

ret = func('tom',18) # --> dec(dec2(func))('tom',18)
print("總耗時： ",ret)

多個裝飾器的 順序：與聲明順序 相反，  

 

 

Python  中 內置裝飾器 ： 

在Python中有三個內置的裝飾器，都是跟class相關的：staticmethod、classmethod 和property。

• staticmethod 是類靜態方法，其跟成員方法的區別是沒有 self 參數，並且可以在類不進行實例化的情況下調用
• classmethod 與成員方法的區別在於所接收的第一個參數不是 self （類實例的指針），而是cls（當前類的具體類型）
• property 是屬性的意思，表示可以通過通過類實例直接訪問的信息

 

property 裝飾器 的 作用是：把一個方法 偽裝成一個屬性。  這個方法必須要有返回值，  而且一般它只有self 一個參數。  

 

property裝飾器的應用場景 ----  結合私有屬性使用   ：

class Person:
    def __init__(self,name):
        self.__name = name

    @property
    def name(self):
        return self.__name

p = Person('jack')
print(p.name)
p.name = 'tom'
'''
jack
Traceback (most recent call last):
  File "D:/.project/project_python/test02/bin/start.py", line 11, in <module>
    p.name = 'tom'
AttributeError: can't set attribute
'''

property 進階： 

上面代碼，如果我們是真的想改個名字，怎么辦呢？

class Person:
    def __init__(self,name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,new_val):
        self.__name = new_val


p = Person('jack')
print(p.name)  # 此時調用的是 @property裝飾的 name
p.name = 'tom' # 此時調用的是 @name.setter裝飾的 name
print(p.name)  # 此時調用的是 @property裝飾的 name
'''
jack
tom
'''

參看： https://www.liaoxuefeng.com/wiki/897692888725344/923030547069856

 

Python  中 模塊 ： 

什么是模塊：本質的就是 .py 文件， 它是封裝語句的 最小單位， 一行語句也得放到一個模塊中，

sys  模塊： 

模塊對象的使用： 

import sys
def f():
    print('aaaaaaa')
num = 10

m_obj = sys.modules['__main__']
print(m_obj)
m_obj.f()
print(m_obj.num)

 

 

datetime模塊： 

from datetime import date,time,timedelta
# 年月日
date = date(2020,2,27)
print(date)

# 時分秒
time = time(10,10,10)
print(time)

# 時間 delta 
# timedelta()

import datetime


t0  = datetime.datetime(2010,2,20)
t1  = datetime.datetime(2020,3,30)

res = t1 - t0
print(res)
print(type(res))
print(res.days)

 

 

 

json 和 pickle 模塊： 

json 模塊，不能完全將Python中 的全部數據類型 都序列化， 

 

於是，就有了 pickle 模塊，它可以完全序列化，  使用方法 和 json 模塊一樣，  dump  和 load  

 

二者區別： json 是跨語言的， pickle 不跨語言（只是Python 中使用），  

hashlib 模塊： 

它 封裝了一些 用於加密的類， 

加密的目的：是用於 判斷 和 驗證， 不是用於解密， 

 

不同模塊之間導入方法：

直接將項目 目錄添加到 sys.path ,然后每次 使用from import 使用  例如：

import sys
sys.path.append("../..") # 添加了 項目的 根目錄
from core import src
from lib import test 
def run():
    print("開始執行吧")
    src.main()

if __name__ == '__main__':
    run()

re模塊：

正則表達式

https://www.geeksforgeeks.org/regular-expression-python-examples-set-1/

https://www.geeksforgeeks.org/regular-expressions-python-set-1-search-match-find/

 

 

 

  

logging模塊： 

為什么要有log ，

1，排錯 

2，做數據分析  

3，追責  

 

可以通過 logging.basicConfig(level = logging.DEBUG)   類似的調整等級，  

寫日志，都是自己覺得 可能出錯的地方，寫一下，（都是自己寫）

 

日志的格式 設置 --  logging.basicConfig(） 來設置：

import logging

logging.basicConfig(
    format='%(asctime)s | %(name)s | %(levelname)s |%(module)s: %(lineno)d | %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)
logging.warning("func(1+20)") '''2020-02-27 17:27:25 PM | root | WARNING |start: 7 | func(1+20)     '''

 

上面都是輸出到 屏幕，下面輸出到 文件：  

還是在  logging.basicConfig(）

使用關鍵字 filename 來指定，一般文件命名以.log  結尾，而且，是追加的方式 寫文件，  

import logging

logging.basicConfig(
    format='%(asctime)s | %(name)s | %(levelname)s |%(module)s: %(lineno)d | %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    filename='my.log'
)
logging.warning("func(1+20) ")

 

如何同時 輸出到 屏幕 和 文件？

這時要用handlers 來指定 要輸出的文件描述符了， 此時也可以指定寫入文件時候的編碼了，  

import logging


fh = logging.FileHandler('my.log',encoding="utf8")
sh = logging.StreamHandler()
logging.basicConfig(
    format='%(asctime)s | %(name)s | %(levelname)s |%(module)s: %(lineno)d | %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    handlers=[fh,sh]
)
logging.warning("func(1+20) ")

 

日志切割： 

import time
import logging
from logging import handlers  4 
sh = logging.StreamHandler()
rh = handlers.RotatingFileHandler('myapp.log', maxBytes=1024,backupCount=5)  # 按大小切割 最多5個備份
fh = handlers.TimedRotatingFileHandler(filename='x2.log', when='s', interval=5, encoding='utf-8') #  按時間切， when:按秒 ，

logging.basicConfig(  9 format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s', 10 datefmt='%Y-%m-%d %H:%M:%S %p', 11 handlers=[fh,sh,rh], 12 level=logging.ERROR 13 ) 14 15 for i in range(1,100000): 16 time.sleep(1) 17 logging.error('KeyboardInterrupt error %s'%str(i))

Python 面向對象相關知識：

參看：  

https://www.cnblogs.com/linhaifeng/articles/6204014.html#_label6

https://www.cnblogs.com/linhaifeng/articles/8029564.html

類對象 和 實例對象 的 屬性字典： 

class Demo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def run(self):
        print("跑")

# 類對象的 屬性字典
print(Demo.__dict__)
demo = Demo('tom',18)
# 實例對象的 屬性字典
print(demo.__dict__)
'''
{'__module__': '__main__', '__init__': <function Demo.__init__ at 0x10FCE0C0>, 'run': <function Demo.run at 0x10FCE078>, '__dict__': <attribute '__dict__' of 'Demo' objects>, '__weakref__': <attribute '__weakref__' of 'Demo' objects>, '__doc__': None}
{'name': 'tom', 'age': 18}
'''

 

類中的  一般方法 和 類方法  和 靜態方法： 

class Demo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def run(self):
        print("跑")

    @classmethod
    def test(cls):
        print("hahaha")

    @staticmethod
    def test02():
        print("我去")


Demo.test()  # 類方法 （其實里面有  參數 ）
Demo.test02() # 靜態方法 (沒參數 )
#===========
demo = Demo("name",18)
demo.run()  # 一般方法 （里面有 參數）

注：類方法  和  靜態方法 在使用的時候，其實是差不多的，   

 

 

類的 類  type(元類)  : 

類的類 是type  ,即類對象 是由 type 類產生的，  

type 是Pyhton一個內置類，Python中，任何class 定義的類  其實都是type 實例化的對象，  

 

其實定義類有兩種方式：

1，用class 

2,  用type 類

Demo = type('Demo',(object,),{'name':'tom',"age":18})
print(Demo.__dict__)

class Demo02:
    name:'tom'
    age:18
print(Demo02.__dict__ )
'''
{'name': 'tom', 'age': 18, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Demo' objects>, '__weakref__': <attribute '__weakref__' of 'Demo' objects>, '__doc__': None}
{'__module__': '__main__', '__annotations__': {'name': 'tom', 'age': 18}, '__dict__': <attribute '__dict__' of 'Demo02' objects>, '__weakref__': <attribute '__weakref__' of 'Demo02' objects>, '__doc__': None}
'''

def init(self,name,age):
    self.name = name
    self.age = age
def run(self):
    print("跑")

Demo = type('Demo',(object,),{'__init__':init,'run':run})
demo =Demo('tom',18)
print(demo.__dict__)
demo.run()

# ==========================================================

class Demo02:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def run(self):
        print("跑")
demo02 =Demo02('tom',18)
print(demo02.__dict__)
demo02.run()

 

type() 的三個參數：1，類名，2，繼承的對象（必須是 元組），3類對象的 屬性字典  

 

metaclass 關鍵字  : 

Python 內置的元類 只有一個type ，

其實，平時 用class 定義類的時候，默認就加了 metaclass = type 的， 只是我們不知道， 

class Demo:
    pass 

class Demo(metaclass=type):
    pass 

自定義元類  : 

因為type 是Python 內置的元類，我們可以通過自己創建繼承 type 就構建成了 我們自己的元類， 

class MyType(type,metaclass=type):  # metaclass=type 可以省略
    pass

通過自定義元類  研究  “實例化”: 

實例化就是 類名 + 括號， 

class MyType(type,metaclass=type):  # metaclass=type 可以省略
    def __init__(self,a,b,c):
        print('自定義 元類 的 init 方法 ')
        print(a)
        print(b)
        print(c)
    def __call__(self,a):
        print("hhh ")
        print(a)
        obj = object.__new__(self) # 這里的self 是 Demo 類對象，生成的obj 是demo 對象
        self.__init__(obj,a)
        return obj


class Demo(metaclass=MyType): # 如果不寫 metaclass ，默認是 metaclass = type
    name = 'tom'
    def __init__(self,age):
        self.age = age

demo = Demo(18) 21 # Demo(18) 會做如下 操作：
#第一步：MyType('Demo',(),{{'__module__': '__main__', '__qualname__': 'Demo', 'name': 'tom', '__init__': <function Demo.__init__ at 0x10E4E0C0>}})
#第二步：把 18 參數 傳給MyType 中的 __call__ 方法
#第三步：在__call__ 方法中，創建demo 對象，初始化 ，並返回

 

總結：所以平時 我們實例化的過程實際上是 type 幫我們創建demo 對象，然后 初始化它，然后返回給我們的，  上面用重寫的方式，重現了這一過程，  

 

類對象 屬性  和 實例對象屬性的 尋找范圍： 

class MyType(type,metaclass=type):  # metaclass=type 可以省略
    name = "aaa"
    def __init__(self,*args,**kwargs):
        self.name = 'aaa2'
        pass

    def __call__(self, *args, **kwargs):
        obj = object.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj
    
class Demo(object,metaclass=MyType): # 其實 默認也是繼承 object
    name = 'bbb'
    def __init__(self):
        self.name = 'bbb2'
    pass

class Demo2(Demo): # metaclass=MyType 也繼承過來了
    name = 'ccc'
    def __init__(self):
        self.name = 'ccc2'
    pass

class Demo3(Demo2):  # metaclass=MyType 也繼承過來了
    name = 'ddd'
    def __init__(self):
        self.name = 'ddd2'
        pass

# print(Demo3.name) # 先找 aaa2-->ddd --> ccc ---> bbb --> aaa 類對象的屬性 尋找范圍

demo = Demo3()
print(demo.name)   # 先找 ddd2 --> aaa2 -->ddd --> ccc --> bbb 對象的屬性 尋找范圍

 

類 中的 __new__()  函數 ： 

class MyType(type,metaclass=type):  # metaclass=type 可以省略
    def __init__(self,name,bases,attrs):
        print('4')
        print(name)
        print(bases)
        print(attrs)

    def __new__(cls, name,bases,attrs): #新建 MyType 它自己,之后會初始化 它
        print('2')
        print(name)
        print(bases)
        print(attrs)
        # 重寫 type 中 __new__
        return type.__new__(cls,name,bases,attrs)

class Demo(object,metaclass=MyType): # 其實 默認也是繼承 object
    print('1')
    def __init__(self):
        print('3')
'''

1
2
Demo
(<class 'object'>,)
{'__module__': '__main__', '__qualname__': 'Demo', '__init__': <function Demo.__init__ at 0x1091E0C0>}
4
Demo
(<class 'object'>,)
{'__module__': '__main__', '__qualname__': 'Demo', '__init__': <function Demo.__init__ at 0x1091E0C0>}

''' 

 

Python 中的組合  ： 

一個類的對象 作為了另一個類的屬性， 

 

class Course:
    def __init__(self,course_name,dur,price):
        self.course_name = course_name
        self.dur = dur
        self.price =price

class Banji:
    def __init__(self,name,course):
        self.name = name
        self.course = course

bj1 = Banji('八年級',Course('數學','10個月',10000))
bj2 = Banji('八年級',Course('英語','5個月',1000))

 

Python 中的 抽象類 ： 

與java一樣，python也有抽象類的概念但是同樣需要借助模塊實現，抽象類是一個特殊的類，它的特殊之處在於只能被繼承，不能被實例化

from abc import ABCMeta,abstractmethod  2 class Animal(metaclass=ABCMeta):
    '''
    所有動物 都會跑 和 吃
    '''
    @abstractmethod
    def run(self):
        pass

    @abstractmethod
    def eat(self):
        pass

class Dog(Animal):
    def __init__(self,name):
        self.name = name

dog = Dog('tom')

 

Python 中的 多態： 

處處是 多態，因為 Python 是 不是很 重視類型   的語言，  

 

鴨子類型： 

https://www.jianshu.com/p/e97044a8169a

Python 中的 super() ： 

super() 尋找是 按照 mro 順序 尋找父類的 ，  

 

Python 中的反射：  

反射的概念是由Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。這一概念的提出很快引發了計算機科學領域關於應用反射性的研究。它首先被程序語言的設計領域所采用,並在Lisp和面向對象方面取得了成績。

 

上面一點用都沒有，就四個內置函數 ，用於判斷一個對象有沒有 一個屬性的

hasattr()

getattr()

setattr()

delattr()

class Person:
    def __init__(self,name):
        self.name = name
    def run(self):
        print('run')


p = Person('jack')
ret = hasattr(p,'name')
print(ret)

#================================
print(p.name)
setattr(p,'name','tom')
print(p.name)

#================================
ret = getattr(p,'name')
print(ret)

#================================
print(p.__dict__)
delattr(p,'name')
print(p.__dict__)

#===============類也是 對象=================
ret = hasattr(Person,'run')
print(ret)

#===============模塊也是 對象=================
import sys
m = sys.modules[__name__]
ret = hasattr(m,'Person')
print(ret)

ret = getattr(m,'Person')
print(ret)

 

Python 中的 類的 三個保留方法 __setattr__ ,__getattr__,__delattr__：  

1,__setattr__:  給對象 添加/修改 屬性的時候會 調用它 

2,__getattr__: 在使用對象 調用一個不存在的屬性的時候 會調用它  （p.name = 'tom'  這不算調用屬性了，這是設置屬性   ）

3,__delattr__: 在刪除 對象的 屬性的時候回調用它  

 

如果我們不寫 __getattr__() 方法的話，如果直接引用一個不存在的 的屬性，那么此時就會報錯，如果寫了就不報錯了，這也是它的作用。  

class Person:
    def __init__(self,name):
        self.name = name

    def run(self):
        print('run')

    def __setattr__(self, key, value):
        self.__dict__[key] = value


    # def __getattr__(self, item):
    #     print(item)
    #     print('h')

    def __delattr__(self, item):
        print(item)
        print('w')

p = Person('jack')
p.age = 19

# p.sex

 

'''
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

p = Person('jack')
p.name = 'tom'
p.age = 18
'''
#需求 控制 name 必須是字符串， 控制 age 的范圍是 [30-50]
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __setattr__(self, key, value):
        if key == 'name':
            if type(value) == str:
                self.__dict__[key] = value
            else:
                print('name 屬性類型應為字符串') # 此時就不會 設置到self 的屬性字典中
        if key == 'age':
            if type(value) == int:
                if value > 50 or value < 30:
                    print('age 屬性的范圍有誤 ,應為 [30,50] ')
                else:
                    self.__dict__[key] = value
            else:
                print('age 屬性類型應為int')


# p = Person(10,18)  # name 屬性類型應為字符串  age 屬性的范圍有誤 ,應為 [30,50]
# p = Person('tom',18) #age 屬性的范圍有誤 ,應為 [30,50]
p = Person('tom',30) # √
p = Person('tom',51) # age 屬性的范圍有誤 ,應為 [30,50] 

 

Python 中的 包裝 ：  

基於標准數據類型來定制我們自己的數據類型。 

class List_Str(list):
    def append(self,val):
        if type(val) == str:
            super().append(val)
        else:
            print("添加失敗,列表中只允許添加字符串")


l = List_Str()
l.append(10)
print(l)

#================================
l.append('tom')
l.append('jack')
print(l)
'''
添加失敗,列表中只允許添加字符串
[]
['tom', 'jack']
'''

這就是包裝，說到底 還是封裝，  

Python 中的 授權：  

class Open:
    def __init__(self,filename,mode='r',encoding='utf8'):
        self.f = open(filename,mode,encoding=encoding)
        self.name = 'tom'

    def write(self,line):
        # 控制用戶寫的內容
        if 'hello' in line:
            print('您的內容 違法,清重新輸入 hhh')
        else:
            self.f.write(line)

    def __getattr__(self, item):
        return getattr(self.f,item)

'''
op = Open('test.txt','w')
# op.write('hello world') # 違法 
op.write('hell world')
'''

#================================
# 下面再 讀文件
op = Open('test.txt')
ret = op.read() # 此時會調用 __getattr__， 然后，就可以獲取到 文件對象的 read() 方法了
print(ret)

說到底，還是 封裝，  

Python 類 中的  __getattribute__  保留方法 ：  

1，如果對象 調用一個已存在的  屬性，它是不會調用 __getattr__ 的， 會調用 __getattribute__方法，  

2，如果對象調用一個不存在的 屬性，

　 a) 如果此時只有 __getattr__ 沒有  __getattribute__，那么 調用 __getattr__ ,

    b) 如果此時一旦存在 __getattribute__ 沒有  ，那么無論存不存在__getattr__ ,都只是 調用 __getattribute__ , 

一句話：__getattribute__ 是大哥， __getattrr__ 是小弟， 

 

其實， 真正觸發 __getattr__ 的原因是  一個異常的拋出， AttributeError ，所以，可以在大哥中 拋出這個異常，就可以召喚 小弟了。 

class Demo:
    def __init__(self,name ):
        self.name = name

    def __getattr__(self, item):
        print(item)
        print('h')

    def __getattribute__(self, item):
        print(item )
        print('hh')
        raise AttributeError("小弟快來...")

demo  =Demo('tom')
demo.name
demo.age

 

總結：

__getattribute__ ：是只要是 調用了 屬性，不管有沒有，就觸發它，

__getattr__ : 捕獲 AttributeError 異常時，才會觸發 。 

 

python 類中的 保留方法 __getitem,__setitem__,__delitem__： 

它們 和 attr 很類似，主要是 attr 是點操作， 它們是 [ ]  操作， 

__getitem__: 

class Demo:
    def __init__(self,name ):
        self.name = name

    def __getitem__(self, item):
        print(item)


demo  =Demo('tom')
# demo.name  #此時不觸發 __getitem__
demo['name'] #這種形式的時候觸發
demo['age'] # 沒有該屬性也觸發

class Demo:
    def __init__(self,name ):
        self.name = name

    def __getitem__(self, item):
        print(item)

    def __setitem__(self, key, value):
        print(key)
        print(value)

    def __delitem__(self, key):
        print(key)

demo  =Demo('tom')
demo['name'] = 'jack'

del demo['name']

 

python 中的 另一個保留方法----    析構方法 __del__ :

析構方法，當對象在內存中被釋放時，自動觸發執行。

 

python 類 中的   保留方法 __get__ , __set__ , __delete__   :

它們的調用時機不是  實例對象操作屬性的時候， 

class Demo:
    def __init__(self,name ):
        self.name = name

    def __get__(self, instance, owner):
        print(instance)
        print(owner)

    def __set__(self, instance, value):
        print(instance)
        print(value)

    def __delete__(self, instance):
        print(instance)


demo  =Demo('tom')
demo.name = 'jack'
del demo.name

它們的調用時機，是這個類的對象   作為另一個類的類屬性的時候，   

class MyStr:
    def __get__(self, instance, owner):
        print('get')
        print(instance) # 這里的instance 指的是下面的 People 對象  
        print(owner)
    def __set__(self, instance, value):
        print('set')
        print(instance)
        print(value)
    def __delete__(self, instance):
        print('delete')
        print(instance)

class People:
    name = MyStr()
    def __init__(self,name,age):
        self.name = name #對象字典中 不會有name 了，跑到 類屬性字典了，
        self.age = age

p = People('tom',18)
print(p.__dict__)
print(People.__dict__)
print("#================================")
p.name
print("#================================")
del p.name

 

它們的應用場景： 

class MyType:
    def __init__(self,key,type):
        self.type = type
        self.key  = key

    def __set__(self, instance, value):
        if type(value) == self.type:
            instance.__dict__[self.key] = value
        else:
            print(self.key,"的類型應該是 ",self.type )

class People:
    name = MyType('name',str)
    age = MyType('age',int)
    def __init__(self,name,age):
        self.name = name #對象字典中 不會有name 了，跑到 類屬性字典了，
        self.age = age #對象字典中 不會有age ，跑到 類屬性字典了，

p = People('tom',18)
print('===============')
p1 = People('tom','18')
print('===============')
p2 = People(18,18)
print('===============')
p3 = People(18,'18')
print('===============')

 

模仿內置裝飾器  @property ： 

一個類 也可以成為一個裝飾器，（不僅僅是 函數）

class MyProperty:
    def __init__(self,func):
        self.func = func

    def __get__(self, instance, owner):
        print(instance) # Demo 實例對象
        print(owner) # instance 的類型
        return self.func(instance)


class Demo:
    def __init__(self,w,h):
        self.w = w
        self.h = h

    @MyProperty  # --> area = MyProperty(area) # 此時，area 是個類變量~ 會觸發 __get__方法
    def area(self):
        return self.w*self.h

demo = Demo(18,10)
print(demo.area)

 

再看 @property :

'''

class Demo:
    def __init__(self,w,h):
        self.w = w
        self.h = h

    @property
    def area(self):
        return self.w*self.h

demo = Demo(18,10)

# demo.area = 18
# del demo.area
# 此時如果是真的想給 area 賦值 ,或者 刪除 area 均會報錯，
'''
#============================================================
class Demo:
    def __init__(self,w,h):
        self.w = w
        self.h = h
        self.__area = w*h

    @property
    def area(self):
        if not hasattr(self,"_Demo__area"):
            print('沒有此屬性')
            return None;
        return self.__area

    @area.setter
    def area(self,val):
        self.__area = val

    @area.deleter
    def area(self):
        del self.__area

demo = Demo(18,10)
print(demo.area)
#================================
demo.area =  18
print(demo.area)
#
#================================
del demo.area
print('============================')
print(demo.area)

print('============================')
demo.area = 10
print(demo.area)

 

python 類 中的   保留方法 __call__  :

如果 實現了它，那么就可以用對象  + 括號 了，  

class Demo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __call__(self, *args, **kwargs):
        print('ha')

Demo('tom',18)() 10 '''
ha
'''

 

 

 

Python 中  類的裝飾器：

裝飾器 不僅可以裝飾函數 也可以裝飾類， 

class Demo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

def dec(c):
    def inner(name,age):
        print("給類 加額外功能")
        obj = c(name,age)
        return obj
    return inner

ret = dec(Demo)('tom',18)
print(ret)
print(ret.name)
print(ret.age)

def dec(c):
    def inner(name,age):
        print("給類 加額外功能")
        obj = c(name,age)
        return obj
    return inner

@dec  9 class Demo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

demo = Demo('tom',18)
print(demo.name)
print(demo.age)

 

 

單例模式：

單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。

這種模式涉及到一個單一的類，該類確保只有單個對象被創建。

注意：

• 1、單例類只能有一個實例。
• 2、單例類必須自己創建自己的唯一實例。
• 3、單例類必須給所有其他對象提供這一實例。

 

單例模式的應用場景： 

1. Windows的Task Manager（任務管理器）就是很典型的單例模式（這個很熟悉吧），想想看，是不是呢，你能打開兩個windows task manager嗎？ 不信你自己試試看哦~

2. windows的Recycle Bin（回收站）也是典型的單例應用。在整個系統運行過程中，回收站一直維護着僅有的一個實例。

3. 操作系統的文件系統，也是大的單例模式實現的具體例子，一個操作系統只能有一個文件系統。

 

Python實現單例模式：

參看： 

https://www.cnblogs.com/huchong/p/8244279.html

最簡單的單例模式是 ：Python的一個模塊 即可以實現單例模式，   

'''
class Demo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

demo = Demo('tom',18)
print(demo)
demo2 = Demo('a',20)
print(demo2)

<__main__.Demo object at 0x02FBF990>
<__main__.Demo object at 0x02FBFA70>

'''
# 如何將 上面 改為一個單例模式的 類呢？
class Demo:
    __singleInstance = None

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        if cls.__singleInstance is None:
            cls.__singleInstance = object.__new__(cls)
        return cls.__singleInstance


demo = Demo('tom',18)
print(demo)
demo2 = Demo('a',20)
print(demo2)
'''
<__main__.Demo object at 0x02BCFA30>
<__main__.Demo object at 0x02BCFA30>
'''

其實，默認 調用new 也是object.__new__( ) 。 

 

new的調用時機，它在init 之前，其實它是在call里被調用的，     

 

 

 

Python 的with 關鍵字 的使用  ：

class Demo:
    def __init__(self,name):
        self.name = name

    def __enter__(self):
        print("我來了 ")
        return 'zcb'

    def __exit__(self, exc_type, exc_val, exc_tb):
        # __exit__()方法的3個參數，分別代表異常的類型、值、以及堆棧信息
        print('===========')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        print("我走了")

# with 后跟的對象的類中  一定要有 __enter__ 和 __exit__方法，不然報錯
# as 可以省略， as 后跟的是 __enter__ 的返回值 
with Demo('tom') as ret:
    print(ret)

我來了
zcb
===========
None
None
None
我走了

class Demo:
    def __enter__(self):
        print('1')
        return self

    def run(self):
        print('跑')
        print(1/0)

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(exc_type)
        print(exc_val)
        print(exc_tb)

with Demo() as d: # d是__enter__ 的返回值
    d.run()       

'''
Traceback (most recent call last):
  File "D:/.project/project_python/test02/bin/start.py", line 16, in <module>
    d.run()       
  File "D:/.project/project_python/test02/bin/start.py", line 8, in run
    print(1/0)
ZeroDivisionError: division by zero
1
跑
<class 'ZeroDivisionError'>
division by zero
<traceback object at 0x102CC350>
'''

 

 

網絡通信：

粘包 現象：

TCP才可能出現 粘包現象，UDP 不可能粘包，  

所謂粘包問題主要還是因為接收方不知道消息之間的界限，不知道一次性提取多少字節的數據所造成的。

此外，發送方引起的粘包是由TCP協議本身造成的，TCP為提高傳輸效率，發送方往往要收集到足夠多的數據后才發送一個TCP段。若連續幾次需要send的數據都很少，通常TCP會根據優化算法把這些數據合成一個TCP段后一次發送出去，這樣接收方就收到了粘包數據。

參看： 

https://www.cnblogs.com/steve214/p/10022692.html

 

解決粘包的方法：設置邊界  ， 

發送消息之前，先發送消息的字節長度，然后，再發送真實的消息。注：消息的發送長度的 字節要固定，因為要防止 長度 和 真實消息 也粘在一起。 

 

import socket
'''
server 端
'''
sk = socket.socket()

sk.bind(('127.0.0.1',8080))
sk.listen()

import time

while 1:
    conn,addr = sk.accept()
    while 1:
        time.sleep(30)
        size = conn.recv(4)  #先接受 消息 字節數
        print(size)
        size = int(size.decode().zfill(4))
        data = conn.recv(size)
        print(data)

        d = input(">>> [server]")
        conn.send(str(len(d.encode())).zfill(4).encode())   # 先發送 消息字節數
        conn.send(d.encode())


    conn.close()

sk.close()

import socket
'''
client 端
'''
sk = socket.socket()

sk.connect(('127.0.0.1',8080))

while 1:
    d = input(">>> [client]")
    sk.send(str(len(d.encode())).zfill(4).encode())  # 先發送 消息字節數
    sk.send(d.encode())

    size = sk.recv(4)  # 先接受 消息 字節數
    print(size)
    size = int(size.decode().zfill(4))
    data = sk.recv(size)
    print(data)

sk.close()

但是，上面代碼里 最多接受字節的長度是 9999，也就是最多10000 個字節（有點少），  如果多於，就不行了， 上面用 zfill （ ） 直接在 左面加0 ， 不是很好， 

 

Python有個模塊，struct ，

參看： https://www.cnblogs.com/leomei91/p/7602603.html

它的pack()  可以將 Python中的數據  按照 fmt ,轉為 對應的字節流對象。    

它的unpack() 可以將 字節流對象，轉換回 python 中的數據 。 

 

import struct

a = 111111111
b = 111111
c = 1

ret1 = struct.pack('i',a)
ret2 = struct.pack('i',b)
ret3 = struct.pack('i',c)

print(ret1)
print(ret2)
print(ret3)

print(struct.unpack('i',ret1))
print(struct.unpack('i',ret2))
print(struct.unpack('i',ret3))

 

所以，我們可以將我們的 len 用 struct.pack() 轉換為 二進制形式（int  ,4個字節）,  這4個字節 最大的數  是 2^32 - 1  (4294967295)  , 

所以，這已經足夠我們使用了， 4294967295個字節是 4294967295/（1024 ^2 ） = 3.9G ，所以，單次傳輸 不可能這么大的數據量。  

import socket
import struct
'''
server 端
'''
sk = socket.socket()

sk.bind(('127.0.0.1',8080))
sk.listen()

import time

while 1:
    conn,addr = sk.accept()
    while 1:
        time.sleep(10)
        size = conn.recv(4)  #先接受 消息 字節數
        size = struct.unpack('i',size)[0]
        print(size)
        data = conn.recv(size)
        print(data)

        d = input(">>> [server]")
        conn.send(struct.pack('i',len(d.encode())))   # 先發送 消息字節數
        conn.send(d.encode())
        
        
    conn.close()
sk.close()

import socket
import struct
'''
client 端
'''

sk = socket.socket()

sk.connect(('127.0.0.1',8080))

while 1:
    d = input(">>> [client]")

    sk.send(struct.pack('i',len(d.encode())))  # 先發送 消息字節數
    sk.send(d.encode())

    size = sk.recv(4)  # 先接受 消息 字節數
    size = struct.unpack('i',size)[0]
    print(size)
    data = sk.recv(size)
    print(data)

sk.close()

 

 

大文件 多次傳輸 ：

import socket
import struct
'''
server 端
'''
sk = socket.socket()

sk.bind(('127.0.0.1',8080))
sk.listen()

while 1:
    conn,addr = sk.accept()
    while 1:
        size = conn.recv(4)  #先接受 消息 字節數
        size = struct.unpack('i',size)[0]
        print(size)
        i = 0
        while 1:
            with open("recv.txt","ab") as f:
                if size > 1024:
                    data = conn.recv(1024)
                else:
                    data = conn.recv(size)
                size = size - len(data)  # 每次不一定 接收的是 1024 ，所以最好用 len(data)
                f.write(data)
                i += 1
                if size <= 0:
                    break
        print('總次數： ',i)
        input()
    conn.close()
sk.close()

import socket
import struct
'''
client 端
'''

sk = socket.socket()

sk.connect(('127.0.0.1',8080))

while 1:
    with open("test.txt","rb") as f:
        d = f.read()
    sk.send(struct.pack('i',len(d)))  # 先發送 消息字節數
    sk.send(d)

sk.close()

 

驗證 客戶端的合法性 ：

如何生成一個隨機的字節， 

os.urandom(32)   可以隨機生成一個32位的隨機字節，  

用算法 將它  和 密鑰 在一起生成結果，  

import os,hashlib
r_b = os.urandom(32)

key = 'towqndsjfkgn%$#@skg&*(ngn)!@sliengah' # 密鑰  服務端 和 客戶端 都有
ret = hashlib.md5(key.encode())
ret.update(r_b)
res = ret.hexdigest()
print(res)

 

import socket
import os,hashlib

key = 'towqndsjfkgn%$#@skg&*(ngn)!@sliengah'

sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()

while 1:
    #================================
    r_b = os.urandom(32)
    ret = hashlib.md5(key.encode())
    ret.update(r_b)
    res = ret.hexdigest()
    #================================
    conn,addr = sk.accept()
    conn.send(r_b)
    recv = conn.recv(1024)
    if recv.decode() == res:
        print('合法，開始通信')
        # 合法
        while 1:
            data = conn.recv(1024)
            print(data)

            ret = input('>>>[server]').encode()
            conn.send(ret)
    else:
        print('不合法，拜拜')
        # 不合法 關閉連接
        conn.close()

import socket
import hashlib

key = 'towqndsjfkgn%$#@skg&*(ngn)!@sliengah'
sk = socket.socket()
sk.connect(('127.0.0.1',8080))

r_b = sk.recv(1024)
# ================================
ret = hashlib.md5(key.encode())
ret.update(r_b)
res = ret.hexdigest()
# ================================
sk.send(res.encode())
while 1:
    d = input('>>> [client]')
    sk.send(d.encode())

    data = sk.recv(1024)
    print(data.decode())

 

Python 的  sockserver 模塊  ：

sockserver  和  socket 模塊的關系， 它是基於 socket 的，  而且，它們都是Python 內置的模塊 ， 

它幫我們做的事情是： 幫助我們處理  並發的客戶端請求 ，  

import socketserver

class MyServer(socketserver.BaseRequestHandler):
    # 重寫 handle 方法
    def handle(self):
        conn = self.request
        while 1:
            try:
                data = conn.recv(1024)
                print(data.decode())
            except ConnectionResetError:
                break

server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)
server.serve_forever()

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',8080))

while 1:
    d = input(">>> [client]").encode()
    sk.send(d)

import socket

sk = socket.socket()

sk.connect(('127.0.0.1', 8080))

while 1:
    d = input(">>> [client]").encode()
    sk.send(d)

 

 

 

進程的三種狀態：  

就緒， 運行  ，還有阻塞 三個狀態 ，   

 

操作系統 ：  

我們日常生活中的系統 都是 分時 系統，分時是 分時間片。  

也又實時系統， 它是一個cpu 只為一個 程序工作，它一般都是用於  飛機飛行，導彈發射之類的，不能有一分一毫的 差錯，對響應度要求高（不能 分時間片）。

 

分布式 ：  

只要是把 大的任務分解為小的任務 都可以稱為分布式，   

分布式，可以在操作系統級別實現，也可以在 程序級別實現， Python  的框架： celery   

 

Python 的進程 ：  

進程  相關的模塊 及函數  ：  

和進程 相關的 模塊： multiprocessing     

from multiprocessing import Processing    

os 模塊中的兩個 函數  getpid()  進程id  , getppid() 父進程 id    

子進程.join() ：  

只要有子進程.join() ,那么主進程就會阻塞，直到 .join()使用的子進程 執行完畢！ 

 

守護進程  ：  

通過 子進程.daemon = True ，可以將其設置為 守護進程，

該進程 會在 主進程代碼執行徹底完之后 自動結束。  

 

 

利用 多進程 實現 socket 並發：  

import socket
from multiprocessing import Process

def commun_with_client(conn):
    while 1:
        d = conn.recv(1024)
        print(d)

if __name__ == '__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1', 8080))
    sk.listen()

    while 1:
        conn,addr = sk.accept() #不停的 accept,  來一個client 開一個子進程
        p = Process(target=commun_with_client,args=(conn,))
        p.start()

import socket
sk = socket.socket()

sk.connect(('127.0.0.1',8080))

while 1:
    d = input(">>> [client]").encode()
    sk.send(d)

import socket
sk = socket.socket()

sk.connect(('127.0.0.1',8080))

while 1:
    d = input(">>> [client]").encode()
    sk.send(d)

 

 

進程 之間的數據共享 --- Manager  ：  

Python 多進程 無法直接獲得   一個函數的 返回值，  但是，可以通過共享變量來實現，

我們可以通過 Manager  去創建 共享變量，它有很多數據類型： list   dict  Queue  等等，  

 

進程 同步 --- Lock ：  

為什么要用鎖： 

from multiprocessing import Process,Manager
import time

def add(d):
    temp = d['num'] + 1
    time.sleep(0.001)
    d['num'] = temp

if __name__ == '__main__':
    m = Manager()
    d = m.dict({'num':0})
    p_list = []
    for i in range(10):
        p = Process(target=add,args=(d,))
        p_list.append(p)
    for p in p_list:
        p.start()

    for p in p_list:
        p.join()
    print(d)

 

下面使用 鎖： 上鎖  .acquire()   下鎖： .release()     。   除了用 .acquire() 和 .release()也可以使用 with 語句，更方便，

from multiprocessing import Process,Manager,Lock
import time

def add(d,lock):
    lock.acquire()
    temp = d['num'] + 1
    time.sleep(0.001)
    d['num'] = temp
    lock.release()

if __name__ == '__main__':
    m = Manager()
    d = m.dict({'num':0})
    lock = Lock()
    p_list = []
    for i in range(10):
        p = Process(target=add,args=(d,lock))
        p_list.append(p)
    for p in p_list:
        p.start()

    for p in p_list:
        p.join()
    print(d)

from multiprocessing import Process,Manager,Lock
import time

def add(d,lock):
    with lock:  # 它會自動 上鎖， 然后執行完代碼 自動解鎖 
        temp = d['num'] + 1
        time.sleep(0.001)
        d['num'] = temp

if __name__ == '__main__':
    m = Manager()
    d = m.dict({'num':0})
    lock = Lock()
    p_list = []
    for i in range(10):
        p = Process(target=add,args=(d,lock))
        p_list.append(p)
    for p in p_list:
        p.start()

    for p in p_list:
        p.join()
    print(d)

 

注： 不能連續 acquire () 傻子也知道，

 

 

死鎖 現象：使用多個鎖才會出現的情況，  

進程 間通信 --- Queue ：  

進程間 通信 （  IPC  inter process communciate ）  的方式  ：

1，基於文件  ： 同一台機器上 進程間通信  

2，基於網絡  ： 同一台 或者 不同電腦 都可 

 

這里的隊列   Queue   就是基於文件 來實現 進程間通信的，  它在 multiprocessing 模塊中，  

from multiprocessing import Process,Queue
import time

def func(q):
    q.put('hello')

def func2(q):
    time.sleep(1)
    q.get()

if __name__ == '__main__':
    q = Queue()
    p_list = []
    for i in range(10): # 10 個進程 放 到隊列中
        p = Process(target=func,args=(q,))
        p_list.append(p)

    for i in range(5):  # 5 個進程 去 從隊列中拿出來 ， 最終應該是只剩 5個hello
        p = Process(target=func2,args=(q,))
        p_list.append(p)

    for p in p_list:
        p.start()

    for p in p_list:
        p.join()
    while not q.empty():
        print(q.get())

 

除了上面的基本方法： q.put() q.get()  q.empty(), 

還有其他方法： 

1，get_nowait()  :

當隊列為空，時，如果是q.get(),那么程序就會阻塞了， 而使用 get_nowait() 則不會阻塞，但是 它會拋出一個異常 ， queue.Empty 異常 (queue 為普通的隊列   )

 

q.get_nowait() 取不到值時觸發異常：queue.Empty

捕獲這個異常 需要導入import queue(普通的隊列，不是進程間的Queue)

from multiprocessing import Process,Queue
import time
import queue

def func(q):
    q.put('hello')

def func2(q):
    try:
        q.get_nowait()
    except queue.Empty as e:
        print(e)


if __name__ == '__main__':
    q = Queue()
    p_list = []
    # for i in range(10): # 10 個進程 放 到隊列中
    #     p = Process(target=func,args=(q,))
    #     p_list.append(p)

    for i in range(5):  # 5 個進程 去 從隊列中拿出來 ， 最終應該是只剩 5個hello
        p = Process(target=func2,args=(q,))
        p_list.append(p)

    for p in p_list:
        p.start()

    for p in p_list:
        p.join()
    while not q.empty():
        print(q.get())

2，put_nowait()  :

與 get_nowait() , 當隊列滿了，此時再put 數據的話，

如果使用q.put(),就阻塞了，直到 q不為空，  如果使用put_nowait()  則不會阻塞，但是，它會拋出異常，  queue.Full ，同樣它也在  queue中。  

from multiprocessing import Process,Queue
import time
import queue

def func(q):
    q.put('hello')

def func2(q):
    time.sleep(1)
    try:
        q.put_nowait('hello')
    except queue.Full as e:
        print('滿了')
        print(e)


if __name__ == '__main__':
    q = Queue(10) # 最多10個
    p_list = []
    for i in range(10): # 10 個進程 放 到隊列中
        p = Process(target=func,args=(q,))
        p_list.append(p)

    p = Process(target=func2,args=(q,))
    p_list.append(p)


    for p in p_list:
        p.start()

    for p in p_list:
        p.join()
    while not q.empty():
        print(q.get())

 

3，full()  :

創建隊列時，如果有指明大小則有大小，反之，不限大小。  

如果隊列滿了，返回True,反之False；

 

Queue 的一個子類：JoinableQueue:

JoinableQueue類 ，相對於 Queue 類來說，多了兩個方法 一個是 task_done() ，一個是join()  

JoinableQueue 的 put 方法時，Queue 計數器加一，但是 get方法時，不會主動減一，我們調用  task_done()才會減一。 

join() 方法時，當計數器為 0 時候，才不阻塞，否則一直阻塞。 

from multiprocessing import Process,JoinableQueue
import time

def func(q):
    print('put hello')
    q.put('hello')

def func2(q):
    time.sleep(1)
    print('get hello')
    q.get()

if __name__ == '__main__':
    q = JoinableQueue(10) # 最多10個
    p_list = []
    for i in range(10):
        p = Process(target=func,args=(q,))
        p_list.append(p)

    for i in range(10):
        p = Process(target=func2,args=(q,))
        p_list.append(p)
    for p in p_list:
        p.start()

    time.sleep(1)
    q.join()  # 此時會一直 阻塞 
    print('h')
    while not q.empty():
        print(q.get())

 

上面之所以 一直阻塞，是因為  沒有調用task_done()  

from multiprocessing import Process,JoinableQueue
import time

def func(q):
    print('put hello')
    q.put('hello')

def func2(q):
    time.sleep(1)
    print('get hello')
    q.get()
    q.task_done()
    

if __name__ == '__main__':
    q = JoinableQueue(10) # 最多10個
    p_list = []
    for i in range(10):
        p = Process(target=func,args=(q,))
        p_list.append(p)

    for i in range(10):
        p = Process(target=func2,args=(q,))
        p_list.append(p)
    for p in p_list:
        p.start()

    time.sleep(1)
    q.join()  # 此時 不會一直阻塞  
    print('h')
    while not q.empty():
        print(q.get())

 

Python 的線程：  

一般處理 並發 都是多線程，不會開啟 多進程，  

Python 的GIL 鎖：  

它是CPython 解釋器的產物， 它帶來的影響是 多線程 同一時刻 只有一個線程 可以被cpu執行，

這就造成了 Python 中的 多線程 不能利用多核， 即Python中的多線程 是 fake 多線程。  

GIL 不會影響我們很多   。  

線程  相關的模塊 及函數  ：  

和線程 相關的 模塊： threading 

from threading import Thread 

threading 模塊 是模仿着 multiprocessing 來寫的，所以 學習線程就變得 很輕松 ~    

線程也又線程id (搜) 

 

多線程用法：

多線程 大部分 和 進程 寫法一致 ：

from threading import Thread
import time

def func():
    time.sleep(1)
    print('hello world')  # 這個時候 就是阻塞的

if __name__ == '__main__':
    t_list = []
    for i in range(10):
        t = Thread(target=func)
        t_list.append(t)

    for t in t_list: # 開啟10 個線程
        t.start()

    for t in t_list:
        t.join()

    print('wo shi zhu xiancheng')

 

與 多進程不同的是：

多線程的 守護線程 守護的是 其他非守護線程（包含 主線程）

多進程的 守護進程 守護的是 主進程。

from threading import Thread
import time

def test01():
    while True:
        time.sleep(1)
        print("我是守護子線程~")

def test02():
    time.sleep(3)
    print("我是子線程....")

if __name__ == '__main__':
    thread = Thread(target=test01)
    thread.daemon = True
    thread.start()

    thread2 = Thread(target=test02)
    thread2.start()
    print("主線程的代碼結束!") # 證明: 守護線程 守護的是 其他子線程。

from threading import Thread
import time

def test01():
    while True:
        time.sleep(1)
        print("我是守護子線程~")

def test02():
    time.sleep(1)
    print("我是子線程....")

if __name__ == '__main__':
    thread = Thread(target=test01)
    thread.daemon = True
    thread.start()

    thread2 = Thread(target=test02)
    thread2.start()

    time.sleep(10)
    print("主線程的代碼結束!") # 證明: 守護線程 也守護 主線程。

所以，守護線程 守護的是 其他非守護線程  。  

 

多線程  數據共享：

from threading import Thread

def add():
    global num
    num += 1

if __name__ == '__main__':
    num = 0
    t_list = []
    for i in range(100): # 開100個子線程
        t = Thread(target=add)
        t_list.append(t)

    for t in t_list:
        t.start()

    for t in t_list:
        t.join()
    print(num)

from threading import Thread
import time

def add():
    global num
    temp = num + 1
    time.sleep(0.001)
    num = temp

if __name__ == '__main__':
    num = 0
    t_list = []
    for i in range(100): # 開100個子線程
        t = Thread(target=add)
        t_list.append(t)

    for t in t_list:
        t.start()

    for t in t_list:
        t.join()
    print(num)

下面通過加鎖 解決：

from threading import Thread,Lock
import time

def add(lock):
    global num
    with lock:
        temp = num + 1
        time.sleep(0.001)
        num = temp

if __name__ == '__main__':
    num = 0
    lock = Lock()
    t_list = []
    for i in range(100): # 開100個子線程
        t = Thread(target=add,args=(lock,))
        t_list.append(t)

    for t in t_list:
        t.start()

    for t in t_list:
        t.join()
    print(num)

 

多線程 中的隊列：

線程中使用隊列的話，就使用普通的 queue 就行， 

 

threading 中的Timer 函數： 

它相當於 js 中的setTimeout() 

from threading import Timer

import time

def func():
    print('hello',time.time())


if __name__ == '__main__':
    print('hello',time.time())
    t = Timer(1,func)
    t.start()

 

 

Python 的 池：  

 之前 進程  和 線程  都是 有多少個任務 開多少個 進程 /線程，   不好。 

如果  先開好  一個數量的 池， 有任務可以直接執行，而且也可以重復利用 池子，減少了 很大的時間開銷  。  

池 相關的模塊： 

concurrent.futures   模塊  

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

 

進程池： 

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time

def func():
    time.sleep(0.1)
    print('我是一個任務, 進程id 為： ',os.getpid())

def func2():
    time.sleep(0.1)
    print('我是另一個任務, 進程id 為： ',os.getpid())


if __name__ == '__main__':
    p_pool =  ProcessPoolExecutor(4) # 池中有 4個進程

    for i in range(30):
        p_pool.submit(func) # 提交10個 func 任務 給 池

    for i in range(15):
        p_pool.submit(func2) # 提交 5 個func2 任務 給池
'''
我是一個任務, 進程id 為：  1320
我是一個任務, 進程id 為：  14628
我是一個任務, 進程id 為：  18492
我是一個任務, 進程id 為：  15896
我是一個任務, 進程id 為：  18492
我是一個任務, 進程id 為：  14628
我是一個任務, 進程id 為：  15896
我是一個任務, 進程id 為：  1320
我是一個任務, 進程id 為：  1320
我是一個任務, 進程id 為：  18492
我是一個任務, 進程id 為：  14628
我是一個任務, 進程id 為：  15896
我是一個任務, 進程id 為：  1320
我是一個任務, 進程id 為：  14628
我是一個任務, 進程id 為：  18492
我是一個任務, 進程id 為：  15896
我是一個任務, 進程id 為：  1320
我是一個任務, 進程id 為：  18492
我是一個任務, 進程id 為：  14628
我是一個任務, 進程id 為：  15896
我是一個任務, 進程id 為：  15896
我是一個任務, 進程id 為：  18492
我是一個任務, 進程id 為：  1320
我是一個任務, 進程id 為：  14628
我是一個任務, 進程id 為：  1320
我是一個任務, 進程id 為：  18492
我是一個任務, 進程id 為：  14628
我是一個任務, 進程id 為：  15896
我是另一個任務, 進程id 為：  18492
我是一個任務, 進程id 為：  15896
我是一個任務, 進程id 為：  1320
我是另一個任務, 進程id 為：  14628
我是另一個任務, 進程id 為：  18492
我是另一個任務, 進程id 為：  14628
我是另一個任務, 進程id 為：  1320
我是另一個任務, 進程id 為：  15896
我是另一個任務, 進程id 為：  15896
我是另一個任務, 進程id 為：  18492
我是另一個任務, 進程id 為：  1320
我是另一個任務, 進程id 為：  14628
我是另一個任務, 進程id 為：  15896
我是另一個任務, 進程id 為：  18492
我是另一個任務, 進程id 為：  1320
我是另一個任務, 進程id 為：  14628
我是另一個任務, 進程id 為：  15896
'''

 

傳參數：

之前都是 元組，這里直接傳 位置 參數即可， 

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time

def func(a,b):
    time.sleep(0.1)
    print('我是一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)

def func2(a,b):
    time.sleep(0.1)
    print('我是另一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)


if __name__ == '__main__':
    p_pool =  ProcessPoolExecutor(4) # 池中有 4個進程

    for i in range(10):
        p_pool.submit(func,i,i+1) # 提交10個 func 任務 給 池

    for i in range(5):
        p_pool.submit(func2,i,i+1) # 提交 5 個func2 任務 給池


'''
我是一個任務, 進程id 為：  4488  參數： 2 3
我是一個任務, 進程id 為：  21540  參數： 3 4
我是一個任務, 進程id 為：  12624  參數： 0 1
我是一個任務, 進程id 為：  21324  參數： 1 2
我是一個任務, 進程id 為：  4488  參數： 5 6
我是一個任務, 進程id 為：  12624  參數： 7 8
我是一個任務, 進程id 為：  21324  參數： 6 7
我是一個任務, 進程id 為：  21540  參數： 4 5
我是一個任務, 進程id 為：  12624  參數： 8 9
我是另一個任務, 進程id 為：  21324  參數： 0 1
我是另一個任務, 進程id 為：  21540  參數： 1 2
我是一個任務, 進程id 為：  4488  參數： 9 10
我是另一個任務, 進程id 為：  12624  參數： 3 4
我是另一個任務, 進程id 為：  21324  參數： 4 5
我是另一個任務, 進程id 為：  21540  參數： 2 3
'''

獲取返回值： 

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time

def func(a,b):
    time.sleep(0.1)
    print('我是一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)
    return a+b+1

def func2(a,b):
    time.sleep(0.1)
    print('我是另一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)
    return a+b+2


if __name__ == '__main__':
    p_pool =  ProcessPoolExecutor(4) # 池中有 4個進程

    for i in range(10):
        ret = p_pool.submit(func,i,i+1) # ret 的類型是 Future 對象 可以通過 .result() 獲取（.result() 會阻塞的）
        print(ret.result())
    for i in range(5):
        ret = p_pool.submit(func2,i,i+1)  # ret 的類型是 Future 對象
        print(ret.result())

'''
我是一個任務, 進程id 為：  20516  參數： 0 1
2
我是一個任務, 進程id 為：  8468  參數： 1 2
4
我是一個任務, 進程id 為：  4836  參數： 2 3
6
我是一個任務, 進程id 為：  7648  參數： 3 4
8
我是一個任務, 進程id 為：  20516  參數： 4 5
10
我是一個任務, 進程id 為：  8468  參數： 5 6
12
我是一個任務, 進程id 為：  4836  參數： 6 7
14
我是一個任務, 進程id 為：  7648  參數： 7 8
16
我是一個任務, 進程id 為：  20516  參數： 8 9
18
我是一個任務, 進程id 為：  8468  參數： 9 10
20
我是另一個任務, 進程id 為：  4836  參數： 0 1
3
我是另一個任務, 進程id 為：  7648  參數： 1 2
5
我是另一個任務, 進程id 為：  20516  參數： 2 3
7
我是另一個任務, 進程id 為：  8468  參數： 3 4
9
我是另一個任務, 進程id 為：  4836  參數： 4 5
11
'''

上面 主要是 .result()是個同步 阻塞的過程，  

我們可以先加入，后面統一 .result() ：

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time

def func(a,b):
    time.sleep(0.1)
    print('我是一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)
    return a+b+1

def func2(a,b):
    time.sleep(0.1)
    print('我是另一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)
    return a+b+2


if __name__ == '__main__':
    p_pool =  ProcessPoolExecutor(4) # 池中有 4個進程

    res = []
    for i in range(10):
        ret = p_pool.submit(func,i,i+1) # ret 的類型是 Future 對象 可以通過 .result() 獲取（.result() 會阻塞的）
        res.append(ret)
    for i in range(5):
        ret = p_pool.submit(func2,i,i+1)  # ret 的類型是 Future 對象
        res.append(ret)


    p_pool.shutdown() # 阻塞， 直到所有任務 結束
    # 等所有 任務都結束之后 ，再一起看結果
    for item in res:
        print(item.result()) # .result() 是同步 ， 阻塞的
'''
我是一個任務, 進程id 為：  17700  參數： 0 1
我是一個任務, 進程id 為：  13092  參數： 2 3
我是一個任務, 進程id 為：  9452  參數： 1 2
我是一個任務, 進程id 為：  13324  參數： 3 4
我是一個任務, 進程id 為：  17700  參數： 4 5
我是一個任務, 進程id 為：  13092  參數： 5 6
我是一個任務, 進程id 為：  13324  參數： 7 8
我是一個任務, 進程id 為：  9452  參數： 6 7
我是一個任務, 進程id 為：  17700  參數： 8 9
我是另一個任務, 進程id 為：  13092  參數： 0 1
我是另一個任務, 進程id 為：  9452  參數： 1 2
我是一個任務, 進程id 為：  13324  參數： 9 10
我是另一個任務, 進程id 為：  17700  參數： 2 3
我是另一個任務, 進程id 為：  13324  參數： 4 5
我是另一個任務, 進程id 為：  9452  參數： 3 4
2
4
6
8
10
12
14
16
18
20
3
5
7
9
11
'''

map() 方法 ： 

它是為了 取代 for  循環 submit  這個操作，

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time

def func(a):
    b = a+1
    time.sleep(0.1)
    print('我是一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)
    return a+b+1

def func2(a):
    b = a+1
    time.sleep(0.1)
    print('我是另一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)
    return a+b+2


if __name__ == '__main__':
    p_pool =  ProcessPoolExecutor(4) # 池中有 4個進程

    ret1 = p_pool.map(func,range(10)) # func 為任務函數 ，第二個要求是可迭代對象，為傳入的參數，返回 ret1 為可迭代對象 ，里面放的 直接是 任務函數的返回值
    ret2 = p_pool.map(func2,range(5))

    p_pool.shutdown() # 阻塞， 直到所有任務 結束
    # 等所有 任務都結束之后 ，再一起看結果
    for item in ret1:
        print(item)
    for item in ret2:
        print(item)

'''
我是一個任務, 進程id 為：  8972  參數： 0 1
我是一個任務, 進程id 為：  15204  參數： 1 2
我是一個任務, 進程id 為：  18936  參數： 3 4
我是一個任務, 進程id 為：  22288  參數： 2 3
我是一個任務, 進程id 為：  8972  參數： 4 5
我是一個任務, 進程id 為：  18936  參數： 6 7
我是一個任務, 進程id 為：  22288  參數： 7 8
我是一個任務, 進程id 為：  15204  參數： 5 6
我是一個任務, 進程id 為：  8972  參數： 8 9
我是另一個任務, 進程id 為：  18936  參數： 0 1
我是另一個任務, 進程id 為：  22288  參數： 1 2
我是一個任務, 進程id 為：  15204  參數： 9 10
我是另一個任務, 進程id 為：  8972  參數： 2 3
我是另一個任務, 進程id 為：  22288  參數： 3 4
我是另一個任務, 進程id 為：  15204  參數： 4 5
2
4
6
8
10
12
14
16
18
20
3
5
7
9
11
'''

不過 map 傳參時 稍顯復雜，只能傳遞一個 可迭代對象，  

add_done_callback（fn）:

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time

def func(a,b):
    time.sleep(0.1)
    print('我是一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)
    return a+b+1

def func2(a,b):
    time.sleep(0.1)
    print('我是另一個任務, 進程id 為： ',os.getpid(),' 參數：',a,b)
    return a+b+2

def ck(ret):
    print(ret.result())

if __name__ == '__main__':
    p_pool =  ProcessPoolExecutor(4) # 池中有 4個進程

    for i in range(10):
        ret = p_pool.submit(func,i,i+1)
        ret.add_done_callback(ck) #ret 獲取成功 之后 執行回調 函數 
    for i in range(5):
        ret = p_pool.submit(func2,i,i+1)
        ret.add_done_callback(ck)

'''
我是一個任務, 進程id 為：  14096  參數： 2 3
我是一個任務, 進程id 為：  18004  參數： 0 1
我是一個任務, 進程id 為：  7292  參數： 1 2
我是一個任務, 進程id 為：  20532  參數： 3 4
6
2
4
8
我是一個任務, 進程id 為：  7292  參數： 5 6
我是一個任務, 進程id 為：  14096  參數： 4 5
我是一個任務, 進程id 為：  20532  參數： 7 8
我是一個任務, 進程id 為：  18004  參數： 6 7
12
10
16
14
我是一個任務, 進程id 為：  14096  參數： 9 10
我是另一個任務, 進程id 為：  18004  參數： 1 2
我是另一個任務, 進程id 為：  20532  參數： 0 1
我是一個任務, 進程id 為：  7292  參數： 8 9
20
18
3
5
我是另一個任務, 進程id 為：  14096  參數： 2 3
我是另一個任務, 進程id 為：  7292  參數： 3 4
我是另一個任務, 進程id 為：  18004  參數： 4 5
9
7
11
'''

 

 

Python 的協程 Coroutines：  

協程 是 操作系統也不可見的，操作系統能調度的最小單位是 線程，  

協程 做的工作 是 利用 阻塞的時間，然后執行其他任務，（還是在 一個線程上  ）

 

 

協程相關的模塊： 

兩個 模塊：  

1，gevent （第三方）  :它是利用了 greenlet （c語言寫）這個模塊 進行 切換任務  ，還有自己內部加的自動規避 io 的功能  

2，asyncio  ：它是利用了 yield（python 的語法）進行 切換任務  ，        還有自己內部加的自動規避 io 的功能  

 

協程間 是 數據安全的：

 

 

 

之所以，進程  和 線程 數據不安全，是因為它們都是由 操作系統 控制切換的， 而協程 是 用戶控制切換的。 

 

進程 ，線程，協程 的開銷：

進程 很大 

線程 小 

協程 更小，（幾乎 和 調用一個函數一樣小）

Python 中 多線程 是否 無用： 

 

 

通過上述對比，明顯感到 協程 比多線程 好，那么都用協程不就可以了 ，多線程 不用不就行了？

no ,no,no ,

協程有個很大的弊端，它的所有切換都是 基於用戶的 ，只能切換一些 網絡，sleep 等用戶可以感知到的，

但是，像 print, 文件操作 等用戶感知不到的，它是無法切換的，所以只能用 多線程，

所以，多線程 是有用的，   

 

協程 使用：

import gevent

def func1():
    print('任務一：開始')
    gevent.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務一：結束')

if __name__ == '__main__':
    cor = gevent.spawn(func1)
    print('主任務')
    gevent.sleep(1) # 切出去執行 別的沒有阻塞的任務
'''
主任務
任務一：開始
'''

import gevent

def func1():
    print('任務一：開始')
    gevent.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務一：結束')

if __name__ == '__main__':
    cor = gevent.spawn(func1)
    print('主任務')
    gevent.sleep(2) # 切出去執行 別的沒有阻塞的任務
'''
主任務
任務一：開始
任務一：結束
'''

 

協程.join()  方法：

import gevent

def func1():
    print('任務一：開始')
    gevent.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務一：結束')

if __name__ == '__main__':
    cor = gevent.spawn(func1)
    print('主任務')
    cor.join()
    print('所有 協程 任務都完成了')



'''
主任務
任務一：開始
任務一：結束
所有 協程 任務都完成了
'''

import gevent

def func1():
    print('任務一：開始')
    gevent.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務一：結束')

def func2():
    print('任務二：開始')
    gevent.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務二：結束')



if __name__ == '__main__':
    cor_list = []
    for i in range(10):
        cor = gevent.spawn(func1) # 10個協程任務 處理 func1
        cor_list.append(cor)

    for i in range(5):
        cor = gevent.spawn(func2) # 5個協程任務 處理 func2
        cor_list.append(cor)

    for cor in cor_list:
        cor.join()
    print('所有 協程 任務都完成了')



'''
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務二：開始
任務二：開始
任務二：開始
任務二：開始
任務二：開始
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務二：結束
任務二：結束
任務二：結束
任務二：結束
任務二：結束
所有 協程 任務都完成了
'''

 

簡便寫法 gevent.joinall() 方法：

import gevent

def func1():
    print('任務一：開始')
    gevent.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務一：結束')

def func2():
    print('任務二：開始')
    gevent.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務二：結束')



if __name__ == '__main__':
    cor_list = []
    for i in range(10):
        cor = gevent.spawn(func1) # 10個協程任務 處理 func1
        cor_list.append(cor)

    for i in range(5):
        cor = gevent.spawn(func2) # 5個協程任務 處理 func2
        cor_list.append(cor)

    gevent.joinall(cor_list) # gevent.joinall() 更方便
    print('所有 協程 任務都完成了')



'''
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務一：開始
任務二：開始
任務二：開始
任務二：開始
任務二：開始
任務二：開始
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務一：結束
任務二：結束
任務二：結束
任務二：結束
任務二：結束
任務二：結束
所有 協程 任務都完成了
'''

協程 傳遞參數： 

直接 放入 位置參數即可，

 

協程  不認是 time.sleep() 類似 問題 ：

如何解決： 

import gevent

#================================
from gevent import monkey
monkey.patch_all()
import time
#================================
def func1():
    print('任務一：開始')
    time.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務一：結束')

def func2():
    print('任務二：開始')
    time.sleep(1) # 切出去執行 別的沒有阻塞的任務
    print('任務二：結束')

if __name__ == '__main__':
    cor_list = []
    for i in range(10):
        cor = gevent.spawn(func1) # 10個協程任務 處理 func1
        cor_list.append(cor)

    for i in range(5):
        cor = gevent.spawn(func2) # 5個協程任務 處理 func2
        cor_list.append(cor)

    gevent.joinall(cor_list) # gevent.joinall() 更方便
    print('所有 協程 任務都完成了')

 

 

使用 gevent 協程實現 socket 並發：  

import gevent

#================================
from gevent import monkey
monkey.patch_all()
import socket
#================================

def comm_withclient(conn):
    while 1:
        d = conn.recv(1024)
        print(d.decode())



if __name__ == '__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1', 8080))
    sk.listen()

    while 1:
        conn,addr = sk.accept()
        # 開協程  來一個 客戶端 開一個協程
        cor = gevent.spawn(comm_withclient,conn)

import socket
sk = socket.socket()

sk.connect(('127.0.0.1',8080))

while 1:
    d = input(">>> [client]").encode()
    sk.send(d)

import socket
sk = socket.socket()

sk.connect(('127.0.0.1',8080))

while 1:
    d = input(">>> [client]").encode()
    sk.send(d)

一台4cpu的電腦 開 5個進程，每個進程開 20個線程，每個線程可以開 500個協程 這一共是：5w 的並發量  （很多了）。 

asyncio 模塊 ：  

參考：https://www.cnblogs.com/Eva-J/articles/10437164.html

它是Python 自帶的一個模塊， 

import asyncio

async def func(a):
    print('開始',a)
    await asyncio.sleep(1)  # 此時會 切換出去執行  沒有阻塞的任務~
    print('結束',a+1)

#  await 后面 是個可能會阻塞的方法
#  await 必須在 async 函數里

#================================
# 上面操作后， 就不能直接 調一個   協程函數 func    了， |  func() ×

evt_loop = asyncio.get_event_loop()
# evt_loop.run_until_complete(func(0))  # 這是 開啟一個任務
evt_loop.run_until_complete(asyncio.wait([func(1),func(2),func(3)]) )  # 這是 開啟 多個任務

 

數據庫：

基礎點：

通配符：

% ：不限長度，

_:匹配一個字符，  

mysql 引擎介紹（存儲引擎）：  

https://www.cnblogs.com/eva-J/articles/9682063.html

存儲數據的格式，

 

默認的存儲引擎是 innodb ,  它支持  事務（transactions ）,行級鎖（row-level locking）, 外鍵（foreign keys）

 

只有 innodb 支持行級鎖，例如myisam 支持的是 表級鎖，   （innodb 行級鎖 肯定比  myisam 的表級鎖  效率高  ）

 

各種存儲引擎的使用場景：

一般 默認 innnodb  

當只查時， myisam  

當數據不是很重要，而且要求速度時：memory ,例如：每個用戶的登錄狀態， 

 

innodb :是一個文件存表結構，一個文件存  數據， 

myisam: 三個表，一個文件存結構，一個存數據，還有就是索引，（這也是它快的原因）

memory 和 blackhole ：都是只存表結構， 

 

mysql中的數據類型：   

https://www.cnblogs.com/eva-J/articles/9683316.html

數值，

1，小數精度要求高的場景（匯率，科研，利息，金融，銀行等），要使用 decimal ,float  和  double 不准，  

為什么decimal 准確度：它底層是以 字符串來存的， 

不過 decimal 有缺點：就是它

 

2，整型的約束，沒用，

時間，

date  年月日，

time 時分秒  ，

datetime 年月日時分秒，（ 常用  范圍 1000-01-01   --->   9999-12-31 ）

還有timestramp  (范圍較小， 1970  -  2038）

平時常用：date  , datetime   

注：

timestramp 不能為空，默認當前時間，  

 

mysql 中 now() 函數 是當前時間，  

字符串，

常用的是 char  varchar ,如果要有的話，longtext（存個視頻），但是一般已經不用mysql 存大量數據了，  

char : 定長，浪費硬盤，存取速度非常快

varchar:變長，節省空間，存取速度相對慢，  (varchar 除了數據以外，要額外存 長度）

 

char :適合 數據 的長度變化小， 例如手機號，身份證，學號，

varchar:數據長度變化大 ，

 

枚舉 和 集合  ：

枚舉：單選       例如, 性別

集合：多選       例如， 興趣愛好  

 

 

 

 

表的完整性約束：

是否允許空（not null / null ），是否唯一(  unique  )，主鍵(primary key)，外鍵(foreign key)，自增(auto)等， 

一般是：唯一  非空， 

主鍵的特點也是 ：唯一，非空，  

外鍵：只有innodb 支持外鍵，  

連級： cascade  , 連級 刪除 ，連級更新，  

 

補： 數據庫的模式很重要，一般要設置為 嚴格模式， 

 

聯合主鍵：

為一個以上的字段 設置 唯一非空，

例如 ip  和 端口  唯一，  

create table t (id int, ip char(12)  ,port char(10) ，primary key(ip,port )  )

 

聯合唯一：

unique 

create table t(id int primary key ,ip char(12),port char(10) ,unique(ip,port) )

 

上面ip 和 port 作為主鍵，我們一般習慣 將id 作為主鍵，所以可以用聯合唯一，代替聯合 主鍵：

create table t(id int ,ip char(12) not null ,port char(10) not null ,unique(ip,port) );  

注：  不寫主鍵，默認第一個就是，

 

修改表結構：

https://www.cnblogs.com/eva-J/articles/9677452.html

修改字段名，修改約束 ，修改字段排列順序等，  

SQL三種類型： 

DDL 語句（數據庫，表，視圖，索引，存儲過程）

DML 語句 （增刪改查）

DCL語句  （權限控制）

 

記錄操作： 

https://www.cnblogs.com/eva-J/articles/9688293.html

主要有 增刪改查：

它是DML ，

查詢：  

單表查詢：

https://www.cnblogs.com/Eva-J/articles/9688313.html

 

 

 

多表查詢：

https://www.cnblogs.com/eva-J/articles/9688383.html

表連接：

內連接，

左外連接 （左優先）

右外連接  （右優先）

全外連接  （mysql 中 使用 左 ，右連接， 然后union 關聯下 ），#注意 union與union all的區別：union會去掉相同的記錄

 

union 的 作用：  union查詢就是把2條或者多條sql語句的查詢結果，合並成一個結果集

 

 

子查詢：

#1：子查詢是將一個查詢語句嵌套在另一個查詢語句中。
#2：內層查詢語句的查詢結果，可以為外層查詢語句提供查詢條件。
#3：子查詢中可以包含：IN、NOT IN、ANY、ALL、EXISTS 和 NOT EXISTS等關鍵字
#4：還可以包含比較運算符：= 、 !=、> 、<等

 

Python 的 sqlite3 簡單查詢 sqlite3 ：

import sqlite3  

conn = sqlite3.connect('db.sqlite3')

cursor = conn.cursor()  
ret = cursor.execute('PRAGMA table_info(news_test)') # 表結構信息
print(ret.fetchall())

ret = cursor.execute('select * from news_test')
print(ret.fetchall())

cursor.close()
conn.close()

 

 

 

 

pymysql 模塊 的使用：  

它是個第三方模塊，  

pymysql的基本使用

import pymysql
conn = pymysql.connect(host='127.0.0.1',
                       user='root',
                       password="123456",
                       database='course',)
cursor = conn.cursor() #cursor 游標
cursor.execute('show tables;')
ret = cursor.fetchall()
print(ret) #(('course',), ('dept',), ('dept_temp',), ('students',), ('teacher',))

#================================

cursor.execute('select * from dept')
ret = cursor.fetchall()
print(ret)
#================================
cursor.execute('select * from dept')
ret = cursor.fetchone()
print(ret)
#================================

cursor.execute('select * from dept')
ret = cursor.fetchmany(3)
print(ret)


#================================
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) # 此時返回的是 字典~
cursor.execute('select * from dept')
ret = cursor.fetchmany(3)
print(ret)


cursor.close()   # 用完之后 關閉 游標
conn.close()     # conn 也要斷開連接

'''
(('course',), ('dept',), ('dept_temp',), ('students',), ('teacher',))
((1002, 'a'), (1003, 'a'), (1004, '高中部'), (1005, '大學'))
(1002, 'a')
((1002, 'a'), (1003, 'a'), (1004, '高中部'))
[{'id': 1002, 'dept_name': 'a'}, {'id': 1003, 'dept_name': 'a'}, {'id': 1004, 'dept_name': '高中部'}]
'''

 

pymysql 增 刪 改 （要 commit ）：

import pymysql
conn = pymysql.connect(host='127.0.0.1',
                       user='root',
                       password="123456",
                       database='course',)
cursor = conn.cursor()
#================================
try:
    cursor.execute('insert into dept values(1001,"中")')
    
    
    conn.commit()    # 當對  表 增刪改 的時候，都需要 進行 commit 提交
except:
    #如果出現 問題就 進行 回滾
    print('Q')
    conn.rollback()

cursor.close()   # 用完之后 關閉 游標
conn.close()     # conn 也要斷開連接

 

cursor.rowcount() ：

import pymysql
conn = pymysql.connect(host='127.0.0.1',
                       user='root',
                       password="123456",
                       database='course',)
cursor = conn.cursor()
#================================
cursor.execute('select * from dept')

count = cursor.rowcount  # 行數

for i in range(count):
    print(cursor.fetchone())


cursor.close()   # 用完之后 關閉 游標
conn.close()     # conn 也要斷開連接

 

python 代碼登陸 數據庫 （sql  注入  問題） ：

如果是用 拼接 參數 來登錄會有下面的問題：

1，是要記得 用戶名 和 密是是雙引號，

2，要注意   --  代表注釋掉 后面的內容，   

3，使用 or  條件 

它叫 sql  注入 問題，

 

我們可以利用 cursor.execute(sql,  (user,pwd)  )  來幫我們做，它會防止一些 sql 注入的問題  ，  

 

總結： 一定不能自己拼接 字符串，

 

python 趣實現：

Python代碼實現進度條：

import time
for i in range(0,101):
    time.sleep(0.2)
    char_num = i # 打印多少個 字符
    if i == 100:
        s = '\r{}% : {}\n'.format(i,'*'*char_num)
    else:
        s = '\r{}% : {}'.format(i,'*'*char_num)
    print(s,end='',flush=True)