文章目錄

• Python 進(jìn)階知識(shí)
• • 知識(shí)點(diǎn)一 : 數(shù)據(jù)類型
  • • 1.數(shù)據(jù)類型 列表與元組
    • 2.數(shù)據(jù)類型 字典與集合
    • 3.數(shù)據(jù)類型 字符串
  • 知識(shí)點(diǎn)二 : 推導(dǎo)式
  • • 1.列表推導(dǎo)式
    • 2.字典推導(dǎo)式
    • 3.元組推導(dǎo)式
    • 4.集合推導(dǎo)式
  • 知識(shí)點(diǎn)三 : 高階函數(shù)
  • • 1.filter 函數(shù)
    • 2.map 函數(shù)
    • 3.reduce 函數(shù)
    • 4.zip 函數(shù)
    • 5.enumerate 函數(shù)
  • 知識(shí)點(diǎn)四 : 裝飾器
  • • 1.裝飾器 單個(gè)無(wú)參裝飾器修飾無(wú)參函數(shù)
    • 2.裝飾器 單個(gè)無(wú)參裝飾器裝飾帶參函數(shù)
    • 3.裝飾器 單個(gè)帶參裝飾器裝飾帶參函數(shù)
    • 4.裝飾器 多個(gè)無(wú)參裝飾器修飾帶參函數(shù)
    • 5.裝飾器 解決元信息丟失
    • 6.裝飾器 基于類的裝飾器
    • 7.裝飾器 內(nèi)置裝飾器@property
    • 8.裝飾器 內(nèi)置裝飾器@staticmethod
    • 9.裝飾器 內(nèi)置裝飾器@classmethod
  • 知識(shí)點(diǎn)五 : 閉包
  • • 1.閉包 閉包基本操作
    • 2.閉包 閉包的作用域
    • 3.閉包 閉包實(shí)際作用
    • 4.閉包 判斷閉包函數(shù)
    • 5.閉包 閉包存在的問(wèn)題
  • 知識(shí)點(diǎn)六 : 日期和時(shí)間
  • • 1.時(shí)間模塊 time
    • • 1.1 時(shí)間模塊 獲取時(shí)鐘基本信息
      • 1.2 時(shí)間模塊 獲取時(shí)間戳
      • 1.3 時(shí)間模塊 獲取可讀時(shí)間
      • 1.4 時(shí)間模塊 從系統(tǒng)啟動(dòng)時(shí)開始計(jì)時(shí)
      • 1.5 時(shí)間模塊 處理器時(shí)鐘時(shí)間
      • 1.6 時(shí)間模塊 性能計(jì)數(shù)器
      • 1.7 時(shí)間模塊 時(shí)間組件
      • 1.8 時(shí)間模塊 解析和格式化時(shí)間
    • 2.日期模塊 datetime
    • • 2.1 日期模塊 date類
      • 2.2 日期模塊 time類
      • 2.3 日期模塊 datetime類
    • 3.日歷模塊 calendar
  • 知識(shí)點(diǎn)七 : 作用域
  • • 1.作用域 作用域解釋
    • 2.作用域 Python中的作用域
    • 3.作用域 global關(guān)鍵字
    • 4.作用域 nonlocal關(guān)鍵字

Python 進(jìn)階知識(shí)

知識(shí)點(diǎn)一 : 數(shù)據(jù)類型

1.數(shù)據(jù)類型 列表與元組

"""1.列表與元組最直接的的區(qū)別是:列表長(zhǎng)度大小不固定,是可變的. --動(dòng)態(tài)元組長(zhǎng)度大小固定,不可變. --靜態(tài)2.__sizeof__()方法 : Python的內(nèi)置函數(shù),用來(lái)打印系統(tǒng)分配空間的大小.3.列表會(huì)一次性增加4個(gè)元素的空間,當(dāng)空間使用完畢后才會(huì)繼續(xù)增加 (64位操作系統(tǒng)中地址占用8個(gè)字節(jié))4.namedtuple模塊 : 繼承自tuple的子類,用來(lái)創(chuàng)建一個(gè)和tuple類似的對(duì)象,且對(duì)象擁有可訪問(wèn)的屬性.5.初始化空列表使用 []比 list() 快6.非空列表與非空元組初始化時(shí),元組的效率更高 """# 1.用列表檢測(cè)系統(tǒng)如何進(jìn)行空間分配 my_list = [] print("初始化大小", my_list.__sizeof__(), ":", my_list)my_list.append("a") print("追加1個(gè)元素之后的大小", my_list.__sizeof__(), ":", my_list)my_list.append("b") print("追加2個(gè)元素之后的大小", my_list.__sizeof__(), ":", my_list)my_list.append("c") print("追加3個(gè)元素之后的大小", my_list.__sizeof__(), ":", my_list)my_list.append("d") print("追加4個(gè)元素之后的大小", my_list.__sizeof__(), ":", my_list)my_list.append("e") print("追加5個(gè)元素之后的大小", my_list.__sizeof__(), ":", my_list) print("--------------")# 2.使用namedtuple模塊 from collections import namedtuple Point = namedtuple(typename='Point', field_names=['x', 'y']) # typename相當(dāng)于是創(chuàng)建的類名,field_names用于為創(chuàng)建的元組的每個(gè)元素命名,可以傳入列表或元組 p = Point(10, 20) print(p.x) print(p.y) print("--------------")# 3.比較 list() 與 [] 初始化效率 import timeit a = timeit.timeit('a=list()', number=10000000 ) b = timeit.timeit('a=[]', number=10000000 ) print(a) print(b) print("--------------")# 4.比較 非空元組 與 非空列表 初始化效率 import timeit a = timeit.timeit('a=("a","b","c")', number=10000) b = timeit.timeit('b=["a","b","c"]', number=10000) print(a) print(b) print("--------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 初始化大小 40 : [] 追加1個(gè)元素之后的大小 72 : ['a'] 追加2個(gè)元素之后的大小 72 : ['a', 'b'] 追加3個(gè)元素之后的大小 72 : ['a', 'b', 'c'] 追加4個(gè)元素之后的大小 72 : ['a', 'b', 'c', 'd'] 追加5個(gè)元素之后的大小 104 : ['a', 'b', 'c', 'd', 'e'] -------------- 10 20 -------------- 0.4988713 0.20966529999999994 -------------- 0.00011539999999998773 0.0003946999999999701 --------------進(jìn)程已結(jié)束,退出代碼0

2.數(shù)據(jù)類型 字典與集合

