Python 进阶知识

知识点一 : 数据类型

1.数据类型 列表与元组

"""1.列表与元组最直接的的区别是:列表长度大小不固定,是可变的.     --动态元组长度大小固定,不可变.        --静态2.__sizeof__()方法 : Python的内置函数,用来打印系统分配空间的大小.3.列表会一次性增加4个元素的空间,当空间使用完毕后才会继续增加 (64位操作系统中地址占用8个字节)4.namedtuple模块 : 继承自tuple的子类,用来创建一个和tuple类似的对象,且对象拥有可访问的属性.5.初始化空列表使用 []比 list() 快6.非空列表与非空元组初始化时,元组的效率更高
"""# 1.用列表检测系统如何进行空间分配
my_list = []
print("初始化大小", my_list.__sizeof__(), ":", my_list)my_list.append("a")
print("追加1个元素之后的大小", my_list.__sizeof__(), ":", my_list)my_list.append("b")
print("追加2个元素之后的大小", my_list.__sizeof__(), ":", my_list)my_list.append("c")
print("追加3个元素之后的大小", my_list.__sizeof__(), ":", my_list)my_list.append("d")
print("追加4个元素之后的大小", my_list.__sizeof__(), ":", my_list)my_list.append("e")
print("追加5个元素之后的大小", my_list.__sizeof__(), ":", my_list)
print("--------------")# 2.使用namedtuple模块
from collections import namedtuple
Point = namedtuple(typename='Point', field_names=['x', 'y'])  # typename相当于是创建的类名,field_names用于为创建的元组的每个元素命名,可以传入列表或元组
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个元素之后的大小 72 : ['a']
追加2个元素之后的大小 72 : ['a', 'b']
追加3个元素之后的大小 72 : ['a', 'b', 'c']
追加4个元素之后的大小 72 : ['a', 'b', 'c', 'd']
追加5个元素之后的大小 104 : ['a', 'b', 'c', 'd', 'e']
--------------
10
20
--------------
0.4988713
0.20966529999999994
--------------
0.00011539999999998773
0.0003946999999999701
--------------进程已结束,退出代码0

2.数据类型 字典与集合

"""1.字典:1.1 在使用字典索引键时,若键不存在则出现KeyError错误,解决方法是在索引键时使用get(key,default)函数即可.(如 my_dict.get("F","None"))2.集合:2.1 集合不支持索引操作,使用索引查找对应元素值会报错(TypeError: 'set' object is not subscriptable)2.2 集合的执行效率远高于列表
"""# 1.字典与集合的效率问题
import time# 1.1 计算列表运行的时间
def find_unique_weight(students):# 声明一个统计列表unique_list = []# 循环所有学生数据for id, weight in students:# 如果体重没有在统计列表中if weight not in unique_list:# 新增体重数据unique_list.append(weight)# 计算列表长度ret = len(unique_list)return retid = [x for x in range(1, 10000)]
weight = [x for x in range(1, 10000)]  # 体重数据为了计算，也设置从 1 到 10000
students = list(zip(id, weight))start_time = time.perf_counter()
find_unique_weight(students)
end_time = time.perf_counter()
print("列表运算时间为:{}".format(end_time - start_time))# 1.2 计算列表运行的时间def find_unique_weight(students):# 声明一个统计集合unique_set = set()# 循环所有学生数据for id, weight in students:# 集合会自动过滤重复数据unique_set.add(weight)# 计算集合长度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("集合运算时间为:{}".format(end_time - start_time))--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
列表运算时间为:0.6111517
集合运算时间为:0.0007663999999999449进程已结束,退出代码0

3.数据类型 字符串

