學會這些會讓你對python有個更深的理解

時間 2020-07-17

原文原文鏈接

你們好，爲你們帶來python中核心知識的講解，不講最基礎的語法，這個你們都能輕鬆學會，不耽誤時間，只有乾貨。python

查看當前做用域內的全部變量

>>>help('__main__')
    退出鍵

    注：help函數用來查看幫助或運行時信息
複製代碼

自動化內存管理和引用計數

每一個對象會記錄有幾個變量引用自身，當引用的數量爲0時此對象被銷燬，此種自動化內存管理的方式叫引用計數。api

is/is not 運算符

is的做用：判斷兩個對象是不是同一個對象（比較內存中的地址)，當是同一個對象返回True，不然返回False， is not 的做用與 is相反bash

小整數對象池

CPython 中整數 -5 至 256永遠存在於小整數對象池中，不會釋放並可重複使用app

id(x) 函數

做用：返回一個對象在內存中的地址函數

bool(x)返回假值的狀況

bool(x)用於顯示獲取x的布爾值工具

假值狀況
    None        空值
    False       布爾假值
    0  0.0 0j   全部數字零
    '' 			空字符串
    []		    空列表
    () 			空元組
    {}    		空字典
    set()       空集合
    ....        一切空的容器對象bool(x)取值爲假
複製代碼

推導式

列表推導式

列表推導式是用可迭代對象建立列表的表達式ui

做用：用簡易方法生成列表

語法:

[表達式 for 變量 in 可迭代對象]
或
[表達式 for 變量 in 可迭代對象 if 真值表達式]
複製代碼

示例：

# 生成一個數值爲1~9的平方的列表
# [1, 4, 9, 16, .... 81]
# 不用推導式:
L = []
for i in range(1, 10):
    L.append(i**2)
# 推導式實現
L = [i ** 2 for i in range(1, 10)]
複製代碼

# 用列表推導式生成 1~100之內奇數的列表, 結果是:[1, 3, 5, 7, ...., 99]
# 答案:
[i for i in range(1, 100, 2)]

# 或
[i for i in range(1, 100) if i % 2 == 1]
複製代碼

列表推導式的嵌套

語法:

[表達式
  for 變量1 in 可迭代對象1 if真值表達式1
    for 變量2 in 可迭代對象2 if 真值表達式2 ...]
複製代碼

示例：

#將列表[10, 20, 30] 中的元素與列表[1,2,3]元素分別相加,將獲得的元素放於一個列表中

L = [x + y
      for x in [10, 20, 30]
        for y in [1,2,3]]
print(L)  #[11, 12, 13, 21, 22, 23, 31,32,33]
複製代碼

練習：

1. 用字符串"ABC"和字符串"123" 生成以下列表
    ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3', ]
  2. 已知有一個字符串:
  	s = '100,200,300,500,800'
    將其轉化爲列表,列表的內部是整數
    L = [100, 200, 300, 500, 800]
複製代碼

答案：

1. [ x + y for x in "ABC" for y in "123"]
2. L = [int(x) for x in s.split(',')]
複製代碼

字典推導式

是用可迭代對象生成字典的表達式spa

語法：

{鍵表達式 : 值表達式 for 變量 in 可迭代對象[if 真值表達式]}
注: []表示其中的內容可省略
複製代碼

示例:

# 生成一個字典,鍵爲數字 1 ~ 9,值爲鍵的平方
d = {x : x ** 2 for x in range(1, 10)}
複製代碼

高階函數

map 函數

map(func, *iterable)線程

做用：返回一個可迭代對象，此可迭代對象用函數func對可迭代對象iterable中的每個元素做爲參數計算後得新的數據

示例：

# 此示例示意map函數的使用
def power2(x):
    return x**2

for x in map(power2, range(1, 10)):
    print(x)  # 1, 4, 9, 16 ... 81
複製代碼

練習：

求 1**2 + 2**2 +3**2 +...+ 9**2 的和
求 1**3 + 2**3 +3**3 +...+ 9**3 的和
複製代碼

答案：

s = sum((map(lambda x : x**2, range(1, 10))))
print(s)
s = sum((map(lambda x : x**3, range(1, 10))))
print(s)
複製代碼

filter 函數