"""1.字典:1.1 在使用字典索引鍵時(shí),若鍵不存在則出現(xiàn)KeyError錯(cuò)誤,解決方法是在索引鍵時(shí)使用get(key,default)函數(shù)即可.(如 my_dict.get("F","None"))2.集合:2.1 集合不支持索引操作,使用索引查找對(duì)應(yīng)元素值會(huì)報(bào)錯(cuò)(TypeError: 'set' object is not subscriptable)2.2 集合的執(zhí)行效率遠(yuǎn)高于列表 """# 1.字典與集合的效率問(wèn)題 import time# 1.1 計(jì)算列表運(yùn)行的時(shí)間 def find_unique_weight(students):# 聲明一個(gè)統(tǒng)計(jì)列表unique_list = []# 循環(huán)所有學(xué)生數(shù)據(jù)for id, weight in students:# 如果體重沒(méi)有在統(tǒng)計(jì)列表中if weight not in unique_list:# 新增體重?cái)?shù)據(jù)unique_list.append(weight)# 計(jì)算列表長(zhǎng)度ret = len(unique_list)return retid = [x for x in range(1, 10000)] weight = [x for x in range(1, 10000)] # 體重?cái)?shù)據(jù)為了計(jì)算，也設(shè)置從 1 到 10000 students = list(zip(id, weight))start_time = time.perf_counter() find_unique_weight(students) end_time = time.perf_counter() print("列表運(yùn)算時(shí)間為:{}".format(end_time - start_time))# 1.2 計(jì)算列表運(yùn)行的時(shí)間def find_unique_weight(students):# 聲明一個(gè)統(tǒng)計(jì)集合unique_set = set()# 循環(huán)所有學(xué)生數(shù)據(jù)for id, weight in students:# 集合會(huì)自動(dòng)過(guò)濾重復(fù)數(shù)據(jù)unique_set.add(weight)# 計(jì)算集合長(zhǎng)度ret = len(unique_set)return retid = [x for x in range(1, 10000)] weight = [x for x in range(1, 10000)] students = list(zip(id, weight))start_time = time.perf_counter() find_unique_weight(students) end_time = time.perf_counter() print("集合運(yùn)算時(shí)間為:{}".format(end_time - start_time))-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 列表運(yùn)算時(shí)間為:0.6111517 集合運(yùn)算時(shí)間為:0.0007663999999999449進(jìn)程已結(jié)束,退出代碼0

3.數(shù)據(jù)類型 字符串

"""1.字符串:1.1 字符串是不可變的1.2 字符串拼接時(shí),join函數(shù) 比 += 快 """# 1.比較同名字符串內(nèi)存地址 my_str = "hello " print(id(my_str)) my_str += "world" print(id(my_str)) print(my_str) print("---------------")# 2.比較字符串拼接效率 import time# 2.1 += 寫法 def m0():s = ' 'for n in range(0, 100000):s += str(n)start_time = time.perf_counter() m0() end_time = time.perf_counter() print("代碼運(yùn)行時(shí)間為:", end_time - start_time)# 2.2 join 寫法 def m1():l = []for n in range(0, 100000):l.append(str(n))s = ' '.join(l)start_time = time.perf_counter() m1() end_time = time.perf_counter() print("代碼運(yùn)行時(shí)間為:", end_time - start_time)# 2.3 pythonic 寫法 def m2():s = ' '.join(map(str, range(0, 100000)))start_time = time.perf_counter() m2() end_time = time.perf_counter() print("代碼運(yùn)行時(shí)間為:", end_time - start_time)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 2625249362416 2625250809136 hello world --------------- 代碼運(yùn)行時(shí)間為: 0.027465000000000003 代碼運(yùn)行時(shí)間為: 0.022872000000000003 代碼運(yùn)行時(shí)間為: 0.0164642進(jìn)程已結(jié)束,退出代碼0

知識(shí)點(diǎn)二 : 推導(dǎo)式

1.列表推導(dǎo)式

"""1.列表推導(dǎo)式1.1 推導(dǎo)式格式:[表達(dá)式 for 迭代變量 in 可迭代對(duì)象 [if 條件表達(dá)式]]1.2 if 條件表達(dá)式非必選1.3 列表推導(dǎo)式運(yùn)行效率高于傳統(tǒng)for循環(huán)寫法1.4 Python3中列表推導(dǎo)式具備局部作用域,表達(dá)式內(nèi)部變量和賦值只在局部生效 """# 1.傳統(tǒng)for循環(huán)寫法 my_list = [1, 2, 3] new_list = [] for i in my_list:new_list.append(i * 2) print(new_list) print("--------------")# 2.列表推導(dǎo)式寫法 my_list = [1, 2, 3] new_list = [] nn_list = [i * 2 for i in my_list] print(nn_list) print("--------------")# 3.列表推導(dǎo)式if語(yǔ)句 nn_list = [i * 2 for i in my_list if i > 1] print(nn_list) print("--------------")# 4.列表推導(dǎo)式雙重for循環(huán) nn_list = [(x, y) for x in range(3) for y in range(3)] print(nn_list) print("--------------")# 5.列表推導(dǎo)式局部性演示 x = 6 my_var = [x*2 for x in range(3)] print(my_var) print(x) print("--------------")# 6.列表推導(dǎo)式嵌套 my_var = [y*4 for y in [x*2 for x in range(3)]] print(my_var)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe [2, 4, 6] -------------- [2, 4, 6] -------------- [4, 6] -------------- [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)] -------------- [0, 2, 4] 6 -------------- [0, 8, 16]進(jìn)程已結(jié)束,退出代碼0

2.字典推導(dǎo)式

"""1.字典推導(dǎo)式1.1 推導(dǎo)式格式:{鍵:值 for 迭代變量 in 可迭代對(duì)象 [if 條件表達(dá)式]}1.2 字典中不能出現(xiàn)同名key,第二次出現(xiàn)的同名key將會(huì)覆蓋掉前一個(gè)同名key的值 """# 1.字典推導(dǎo)式演示 my_dict = {key: value for key in range(3) for value in range(2)} print(my_dict) print("--------------")# 2.字典推導(dǎo)式遍歷一個(gè)具有鍵值關(guān)系的可迭代對(duì)象 my_tuple_list = [('name', '王小明'), ('age', 18), ('class', 'no1'), ('like', 'python')] my_dict = {key: value for key, value in my_tuple_list} print(my_dict)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe {0: 1, 1: 1, 2: 1} -------------- {'name': '王小明', 'age': 18, 'class': 'no1', 'like': 'python'}進(jìn)程已結(jié)束,退出代碼0

3.元組推導(dǎo)式

"""1.元組推導(dǎo)式:1.1 元組推導(dǎo)式運(yùn)行結(jié)果返回的是一個(gè)地址值. """my_tuple = (i for i in range(10)) print(my_tuple)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe <generator object <genexpr> at 0x000001CFE12EFC10>進(jìn)程已結(jié)束,退出代碼0

4.集合推導(dǎo)式

"""1.集合推導(dǎo)式:1.1 因?yàn)榧鲜菬o(wú)序且不重復(fù)的,所以會(huì)自動(dòng)去掉重復(fù)元素導(dǎo)致每次運(yùn)行顯示的順序不一樣. """my_set = {value for value in 'HelloWorld'} print(my_set)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe {'d', 'e', 'r', 'l', 'o', 'W', 'H'}進(jìn)程已結(jié)束,退出代碼0

