10高阶函数,必报,装饰器,常见的系统模块,pip,自定义模块

高阶函数

1.函数本身就是一种数据类型,我们可以使用类似于变量定义的方法,对函数进行二次命名,这样也可以运行我们的函数

2.在定义一个变量表示一个函数时,函数后米那不能加括号, 加括号表示调用这个函数,

def show():
    print("w shi show")
def get():
    print("w shi get")
    return show
#上面的return show后面可以加一个(),但是调用get()就会直接执行"w shi get "和"w shi show",就是说,show后面有没有() ,,和get后面有几个括号是息息相关的,,但是建议使用show后面不带括号,,而get后面两个括号,,get()()
#get()()    #这是下面写法的缩写,,,,
fn = get()
fn()

闭包

一般指的函数嵌套,就是函数内部还有一个函数,外部无法直接调用函数内部的函数,外部调用只能调用一级(定义了一个函数)的,函数内部的函数为二级(定义的函数里面又定义一个函数),和上面的高阶函数差不多

(闭关锁国…)函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。函数还可以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题

吧函数当做参数进行传参,我们叫做函数式编程

注意区分改变全局变量和外部函数的局部变量的关键字

内部函数想要改变外部函数的局部变量,需要在内部函数中声明一个关键字, nonlocal 变量名

函数想要改变全局变量,需要声明一个关键字 global 变量名

同样 内部函数也能通过global去改变全局变量,没有blobal就不能改

如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure

def outer(n):
    num = n
    def inner():
        return num+1
    return inner

print(outer(3)())  # 4
print(outer(5)())  # 5

函数嵌套

def outer():
    print("我是外部函数")
    def inner():
        print("我是内部函数")
        def last():
            print("我是第三层")
        return last
    return inner
outer()()()

装饰器

…真的绕…

import time
#一个时间装饰器

def get_time(fn):
    def inner():
        t1 = time.time()
        fn()
        t2 = time.time()
        print(t2 - t1)

    return inner


@get_time
def show():
    num = 0
    for i in range(0, 10000000):
        num += i


show()

def w1(func):
​    def inner():
​        # 验证1
​        # 验证2
​        # 验证3
​        func()
​    return inner

@w1
def f1():
​    print('f1')
@w1
def f2():
​    print('f2')
@w1
def f3():
​    print('f3')
@w1
def f4():
​    print('f4')

# 定义函数：完成包裹数据
def makeBold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped

# 定义函数：完成包裹数据
def makeItalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped

@makeBold
def test1():
    return "hello world-1"

@makeItalic
def test2():
    return "hello world-2"

@makeBold
@makeItalic
def test3():
    return "hello world-3"

print(test1())
print(test2())
print(test3())

装饰器(decorator)功能

1. 引入日志

2. 函数执行时间统计

3. 执行函数前预备处理

4. 执行函数后清理功能

5. 权限校验等场景

6. 缓存

   def check_time(action):
   ​    def do_action():
   ​        action()
   ​    return do_action

   @check_time
   def go_to_bed():
   ​     print('去睡觉')

   go_to_bed()
"""
result = check_time(go_to_bed)  # 把go_to_bed 当做参数传入给 check_time函数，再定义一个变量用来保存check_time的运行结果
result()  # check_time 函数的返回值result是一个函数, result()再调用这个函数，让它再调用go_to_bed函数
"""

还有很多,…但是我不太懂…以后再弄弄

导入模块

一个python文件就是一个模块
导入函数有五个方法
1 import 模块名
2 from 模块名 import 功能名
3 from 模块名 import *
4 import 模块名 as 别名
5 from 模块名 import 功能名 as 别名

在Python中用关键字import来引入某个模块，比如要引入系统模块 math，就可以在文件最开始的地方用import math来引入

import 模块1,模块2,...  # 导入方式
模块名.函数名()  # 使用模块里的函数

有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，此时可以用下面方法实现：

from 模块名 import 函数名1,函数名2....
#列子  不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个函数引入
from fib import fibonacci

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用

from modname import *

as 别名

import time as tt  # 导入模块时设置别名为 tt
time.sleep(1)#会直接报错
tt.sleep(1)  # 使用别名才能调用方法

常见系统模块使用

了方便程序员开发代码，Python提供了很多内置的模块给程序员用来提高编码效率。常见的内置模块有:

os模块
sys模块
math模块
random模块
datetime模块
time模块
calendar模块
hashlib模块
hmac模块
copy模块
uuid模块

OS模块

OS全称OperationSystem,即操作系统模块，这个模块可以用来操作系统的功能，并且实现跨平台操作。

