python基础：函数对象函数嵌套名称空间与作用域装饰器

Posted zhangshuyuan

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python基础：函数对象函数嵌套名称空间与作用域装饰器相关的知识，希望对你有一定的参考价值。

  1. 函数对象

  2. 函数嵌套

  3. 名称空间与作用域

  4. 闭包函数

  5. 装饰器

  6. 练习

一 函数对象

#1 可以被引用
def max(x, y):
    return x if x > y else y
func = max
print(func(1, 2))

#2 可以当作参数传递
def max(x, y):
    return x if x > y else y
def max_1(x, func):
    return func(x, 1)
print(max_1(2, max))

#3 返回值可以是函数

#4 可以当作容器类型的元素
def foo():
    print(‘foo‘)

def bar():
    print(‘bar‘)

dic={
    ‘foo‘:foo,
    ‘bar‘:bar,
}
while True:
    choice=input(‘>>: ‘).strip()
    if choice in dic:
        dic[choice]()

 

二 函数嵌套

def foo():
    def bar():
        print(‘from bar‘)
    bar()

foo()
bar() #报错

 

三 名称空间与作用域

#名称空间：存放名字的地方，（x=1，1存放于内存中，名称空间正是存放名字x与1绑定关系的地方）
#三种名称空间：局部名称空间--->全局名称空间--->内置名称空间

内置名称空间在 Python 解释器启动时就创建了，直到 Python 解释器退出时内置名称空间才失效。这使得我们可以在程序的任何位置使用内置名称空间内的名称，例如，id()，print()等函数。 
全局命名空间，每个模块加载执行时创建的，记录了模块中定义的变量，包括模块中定义的函数、类、其他导入的模块、模块级的变量与常量。
python自带的内建命名空间，任何模块均可以访问，放着内置的函数和异常。
#1、作用域即范围
        - 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
　     - 局部范围（局部名称空间属于该范围）：临时存活，局部有效
#2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下
x=1
def f1():
    def f2():
        print(x)
    return f2
x=100
def f3(func):
    x=2
    func()
x=10000
f3(f1())

#3、查看作用域：globals(),locals()


LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间

 

四 闭包函数

它是怎么产生的及用来解决什么问题呢。给出字面的定义先：闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)

def counter():
    n = 0

    def incr():
        nonlocal n
        x = n
        n += 1
        return x

    return incr


c = counter()
print(c())
print(c())
print(c.__closure__[0].cell_contents)  # 查看闭包的元素

用途：延迟计算

from urllib.request import urlopen

def index(url):
    def get():
        return urlopen(url).read()

    return get