知識(shí)點(diǎn)三 : 高階函數(shù)

1.filter 函數(shù)

"""1.filter 函數(shù)1.1 函數(shù)原型:filter ( function or None, iterable ) --> filter object- 第一個(gè)參數(shù)是判斷函數(shù) ( 返回結(jié)果需要是 True 或 False).- 第二個(gè)為序列,該函數(shù)將對(duì) iterable 序列依次執(zhí)行 function ( item ) 操作, 返回結(jié)果是過(guò)濾后結(jié)果組成的序列.1.2 解釋:filter 函數(shù)對(duì)序列中元素進(jìn)行篩選, 獲取符號(hào)條件的序列 """my_list = [1, 2, 3] my_new_list = filter(lambda x: x > 2, my_list) print(my_new_list) print(list(my_new_list)) # 使用list函數(shù)查看序列內(nèi)容-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe <filter object at 0x000002DFEF283FA0> [3]進(jìn)程已結(jié)束,退出代碼0

2.map 函數(shù)

"""1.map 函數(shù)1.1 map 函數(shù)原型:map(func, *iterables) --> map object1.2 解釋:map函數(shù)運(yùn)行后生成一個(gè)list, 第一個(gè)參數(shù)是函數(shù), 第二個(gè)參數(shù)是一個(gè)或多個(gè)序列1.3 map函數(shù)解決的問(wèn)題:1.使用 map 函數(shù)不需要?jiǎng)?chuàng)建一個(gè)空列表.2.調(diào)用函數(shù)時(shí)不再需要帶括號(hào),map 函數(shù)會(huì)自動(dòng)調(diào)用目標(biāo)函數(shù).3.map 函數(shù)會(huì)自動(dòng)匹配序列中的所有元素. """# 1.第一個(gè)參數(shù)為單參 my_list = [-1, 2, -3] my_new_list = map(abs, my_list) print(my_new_list) print(list(my_new_list)) # 使用list函數(shù)查看序列內(nèi)容 print("-----------------")# 2.第一個(gè)參數(shù)為多參 def fun(x, y):return x + ymy_new_list = map(fun, [1, 2, 3], [4, 4, 4]) # fun 函數(shù)有2個(gè)參數(shù)，故需要兩個(gè)序列 print(my_new_list) print(list(my_new_list)) print("-----------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe <map object at 0x00000169BACF7FA0> [1, 2, 3] ----------------- <map object at 0x00000169BACF7EB0> [5, 6, 7] -----------------進(jìn)程已結(jié)束,退出代碼0

3.reduce 函數(shù)

"""1.reduce函數(shù)1.1 函數(shù)原型:reduce(function, sequence[, initial]) -> value- 第一個(gè)參數(shù)是函數(shù)- 第二個(gè)參數(shù)是序列,返回結(jié)算結(jié)果之后的值1.2 解釋:reduce函數(shù)用于滾動(dòng)計(jì)算應(yīng)用于列表中的連續(xù)值 """# 1.測(cè)試代碼 from functools import reducemy_list = [1, 2, 3]def add(x, y):return x + ymy_new_list = reduce(add, my_list) print(my_list) # 1+2+3 print(my_new_list) print("-----------------")# 2.將測(cè)試代碼第三個(gè)參數(shù)設(shè)置為4 my_new_list = reduce(add, my_list, 4) # 第三個(gè)參數(shù)表示初始值,即累加操作初始的數(shù)值 print(my_list) # 4 + 1+2+3 print(my_new_list) print("-----------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe [1, 2, 3] 6 ----------------- [1, 2, 3] 10 -----------------進(jìn)程已結(jié)束,退出代碼0

4.zip 函數(shù)

"""1.zip函數(shù)1.1 函數(shù)原型:zip(iter1 [,iter2 [...]]) --> zip object1.2 解釋:- zip函數(shù)將可迭代對(duì)象作為參數(shù),將對(duì)象中對(duì)應(yīng)的元素打包成一個(gè)個(gè)元組,然后返回由這些元組組成的列表.- 如果各個(gè)迭代器的元素個(gè)數(shù)不一樣,則返回列表長(zhǎng)度與最短的對(duì)象相同,利用星號(hào) (*)操作符將元組解壓為列表 """# 1.測(cè)試代碼 my_list1 = {1, 2, 3} my_list2 = ["a", "b", "c"] print(zip(my_list1, my_list2)) print(list(zip(my_list1, my_list2))) print("-----------------")# 2.測(cè)試代碼展示*操作符 my_list = [(1, 'a'), (2, 'b'), (3, 'c')] print(zip(*my_list)) print(list(zip(*my_list))) print("-----------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe <zip object at 0x00000177A7BB6540> [(1, 'a'), (2, 'b'), (3, 'c')] ----------------- <zip object at 0x00000177A7BB6580> [(1, 2, 3), ('a', 'b', 'c')] -----------------進(jìn)程已結(jié)束,退出代碼0

5.enumerate 函數(shù)

"""1.enumerate函數(shù):1.1 函數(shù)原型:enumerate(iterable, start=0)- sequence: 一個(gè)序列、迭代器或其他支出迭代對(duì)象;- start: 下標(biāo)起始位置.1.2 解釋:enumerate函數(shù)用于將一個(gè)可遍歷的數(shù)據(jù)對(duì)象組合為一個(gè)索引序列,同時(shí)列出數(shù)據(jù)和數(shù)據(jù)下標(biāo),一般用在for循環(huán)當(dāng)中. """weekdays = ['Mon', 'Tus', 'Wen', 'Thir'] print(enumerate(weekdays)) print(list(enumerate(weekdays)))-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe <enumerate object at 0x000001D7D6893CC0> [(0, 'Mon'), (1, 'Tus'), (2, 'Wen'), (3, 'Thir')]進(jìn)程已結(jié)束,退出代碼0

知識(shí)點(diǎn)四 : 裝飾器

1.裝飾器 單個(gè)無(wú)參裝飾器修飾無(wú)參函數(shù)