語法: filter(function, iterbale)
做用:
- 篩選可迭代對象iterable 中的數據，返回一個可迭代對象，此可迭代對象只返回iterable中符合條件的數據
- function將對iterbale中提供的每一個數據進行求布爾值，若是爲True則保留，不然爲False 丟棄數據

示例：

# 將1-20的偶數用filter生成可迭代對象後，將可迭代對象生成的數據存於列表中
l = list(filter(lambda x : x%2==0, range(1,21)))
print(l)
複製代碼

練習：
用filter 函數將1-100之間的全部素數存在列表中

答案：

def isprime(n):
   if n < 2:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True
l = list(filter(isprime, range(1,100)))
print(l)
複製代碼

sorted 函數

做用:
將原可迭代對象的數據進行排序，生成排序後的列表
函數參數格式
sorted(iterable, key=None, reverse=False)
說明
iterable 可迭代對象
【key函數】是用來提供一個值，這個值將做爲排序的依據，若是不給出key函數，則用
原數據的值進行比較和排序
reverse 標誌用來設置是否降序排序

示例

l = [5, -2, -4, 0, 3, 1]
l2 = sorted(l)  # [-4, -2, 0, 1, 3, 5]
l3 = sorted(l, reverse=True)  # [5, 3, 1, 0, -2, -4]
l4 = sorted(l, key=abs)   # [0, 1, -2, 3, -4, 5]

names = ['Tom', 'Jerry', 'Spike', 'Tyke']
l5 = sorted(names)  # ['Jerry', 'Spike', 'Tom', 'Tyke']

names = ['Tom', 'Jerry', 'Spike', 'Tyke']
l5 = sorted(names, key=len)  # ['Tom', 'Tyke', 'Jerry', 'Spike']
複製代碼

練習

names = ['Tom', 'Jerry', 'Spike', 'Tyke']
排序的依據爲字符串的反序
    'moT' 'yrreJ' 'ekipS' 'ekyT'
結果爲
    ['Spike', 'Tyke', 'Tom', 'Jerry']
複製代碼

答案

names = ['Tom', 'Jerry', 'Spike', 'Tyke']
l5 = sorted(names, key=lambda s : s[::-1])
複製代碼

裝飾器

裝飾器是一個函數，主要做用是用來包裝另外一個函數或類
包裝的目的是在不改變原函數（或類名）的狀況下改變被包裝對象的行爲翻譯

函數裝飾器

是指裝飾器是一個函數，傳入的是一個函數，返回的是一個函數

語法

def 裝飾器函數名(參數):
    語句塊
    return 函數對象

@裝飾器函數名<換行>
def 函數名(形參列表):
    語句塊
複製代碼

原理
被裝飾器函數的變量（函數名）綁定裝飾器函數調用後的返回的函數

示例1

# 此示例示意裝飾器函數的定義和調用裝飾器原理
def mydeco(fn):  # <<<----- 裝飾器函數
    def fx():
        print('fx被調用')
    return fx

@mydeco
def myfun():
    print('myfun被調用')

# 上述 mydeco的原理是在 def myfun語句調用以後加了一條以下語句
# myfun = mydeco(myfun)
myfun()  #調用myfun
myfun()
myfun()
複製代碼

示例2

# 此示例示意裝飾器函數用來包裝被裝束函數
def mydeco(fn):  # <<<----- 裝飾器函數
    def fx():
        print('------這個被裝飾函數調用以前-------')
        fn()  # 被調用被裝飾函數
        print('++++++這個被裝飾函數調用以後+++++++')
    return fx

@mydeco
def myfun():
    print('myfun被調用')

# 上述 mydeco的原理是在 def myfun語句調用以後加了一條以下語句
# myfun = mydeco(myfun)
myfun()  #調用myfun
myfun()
myfun()
複製代碼

示例3

# 此示例示意裝飾器的應用場合及功能
# ---------------------如下是楊小哥寫的程序--------------------------
def privileged_check(fn):
    def fx(name, x):
        print('正在進行權限驗證。。。')
        if True:
            fn(name, x)
        else:
            print('權限驗證失敗')
    return fx


def  message_send(fn):
    def fy(n, money):
        fn(n, money)  # 調用被裝飾函數
        print('正在發送短信給', n, '...')
    return fy

