1.1函数简介
1.1.1什么是函数
函数就是具有某个具体功能的工具
1.1.2为什么要用函数
提供开发效率 减少代码冗余 提高程序的扩展性
1.1.11定义一个函数
def是定义函数的关键字 函数名:函数名的命名规则与变量名一致 1.不能以关键字(******) 2.函数也应该做到见名知意 函数在定义的时候只检测函数体语法 不执行函数体代码 def func(): print('hello')
1.1.12调用函数的固定格式
函数名+括号 函数名只要遇到括号会立即执行函数体代码 代码中遇到函数名加括号 优先级最高 先去执行函数 再看下面的代码
1.2函数的返回值
函数内要想返回给调用者值 必须用关键字return 1.不写return 2.只写return 3.写return None 4.写return返回一个值 5.写return返回多个值
# 不写return:函数默认返回None
def func():
print(
'hahaha')
res =
func()
print(res)
# 只写return:return除了可以返回值之外 还可以直接结束整个函数的运行
# 只写return 返回的也是None(None就表示什么都没有)
def func():
l = [
'jason',
'egon',
'tank']
while True:
for i
in l:
if i ==
'egon':
# 当i为egon的时候 直接结束函数运行
# break
return
# print('asdasdkljlsjadl') # 这一行代码拥有都不会运行
print(i)
res =
func()
print(res)
# 写return None:跟上面的只写return是一样的
def func():
return None
res =
func()
print(res)
# 写return返回一个值:这个值可以是python任意数据类型
def func():
return '123'
def func1():
return [1,2,3
]
def func2():
return {
'name':
'jason'}
def func3():
return (1
,)
def func4():
return {1,2,3,4,5
}
def func5():
return True
print(func(),func1(),func2(),func3(),func4(),func5())
# 写return返回多个值:return会自动将多个值以元组的形式返回给调用者
"""
1.为什么组织成元祖返回
函数不希望自己处理的结果被修改
#2.如何不返回元祖
#
#"""
def func():
return 1,2,3,4
# 返回的是(1, 2, 3, 4)
# res = func()
# print(res)
def func1():
return 'a',
'b',
'c' # ('a', 'b', 'c')
res =
func1()
print(res)
def func2():
return [1,2,3],[1,2,3],[1,2,3]
# ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res1 =
func2()
print(res1)
def func3():
return {
'name':
'jason'},{
'username':
'tank'},{
'user_name':
'egon'}
# ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
res2 =
func3()
print(res2)
# 返回多个值 并且不想让return帮你做处理 自己手动加上你想返回的数据类型符号
def func4():
return [[1,2,3,4],[1,2,3,4],[1,2,34
]]
res =
func4()
print(res)
View Code
ps:
1.所有的函数都有返回值,无论你写不写return python中所有的函数都有返回值 不写的情况下默认返回None 2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行
1.3函数的参数
1.3.1函数参数的两大类型
形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参 实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参 形参与实参的关系 形参就相当于变量名,而实参就相当于变量的值 函数调用传参的过程 就是给形参变量名赋值的过程ps:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除 只在函数内部有效 函数外部无任何影响
1.3.2函数的注释
def func(x,y):
"""
该函数的作用
:param x: 对形参x的解释
:param y: 对形参y的解释
:return: 对函数返回值的解释
"""
print(
'hahaha')
return 'heihei'
print(help(func))
print(help(len))
1.3.3位置参数
# 位置参数:在函数定义阶段按照位置从左往右依次书写的变量名 叫做函数位置形参
# 位置形参在调用的时候 必须为其传值
def my_max(x,y):
print(x,y)
if x >
y:
return x
else:
return y
# res = my_max(1) # 在调用函数的时候 少一个实参不行
# res = my_max(1,2,3) # 在调用函数的时候 多一个实参也不行
res = my_max(20,10
)
# 位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参
print(res)
# 第一种直接按照位置传 一一对应
# 第二种指名道姓的传 >>>:关键字传参
my_max(y=20,x=10
)
my_max(10,y=20)
# 位置和关键字混合使用
my_max(20,y=40
)
#my_max(20,y=40,x=30) # 位置参数已经赋值给x了 后面的关键字参数就不能再赋值了
ps:在函数的调用阶段 位置参数和关键字参数可以混合使用 但是必须保证 1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后) 2.同一个形参不能被多次赋值
1.3.4默认参数
# 默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了
# 在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
# 在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值
# 在定义阶段 默认值形参必须放在位置形参的后面
def my_max(x,y=100
):
if x >
y:
return x
return y
# res = my_max(200)
res1 = my_max(200,1000
)
res2 = my_max(y=200,x=1000
)
print(res2)
def register(username,age,gender=
'male'):
print(username,age,gender)
register('jason',18
)
register('tank',28
)
register('egon',84
)
register('kevin',58
)
register('xiaohou',17,
'female')
# 默认值参数的应用场景
# 当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参
def info(username,hobby,l=
None):
if l ==
None:
l =
[]
l.append(hobby)
print(
'%s 的爱好是 %s'%
(username,l))
info('jason',
'study')
info('tank',
'生蚝')
info('kevin',
'喝腰子汤')
info('egon',
'女教练')
# 解决方法1
info(
'jason',
'study',[])
info('tank',
'生蚝',[])
info('kevin',
'喝腰子汤',[])
info('egon',
'女教练',[])
# 解决方法2
info(
'jason',
'study')
info('tank',
'生蚝')
info('kevin',
'喝腰子汤')
info('egon',
'女教练')
m = 100
def my_max(x,y=
m):
print(x,y)
m = 222
# m = 222 并没有为函数传参
my_max(111)
# 结果为: 111 100
def func(x,y=100
):
print(x,y)
View Code
ps:函数在定义阶段 内部所使用的变量都已经初始化完毕了 不会因为调用的位置的变化 而影响到内部的值(暂时可忽略) 函数无论在什么地方被调用 都会跑到函数定义阶段去执行代码 形参中用到的值都是往函数定义阶段代码往上找
1.3.5可变长参数
可变长参数 站在调用函数传递实参的角度 实参的个数不固定的情况 也就意味形参也不固定 站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数
1.3.51站在形参的角度 看 *
形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名
def func(x,y,*
z):
print(x,y,z)
# z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)
1.3.52站在实参的角度 看 *
def func(x,y,z):
print(x,y,z)
# l = [1,2,3]
# a,b,c = l
# func(a,b,c)
# func(*[1,2,3,4,5,6]) # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
func(*(1,2,3))
# 等价于func(1,2,3)
def func(x,*
z):
print(x,z)
func(1,*{1,2,3})
# *在形参中只能接收多余的位置实参 不能接收关键字实参
*
只能将列表 元组 集合 字符串
*的内部你可以看成是for
1.3.53站在形参的角度 看 **
def func(x,y,**
z):
print(x,y,z)
# z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}
func(x=1,y=2,z=1,a=1,b=2,c=3
)
**
会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字
字典的value就是关键字的名字指向的值 将字典交给**后面的变量名
1.3.54站在实参的角度 看 **
def func(x,y,z):
print(x,y,z)
func(12,3,4
)
func(x=1,y=2,z=3
)
d = {
'x':1,
'y':2,
'z':333
}
func(x=1,y=2,z=3
)
func(**d)
# 等价于func(x=1,y=2,z=333)
**会将字典拆封成 key = value的形式
总结 * 与 ** *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名 **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名 *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数 (*就看成是for循环取值) **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数
# 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行
# def func1(*x,**y):
# print(x,y)
# func1(1,2,3,4,5,6,x=1,y=2,z = 3)
"""
注意python推荐形参*和**通用的写法
"""
def func2(*args,**
kwargs):
print(args,kwargs)
func2(1,2,3,4,5,6,x=1,y=2,z = 3)
1.4 函数的对象
1.4.1 函数是第一类对象：指的是函数可以当做数据传递
1.4.11 可以被引用 x=1,y=x
def func(x,y):
print(x,y)
f=
func
f(1,2)
1.4.12 可当做函数的参数传入
def foo():
print(
'from foo')
def bar(func):
# print(func)
func()
bar(foo)
1.4.13 可以当做函数的返回值
def foo():
print(
'from foo')
def bar():
return foo
f=
bar()
f()
1.4.14 可以当做容器类型的元素
def foo():
print(
'from foo')
def bar():
return foo
l=
[foo,bar]
print(l)
l[0]()
def get():
print(
'get')
def put():
print(
'put')
def ls():
print(
'ls')
cmd=input(
'>>: ').strip()
if cmd ==
'get':
get()
elif cmd ==
'put':
put()
elif cmd ==
'ls':
ls()
def get():
print(
'get')
def put():
print(
'put')
def ls():
print(
'ls')
def auth():
print(
'auth')
func_dic=
{
'get':get,
'put':put,
'ls':ls,
'auth':auth
}
# func_dic['put']()
cmd = input(
'>>: ').strip()
if cmd
in func_dic:
func_dic[cmd]()
View Code
1.5 函数的嵌套
1.5.1 函数的嵌套调用
def my_max(x,y):
if x >=
y:
return x
else:
return y
def my_max4(a,b,c,d):
res1=
my_max(a,b)
res2=
my_max(res1,c)
res3=
my_max(res2,d)
return res3
1.5.2 函数的嵌套定义
def f1():
def f2():
print(
'from f2')
def f3():
print(
'from f3')
f3()
# print(f2)
f2()
f1()
1.6 名称空间
名称空间指的是：存放名字与值绑定关系的地方，
1.6.1 内置与全局名称空间
内置名称空间（python解释器启动就有）：python解释器内置的名字，max，len，print
全局名称空间（执行python文件时生效）：文件级别定义的名字
x=1
def func():
pass
import time
if x == 1
:
y=2
#局部名称空间（函数调用时生效，调用结束失效）:函数内部定义的名字
func()
1.6.2 加载与访问顺序
加载顺序：内置---》全局----》局部名称空间
访问名字的顺序：局部名称空间===》全局----》内置
x=1
print(x)
#print(max)
max=2
def func():
# max=1
print(max)
func()
x=
'gobal'
def f1():
# x=1
def f2():
# x=2
def f3():
# x=3
print(x)
f3()
f2()
f1()
1.6.3 全局与局部作用域
全局作用域（全局范围）：内置名称空间与全局名称空间的名字，全局存活，全局有效，globals()
局部作用域（局部范围）：局部名称空间的名字,临时存活，局部有效,locals()
#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=111111111111111111111
print(globals())
print(dir(globals()[
'__builtins__']))
print(locals()
is globals())
def func():
# yyyyyyyyyyyyyyyyyyyyyyyy=22222222
print(globals())
print(locals())
func()
x=100
def func():
global x
x=1
func()
print(x)
x=
'global'
def f1():
# x=1
def f2():
nonlocal x
x=
0
f2()
print(
'===f1 innter--->',x)
f1()
print(x)
1.6.4 强调两点：
1.6.41 打破函数层级限制来调用函数
def outter():
def inner():
print(
'inner')
return inner
f=
outter()
# print(f)
def bar():
f()
bar()
1.6.42 函数的作用域关系是在函数定义阶段就已经固定了，与调用位置无关
x=1
def outter():
# x=2
def inner():
print(
'inner',x)
return inner
f=
outter()
# print(f)
# x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111
def bar():
x=3
f()
# x=11111111111111111111111111111111111111111111111111111111111111111111111111111111
bar()
x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111
1.7 闭包函数
闭包函数：
1 定义在函数内部的函数
2 该函数的函数体代码包含对外部作用域（而不是全局作用域）名字的引用
3 通常将闭包函数用return返回，然后可以在任意使用
z=1
def outer():
x=1
y=2
def inner():
print(x,y)
# print(z)
return inner
f=
outer()
print(f.
__closure__[0].cell_contents)
print(f.
__closure__[1
].cell_contents)
print(f.
__closure__)
def bar():
x=111121
y=2222
f()
bar()
def foo(x,y):
print(x+
y)
foo(1,2)
def outter():
x=1
y=2
def foo():
print(x+
y)
return foo
f=
outter()
f()
1.7.1 闭包的意义：
返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
1.7.2 应用领域：
延迟计算（原来我们是传参，现在我们是包起来）
1.7.3 爬页面:闭包函数为我们提供了一种新的为函数传参的方式
import requests
#pip3 install requests
def get(url):
response=
requests.get(url)
if response.status_code == 200
:
print(len(response.text))
get('https://www.baidu.com')
get('https://www.baidu.com')
get('https://www.baidu.com')
def outter(url):
# url = 'https://www.baidu.com'
def get():
response=
requests.get(url)
if response.status_code == 200
:
print(len(response.text))
return get
baidu=outter(
'https://www.baidu.com')
python=outter(
'https://www.python.org')
# baidu()
# baidu()
# baidu()
转载于:https://www.cnblogs.com/linxidong/p/11161567.html