"""1.裝飾器 裝飾無(wú)參函數(shù)1.1 解釋:裝飾器簡(jiǎn)單來(lái)理解就是套在函數(shù)上的函數(shù),如想統(tǒng)計(jì)1000個(gè)具有不同功能的函數(shù)運(yùn)行的時(shí)間時(shí),需要重構(gòu)的代碼量極為恐怖.而這時(shí)則只需要寫個(gè)統(tǒng)計(jì)時(shí)間的函數(shù),再讓這1000個(gè)函數(shù)直接調(diào)用即可.簡(jiǎn)單來(lái)說(shuō),裝飾器拓展了原函數(shù)的功能,又不需要修改原函數(shù)的代碼1.2 格式:@裝飾器名def 函數(shù)名():pass """# 自定義裝飾器并調(diào)用 import timedef go(func):# 這里的 wrapper 函數(shù)名可以為任意名稱def wrapper():s_time = time.perf_counter()func()e_time = time.perf_counter()print(f"函數(shù){func.__name__}運(yùn)行時(shí)間是：{e_time - s_time}") # func.__name__用來(lái)得到引用指向的真正名字return wrapper@go # go就是我們剛寫好的統(tǒng)計(jì)運(yùn)行時(shí)間的函數(shù),裝飾器使用@來(lái)調(diào)用 def func():i = 0while i < 1000:i += 1@go def func1():i = 0while i < 10000:i += 1if __name__ == '__main__':func() # 調(diào)用函數(shù)時(shí),我們沒(méi)有對(duì)函數(shù)func做任何修改,但是函數(shù)func具有了更多的功能(計(jì)算運(yùn)行時(shí)間的功能)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 函數(shù)func運(yùn)行時(shí)間是：4.4900000000000495e-05進(jìn)程已結(jié)束,退出代碼0

2.裝飾器 單個(gè)無(wú)參裝飾器裝飾帶參函數(shù)

import timedef go(func):def wrapper(x, y):s_time = time.perf_counter()func(x, y)e_time = time.perf_counter()print(f"函數(shù){func.__name__}運(yùn)行時(shí)間是：{e_time - s_time}")return wrapper@go def func(x, y):i = 0while i < 1000:i += 1print(f"x={x},y={y}")if __name__ == '__main__':func(33, 55)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe x=33,y=55 函數(shù)func運(yùn)行時(shí)間是：6.230000000000124e-05進(jìn)程已結(jié)束,退出代碼0

3.裝飾器 單個(gè)帶參裝飾器裝飾帶參函數(shù)

def log(text):def decorator(func):def wrapper(x):print('%s %s():' % (text, func.__name__))func(x)return wrapperreturn decorator# 1.使用帶參裝飾器,相當(dāng)于是在裝飾器外又包裹了一個(gè)函數(shù),使用該函數(shù)接受參數(shù)且返回一個(gè)裝飾器函數(shù). # 2.運(yùn)行順序?yàn)? my_fun = log('執(zhí)行')(my_fun) # 3.注意: 裝飾器只能接收一個(gè)參數(shù),且必須是函數(shù)類型. @log('執(zhí)行') def my_fun(x):print(f"我是 my_fun 函數(shù)，我的參數(shù) {x}")if __name__ == '__main__':my_fun(123)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 執(zhí)行 my_fun(): 我是 my_fun 函數(shù)，我的參數(shù) 123進(jìn)程已結(jié)束,退出代碼0

4.裝飾器 多個(gè)無(wú)參裝飾器修飾帶參函數(shù)

import timedef go(func):def wrapper(x, y):s_time = time.perf_counter()func(x, y)e_time = time.perf_counter()print(f"函數(shù){func.__name__}運(yùn)行時(shí)間是：{e_time - s_time}")return wrapperdef gogo(func):def wrapper(x, y):print("我是第二個(gè)裝飾器")return wrapper# 1.運(yùn)行后 print(f"x={x},y={y}") 代碼運(yùn)行結(jié)果丟失,這里涉及到多個(gè)修飾器執(zhí)行順序問(wèn)題 # 2.被裝飾的函數(shù)在最內(nèi)層,裝飾器外函數(shù)與內(nèi)函數(shù)間的語(yǔ)句沒(méi)有裝飾到目標(biāo)函數(shù)函數(shù)上,而是在裝載裝飾函數(shù)時(shí)的附加操作.在對(duì)函數(shù)進(jìn)行裝飾時(shí),外函數(shù)和內(nèi)函數(shù)間的代碼會(huì)被運(yùn)行. # 3.在執(zhí)行裝飾器代碼裝飾后,調(diào)用func(33,55)已經(jīng)切換為go(gogo(func)). # 3.1 運(yùn)行g(shù)ogo(func)代碼,內(nèi)容轉(zhuǎn)換如下: # def wrapper(x, y): # print("我是第二個(gè)裝飾器") # 3.2 運(yùn)行g(shù)o(wrapper)代碼,內(nèi)容轉(zhuǎn)換如下: # s_time = time.perf_counter() # print("我是第二個(gè)裝飾器") # e_time = time.perf_counter() # print(f"函數(shù){func.__name__}運(yùn)行時(shí)間是：{e_time-s_time}") @go @gogo def func(x, y):i = 0while i < 1000:i += 1print(f"x={x},y={y}")if __name__ == '__main__':func(33, 55)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 我是第二個(gè)裝飾器 函數(shù)wrapper運(yùn)行時(shí)間是：1.7799999999998373e-05進(jìn)程已結(jié)束,退出代碼0

5.裝飾器 解決元信息丟失

# 1.使用裝飾器可大幅度提高代碼復(fù)用性,但是缺點(diǎn)是會(huì)導(dǎo)致原函數(shù)的原信息丟失,如函數(shù)的__doc__、__name__ # 2.導(dǎo)入functools.wraps來(lái)解決元信息丟失的問(wèn)題 from functools import wraps# 裝飾器 def logged(func):@wraps(func)def logging(*args, **kwargs):print(func.__name__)print(func.__doc__)func(*args, **kwargs)return logging# 函數(shù) @logged def f(x):"""函數(shù)文檔，說(shuō)明"""return x * xprint(f.__name__) # 未導(dǎo)入前輸出logging, 導(dǎo)入后輸出 f print(f.__doc__) # 未導(dǎo)入前輸出None, 導(dǎo)入后輸出 函數(shù)文檔，說(shuō)明-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe f 函數(shù)文檔，說(shuō)明進(jìn)程已結(jié)束,退出代碼0

6.裝飾器 基于類的裝飾器

class H1(object):# 1.__init__方法:接收一個(gè)函數(shù)作為參數(shù),即待被裝飾的函數(shù)def __init__(self, func):self.func = func# 2.__call__方法:讓類對(duì)象可以調(diào)用,類似函數(shù)調(diào)用,觸發(fā)點(diǎn)是被裝飾的函數(shù)調(diào)用時(shí)觸發(fā).def __call__(self, *args, **kwargs):return '<h1>' + self.func(*args, **kwargs) + '</h1>'@H1 def text(name):return f'text {name}'s = text('class') print(s)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe <h1>text class</h1>進(jìn)程已結(jié)束,退出代碼0

7.裝飾器 內(nèi)置裝飾器@property