# ---------------------如下是楊小哥寫的程序--------------------------
@ message_send
@ privileged_check
def savemoney(name, x):
    print(name, '存錢', x, '元')
# 實質是
# savemoney = privileged_check(savemoney)
# savemoney = message_send(savemoney)


def withdraw(name, x):
    print(name, '取錢', x, '元')


# ---------------------如下是調用者寫的程序--------------------------
savemoney('小王', 200)
savemoney('小趙', 400)

withdraw('小李', 500)
複製代碼

函數的文檔字符串

函數內第一次未賦值給任何變量的字符串是此函數的文檔字符串

語法

def 函數名(參數列表):
	'''函數文檔字符串'''
    語句塊
複製代碼

說明
1. 文檔字符串一般用來講明函數功能和使用方法
2. 在交互模式下，輸入:
>>>help(函數名) 能夠查看函數的文檔字符串
3. 函數的文檔字符串綁定在函數的__doc__屬性上

示例

def mysum(n):
   '''1 + 2 + 3 + 4 + ...+ n'''
    return 100
help(mysum)
複製代碼

函數的doc屬性

__doc__屬性用於記錄文檔字符串

函數的name屬性

__name__屬性用於記錄函數名

迭代器和生成器

迭代器 Iterator

迭代器是訪問可迭代對象的工具
迭代器是指用iter(obj)函數返回的對象（實例）
迭代器能夠用next(it)函數獲取可迭代對象的數據

迭代器函數iter 和 next

iter(iterable)
 	從可迭代對象中返回一個迭代器，iterable 必須是能提供一個迭代器的對象
next(iterator)
    從迭代器iterable中獲取下一個記錄，若是沒法獲取下一條記錄，則觸發StopIteration 異常

說明
    1. 迭代器只能往前取值，不會後退
    2. 用iter 函數能夠返回一個可迭代對象的迭代器
複製代碼

示例

l = [1, 3, 5, 7]
it = iter(l)  # 讓l提供一個能訪問本身的迭代器
print(next(it))  # 1 從迭代器中取值，讓迭代器去獲取l中的一個元素
print(next(it))  # 3 從迭代器中取值，讓迭代器去獲取l中的一個元素
print(next(it))  # 5 從迭代器中取值，讓迭代器去獲取l中的一個元素
print(next(it))  # 7 從迭代器中取值，讓迭代器去獲取l中的一個元素
# next(it) # StopIteration 異常
複製代碼

迭代器的用途

用迭代器能夠依次訪問可迭代對象的數據

l = [2, 3, 5, 7]
for i in l:
    print(l)

# 如下用迭代器來訪問
l = [2, 3, 5, 7]
it = iter(l)
while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
    	break
複製代碼

練習

有一個集合，
s = {'唐僧', '悟空', '八戒', '沙僧'}

用for語句來遍歷全部元素以下
	for x in s:
	    print(x)
	else:
	    print('遍歷結束')
將for語句改寫爲while語句和迭代器實現
複製代碼

生成器 Generator

生成器是可以動態提供數據的對象，生成器對象也是可迭代對象（實例）

生成器的兩種方式

生成器函數
生成器表達式

生成器函數的定義

含有yield語句的函數是生成器函數，此函數被調用將返回一個生成器對象
yield 翻譯爲（產生或生成）

yield 語句

語法
	yield表達式
說明
	yield 用於 def 函數中，目的是將此函數做爲生成器函數使用
	yield 用來生成數據， 供迭代器和next(it) 函數使用    
複製代碼

示例

# 生成器函數只有在next(it) 函數調用時纔會執行，且遇到yield後返回相應的值給next(it)函數
def my_yield():
    print('即將生成2')
    yield 2
    print('即將生成3')
    yield 3
    print('即將生成5')
    yield 5
    print('即將生成7')
    yield 7
    print('生成器生成結束 ')


for i in my_yield():
    print(i)

g = my_yield()  # 調用生成器函數來建立一個生成器，今生成器能生成 2 3 5 7 四個數
it = iter(g)  # 用生成器拿到對應的迭代器
print(next(it))
print(next(it))
複製代碼

# 用生成器函數來生成一些列的整數， 0 - n
def myinteger(n):
    i = 0
    while i < n:
        yield i
        i += 1