"""1.字符串:1.1 字符串是不可变的1.2 字符串拼接时,join函数 比 += 快
"""# 1.比较同名字符串内存地址
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("代码运行时间为:", 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("代码运行时间为:", 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("代码运行时间为:", end_time - start_time)--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
2625249362416
2625250809136
hello world
---------------
代码运行时间为: 0.027465000000000003
代码运行时间为: 0.022872000000000003
代码运行时间为: 0.0164642进程已结束,退出代码0

知识点二 : 推导式

1.列表推导式

"""1.列表推导式1.1 推导式格式:[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]]1.2 if 条件表达式非必选1.3 列表推导式运行效率高于传统for循环写法1.4 Python3中列表推导式具备局部作用域,表达式内部变量和赋值只在局部生效
"""# 1.传统for循环写法
my_list = [1, 2, 3]
new_list = []
for i in my_list:new_list.append(i * 2)
print(new_list)
print("--------------")# 2.列表推导式写法
my_list = [1, 2, 3]
new_list = []
nn_list = [i * 2 for i in my_list]
print(nn_list)
print("--------------")# 3.列表推导式if语句
nn_list = [i * 2 for i in my_list if i > 1]
print(nn_list)
print("--------------")# 4.列表推导式双重for循环
nn_list = [(x, y) for x in range(3) for y in range(3)]
print(nn_list)
print("--------------")# 5.列表推导式局部性演示
x = 6
my_var = [x*2 for x in range(3)]
print(my_var)
print(x)
print("--------------")# 6.列表推导式嵌套
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]进程已结束,退出代码0

2.字典推导式

"""1.字典推导式1.1 推导式格式:{键:值 for 迭代变量 in 可迭代对象 [if 条件表达式]}1.2 字典中不能出现同名key,第二次出现的同名key将会覆盖掉前一个同名key的值
"""# 1.字典推导式演示
my_dict = {key: value for key in range(3) for value in range(2)}
print(my_dict)
print("--------------")# 2.字典推导式遍历一个具有键值关系的可迭代对象
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'}进程已结束,退出代码0

3.元组推导式

"""1.元组推导式:1.1 元组推导式运行结果返回的是一个地址值.
"""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>进程已结束,退出代码0

4.集合推导式

"""1.集合推导式:1.1 因为集合是无序且不重复的,所以会自动去掉重复元素导致每次运行显示的顺序不一样.
"""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'}进程已结束,退出代码0

知识点三 : 高阶函数

1.filter 函数

"""1.filter 函数1.1 函数原型:filter ( function or None, iterable ) --> filter object- 第一个参数是判断函数 ( 返回结果需要是 True 或 False).- 第二个为序列,该函数将对 iterable 序列依次执行 function ( item ) 操作, 返回结果是过滤后结果组成的序列.1.2 解释:filter 函数对序列中元素进行筛选, 获取符号条件的序列
"""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函数查看序列内容--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
<filter object at 0x000002DFEF283FA0>
[3]进程已结束,退出代码0

2.map 函数

"""1.map 函数1.1 map 函数原型:map(func, *iterables) --> map object1.2 解释:map函数运行后生成一个list, 第一个参数是函数, 第二个参数是一个或多个序列1.3 map函数解决的问题:1.使用 map 函数不需要创建一个空列表.2.调用函数时不再需要带括号,map 函数会自动调用目标函数.3.map 函数会自动匹配序列中的所有元素.
"""# 1.第一个参数为单参
my_list = [-1, 2, -3]
my_new_list = map(abs, my_list)
print(my_new_list)
print(list(my_new_list))  # 使用list函数查看序列内容
print("-----------------")# 2.第一个参数为多参
def fun(x, y):return x + ymy_new_list = map(fun, [1, 2, 3], [4, 4, 4])    # fun 函数有2个参数，故需要两个序列
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]
-----------------进程已结束,退出代码0

3.reduce 函数

"""1.reduce函数1.1 函数原型:reduce(function, sequence[, initial]) -> value- 第一个参数是函数- 第二个参数是序列,返回结算结果之后的值1.2 解释:reduce函数用于滚动计算应用于列表中的连续值
"""# 1.测试代码
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.将测试代码第三个参数设置为4
my_new_list = reduce(add, my_list, 4)       # 第三个参数表示初始值,即累加操作初始的数值
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
-----------------进程已结束,退出代码0

4.zip 函数

"""1.zip函数1.1 函数原型:zip(iter1 [,iter2 [...]]) --> zip object1.2 解释:- zip函数将可迭代对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表.- 如果各个迭代器的元素个数不一样,则返回列表长度与最短的对象相同,利用星号 (*)操作符将元组解压为列表
"""# 1.测试代码
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.测试代码展示*操作符
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')]
-----------------进程已结束,退出代码0

5.enumerate 函数

"""1.enumerate函数:1.1 函数原型:enumerate(iterable, start=0)- sequence: 一个序列、迭代器或其他支出迭代对象;- start: 下标起始位置.1.2 解释:enumerate函数用于将一个可遍历的数据对象组合为一个索引序列,同时列出数据和数据下标,一般用在for循环当中.
"""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')]进程已结束,退出代码0