"""1.Python property屬性1.1 解釋:property屬性可用來(lái)個(gè)屬性添加約束.如:溫度屬性,我們?cè)O(shè)置不得低于-273℃;成績(jī)屬性,我們不允許出現(xiàn)0分以下;使用property屬性將來(lái)修改約束條件時(shí)很方便,可在代碼的調(diào)用方式不變的情況下改變結(jié)果.1.2 使用方法:- @property 裝飾器- property() 函數(shù)"""class Student(object):def __init__(self, score=0):self._score = score@propertydef score(self):print(self._score)return self._score@score.setterdef score(self, value):print("setting score")if not isinstance(value, int):raise ValueError("score must be an integer!")if value < 0 or value > 100:raise ValueError('score must between 0 ~ 100!')self._score = value# 1.直接傳入成績(jī) s = Student(60) s.score# 2.使用 @property 裝飾器傳入成績(jī) s.score = 88 # 直接傳入?yún)?shù)即可,使用更加簡(jiǎn)潔 s.score-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 60 setting score 88進(jìn)程已結(jié)束,退出代碼0

8.裝飾器 內(nèi)置裝飾器@staticmethod

class Foo:# 綁定方法def __init__(self, name):self.name = name# 靜態(tài)方法,不需要表示自身對(duì)象的self和自身類的cls參數(shù),就跟使用函數(shù)一樣.@staticmethoddef show():print('have a good time!')# 實(shí)例化變量 test = Foo('LiHua') test.show() # 在不傳參情況下得到預(yù)期的結(jié)果:have a good time!-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe have a good time!進(jìn)程已結(jié)束,退出代碼0

9.裝飾器 內(nèi)置裝飾器@classmethod

class Foo:bar = 'Nice'# 綁定方法def __init__(self, name):self.name = name# 實(shí)例方法def print_name(self):print(self.name)# 靜態(tài)方法@staticmethoddef show():print('have a good time!')# 類方法:不需要self參數(shù),但是第一個(gè)參數(shù)需要是表示自身類的cls參數(shù).@classmethoddef get(cls):print(cls.bar)test = Foo('LiHua') # 實(shí)例化變量 test.print_name() test.show() test.get()-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe LiHua have a good time! Nice進(jìn)程已結(jié)束,退出代碼0

知識(shí)點(diǎn)五 : 閉包

1.閉包 閉包基本操作

"""1.閉包1.1 解釋:在 Python 中,閉包就是調(diào)用一個(gè)函數(shù)X,函數(shù)X返回一個(gè)Y函數(shù),這個(gè)返回的函數(shù)Y就是閉包1.2 流程說(shuō)明:1.在調(diào)用 func("外")時(shí), 產(chǎn)生了一個(gè)閉包函數(shù)inner_func;2.該閉包函數(shù)內(nèi)調(diào)用了外部函數(shù)func的參數(shù)parmas,此時(shí)parmas參數(shù)是自由變量;3.當(dāng)func的聲明周期結(jié)束后,parmas這個(gè)變量依然存在,原因就是被閉包函數(shù)inner_func調(diào)用了而不會(huì)被回收.1.3 閉包的實(shí)現(xiàn)步驟:1.必須有一個(gè)內(nèi)層函數(shù);2.內(nèi)層函數(shù)必須使用外層函數(shù)的變量,如果不使用則閉包將毫無(wú)意義;3.外層含的返回值必須是內(nèi)層函數(shù). """# 定義外部（外層）函數(shù) def func(parmas):# 定義內(nèi)部（內(nèi)層）函數(shù)def inner_func(p):print(f"外部函數(shù)參數(shù){parmas}，內(nèi)部函數(shù)參數(shù){p}")# 一定要返回內(nèi)層函數(shù)return inner_func# 調(diào)用外層函數(shù)，賦值給一個(gè)新變量 inner，此時(shí)的 inner 相當(dāng)于內(nèi)層函數(shù)，并且保留了自由變量 params inner = func("外") inner("內(nèi)")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 外部函數(shù)參數(shù)外，內(nèi)部函數(shù)參數(shù)內(nèi)進(jìn)程已結(jié)束,退出代碼0

2.閉包 閉包的作用域

def outer_func():my_list = []def inner_func(x):my_list.append(len(my_list) + 1)print(f"{x}-my_list:{my_list}")return inner_func# 1.自由變量my_list的作用域只跟 每次調(diào)用的外層函數(shù) 及 生成的變量有關(guān); # 2.閉包每個(gè)實(shí)例引用的變量互不干擾. test1 = outer_func() test1("i1") test1("i1") test1("i1") test1("i1")test2 = outer_func() test2("i2") test2("i2") test2("i2") test2("i2")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe i1-my_list:[1] i1-my_list:[1, 2] i1-my_list:[1, 2, 3] i1-my_list:[1, 2, 3, 4] i2-my_list:[1] i2-my_list:[1, 2] i2-my_list:[1, 2, 3] i2-my_list:[1, 2, 3, 4]進(jìn)程已結(jié)束,退出代碼0

3.閉包 閉包實(shí)際作用

def outer_func():msg = "王小明"def inner_func():print(msg)return inner_func# 1.閉包:保存了一些非全局變量,即保存局部信息不被銷毀. # 2.流程:使用閉包后,outer_func 函數(shù)在執(zhí)行后, 原本不可再使用的 msg 變量變得可再使用; # 因?yàn)樯厦鎴?zhí)行了outer_func之后,再調(diào)用outer的時(shí)候,msg變量也被輸出了.這種情況下 # 可以把局部變量當(dāng)全局變量使用. outer = outer_func() outer()-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 王小明進(jìn)程已結(jié)束,退出代碼0

4.閉包 判斷閉包函數(shù)

def outer_func():msg = "王小明"def inner_func():print(msg)return inner_funcouter = outer_func() outer() # 1.通過(guò) 函數(shù)名.__closure__判斷一個(gè)函數(shù)是否是閉包函數(shù) # 2.返回元組中第一項(xiàng)是 CELL 即為閉包函數(shù) print(outer.__closure__)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 王小明 (<cell at 0x00000186967F3FD0: str object at 0x00000186966A5570>,)進(jìn)程已結(jié)束,退出代碼0

5.閉包 閉包存在的問(wèn)題

def count():fs = []for i in range(1, 4):def f():return ifs.append(f)return fs# 1.閉包函數(shù)的問(wèn)題是地址和值的問(wèn)題,由操作系統(tǒng)抵觸原理導(dǎo)致. # 2.結(jié)論:避免在閉包中引用循環(huán)變量 或 后續(xù)會(huì)發(fā)生變化的變量. f1, f2, f3 = count() print(f1()) print(f2()) print(f3())-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 3 3 3進(jìn)程已結(jié)束,退出代碼0

知識(shí)點(diǎn)六 : 日期和時(shí)間

1.時(shí)間模塊 time

1.1 時(shí)間模塊 獲取時(shí)鐘基本信息