for x in myinteger(3):
    print(x)

l = [x for x in myinteger(100) if x % 2 == 1]
print(l)
複製代碼

生成器函數的說明

生成器函數的調用將返回一個生成器對象，生成器對象是一個可迭代對象，一般用來動態生成數據
生成器函數調用return 語句會觸發一個StopIteration 異常
練習
寫一個生成器函數，myeven(start, stop)用來生成start開始帶stop結束（不包含）的偶數

生成器表達式

語法
    （表達式 for 變量 in 可迭代對象 [if 真值表達式]）
做用
    用推導式形式建立一個新的生成器
說明
    if 子句能夠省略
示例
    gen = (x**2 for x in range(1, 5))
    it = iter(gen)
    print(next(it))  # 1
    print(next(it))  # 4
    print(next(it))  # 9
    print(next(it))  # 16
    print(next(it))  # StopIteration
複製代碼

練習

已知有列表
l = [2, 3, 5, 7]
1) 寫一個生成器函數，讓此函數可以動態提供數據，數據爲原列表數字的平方加1
2) 寫一個生成器表達式，讓此表達式可以動態提供數據，數據爲原列表數字的平方加1
3) 生成一個列表，此列表內的數據是原列表數據的平方加1
複製代碼

生成器表達式和列表推導式的區別

l = [2, 3, 5, 7]
	l2 = [x ** 2 + 1 for x in l]
	it = iter(l2)
	print(next(it))  # ?
	
	l[1] = 30
	print(next(it))  # ??
	
	# 如下是生成器表達式
	
	l = [2, 3, 5, 7]
	l2 = (x ** 2 + 1 for x in l)
	it = iter(l2)
	print(next(it))  # ?
	
	l[1] = 30
	print(next(it))  # ??
	
	# 生成器表達式是現用現生成，列表推導式一次性生成靜態數據
複製代碼

迭代工具函數

做用是生成一個個性化的可迭代對象

zip(iter1 [, iter2[...]])
    返回一個zip對象，此對象用於生成元組，此元組的每一個數據來源於參數中的可迭代對象，當最小的可迭代對象再也不提供數據時迭代結束

enumerate(iterable [, start])
複製代碼

ZIP示例

numbers = [10086, 10000, 10010, 95588]
names = ['中國移動', '中國聯通', '中國電信']
for t in zip(numbers, names):
    print(t)
for No, number, name in zip(range(1, 100), numbers, names):
    print('序號', No, name, '的客服電話是', number)
複製代碼

ENUMERATE 示例

names = ['中國移動', '中國聯通', '中國電信']
for t in enumerate(names):
    print(t)

for t in enumerate(names, 101):
    print(t)

# 既能獲得索引又能獲得值
for index, name in enumerate(name):
    print(index, name)
複製代碼

練習

寫一個程序，讀入任意行文字，當輸入空行時結束，打印帶有行號的輸入的結果
    如：
        請輸入：abdce <回車>
        請輸入：hello <回車>
        請輸入：bye <回車>
        請輸入：<回車>
    輸出以下：
        第1行：abdce <回車>
        第2行：hello <回車>
        第3行：bye <回車>
複製代碼

迭代器（高級）

由iter(iterable) 函數返回，能夠經過next(iterator) 函數取值的對象就是迭代器

迭代器協議

迭代器協議是指對象可以使用next()函數獲取下一項數據，在沒有下一項數據時觸發一個StopIteration異常來終止迭代的約定

迭代器協議的實現方法

def __next__(self):
      ...
  注： 此方法須要實現迭代器協議
複製代碼

# 此示例示意將自定義的類MyList建立的對象製做爲可迭代對象
class MyList:
    '''這是一個自定義的列表類型，此類型的對象用data屬性綁定的列表來存儲數據'''
    def __init__(self, iterable=()):
        self.__data = [x for x in iterable]

    def __repr__(self):
        return 'MyList(%s)' % self.__data

    def __iter__(self):
        '''此方法用來返回一個能訪問self對象'''
        '''此方法用來返回一個能訪問self對象迭代器'''
        # return iter(self.__data)
        return MyListIterator(self.__data)