知识点四 : 装饰器

1.装饰器 单个无参装饰器修饰无参函数

"""1.装饰器 装饰无参函数1.1 解释:装饰器简单来理解就是套在函数上的函数,如想统计1000个具有不同功能的函数运行的时间时,需要重构的代码量极为恐怖.而这时则只需要写个统计时间的函数,再让这1000个函数直接调用即可.简单来说,装饰器拓展了原函数的功能,又不需要修改原函数的代码1.2 格式:@装饰器名def 函数名():pass
"""# 自定义装饰器并调用
import timedef go(func):# 这里的 wrapper 函数名可以为任意名称def wrapper():s_time = time.perf_counter()func()e_time = time.perf_counter()print(f"函数{func.__name__}运行时间是：{e_time - s_time}")  # func.__name__用来得到引用指向的真正名字return wrapper@go  # go就是我们刚写好的统计运行时间的函数,装饰器使用@来调用
def func():i = 0while i < 1000:i += 1@go
def func1():i = 0while i < 10000:i += 1if __name__ == '__main__':func()  # 调用函数时,我们没有对函数func做任何修改,但是函数func具有了更多的功能(计算运行时间的功能)--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
函数func运行时间是：4.4900000000000495e-05进程已结束,退出代码0

2.装饰器 单个无参装饰器装饰带参函数