"""1.日期與時(shí)間:1.1 與操作日期與時(shí)間相關(guān)的三個(gè)模塊:1.time:可操作C語(yǔ)言庫(kù)中低端時(shí)間相關(guān)函數(shù),時(shí)鐘時(shí)間和處理器運(yùn)行時(shí)間都可以獲取.2.datetime:提供了日期與時(shí)間的高級(jí)接口3.calendar:提供通用日歷相關(guān)函數(shù),用于創(chuàng)建數(shù)周、數(shù)月、數(shù)年的周期性事件.1.2 必要術(shù)語(yǔ):1.紀(jì)元 ( epoch ): 時(shí)間開始的點(diǎn),其值取決于平臺(tái);- 對(duì)于Unix, 紀(jì)元的1970年1月1日00:00:00(UTC);- 要找出給定平臺(tái)的epoch,使用time.gmtime(0)進(jìn)行查看.2.紀(jì)元秒數(shù): 指紀(jì)元時(shí)間點(diǎn)以來(lái)經(jīng)過(guò)的總秒數(shù),通常不包含閏秒.- 程序員間常把 紀(jì)元秒數(shù) 稱為 時(shí)間戳. """import time# 1.get_clock_info 函數(shù):用于獲取時(shí)鐘的基本信息 # 1.1 name可取的值: # - monotonic: time.monotonic() # - perf_counter: time.perf_counter() # - process_time: time.process_time() # - thread_time: time.thread_time() # - time: time.time() # 1.2 get_clock_info 函數(shù)的返回值具有的屬性: # - adjustable: 返回True或False.(如果時(shí)鐘可自動(dòng)更改或由系統(tǒng)管理員手動(dòng)更改則為True,否則為False) # - implementation: 用于獲取時(shí)鐘的基礎(chǔ)C函數(shù)的名稱(說(shuō)白了就是調(diào)底層C的函數(shù)) # - monotonic: 如果時(shí)鐘不能倒退則為True,否則為False # - resolution: 以秒為單位的時(shí)鐘分辨率(float)available_clocks = [('monotonic', time.monotonic()),('perf_counter', time.perf_counter()),('process_time', time.process_time()),('time', time.time()), ]for clock_name, func in available_clocks:print('''{name}:adjustable : {info.adjustable}implementation: {info.implementation}monotonic : {info.monotonic}resolution : {info.resolution}current : {current}'''.format(name=clock_name,info=time.get_clock_info(clock_name),current=func))-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exemonotonic:adjustable : Falseimplementation: GetTickCount64()monotonic : Trueresolution : 0.015625current : 168333.437perf_counter:adjustable : Falseimplementation: QueryPerformanceCounter()monotonic : Trueresolution : 1e-07current : 0.0315589process_time:adjustable : Falseimplementation: GetProcessTimes()monotonic : Trueresolution : 1e-07current : 0.03125time:adjustable : Trueimplementation: GetSystemTimeAsFileTime()monotonic : Falseresolution : 0.015625current : 1658576633.6705935進(jìn)程已結(jié)束,退出代碼0

1.2 時(shí)間模塊 獲取時(shí)間戳

import time# 1.time.time(): 獲取紀(jì)元秒數(shù),將epoch開始之后的秒數(shù)以浮點(diǎn)數(shù)格式返回 print(time.time())-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 1658576718.0507917進(jìn)程已結(jié)束,退出代碼0

1.3 時(shí)間模塊 獲取可讀時(shí)間

import time# 1.直接獲取可讀時(shí)間 print(time.ctime()) print("--------------")# 2.時(shí)間戳轉(zhuǎn)為可讀時(shí)間 localtime = time.localtime(time.time()) print("本地時(shí)間為 :", localtime) print("--------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe Sat Jul 23 19:46:07 2022 -------------- 本地時(shí)間為 : time.struct_time(tm_year=2022, tm_mon=7, tm_mday=23, tm_hour=19, tm_min=46, tm_sec=7, tm_wday=5, tm_yday=204, tm_isdst=0) --------------進(jìn)程已結(jié)束,退出代碼0

1.4 時(shí)間模塊 從系統(tǒng)啟動(dòng)時(shí)開始計(jì)時(shí)

import time# 1.monotonic time:從系統(tǒng)啟動(dòng)時(shí)開始計(jì)時(shí),從0開始單調(diào)遞增 time.monotonic() print("單調(diào)時(shí)間", time.monotonic())-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 單調(diào)時(shí)間 168508.031進(jìn)程已結(jié)束,退出代碼0

1.5 時(shí)間模塊 處理器時(shí)鐘時(shí)間

"""1.time函數(shù)返回的是時(shí)間戳,clock函數(shù)返回的是處理器時(shí)鐘時(shí)間.該函數(shù)的返回值:- 在第一次調(diào)用時(shí),返回的是程序運(yùn)行的實(shí)際時(shí)間- 在第二次之后的調(diào)用,返回的是自第一次調(diào)用后到這次調(diào)用的時(shí)間間隔2.注意:Python3.8版本后已移除clock()函數(shù);應(yīng)使用time.perf_counter()或time.process_time()代替""" import timet0 = time.perf_counter() print(time.perf_counter() - t0, "程序運(yùn)行時(shí)間")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 1.6000000000043757e-06 程序運(yùn)行時(shí)間進(jìn)程已結(jié)束,退出代碼0

1.6 時(shí)間模塊 性能計(jì)數(shù)器

"""1.性能計(jì)數(shù)器使用time.perf_counter函數(shù)進(jìn)行操作- perf_counter函數(shù)的紀(jì)元是未定義的,一般使用該函數(shù)都是為了比較和計(jì)算,而非用作絕對(duì)時(shí)間- perf_counter函數(shù)用于測(cè)量較短持續(xù)時(shí)間的具有最高有效精度的時(shí)鐘,包括睡眠狀態(tài)消耗的時(shí)間,使用兩次調(diào)用才會(huì)生效2.與time.perf_counter函數(shù)功能相似的函數(shù):- perf_counter_ns()- process_time()- process_time_ns() """ import timet0 = time.perf_counter() for i in range(100000):pass print("程序運(yùn)行時(shí)間", time.perf_counter() - t0)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 程序運(yùn)行時(shí)間 0.0032179000000000027進(jìn)程已結(jié)束,退出代碼0

1.7 時(shí)間模塊 時(shí)間組件

import time# 1.time.gmtime(): 返回UTC中的當(dāng)前時(shí)間 print(time.gmtime()) print("------------------")# 2.time.localtime(): 返回當(dāng)前時(shí)區(qū)對(duì)應(yīng)的時(shí)間 print(time.localtime()) print("------------------")# 3.time.localtime()): 接收struce_time類型數(shù)據(jù)并將其轉(zhuǎn)換成浮點(diǎn)型數(shù)值(即時(shí)間戳) # - tm_wday: 星期 # - tm_yday: 一年中的某一天 # - tm_isdst: 在夏令時(shí)生效時(shí)設(shè)置為1,夏令時(shí)不生效時(shí)設(shè)置為0,值-1表示未知 print(time.mktime(time.localtime())) print("------------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe time.struct_time(tm_year=2022, tm_mon=7, tm_mday=23, tm_hour=11, tm_min=49, tm_sec=40, tm_wday=5, tm_yday=204, tm_isdst=0) ------------------ time.struct_time(tm_year=2022, tm_mon=7, tm_mday=23, tm_hour=19, tm_min=49, tm_sec=40, tm_wday=5, tm_yday=204, tm_isdst=0) ------------------ 1658576980.0 ------------------進(jìn)程已結(jié)束,退出代碼0