import os
os.getcwd()  # 获取当前的工作目录，即当前python脚本工作的目录
os.chdir('test') # 改变当前脚本工作目录，相当于shell下的cd命令
os.rename('毕业论文.txt','毕业论文-最终版.txt') # 文件重命名
os.remove('毕业论文.txt') # 删除文件
os.rmdir('demo')  # 删除空文件夹
os.removedirs('demo') # 删除空文件夹
os.mkdir('demo')  # 创建一个文件夹
os.chdir('C:\\') # 切换工作目录
os.listdir('C:\\') # 列出指定目录里的所有文件和文件夹
os.name # nt->widonws posix->Linux/Unix或者MacOS
os.environ # 获取到环境配置
os.environ.get('PATH') # 获取指定的环境配置

os.path.abspath(path) # 获取Path规范会的绝对路径
os.path.exists(path)  # 如果Path存在，则返回True
os.path.isdir(path)  # 如果path是一个存在的目录，返回True。否则返回False
os.path.isfile(path) # 如果path是一个存在的文件，返回True。否则返回False
os.path.splitext(path)  # 用来将指定路径进行分隔，可以获取到文件的后缀名

sys模块

该模块提供对解释器使用或维护的一些变量的访问，以及与解释器强烈交互的函数。

import sys
sys.path # 模块的查找路径
sys.argv # 传递给Python脚本的命令行参数列表
sys.exit(code) # 让程序以指定的退出码结束

sys.stdin # 标准输入。可以通过它来获取用户的输入
sys.stdout # 标准输出。可以通过修改它来百变默认输出
sys.stderr # 错误输出。可以通过修改它来改变错误删除

math模块

math模块保存了数学计算相关的方法，可以很方便的实现数学运算。

import math
print(math.fabs(-100)) # 取绝对值
print(math.ceil(34.01))  #向上取整
print(math.factorial(5)) # 计算阶乘
print(math.floor(34.98))  # 向下取整
print(math.pi)   # π的值，约等于 3.141592653589793
print(math.pow(2, 10)) # 2的10次方
print(math.sin(math.pi / 6))  # 正弦值
print(math.cos(math.pi / 3))  # 余弦值
print(math.tan(math.pi / 2))  # 正切值

random模块

random 模块主要用于生成随机数或者从一个列表里随机获取数据。

print(random.random())  # 生成 [0,1)的随机浮点数
print(random.uniform(20, 30))  # 生成[20,30]的随机浮点数
print(random.randint(10, 30))  # 生成[10,30]的随机整数
print(random.randrange(20, 30))  # 生成[20,30)的随机整数
print(random.choice('abcdefg'))  # 从列表里随机取出一个元素
print(random.sample('abcdefghij', 3)) # 从列表里随机取出指定个数的元素

datetime模块

datetime模块主要用来显示日期时间，这里主要涉及 date类，用来显示日期；time类，用来显示时间；dateteime类，用来显示日期时间;timedelta类用来计算时间。

import datetime
print(datetime.date(2020, 1, 1))  # 创建一个日期
print(datetime.time(18, 23, 45)) # 创建一个时间
print(datetime.datetime.now())  # 获取当前的日期时间
print(datetime.datetime.now() + datetime.timedelta(3))  # 计算三天以后的日期时间

time模块

除了使用datetime模块里的time类以外，Python还单独提供了另一个time模块，用来操作时间。time模块不仅可以用来显示时间，还可以控制程序，让程序暂停(使用sleep函数)

print(time.time())  # 获取从1970-01-01 00:00:00 UTC 到现在时间的秒数
print(time.strftime("%Y-%m-%d %H:%M:%S")) # 按照指定格式输出时间
print(time.asctime()) #Mon Apr 15 20:03:23 2019
print(time.ctime()) # Mon Apr 15 20:03:23 2019

print('hello')
print(time.sleep(10)) # 让线程暂停10秒钟
print('world')

calendar模块

calendar模块用来显示一个日历，使用的不多，了解即可。

calendar.setfirstweekday(calendar.SUNDAY) # 设置每周起始日期码。周一到周日分别对应 0 ~ 6
calendar.firstweekday()# 返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回0，即星期一。
c = calendar.calendar(2019)  # 生成2019年的日历，并且以周日为其实日期码
print(c)  #打印2019年日历
print(calendar.isleap(2000)) # True.闰年返回True,否则返回False
count = calendar.leapdays(1996,2010) # 获取1996年到2010年一共有多少个闰年
print(calendar.month(2019, 3))  # 打印2019年3月的日历

hashlib模块

hashlib是一个提供字符加密功能的模块，包含MD5和SHA的加密算法，具体支持md5,sha1, sha224, sha256, sha384, sha512等算法。 该模块在用户登录认证方面应用广泛，对文本加密也很常见。

import hashlib

# 待加密信息
str = '这是一个测试'

# 创建md5对象
hl = hashlib.md5('hello'.encode(encoding='utf8'))
print('MD5加密后为 ：' + hl.hexdigest())