import timedef go(func):def wrapper(x, y):s_time = time.perf_counter()func(x, y)e_time = time.perf_counter()print(f"函数{func.__name__}运行时间是：{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
函数func运行时间是：6.230000000000124e-05进程已结束,退出代码0

3.装饰器 单个带参装饰器装饰带参函数

def log(text):def decorator(func):def wrapper(x):print('%s %s():' % (text, func.__name__))func(x)return wrapperreturn decorator# 1.使用带参装饰器,相当于是在装饰器外又包裹了一个函数,使用该函数接受参数且返回一个装饰器函数.
# 2.运行顺序为: my_fun = log('执行')(my_fun)
# 3.注意: 装饰器只能接收一个参数,且必须是函数类型.
@log('执行')
def my_fun(x):print(f"我是 my_fun 函数，我的参数 {x}")if __name__ == '__main__':my_fun(123)--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
执行 my_fun():
我是 my_fun 函数，我的参数 123进程已结束,退出代码0

4.装饰器 多个无参装饰器修饰带参函数

import timedef go(func):def wrapper(x, y):s_time = time.perf_counter()func(x, y)e_time = time.perf_counter()print(f"函数{func.__name__}运行时间是：{e_time - s_time}")return wrapperdef gogo(func):def wrapper(x, y):print("我是第二个装饰器")return wrapper# 1.运行后 print(f"x={x},y={y}") 代码运行结果丢失,这里涉及到多个修饰器执行顺序问题
# 2.被装饰的函数在最内层,装饰器外函数与内函数间的语句没有装饰到目标函数函数上,而是在装载装饰函数时的附加操作.在对函数进行装饰时,外函数和内函数间的代码会被运行.
# 3.在执行装饰器代码装饰后,调用func(33,55)已经切换为go(gogo(func)).
#   3.1 运行gogo(func)代码,内容转换如下:
#     def wrapper(x, y):
#         print("我是第二个装饰器")
#   3.2 运行go(wrapper)代码,内容转换如下:
#      s_time = time.perf_counter()
#      print("我是第二个装饰器")
#      e_time = time.perf_counter()
#      print(f"函数{func.__name__}运行时间是：{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
我是第二个装饰器
函数wrapper运行时间是：1.7799999999998373e-05进程已结束,退出代码0

5.装饰器 解决元信息丢失

# 1.使用装饰器可大幅度提高代码复用性,但是缺点是会导致原函数的原信息丢失,如函数的__doc__、__name__
# 2.导入functools.wraps来解决元信息丢失的问题
from functools import wraps# 装饰器
def logged(func):@wraps(func)def logging(*args, **kwargs):print(func.__name__)print(func.__doc__)func(*args, **kwargs)return logging# 函数
@logged
def f(x):"""函数文档，说明"""return x * xprint(f.__name__)  # 未导入前输出logging, 导入后输出 f
print(f.__doc__)   # 未导入前输出None, 导入后输出 函数文档，说明--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
f
函数文档，说明进程已结束,退出代码0

6.装饰器 基于类的装饰器

class H1(object):# 1.__init__方法:接收一个函数作为参数,即待被装饰的函数def __init__(self, func):self.func = func# 2.__call__方法:让类对象可以调用,类似函数调用,触发点是被装饰的函数调用时触发.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>进程已结束,退出代码0

7.装饰器 内置装饰器@property

"""1.Python property属性1.1 解释:property属性可用来个属性添加约束.如:温度属性,我们设置不得低于-273℃;成绩属性,我们不允许出现0分以下;使用property属性将来修改约束条件时很方便,可在代码的调用方式不变的情况下改变结果.1.2 使用方法:- @property 装饰器- property() 函数"""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.直接传入成绩
s = Student(60)
s.score# 2.使用 @property 装饰器传入成绩
s.score = 88  # 直接传入参数即可,使用更加简洁
s.score--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
60
setting score
88进程已结束,退出代码0

8.装饰器 内置装饰器@staticmethod

class Foo:# 绑定方法def __init__(self, name):self.name = name# 静态方法,不需要表示自身对象的self和自身类的cls参数,就跟使用函数一样.@staticmethoddef show():print('have a good time!')# 实例化变量
test = Foo('LiHua')
test.show()  # 在不传参情况下得到预期的结果:have a good time!--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
have a good time!进程已结束,退出代码0

9.装饰器 内置装饰器@classmethod

class Foo:bar = 'Nice'# 绑定方法def __init__(self, name):self.name = name# 实例方法def print_name(self):print(self.name)# 静态方法@staticmethoddef show():print('have a good time!')# 类方法:不需要self参数,但是第一个参数需要是表示自身类的cls参数.@classmethoddef get(cls):print(cls.bar)test = Foo('LiHua')  # 实例化变量
test.print_name()
test.show()
test.get()--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
LiHua
have a good time!
Nice进程已结束,退出代码0

知识点五 : 闭包

1.闭包 闭包基本操作

"""1.闭包1.1 解释:在 Python 中,闭包就是调用一个函数X,函数X返回一个Y函数,这个返回的函数Y就是闭包1.2 流程说明:1.在调用 func("外")时, 产生了一个闭包函数inner_func;2.该闭包函数内调用了外部函数func的参数parmas,此时parmas参数是自由变量;3.当func的声明周期结束后,parmas这个变量依然存在,原因就是被闭包函数inner_func调用了而不会被回收.1.3 闭包的实现步骤:1.必须有一个内层函数;2.内层函数必须使用外层函数的变量,如果不使用则闭包将毫无意义;3.外层含的返回值必须是内层函数.
"""# 定义外部（外层）函数
def func(parmas):# 定义内部（内层）函数def inner_func(p):print(f"外部函数参数{parmas}，内部函数参数{p}")# 一定要返回内层函数return inner_func# 调用外层函数，赋值给一个新变量 inner，此时的 inner 相当于内层函数，并且保留了自由变量 params
inner = func("外")
inner("内")--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
外部函数参数外，内部函数参数内进程已结束,退出代码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的作用域只跟 每次调用的外层函数 及 生成的变量有关;
# 2.闭包每个实例引用的变量互不干扰.
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]进程已结束,退出代码0

3.闭包 闭包实际作用

def outer_func():msg = "王小明"def inner_func():print(msg)return inner_func# 1.闭包:保存了一些非全局变量,即保存局部信息不被销毁.
# 2.流程:使用闭包后,outer_func 函数在执行后, 原本不可再使用的 msg 变量变得可再使用;
#       因为上面执行了outer_func之后,再调用outer的时候,msg变量也被输出了.这种情况下
#       可以把局部变量当全局变量使用.
outer = outer_func()
outer()--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
王小明进程已结束,退出代码0

4.闭包 判断闭包函数

def outer_func():msg = "王小明"def inner_func():print(msg)return inner_funcouter = outer_func()
outer()
# 1.通过 函数名.__closure__判断一个函数是否是闭包函数
# 2.返回元组中第一项是 CELL 即为闭包函数
print(outer.__closure__)--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
王小明
(<cell at 0x00000186967F3FD0: str object at 0x00000186966A5570>,)进程已结束,退出代码0

5.闭包 闭包存在的问题