1.8 時(shí)間模塊 解析和格式化時(shí)間

---

指令意義

%a	本地化的縮寫星期中沒(méi)人的名稱
%A	本地化的星期中沒(méi)人的完整名稱
%b	本地化的月縮寫名稱
%B	本地化的月完整名稱
%c	本地化的適當(dāng)日期和時(shí)間表示
%d	十進(jìn)制數(shù) [01,31] 表示的月中日
%H	十進(jìn)制數(shù) [00,23] 表示的小時(shí) (24小時(shí)制)
%I	十進(jìn)制數(shù) [01,12] 表示的小時(shí) (12小時(shí)制)
%j	十進(jìn)制數(shù) [001,366] 表示的月中日
%m	十進(jìn)制數(shù) [01,12] 表示月
%M	十進(jìn)制數(shù) [00,59] 表示的分鐘
%p	本地化的 AM 或 PM
%S	十進(jìn)制數(shù) [00,61] 表示的秒
%U	十進(jìn)制 [00,53] 表示的一年中的周數(shù) (星期日作為一周的第一天), 在第一個(gè)星期日之前的新年中的所有日子都被認(rèn)為是在第 0 周.
%w	十進(jìn)制 [0(星期日), 6] 表示的周中日
%W	十進(jìn)制 [00,53] 表示的一年中的周數(shù) (星期一作為一周的第一天), 在第一個(gè)星期一之前的新年中的所有日子都被認(rèn)為是在第 0 周.
%x	本地化的適當(dāng)日期表示
%X	本地化的適當(dāng)時(shí)間表示
%y	十進(jìn)制 [00,99] 表示的沒(méi)有世紀(jì)的年份
%Y	十進(jìn)制 [00,99] 表示的帶世紀(jì)的年份
%z	時(shí)區(qū)偏移以格式 +HHMM 或 -HHMM 形式的UTC/GMT 的正或負(fù)時(shí)差指示, 其中H表示十進(jìn)制小時(shí)數(shù)字, M表示小數(shù)分鐘數(shù)字 [-23:59, +23:59]
%Z	時(shí)區(qū)名稱 (如果不存在時(shí)區(qū), 則不包含字符)
%%	字面的 '%' 字符

---

"""1.strftime()和strptime(): 使時(shí)間值在struct_time表示和字符串表示之間互相轉(zhuǎn)換. """ import time# 1.strftime()函數(shù)的使用: strftime和strptime函數(shù)區(qū)別只有中間的字符不同 x = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) print(x) print("----------------")# 2.strptime()函數(shù)的使用: 方向操作，字符串格式化成 time.struct_time struct_time = time.strptime(x, "%Y-%m-%d %H:%M:%S") print(struct_time) print("----------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 2022-07-23 19:50:32 ---------------- time.struct_time(tm_year=2022, tm_mon=7, tm_mday=23, tm_hour=19, tm_min=50, tm_sec=32, tm_wday=5, tm_yday=204, tm_isdst=-1) ----------------進(jìn)程已結(jié)束,退出代碼0

2.日期模塊 datetime

2.1 日期模塊 date類

"""1.在 datetime 模塊中,python 提供了5個(gè)主要的對(duì)象類:1.1 datetime: 運(yùn)行同時(shí)操作日期和時(shí)間;1.2 date: 只操作日期;1.3 time: 只操作時(shí)間;1.4 timedelta: 用于操作日期及其測(cè)量時(shí)間跨度;1.5 tzinfo: 處理時(shí)區(qū);2.datetime 模塊下的 date類的屬性和方法:2.1 min、max: date對(duì)象能表示的最大、最小日期;2.2 resolution: date對(duì)象表示日期的最小單位,返回天;2.3 today(): 返回表示當(dāng)前本地日期的date對(duì)象;2.4 fromtimestamp(timestamp): 根據(jù)時(shí)間戳,返回一個(gè)date對(duì)象.3.date對(duì)象的屬性和方法:3.1 d.year: 返回年;3.2 d.month: 返回月;3.3 d.day: 返回日;3.4 d.weekday(): 返回weekday,如果是星期一返回0,如果是星期二返回1,后面以此類推;3.5 d.isoweekday(): 返回weekday,如果是星期一返回1,如果是星期二返回2,后面以此類推;3.6 d.isocalendar(): 返回格式如(year, wk num, wk day);3.7 d.isoformat(): 返回格式如'YYYY-MM-DD'的字符串;3.8 d.strftime(fmt): 自定義格式化字符串, 與 time 模塊中的 strftime 類似. """ from datetime import date import time# 1.測(cè)試date類的屬性和方法 print('date.min:', date.min) print('date.max:', date.max) print('date.resolution:', date.resolution) print('date.today():', date.today()) print('date.fromtimestamp():', date.fromtimestamp(time.time())) print("----------------")# 2.測(cè)試date對(duì)象的屬性和方法 d = date(year=2022, month=7, day=23) print(d) print("----------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe date.min: 0001-01-01 date.max: 9999-12-31 date.resolution: 1 day, 0:00:00 date.today(): 2022-07-23 date.fromtimestamp(): 2022-07-23 ---------------- 2022-07-23 ----------------進(jìn)程已結(jié)束,退出代碼0

2.2 日期模塊 time類

"""1.time類定義的類屬性:1.1 min、max: time類孫表示的最小和最大時(shí)間;- time.min = time(0, 0, 0, 0)- time.max = time(23, 59, 59, 999999)1.2 resolution: 時(shí)間的最小單位,這里是1微妙.2.time類提供的實(shí)例方法和屬性:2.1 t.hour | t.minute | t.second | t.microsecond: 時(shí)、分、秒、微妙;2.2 t.tzinfo: 時(shí)區(qū)信息;2.3 t.isoformat: 返回形如"HH:MM:SS"格式的字符串時(shí)間表示;2.4 t.strftime(fmt): 返回自定義格式化字符串.""" from datetime import time# 通過(guò)構(gòu)造函數(shù)創(chuàng)建一個(gè)time對(duì)象 t = time(hour=20, minute=20, second=40) print(t)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 20:20:40進(jìn)程已結(jié)束,退出代碼0

2.3 日期模塊 datetime類

"""1.datetime類是date類和time類的結(jié)合體 """ from datetime import datetime# 1.獲取當(dāng)前日期和時(shí)間 dt = datetime.now() print(dt) print("----------------")# 2.獲取時(shí)間戳: 使用 datetime 的內(nèi)置函數(shù) timestamp() stamp = datetime.timestamp(dt) print(stamp) print("----------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 2022-07-23 20:45:50.143048 ---------------- 1658580350.143048 ----------------進(jìn)程已結(jié)束,退出代碼0