h1 = hashlib.sha1('123456'.encode())
print(h1.hexdigest())
h2 = hashlib.sha224('123456'.encode())
print(h2.hexdigest())
h3 = hashlib.sha256('123456'.encode())
print(h3.hexdigest())
h4 = hashlib.sha384('123456'.encode())
print(h4.hexdigest())

hmac模块

HMAC算法也是一种一种单项加密算法，并且它是基于上面各种哈希算法/散列算法的，只是它可以在运算过程中使用一个密钥来增增强安全性。hmac模块实现了HAMC算法，提供了相应的函数和方法，且与hashlib提供的api基本一致。

h = hmac.new('h'.encode(),'你好'.encode())
result = h.hexdigest()
print(result)  # 获取加密后的结果

copy模块

copy模块里有copy和deepcopy两个函数，分别用来对数据进行深复制和浅复制。

import copy

nums = [1, 5, 3, 8, [100, 200, 300, 400], 6, 7]
nums1 = copy.copy(nums)  # 对nums列表进行浅复制
nums2 = copy.deepcopy(nums)  # 对nums列表进行深复制

uuid模块

UUID是128位的全局唯一标识符，通常由32字节的字母串表示，它可以保证时间和空间的唯一性，也称为GUID。通过MAC地址、时间戳、命名空间、随机数、伪随机数来保证生产的ID的唯一性。随机生成字符串，可以当成token使用，当成用户账号使用，当成订单号使用。

#一般而言，在对uuid的需求不是很复杂的时候，uuid1或者uuid4方法就已经够用了，使用方法如下：
import uuid

print(uuid.uuid1())  # 根据时间戳和机器码生成uuid,可以保证全球唯一
print(uuid.uuid4())  # 随机生成uuid,可能会有重复

# 使用命名空间和字符串生成uuid.
# 注意一下两点:
# 1. 命名空间不是随意输入的字符串，它也是一个uuid类型的数据
# 2. 相同的命名空间和想到的字符串，生成的uuid是一样的
print(uuid.uuid3(uuid.NAMESPACE_DNS, 'hello'))
print(uuid.uuid5(uuid.NAMESPACE_OID, 'hello'))

pip的安装配置

在安装Python时，同时还会安装pip软件，它是Python的包管理工具，可以用来查找、下载、安装和卸载Python的第三方资源包。

配置pip

可以直接在终端中输入pip命令，如果出错，可能会有两个原因:

1. pip安装成功以后没有正确配置
2. 安装Python时，没有自动安装pip(很少见)

自定义模块

除了使用系统提供的内置模块以外，我们还能自己写一个模块供自己的程序使用。一个py文件就是一个模块，所以，自定义模块很简单，基本上相当于创建一个py文件。但是，需要注意的是,如果一个py文件要作为一个模块被别的代码使用，这个py文件的名字一定要遵守标识符的命名规则。

模块的查找路径

创建一个模块非常简单，安装标识符的命名规则创建一个py文件就是一个模块。但是问题是，我们需要把创建好的这个py文件放在哪个位置，在代码中使用 import语句才能找到这个模块呢?

Python内置sys模块的path属性，列出了程序运行时查找模块的目录，只需要把我们创建好的模块放到这些任意的一个目录里即可。

import sys
print(sys.path)
[
 'C:\\Users\\chris\\Desktop\\Test',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37\\python37.zip',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37\\DLLs',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37\\lib',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37',
 'C:\\Users\\chris\\AppData\\Roaming\\Python\\Python37\\site-packages',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37\\lib\\site-packages'
]

__all__的使用

使用from <模块名> import *导入一个模块里所有的内容时，本质上是去查找这个模块的__all__属性，将__all__属性里声明的所有内容导入。如果这个模块里没有设置__all__属性，此时才会导入这个模块里的所有内容

模块里的私有成员

模块里以一个下划线_开始的变量和函数，是模块里的私有成员，当模块被导入时，以_开头的变量默认不会被导入。但是它不具有强制性，如果一个代码强行使用以_开头的变量，有时也可以。但是强烈不建议这样使用，因为有可能会出问题。

from test1 import *
from test2 import *
from test3 import *

print(a)
fn()

print(x)
# print(y) 会报错，test2的__all__里没有变量 y
foo()


print(m)
# print(_n)  会报错，导入test3时， _n 不会被导入

import test3
print(test3._n)  # 也可以强行使用，但是强烈不建议

__name__的使用

在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如：

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

# 这段代码应该只有直接运行这个文件进行测试时才要执行
# 如果别的代码导入本模块，这段代码不应该被执行
ret = add(12,22)
print('测试的结果是',ret)

在自定义模块时，需要注意一点，自定义模块名不要和系统的模块名重名，否则会出现问题