baidu = index(‘http://www.baidu.com‘)
print(baidu().decode(‘utf-8‘))

 

五 装饰器

装饰器就是闭包函数的一种应用场景，用于拓展原来函数功能的一种函数

强调装饰器的原则：1 不修改被装饰对象的源代码  2 不修改被装饰对象的调用方式

装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能

装饰器函数以目标函数名为参数，且必须返回一个函数调用目标函数参数执行

 

import time

def deco1(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        print(‘deco1 start‘)
        func(*args, **kwargs)
        print(‘deco1 end‘)
        end_time = time.time()
        print(end_time - start_time)
    return wrapper

def deco2(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        print(‘deco2 start‘)
        func(*args, **kwargs)
        print(‘deco2 end‘)
        end_time = time.time()
        print(end_time - start_time)
    return wrapper

@deco1
@deco2
def fun(x, y):
    time.sleep(2)
    print(x + y)

fun(1, 2)

 

装饰器函数的参数为被装饰函数。装饰后执行被装饰函数相当于执行装饰器函数返回的函数，即例子中的wrapper

 

六 练习

# 编写函数，函数执行的时间是随机的
import random
import time
def func1():
    t = random.random()
    print(‘sleeping time =‘, t)
    print(‘sleeping starts‘)
    time.sleep(t)
    print(‘sleeping ends‘)
func1()
# 编写装饰器，为函数加上统计时间的功能
import random
import time

def deco(func):
    def wrapper(*args, **kwargs):
        stime = time.time()
        func(*args, **kwargs)
        etime = time.time()
        print(‘deco time:‘, (etime - stime))
    return wrapper

@deco
def func():
    t = random.random()
    print(‘sleeping time =‘, t)
    print(‘sleeping starts‘)
    time.sleep(t)
    print(‘sleeping ends‘)

func()

 

# 编写装饰器，为多个函数加上认证功能，要求登录成功一次，在超时时间内无需重复登录，超过了超时时间，则必须重新登录
# db.txt内容：{‘user‘: ‘zsy‘, ‘passwd‘: ‘123‘}
db = ‘db.txt‘

def auth(authtype=‘file‘):
    user_status = {‘user‘: None, ‘passwd‘: None}
    def origin_auth(func):
        def wrapper(*args, **kwargs):
            if authtype == ‘file‘:
                if user_status[‘user‘] != None or user_status[‘passwd‘] != None:
                    func(*args, **kwargs)
                else:
                    dict = eval(open(db, ‘r‘, encoding=‘utf-8‘).read())
                    user_name = input(‘Name: ‘)
                    user_passwd = input(‘Passwd: ‘)
                    if user_name == dict[‘user‘] and user_passwd == dict[‘passwd‘]:
                        user_status[‘user‘] = user_name
                        user_status[‘passwd‘] = user_passwd
                        print(‘登录成功‘)
                        func(*args, **kwargs)
                    else:
                        print(‘用户名或密码错误‘)
            elif authtype == ‘sql‘:
                print(‘暂无sql库‘)
            else:
                print(‘错误的authtyoe‘)
        return wrapper
    return origin_auth

origin_auth = auth()
@origin_auth
def func():
    print(‘func‘)

func()

@origin_auth
def func2():
    print(‘func2‘)

func2()

 

# 编写装饰器，实现缓存网页内容的功能：
具体：实现下载的页面存放于文件中，如果文件内有值（文件大小不为0），就优先从文件中读取网页内容，否则，就去下载，然后存到文件中

import os, requests, hashlib
engine_conf = {
    ‘file‘: {‘dirname‘: ‘db‘},
    ‘sql‘: {
        ‘host‘: ‘127.0.0.1‘,
        ‘port‘: 3306,
        ‘user‘: ‘root‘,
        ‘password‘: ‘123‘},
    ‘redis‘: {
        ‘host‘: ‘127.0.0.1‘,
        ‘port‘: 6379,
        ‘user‘: ‘root‘,
        ‘password‘: ‘123‘}
}

db = ‘db.txt‘

def make_cache(engine = ‘file‘):
    if engine not in engine_conf:
        raise TypeError(engine + ‘ not in engine_conf‘)
    user_status = {‘user‘: None, ‘passwd‘: None}
    def deco(func):
        if user_status[‘user‘] == None or user_status[‘passwd‘] == None:
            user_info = eval(open(db, ‘r‘).read())
            user_name = input(‘User: ‘)
            user_passwd = input(‘Passwd: ‘)
            if user_name != user_info[‘user‘] or hashlib.md5(user_passwd.encode(‘utf-8‘)).hexdigest() != user_info[‘passwd‘]:
                print(‘用户名或密码错误‘)
                exit()
            else:
                user_status[‘user‘] = user_name
                user_status[‘passwd‘] = user_passwd
        def wrapper(url):
            if engine == ‘file‘:
                filename = hashlib.md5(url.encode(‘utf-8‘)).hexdigest()
                filepath = os.path.join(engine_conf[‘file‘][‘dirname‘], filename)
                if os.path.exists(filepath):
                    print(‘已爬取该网页‘)
                else:
                    content = func(url)
                    if content == None:
                        print(‘爬取内容为空‘)
                    else:
                        with open(filepath, ‘w‘, encoding=‘utf-8‘) as f:
                            f.write(content)
            elif engine == ‘sql‘:
                pass
            elif engine == ‘redis‘:
                pass
        return wrapper
    return deco

@make_cache()
def get_html_text(url, *args, **kwargs):
    try:
        response = requests.get(url)
        response.encoding = response.apparent_encoding
        response.raise_for_status()
        return response.text
    except:
        return None


get_html_text(‘http://www.baidu.com‘)

 

 

 







以上是关于python基础：函数对象函数嵌套名称空间与作用域装饰器的主要内容，如果未能解决你的问题，请参考以下文章

函数基础之对象，嵌套，名称空间和作用域

python之旅：函数对象函数嵌套名称空间与作用域装饰器

python基础之名称空间和作用域函数嵌套

python--函数的返回值函数参数的使用名称空间与作用域函数嵌套函数对象

Python的学习之旅———函数对象函数嵌套名称空间与作用域装饰器

Python-函数基础