函数基础
函数优势
#1、代码的组织结构不清晰，可读性差
#2、遇到重复的功能只能重复编写实现代码，代码冗余
#3、功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大 函数分类
内置函数：无需事先定义，可直接使用。如len(),sum(),max()。
自定义函数：根据需求，事先定制来实现某种功能。
定义函数
#语法
def 函数名(参数1,参数2,参数3,...):
'''注释'''
函数体
return 返回的值
#函数名要能反映其意义函数使用的原则：先定义，再调用
#测试一
def foo():
print('from foo')
bar()
foo() #报错
#测试二
def bar():
print('from bar')
def foo():
print('from foo')
bar()
foo() #正常定义函数的三种形式
#1、无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印
#2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值
#3、空函数：设计代码结构#定义阶段
def tell_tag(tag,n): #有参数
print(tag*n)
def tell_msg(): #无参数
print('hello world')
#调用阶段
tell_tag('*',12)
tell_msg()
tell_tag('*',12)空函数
def auth(user,password):
'''
auth function
:param user: 用户名
:param password: 密码
:return: 认证结果
'''
pass 调用函数
- 调用函数
函数名加括号
1 先找到名字
2 根据名字调用代码- 函数返回值
无return->None
return 1个值->返回1个值
return 逗号分隔多个值->元组
通常有参函数需要有返回值。
通常无参函数不需要有返回值。- 函数调用的三种形式：
1 语句形式：foo()
2 表达式形式：3*len('hello')
3 当中另外一个函数的参数：range(len('hello'))- 函数的参数（形参与实参）
#形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定。
位置参数：按照从左到右的顺序定义的参数。
关键字参数：按照key=value的形式定义的实参：
无需按照位置为形参传值
1. 关键字实参必须在位置实参右面
2. 对同一个形参不能重复传值
默认参数：形参在定义时就已经为其赋值。
可以传值也可以不传值:
1. 只在定义时赋值一次
2. 默认参数的定义应该在位置形参右面
3. 默认参数通常应该定义成不可变类型
可变长参数：可变长指的是实参值的个数不固定:分别是*args(位置参数)，**kwargs（关键字参数）
#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递，可以保证，传入的参数中一定包含某些关键字：
def foo(x,y,*args,a=1,b,**kwargs):
print(x,y)
print(args)
print(a)
print(b)
print(kwargs)
foo(1,2,3,4,5,b=3,c=4,d=5)
结果：
1
2
(3, 4, 5)
1
3
{'c': 4, 'd': 5}
函数对象+作用域+装饰器
函数对象
函数可以当作数据传递：
可以被引用
可以当作参数传递
返回值可以是函数
可以当作容器类型的元素优雅的取代多分支的if：
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 f1():
def f2():
def f3():
print('from f3')
f3()
f2()
f1() # 结果为from f3
f3() #报错名称空间与作用域
- 名称空间：
存放名字的地方，三种名称空间，
（之前遗留的问题x=1，1存放于内存中，名字x存放在名称空间，
是存放名字x与1绑定关系的地方）- 名称空间的加载顺序
python test.py
#1、python解释器先启动，因而首先加载的是：内置名称空间
#2、执行test.py文件，然后以文件为基础，加载全局名称空间
#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间- 名字的查找顺序
局部名称空间--->全局名称空间--->内置名称空间
备注：在全局无法查看局部的，在局部可以查看全局的
# max=1
def f1():
# max=2
def f2():
# max=3
print(max)#先打印
f2()
f1()
print(max)#后打印- 作用域:
全局范围:内置名称空间与全局名称空间属于该范围.
局部范围:局部名称空间属于该范围.
作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关.
x=1 #定义1
def f1(): #定义2 执行1
def f2(): # 执行2 执行8
print(x) #执行9
return f2 #执行3
x=100 #定义3
def f3(func):#定义4 执行5
x=2 #执行6
func() #执行7 执行10
x=10000 #定义5
f3(f1()) #执行4 执行11闭包函数
- 闭包函数包含对外部作用域而非全局作用域的引用。
def counter():
n=0
def incr():
nonlocal n
x=n
n+=1
return x
return incr
c=counter()
print(c()) #0
print(c()) #1
print(c()) #2
print(c.__closure__[0].cell_contents) #3 #查看闭包的元素- 闭包的意义与应用：
返回的函数对象，不仅是一个函数对象，在该函数外还包裹了一层作用域，
这使该函数无论在何处调用，优先使用自己外层包裹的作用域- 应用领域：延迟计算（原来我们是传参，现在我们是包起来）
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 timmer(func):
def wrapper(*args,**kwargs):
start_time=time.time()
res=func(*args,**kwargs)
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
return wrapper
@timmer
def foo():
time.sleep(3)
print('from foo')
foo()# 有参装饰器
def auth(driver='file'):
def auth2(func):
def wrapper(*args,**kwargs):
name=input("user: ")
pwd=input("pwd: ")
if driver == 'file':
if name == 'egon' and pwd == '123':
print('login successful')
res=func(*args,**kwargs)
return res
elif driver == 'ldap':
print('ldap')
return wrapper
return auth2
@auth(driver='file')
def foo(name):
print(name)
foo('egon')- 装饰器补充：wraps
from functools import wraps
def deco(func):
@wraps(func) #加在最内层函数正上方
def wrapper(*args,**kwargs):
return func(*args,**kwargs)
return wrapper
@deco
def index():
'''哈哈哈哈'''
print('from index')
print(index.__doc__) # 哈哈哈哈迭代器+生成器+面向过程编程
迭代器
迭代是一个重复的过程，每次重复即一次迭代，每次迭代的结果都是下一次迭代的初始值。
可迭代对象
- 内置有_iter_方法的对象，即obj._iter_
'hello'.__iter__
(1,2,3).__iter__
[1,2,3].__iter__
{'a':1}.__iter__
{'a','b'}.__iter__
open('a.txt').__iter__迭代器对象即内置有_iter_，又内置有__next_方法的对象。
文件类型是迭代器对象：
open('a.txt').__iter__()
open('a.txt').__next__()迭代器对象的使用
dic={'a':1,'b':2,'c':3}
iter_dic=dic.__iter__()
#迭代器.__iter__()得到的仍然是迭代器本身
print(iter_dic.__next__()) #等同于next(iter_dic)# 迭代器可以代替不依赖索引，进行迭代取值:
iter_dic=dic.__iter__()
while 1:
try:
k=next(iter_dic)
print(dic[k])
except StopIteration:
breakfor循环：
# for循环：可以不再依赖索引去取值
dic={'a':1,'b':2,'c':3}
for k in dic:
print(dic[k])for循环工作原理：
1：执行in后对象的dic.iter()方法，得到一个迭代器对象iter_dic
2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码。
3: 重复过程2，直到捕捉到异常StopIteration,结束循环。
迭代器的优缺点
#优点：
- 提供一种统一的、不依赖于索引的迭代方式
- 惰性计算，节省内存
#缺点：
- 无法获取长度（只有在next完毕才知道到底有几个值）
- 一次性的，只能往后走，不能往前退生成器
函数内部包含有yield关键字，函数名()的到的结果就是生成器，并且不会执行函数内部代码。
def func():
print('====>first')
yield 1
print('====>second')
yield 2
print('====>third')
yield 3
print('====>end')
g=func()
print(g) #<generator object func at 0x0000000002184360> - 生成器就是迭代器：
g.__iter__
g.__next__
res=next(g)
print(res)案例：自定义函数模拟range(1,7,2)
def my_range(start,stop,step=1):
while start < stop:
yield start
start+=step
#执行函数得到生成器，本质就是迭代器
obj=my_range(1,7,2) #1 3 5
print(next(obj)) # 进入函数中开始执行
print(next(obj)) # 接收yield第一次返回的数据
print(next(obj)) # 接收第二次返回的数据
print(next(obj)) #StopIteration# 接收第三次返回的数据协程函数
#yield关键字的另外一种使用形式：表达式形式的yield
def eater(name):
print('%s 准备开始吃饭啦' %name)
food_list=[]
while True:
food=yield food_list
print('%s 吃了 %s' % (name,food))
food_list.append(food)
g=eater('egon')
g.send(None) #对于表达式形式的yield，在使用时，第一次必须传None，g.send(None)等同于next(g)
g.send('蒸羊羔')
g.send('蒸鹿茸')
g.send('蒸熊掌')
g.send('烧素鸭')
g.close()
g.send('烧素鹅')
g.send('烧鹿尾')yield总结
#1、把函数做成迭代器
#2、对比return，可以返回多次值，可以挂起/保存函数的运行状态面向过程编程
基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式。
优点：复杂的问题流程化，进而简单化
缺点：可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身。
应用：扩展性要求不高的场景，典型案例如linux内核，git，httpd。
举例：
流水线1：
用户输入用户名、密码--->用户验证--->欢迎界面
流水线2：
用户输入sql--->sql解析--->执行功能三元表达式+列表推导式+生成器表达式+递归+匿名函数+内置函数
三元表达式(If判断)
name=input('姓名>>: ')
res='SB' if name == 'alex' else 'NB'列表推导式（for循环）
egg_list=['鸡蛋%s' %i for i in range(10)]
# 优点：方便，改变编程习惯，称为声明式编程生成器表达式
列表推导式的[]换成()就是生成器表达式：
优点：省内存，一次只产生一个值在内存中
chicken=('鸡蛋%s' %i for i in range(5))
next(chicken)
list(chicken) #因chicken可迭代，因而可以转成列表递归与二分法
- python中的递归:
#递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用.
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
print(def(5)) #120python中的递归效率低且没有尾递归优化：
python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：
尾递归优化，即在函数的最后一步（而非最后一行)调用自己，python没有尾递归，且对递归层级做了限制.
#总结递归的使用：
1. 必须有一个明确的结束条件.
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少.
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。
由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出.#修改递归最大深度:
import sys
sys.getrecursionlimit()
sys.setrecursionlimit(2000)
n=1
def test():
global n
print(n)
n+=1
test()
test()
虽可设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能无限递归- 二分法:
遍历的效率太低，用二分法可以极大低缩小问题规模.
l=[1,2,10,30,33,99,101,200,301,402] #从小到大排列的数字列表
def search(num,l):
if len(l) > 0:
mid=len(l)//2
if num > l[mid]:
#in the right
l=l[mid+1:]
elif num < l[mid]:
#in the left
l=l[:mid]
else:
print('find it')
return
search(num,l)
else:
#如果值不存在，则列表切为空
print('not exists')
return
search(100,l)匿名函数
lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字
func=lambda x,y,z=1:x+y+z
func(1,2,3)
#让其有名字就没有意义
对应的有名函数：
def func(x,y,z=1):
return x+y+z- 有名函数与匿名函数对比
有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能.
匿名函数：一次性使用，随时随时定义
内置函数
内置函数id()可以返回一个对象的身份，返回值为整数。
这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，即不够精准，
最精准的还是以内存地址为准。
is运算符用于比较两个对象的身份，等号比较两个对象的值，内置函数type()则返回一个对象的类型.
lambda与内置函数结合使用
字典的运算：最小值，最大值，排序
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
迭代字典，取得是key，因而比较的是key的最大和最小值
>>> max(salaries)
'yuanhao'
>>> min(salaries)
'alex'
可以取values来比较
>>> max(salaries.values())
>>> min(salaries.values())
通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键
>>> max(salaries,key=lambda k:salary[k])
'alex'
>>> min(salaries,key=lambda k:salary[k])
'yuanhao'
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