####2.4 日期模塊 timedelta類

"""1.通過(guò) timedelta 函數(shù)返回一個(gè)timedelta時(shí)間間隔對(duì)象2.timedelta 函數(shù)沒(méi)有必要填參數(shù),如果寫入一個(gè)整數(shù)就是間隔多少天的意思3.兩個(gè)時(shí)間間隔對(duì)象可以彼此之間相加或相減，返回的仍是一個(gè)時(shí)間間隔對(duì)象.4. 一個(gè) datetime 對(duì)象如果減去一個(gè)時(shí)間間隔對(duì)象，那么返回的對(duì)應(yīng)減去之后的 datetime 對(duì)象，然后兩個(gè) datetime 對(duì)象如果相減，返回的是一個(gè)時(shí)間間隔對(duì)象. """ from datetime import timedelta# 1.間隔 10 天 print(timedelta(10)) print("----------------")# 2.跨度為1 周 print(timedelta(weeks=1)) print("----------------")-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 10 days, 0:00:00 ---------------- 7 days, 0:00:00 ----------------進(jìn)程已結(jié)束,退出代碼0

3.日歷模塊 calendar

"""1.calendar模塊的函數(shù)都是日歷相關(guān)的，例如打印某月的字符月歷2.calendar模塊定義了 Calendar 類，它封裝了值的計(jì)算， 例如給定月份或年份中周的日期。通過(guò) TextCalendar 和 HTMLCalendar 類可以生成預(yù)格式化的輸出. """ import calendarc = calendar.TextCalendar(calendar.SUNDAY) c.prmonth(2022, 7)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exeJuly 2022 Su Mo Tu We Th Fr Sa1 23 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31進(jìn)程已結(jié)束,退出代碼0

知識(shí)點(diǎn)七 : 作用域

1.作用域 作用域解釋

"""1.變量作用域: 指的是變量的有效作用范圍，- 大白話就是 Python 中的變量不是任意位置都可以訪問(wèn)的,訪問(wèn)有限制條件.2.一般情況下變量的作用域變化范圍是(從小到大): 塊級(jí)、函數(shù)、類、模塊、包- Python 中沒(méi)有塊級(jí)作用域. """# 1.演示Python無(wú)塊級(jí)作用域 # 因?yàn)闆](méi)有塊級(jí)作用域，故 if 代碼塊中的變量 x 可以被外部訪問(wèn)到 if True:x = "hello world" print(x)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe hello world進(jìn)程已結(jié)束,退出代碼0

2.作用域 Python中的作用域

"""1.Python的四種作用域:1.1 L (Local): 最內(nèi)層, 包含局部變量, 例如函數(shù)（方法）內(nèi)部；1.2 E (Enclosing): 包含非局部（nonlocal）也非全局（nonglobal）的變量, 在嵌套函數(shù)中, 函數(shù) A 包含函數(shù) B, 在 B 中去訪問(wèn) A 中的變量, 作用域就是 nonlocal;- 直白理解就是閉包函數(shù)外的函數(shù)中的變量1.3 G (Global): 代碼最外層, 全局變量；1.4 B (Built-in): 包含內(nèi)建變量.2.在 Python 中變量尋找的順序是從內(nèi)到外,先局部后外部, 再全局, 再內(nèi)建, 這種規(guī)則叫做LEGB 規(guī)則. """# 1.演示Python中的作用域# 內(nèi)建作用域 Built-in x = int(5 / 2)# 全局作用域 Global global_var = 0def outer():# 閉包函數(shù)外的函數(shù)中 Enclosingout_var = 1def inner():# 局部作用域 Localinner_var = 2

3.作用域 global關(guān)鍵字

"""1.定義在函數(shù)內(nèi)部的變量擁有一個(gè)局部作用域,定義在函數(shù)外部的變量擁有全局作用域- 局部變量只能在其被聲明的函數(shù)內(nèi)部訪問(wèn), 而全局變量則可以在整個(gè)程序范圍內(nèi)訪問(wèn)."""# 1.演示global關(guān)鍵字# 全局變量 x = 0def demo():# 此時(shí)的 x 是全局變量# 1.如果不使用全局關(guān)鍵字,則輸出結(jié)果函數(shù)內(nèi)部是123,外部依然是0# 2.注意: global關(guān)鍵字要寫在變量操作前# 3.在函數(shù)內(nèi)部使用一個(gè)變量,不修改值的前提下,沒(méi)有聲明,默認(rèn)獲取的是全局變量的值.global xx = 123print("函數(shù)內(nèi)是局部變量 x = ", x)demo() print("函數(shù)外是全局變量 x= ", x)-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 函數(shù)內(nèi)是局部變量 x = 123 函數(shù)外是全局變量 x= 123進(jìn)程已結(jié)束,退出代碼0

4.作用域 nonlocal關(guān)鍵字

"""1.如果要修改嵌套作用域（Enclosing 作用域）中的變量, 需要nonlocal關(guān)鍵字"""# 1.演示nonlocal關(guān)鍵字num = 10def outer():# 1.注意:nonlocal不能代替globalnum = 10 # 注釋掉本行報(bào)錯(cuò)def inner():num = 1000def inner1():# nonlocal 關(guān)鍵字# 1.多重嵌套中,nonlocal只會(huì)上溯一層,如果上一層沒(méi)有,則會(huì)繼續(xù)上溯nonlocal numnum = 100print(num)inner1()print(num)inner()print(num)outer()# 查看局部變量具體有哪些 print(locals()) # 查看全局變量具體有哪些 print(globals())-------------------------------------------------- C:\Users\32495\Envs\python3.9.2\Scripts\python.exe 100 100 10 {'__name__': '__main__', '__doc__': '\n 1.如果要修改嵌套作用域（Enclosing 作用域）中的變量, 需要nonlocal關(guān)鍵字\n\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE79543FD0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\softwareCode\\00_Code\\Python代碼\\Python進(jìn)階知識(shí)\\7.知識(shí)點(diǎn)七 作用域\\4.作用域 nonlocal關(guān)鍵字.py', '__cached__': None, 'num': 10, 'outer': <function outer at 0x000001CE7910F0D0>} {'__name__': '__main__', '__doc__': '\n 1.如果要修改嵌套作用域（Enclosing 作用域）中的變量, 需要nonlocal關(guān)鍵字\n\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE79543FD0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\softwareCode\\00_Code\\Python代碼\\Python進(jìn)階知識(shí)\\7.知識(shí)點(diǎn)七 作用域\\4.作用域 nonlocal關(guān)鍵字.py', '__cached__': None, 'num': 10, 'outer': <function outer at 0x000001CE7910F0D0>}進(jìn)程已結(jié)束,退出代碼0

總結(jié)

以上是生活随笔為你收集整理的3.Python 进阶知识的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。