def count():fs = []for i in range(1, 4):def f():return ifs.append(f)return fs# 1.闭包函数的问题是地址和值的问题,由操作系统抵触原理导致.
# 2.结论:避免在闭包中引用循环变量 或 后续会发生变化的变量.
f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
3
3
3进程已结束,退出代码0

知识点六 : 日期和时间

1.时间模块 time

1.1 时间模块 获取时钟基本信息

"""1.日期与时间:1.1 与操作日期与时间相关的三个模块:1.time:可操作C语言库中低端时间相关函数,时钟时间和处理器运行时间都可以获取.2.datetime:提供了日期与时间的高级接口3.calendar:提供通用日历相关函数,用于创建数周、数月、数年的周期性事件.1.2 必要术语:1.纪元 ( epoch ): 时间开始的点,其值取决于平台;- 对于Unix, 纪元的1970年1月1日00:00:00(UTC);- 要找出给定平台的epoch,使用time.gmtime(0)进行查看.2.纪元秒数: 指纪元时间点以来经过的总秒数,通常不包含闰秒.- 程序员间常把 纪元秒数 称为 时间戳.
"""import time# 1.get_clock_info 函数:用于获取时钟的基本信息
#   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 函数的返回值具有的属性:
#       - adjustable: 返回True或False.(如果时钟可自动更改或由系统管理员手动更改则为True,否则为False)
#       - implementation: 用于获取时钟的基础C函数的名称(说白了就是调底层C的函数)
#       - monotonic: 如果时钟不能倒退则为True,否则为False
#       - resolution: 以秒为单位的时钟分辨率(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进程已结束,退出代码0

1.2 时间模块 获取时间戳

import time# 1.time.time(): 获取纪元秒数,将epoch开始之后的秒数以浮点数格式返回
print(time.time())--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
1658576718.0507917进程已结束,退出代码0

1.3 时间模块 获取可读时间

import time# 1.直接获取可读时间
print(time.ctime())
print("--------------")# 2.时间戳转为可读时间
localtime = time.localtime(time.time())
print("本地时间为 :", localtime)
print("--------------")--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
Sat Jul 23 19:46:07 2022
--------------
本地时间为 : 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)
--------------进程已结束,退出代码0

1.4 时间模块 从系统启动时开始计时

import time# 1.monotonic time:从系统启动时开始计时,从0开始单调递增
time.monotonic()
print("单调时间", time.monotonic())--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
单调时间 168508.031进程已结束,退出代码0

1.5 时间模块 处理器时钟时间

"""1.time函数返回的是时间戳,clock函数返回的是处理器时钟时间.该函数的返回值:- 在第一次调用时,返回的是程序运行的实际时间- 在第二次之后的调用,返回的是自第一次调用后到这次调用的时间间隔2.注意:Python3.8版本后已移除clock()函数;应使用time.perf_counter()或time.process_time()代替"""
import timet0 = time.perf_counter()
print(time.perf_counter() - t0, "程序运行时间")--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
1.6000000000043757e-06 程序运行时间进程已结束,退出代码0

1.6 时间模块 性能计数器

"""1.性能计数器使用time.perf_counter函数进行操作- perf_counter函数的纪元是未定义的,一般使用该函数都是为了比较和计算,而非用作绝对时间- perf_counter函数用于测量较短持续时间的具有最高有效精度的时钟,包括睡眠状态消耗的时间,使用两次调用才会生效2.与time.perf_counter函数功能相似的函数:- perf_counter_ns()- process_time()- process_time_ns()
"""
import timet0 = time.perf_counter()
for i in range(100000):pass
print("程序运行时间", time.perf_counter() - t0)--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
程序运行时间 0.0032179000000000027进程已结束,退出代码0

1.7 时间模块 时间组件

import time# 1.time.gmtime(): 返回UTC中的当前时间
print(time.gmtime())
print("------------------")# 2.time.localtime(): 返回当前时区对应的时间
print(time.localtime())
print("------------------")# 3.time.localtime()): 接收struce_time类型数据并将其转换成浮点型数值(即时间戳)
#   - tm_wday: 星期
#   - tm_yday: 一年中的某一天
#   - tm_isdst: 在夏令时生效时设置为1,夏令时不生效时设置为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
------------------进程已结束,退出代码0

1.8 时间模块 解析和格式化时间

---