class MyListIterator:
    '''此類用來描述可以訪問MyList類型的對象的迭代器'''
    def __init__(self, lst):
        self.__data_lst = lst
        self.__cur_index = 0  #迭代器的起始位置

    def __next__(self):
        '''此方法用來實現迭代器協議'''
        if self.__cur_index >= len(self.__data_lst):
            raise StopIteration
        r = self.__data_lst[self.__cur_index]
        self.__cur_index += 1
        return r


myl = MyList([2, 3, 5, 7])
# ################
it = iter(myl)  # 等同於it = myl.__iter__()
print(next(it))  # 2
# ################
for x in myl:
    print(x)
複製代碼

深拷貝和淺拷貝

淺拷貝 shallow copy

淺拷貝是指在複製過程當中，只複製一層變量，不會複製深層變量綁定的對象的複製過程

L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = L1.copy()  # 淺拷貝
print(L1)  # [1, 2, [3.1, 3.2]]
print(L2)  # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1)  # [1, 2, [3.14, 3.2]]
print(L2)  # [1, 2, [3.14, 3.2]]
複製代碼

深拷貝 deep copy

複製對象及對象關聯的對象一塊兒複製過程叫深拷貝

import copy  # 導入複製模塊
L= [3.1, 3.2]
L1 = [1, 2, L]
L2 = copy.deepcopy(L1) 　# 深拷貝
print(L1)  # [1, 2, [3.1, 3.2]]
print(L2)  # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1)  # [1, 2, [3.1, 3.2]]　　<<< L1不變
print(L2)  # [1, 2, [3.14, 3.2]]
複製代碼

字符串的文本解析方法

S.split(sep=None) 將字符串，使用 sep做用分隔符分割S字符串，返回分割後的字符串列表，當不給定參數時，用空白字符做爲分隔符分割
S.join(iterable) 用可迭代對象中的字符串，返回一箇中間用S進行分隔的字符串

s ='Beijing is capital'
L = s.split(' ')  # L = ['hello', 'world', 'tarena']
s2 = "hello#world#tarena"
L = s2.split('#')  # L = ['hello', 'world', 'tarena']
L = ['aaa', 'bbbb', 'ccccc']
'$'.join(L) # 生成 'aaa$bbbb$ccccc'
複製代碼

python3 中不可變數據類型

bool, int, float, complex, str, tuple, frozenset, bytes

python3 中可變數據類型

list, dict, set, bytearray

dir(obj) 函數

返回全部屬性的字符串列表

with 語句深層次講解

語法
    with 表達式1 [as 變量1], 表達式2 [as, 變量2], ....
        語句塊
做用
    使用於對資源進行訪問的場合，確保使用過程當中無論是否發生異常都會執行必須"清理"的操做，並釋放資源
    如
        文件打開後自動關閉，線程中鎖的自動獲取和釋放等
說明
    as 字句中的變量用於綁定表達式執行後生成的對象
    with 語句並不會改變異常的狀態
複製代碼

環境管理器

1. 類內有__enter__ 和 __exit__ 實例方法的類建立的對象被稱爲環境管理器  
2. 可以使用with語句進行管理的對象必須是環境管理器  
3. __enter__ 方法將在進入with語句時被調用，由as變量綁定返回的對象  
4. __exit__ 方法將在離開with語句時被自動調用，且能夠經過參數來判斷離開with語句時是否有異常發生  
複製代碼

示例

class A:
    '''此類對象能夠用於with語句進行管理'''
    def __enter__(self):
        print('此方法是在with語句內執行的')
        return self  # self 將被with中的as 變量綁定

    def __exit__(self, exc_type, exc_val, exc_tb):
        ''' exc_type 用來綁定錯誤類型,當沒有異常發生時綁定None exc_val 用來綁定錯誤對象，當內有發生異常時綁定None exc_th 用來綁定TraceBack對象，當沒有異常時綁定None '''
        if exc_type is None:
            print('您已離開with語句, 離開時沒有發生任何異常')
        else:
            print('您已離開with語句')
            print('錯誤類型是：', exc_type)
            print('錯誤的數據是：', exc_val)
            print('Traceback：', exc_tb)



with A() as a:
    print('這是with語句內部的輸出')
    int(input('輸入：'))

print('程序正常退出')
複製代碼