大家好，為大家帶來python中核心知識的講解，不講最基礎的語法，這個大家都能輕松學會，不耽誤時間，只有干貨。

###查看當前作用域內的所有變量

>>>help('__main__')

退出鍵

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

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

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

###is/is not 運算符

is的作用：判斷兩個對象是否是同一個對象(比較內存中的地址)，當是同一個對象返回True，否則返回False， is not 的作用與 is相反

###小整數對象池

CPython 中 整數 -5 至 256永遠存在于小整數對象池中，不會釋放并可重復使用

###id(x) 函數

作用：返回一個對象在內存中的地址

###bool(x)返回假值的情況

bool(x)用于顯示獲取x的布爾值

假值情況

None 空值

False 布爾假值

0 0.0 0j 所有數字零

'' 空字符串

[] 空列表

() 空元組

{} 空字典

set() 空集合

.... 一切空的容器對象bool(x)取值為假

推導式

列表推導式

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

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

語法:

[表達式 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 ...]

示例：

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(',')]

####字典推導式

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

語法:

{鍵表達式 : 值表達式 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)

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

# ---------------------以下是XB寫的程序--------------------------

@ 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 函數名(參數列表):

'''函數文檔字符串'''

語句塊

說明

文檔字符串通常用來說明函數功能和使用方法

在交互模式下，輸入:

help(函數名) 可以查看函數的文檔字符串

函數的文檔字符串綁定在函數的__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('程序正常退出')

以上就是用python爬取蝦米播放記錄的代碼過程

我是白白，一個喜歡學習喜歡編程的年輕人

總結

以上是生活随笔為你收集整理的python装饰器深度讲解_python核心知识讲解，干货！！！的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。