指令	意义
%a	本地化的缩写星期中没人的名称
%A	本地化的星期中没人的完整名称
%b	本地化的月缩写名称
%B	本地化的月完整名称
%c	本地化的适当日期和时间表示
%d	十进制数 [01,31] 表示的月中日
%H	十进制数 [00,23] 表示的小时 (24小时制)
%I	十进制数 [01,12] 表示的小时 (12小时制)
%j	十进制数 [001,366] 表示的月中日
%m	十进制数 [01,12] 表示月
%M	十进制数 [00,59] 表示的分钟
%p	本地化的 AM 或 PM
%S	十进制数 [00,61] 表示的秒
%U	十进制 [00,53] 表示的一年中的周数 (星期日作为一周的第一天), 在第一个星期日之前的新年中的所有日子都被认为是在第 0 周.
%w	十进制 [0(星期日), 6] 表示的周中日
%W	十进制 [00,53] 表示的一年中的周数 (星期一作为一周的第一天), 在第一个星期一之前的新年中的所有日子都被认为是在第 0 周.
%x	本地化的适当日期表示
%X	本地化的适当时间表示
%y	十进制 [00,99] 表示的没有世纪的年份
%Y	十进制 [00,99] 表示的带世纪的年份
%z	时区偏移以格式 +HHMM 或 -HHMM 形式的UTC/GMT 的正或负时差指示, 其中H表示十进制小时数字, M表示小数分钟数字 [-23:59, +23:59]
%Z	时区名称 (如果不存在时区, 则不包含字符)
%%	字面的 '%' 字符

---

"""1.strftime()和strptime(): 使时间值在struct_time表示和字符串表示之间互相转换.
"""
import time# 1.strftime()函数的使用: strftime和strptime函数区别只有中间的字符不同
x = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(x)
print("----------------")# 2.strptime()函数的使用: 方向操作，字符串格式化成 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)
----------------进程已结束,退出代码0

2.日期模块 datetime

2.1 日期模块 date类

