1.函数对象
1.对函数象 这个不是新知识点 是告诉你 函数都可以怎么用
在面向对象编程中 一切皆对象
具体的体现
1.函数可以被引用
2.函数可以作为函数的参数
3.函数可以作为函数的返回值
4.可以被存储到容器类型中
# 写一个购物车 具备登陆和注册，购物
def func1():
print("run")
# a = func1()
# a = func1
def func2(func):
func()
func2(func1)
def func3():
return func1
f = func3()
print(f)
print(func1)
a = 10
b = 1
c = 2
li = [a,b,c]
def func5():
print("func5 run")
li2 = [func5]
li2[0]()
def login():
print("登陆")
def register():
print("注册")
def shopping():
print("购物")
res = input("请选择功能名称：")
if res == "login":
login()
elif res == "register":
register()
elif res == "shopping":
shopping()
else:
print("输入有误")
funcdic = {"login":login,"register":register,"shopping":shopping}
if res in funcdic:
funcdic[res]()
else:
print("输入有误！")
2.函数的嵌套
1.嵌套调用 在一个函数中调用了另一个函数
2.嵌套定义 在一个函数中定义了另一个函数
定义在函数内的函数 只能函数内使用 外界不能访问
嵌套定义
def func1():
print("func1")
def func2():
print("func2")
func2()
func1()
a = 100
print(a)
b = 200
def func():
c = 1
if a > 100:
p = 1
while True:
s = 10
age = 18
def func():
# age =19
print(age)
func()
print(len)
len = 100
def func2():
len = 1
func2()
print(len)
3.作用域（作用范围）
域 指的是区域 范围的的意思
全局的名称空间和内置的名称空间 在使用上没什么区别
局部的和全局的内置的 就区别了 局部定义的只能在局部使用
给三个空间划分范围
全局的和内置可以划分为同一个范围
global 表示的全局范围 就是所谓的全局作用域
局部的单独划分为一个范围
local 局部作用域
globals（）
locals（）
'''
1. 什么是名称空间namespaces
存放名字与值内存地址绑定关系的地方
2. 为何要有名称空间
3. 如何用名称空间
内置名称空间
全局名称空间
局部名称空间
4. 总结结论:
1. 查找名字的顺序是从当前位置往外查找
2. 名称空间的嵌套关系是在函数定义阶段就固定死的,与调用位置无关
'''
# def outter():
# x=11111111
# def inner():
# print(x)
# return inner
#
#
# f=outter()
#
#
# def foo():
# x=222222222222
# f()
#
# foo()
l=[]
def func():
l.append(111)
l.append(2222)
func()
print(l)
def f1():
y=1111
def f2():
x=33333
def f3():
nonlocal y
y=2222
4.闭包函数
闭包函数 也是一个函数
与普通函数的区别
1.定义在另一个函数中的
2.在这个内部的函数中使用了外部的名称
age = 20
# 如下就是一个闭包函数
def fun1():
age = 18
def inner():
print("hello")
print(age)
# 在返回这个内部的函数时 不是单纯的返回函数 还把函数中访问到的局部名称一起打包了
# 相当于将内部函数与 访问的数据打包在一起了 闭包这个名字就是这么得来的
return inner
f = fun1() # f 就是inner
f()
# 函数的作用域在定义时就固定了 与调用的位置没有关系
c = 1000
# 闭包函数的模板
def func2():
a = 1
b = 10
def inner():
print(a)
print(b)
print(c)
return inner
5.装饰器
"""
什么是装饰 给一个已有的对象(一个函数) 添加新的功能
为什么要装饰 增强功能
器 指一个工具 在python中 值得是具备某个功能的函数
简单的说：装饰器就是 一个用于给其他函数增加功能的函数
"""
'''
1. 什么是装饰器
装饰器指的是为被装饰对象添加新功能的工具
装饰器本身可以是任意可调用对象
被装饰对象本身也可以是任意可调用对象
2. 为何要用装饰器
开放封闭原则:对修改封闭,对扩展开发
装饰器的实现原则:
1. 不能修改被装饰对象的源代码
2. 不能修改被装饰对象的调用方式
装饰器的目的:
就是在遵循原则1和2的前提为被装饰对象添加新功能
'''
'''
# # part1
import time
# def index():
# time.sleep(1)
# print('welcome to index page')
#
# def wrapper():
# start=time.time()
# func()
# stop=time.time()
# print('run time is %s' %(stop -start))
#
# wrapper()
# part2
import time
# def outter(func):
# # func=最原始那个index的内存地址
# def wrapper(*args,**kwargs):
# start=time.time()
# res=func(*args,**kwargs) #最原始那个index的内存地址()
# stop=time.time()
# print('run time is %s' %(stop -start))
# return res
# return wrapper
#
# @outter #index=outter(index) #inex=outter(最原始那个index的内存地址) # index=wrapper的内存地址
# def index():
# time.sleep(1)
# print('welcome to index page')
# return 1234
# #
# @outter #home=outter(home)
# def home(name):
# time.sleep(1)
# print('welcome %s to home page' %name)
# #
# #
# # res=index() #wrapper的内存地址()
# # print('返回值',res)
# #
# home('egon')
# 小练习
import time
from functools import wraps
def auth(func):
@wraps(func)
def wrapper(*args,**kwargs):
name=input('name>>>: ').strip()
pwd=input('pwd>>>: ').strip()
if name == 'egon' and pwd == '123':
print('login successfull')
res=func(*args,**kwargs)
return res
else:
print('user or pwd error')
return wrapper
def outter(func):
def wrapper(*args,**kwargs):
res=func(*args,**kwargs)
return res
return wrapper
@auth
def index():
"""
sadadsda
:return:
"""
time.sleep(1)
print('welcome to index page')
return 1234
print(index.__name__)
print(index.__doc__)
index()
网友评论