"""1.在 datetime 模块中,python 提供了5个主要的对象类:1.1 datetime: 运行同时操作日期和时间;1.2 date: 只操作日期;1.3 time: 只操作时间;1.4 timedelta: 用于操作日期及其测量时间跨度;1.5 tzinfo: 处理时区;2.datetime 模块下的 date类的属性和方法:2.1 min、max: date对象能表示的最大、最小日期;2.2 resolution: date对象表示日期的最小单位,返回天;2.3 today(): 返回表示当前本地日期的date对象;2.4 fromtimestamp(timestamp): 根据时间戳,返回一个date对象.3.date对象的属性和方法: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.测试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.测试date对象的属性和方法
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
----------------进程已结束,退出代码0

2.2 日期模块 time类

"""1.time类定义的类属性:1.1 min、max: time类孙表示的最小和最大时间;- time.min = time(0, 0, 0, 0)- time.max = time(23, 59, 59, 999999)1.2 resolution: 时间的最小单位,这里是1微妙.2.time类提供的实例方法和属性:2.1 t.hour | t.minute | t.second | t.microsecond: 时、分、秒、微妙;2.2 t.tzinfo: 时区信息;2.3 t.isoformat: 返回形如"HH:MM:SS"格式的字符串时间表示;2.4 t.strftime(fmt): 返回自定义格式化字符串."""
from datetime import time# 通过构造函数创建一个time对象
t = time(hour=20, minute=20, second=40)
print(t)--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
20:20:40进程已结束,退出代码0

2.3 日期模块 datetime类

"""1.datetime类是date类和time类的结合体
"""
from datetime import datetime# 1.获取当前日期和时间
dt = datetime.now()
print(dt)
print("----------------")# 2.获取时间戳: 使用 datetime 的内置函数 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
----------------进程已结束,退出代码0

####2.4 日期模块 timedelta类

"""1.通过 timedelta 函数返回一个timedelta时间间隔对象2.timedelta 函数没有必要填参数,如果写入一个整数就是间隔多少天的意思3.两个时间间隔对象可以彼此之间相加或相减，返回的仍是一个时间间隔对象.4. 一个 datetime 对象如果减去一个时间间隔对象，那么返回的对应减去之后的 datetime 对象，然后两个 datetime 对象如果相减，返回的是一个时间间隔对象.
"""
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
----------------进程已结束,退出代码0

3.日历模块 calendar

"""1.calendar模块的函数都是日历相关的，例如打印某月的字符月历2.calendar模块定义了 Calendar 类，它封装了值的计算， 例如给定月份或年份中周的日期。通过 TextCalendar 和 HTMLCalendar 类可以生成预格式化的输出.
"""
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进程已结束,退出代码0

知识点七 : 作用域

1.作用域 作用域解释

"""1.变量作用域: 指的是变量的有效作用范围，- 大白话就是 Python 中的变量不是任意位置都可以访问的,访问有限制条件.2.一般情况下变量的作用域变化范围是(从小到大): 块级、函数、类、模块、包- Python 中没有块级作用域.
"""# 1.演示Python无块级作用域
# 因为没有块级作用域，故 if 代码块中的变量 x 可以被外部访问到
if True:x = "hello world"
print(x)--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
hello world进程已结束,退出代码0

2.作用域 Python中的作用域

"""1.Python的四种作用域:1.1 L (Local): 最内层, 包含局部变量, 例如函数（方法）内部；1.2 E (Enclosing): 包含非局部（nonlocal）也非全局（nonglobal）的变量, 在嵌套函数中, 函数 A 包含函数 B, 在 B 中去访问 A 中的变量, 作用域就是 nonlocal;- 直白理解就是闭包函数外的函数中的变量1.3 G (Global): 代码最外层, 全局变量；1.4 B (Built-in): 包含内建变量.2.在 Python 中变量寻找的顺序是从内到外,先局部后外部, 再全局, 再内建, 这种规则叫做LEGB 规则.
"""# 1.演示Python中的作用域# 内建作用域 Built-in
x = int(5 / 2)# 全局作用域 Global
global_var = 0def outer():# 闭包函数外的函数中 Enclosingout_var = 1def inner():# 局部作用域 Localinner_var = 2

3.作用域 global关键字

"""1.定义在函数内部的变量拥有一个局部作用域,定义在函数外部的变量拥有全局作用域- 局部变量只能在其被声明的函数内部访问, 而全局变量则可以在整个程序范围内访问."""# 1.演示global关键字# 全局变量
x = 0def demo():# 此时的 x 是全局变量# 1.如果不使用全局关键字,则输出结果函数内部是123,外部依然是0# 2.注意: global关键字要写在变量操作前# 3.在函数内部使用一个变量,不修改值的前提下,没有声明,默认获取的是全局变量的值.global xx = 123print("函数内是局部变量 x = ", x)demo()
print("函数外是全局变量 x= ", x)--------------------------------------------------
C:\Users\32495\Envs\python3.9.2\Scripts\python.exe
函数内是局部变量 x =  123
函数外是全局变量 x=  123进程已结束,退出代码0

4.作用域 nonlocal关键字

"""1.如果要修改嵌套作用域（Enclosing 作用域）中的变量, 需要nonlocal关键字"""# 1.演示nonlocal关键字num = 10def outer():# 1.注意:nonlocal不能代替globalnum = 10      # 注释掉本行报错def inner():num = 1000def inner1():# nonlocal 关键字# 1.多重嵌套中,nonlocal只会上溯一层,如果上一层没有,则会继续上溯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关键字\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进阶知识\\7.知识点七 作用域\\4.作用域 nonlocal关键字.py', '__cached__': None, 'num': 10, 'outer': <function outer at 0x000001CE7910F0D0>}
{'__name__': '__main__', '__doc__': '\n    1.如果要修改嵌套作用域（Enclosing 作用域）中的变量, 需要nonlocal关键字\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进阶知识\\7.知识点七 作用域\\4.作用域 nonlocal关键字.py', '__cached__': None, 'num': 10, 'outer': <function outer at 0x000001CE7910F0D0>}进程已结束,退出代码0

3.Python 进阶知识相关推荐

1. 2、Python 进阶知识总结

   1.Python 面向对象 <1>.面向对象的概念 首先,面向对象并不是哪一门语言的编程,而是一种编程思想,在面向对象的思想里,万物皆对象.面向对象更官方的描述为: 把一组数据结构和处理它 ...

2. python进阶之多进程

   python进阶之多进程 0.导语1.进程与线程初识1.1 导包1.2 定义被调函数1.3 创建线程和进程1.4 启动线程和进程2.输出结果存放至Queue2.1 导包2.2 定义被调函数2.3 启动 ...

3. 1、Python 基础知识总结

   1.Python 简介 Python 是一门简单易学的,面向对象的,解释型的脚本语言,也是一种开源的.可移植性强的.可扩展性强的高级编程语言,常用于科学计算与人工智能.WEB 开发.金融.云计算等领域 ...

4. 【Python进阶】Python进阶专栏、编程与开源框架知识星球上线，等你来follow

   大家好,今天我将在有三AI开设新专栏<Python进阶>.在这个专栏中,我们会讲述Python的各种进阶操作,包括Python对文件.数据的处理,Python各种好用的库如NumPy.Sc ...

5. python的格式化输出学号_安利三个关于Python字符串格式化进阶知识

   点击蓝色"Python空间"关注我丫 加个"星标",每天一起快乐的学习 今 日 鸡 汤 名花倾国两相欢,常得君王带笑看. /前言/ 关于Python字符串格式化 ...

6. python进阶学什么意思_为什么要学习python进阶的知识

   前言 python相对于其它语言来说入门简单.入门后无论是web开发,还是爬虫都可以应付得了.大部分的工作都是在现有的框架下,继承某类,按照要求重写某些方法,然后就可以完成工作了.python进阶的那 ...

7. 最全面的Python重点知识汇总，建议收藏！

   点击上方"视学算法",选择加"星标"或"置顶" 重磅干货,第一时间送达 来源丨网络,由法纳斯特整理 这是一份来自于 SegmentFault ...

8. 如果只推荐一本 Python 进阶的书，我要 Pick 它！

   作者 | 豌豆花下猫 今年二月初,我偶然看到了一条推特: <流畅的Python>一书的作者发布了一条激动人心的消息:他正在写作第二版! 如果要票选最佳的 Python 进阶类书目,这本书肯 ...

9. Python 进阶之路 (九) 再立Flag, 社区最全的itertools深度解析（上）

   前言 大家好,今天想和大家分享一下我的itertools学习体验及心得,itertools是一个Python的自带库,内含多种非常实用的方法,我简单学习了一下,发现可以大大提升工作效率,在sf社区内没 ...

10. python进阶书籍推荐-豆瓣评分9.4！年度最值得推荐的Python进阶书

    原标题:豆瓣评分9.4!年度最值得推荐的Python进阶书 来自:程序员书库(ID:OpenSourceTop) 编译 链接:https://whatpixel.com/fluent-python-b ...

最新文章

1. VM页面中遍历枚举类
2. Asp.NetCore-部署到IIS
3. 鼠标点击测试_鼠标键盘如何检测故障，这边教您简单的测试
4. python decimal_python学习笔记一
5. 关于在项目中使用开源项目的疑惑，恳请大家给点意见！
6. Kafka核心概念及核心机制
7. 住户水电费计算c语言程序,(小区水电费管理系统C语言.doc
8. intuitionistic fuzzy set 运算规则python实现
9. Halo 博客网站的SQL
10. 产品 电信nb接口调用_电信物联网平台NBIoT使用Postman模拟测试接口
11. Java对象数组的初始化
12. Hostker云主机
13. Fortran语法汇总（上）
14. 微信小程序,几行代码实现图片瀑布流
15. 数据可视化之数据的图表呈现
16. 【内网学习笔记】23、SMBExec 与 DCOM 的使用
17. hive 窗口函数--常用函数介绍
18. Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?
19. Foxmail 邮件的备份与恢复
20. 路遇又一个流量风口，民宿长期向好的逻辑选对了吗

热门文章

1. html grid插件,grid.html
2. c++ 时间类型详解(time_t和tm)
3. 火焰之纹章java武器代码_《火焰纹章回声：另一个英雄王》金手指全代码一览 代码大全...
4. sony手机刷linux,索尼Z3 Z3C 5.0系统刷recovery教程_Sony Z3第三方recovery
5. MPQ Storm库 源代码分析 一个
6. 现在需要在input框输入年月yyyymm的正则_税务师报名时间、考试报名官网2021年安排_税务师...
7. 0动态规划中等 LeetCode97. 交错字符串
8. ECshop商城程序常见的97个小问题汇总
9. (三) 搭建cocos2d-x-android环境 Windows XP3 + Eclipse + NDKR7(或ndkr7b)+COCOS2DX(没有用到cygwin和minigw)
10. 软件测试个人求职简历该怎么写，模板在这里