python中的函数
1.函数的目的
.避免代码冗余
.增强可读性
2.函数的定义与调用
# 定义函数 使用关键字def
"""
1.定义函数：
def 函数名():
函数体
""" def sayhello():
print("hello") """
2.调用函数:
函数名()
"""
sayhello()
3.函数返回值
# 函数的返回值
"""
1.什么都不写的情况下没有返回值
2.return # 没有返回值 # 结束函数
3.return None
4.return 变量
""" def say_hello1():
print("hello")
print(say_hello1()) def say_hello2():
print("hello")
return
print(say_hello2()) def say_hello3():
print("hello")
return None
print(say_hello3()) def say_hello4():
print("hello")
return "hello"
print(say_hello4())
序列解压
# 序列的解压
a, b, c, d = (1, 2, 3, 4)
print(a, b, c, d) # 1 2 3 4 a, _, _, d = (1, 2, 3, 4) print(a, d) # 1 4 a, *_ = (1, 2, 3, 4)
*_, d = (1, 2, 3, 4)
print(a, d) # 1 4
# 字典、列表、集合同样适用
a, b = {'name': 'eva', 'age': 18}
print(a, b) # age name
多个返回值
def demo():
"""多个返回值情况"""
return 1, 2, 3, 'a' """多个返回值，用一个变量接收时，得到的是一个元祖"""
a = demo()
print(a) # (1, 2, 3, 'a') """适用同等个数的变量接收，个数不相同，报错"""
a, b, c, d = demo()
print(a, b, c, d)
4.函数的参数
实参与形参
"""
1.定义函数使用的是形参
2.调用函数使用的是实参
"""
传参
实参角度
1.按照位置传参
def demo(x, y):
print(x, y) demo(10, 20)
2.按照关键字传参
def demo(x, y):
print(x, y) demo(y=10, x=20)
3.位置与关键字混用(位置参数必须在关键字参数的前面)
def demo(x, y):
print(x, y) demo(10, y=20) # 按照顺序
形参角度 : 位置参数必须传值
默认参数
def info(name, sex='male'):
"""将变化值较小的设置成默认参数"""
print(name, sex) # 调用函数时。默认参数可以不传值
info('a')
info('a', 'female')
def info(name, li=[]):
"""陷阱：默认参数是一个可变数据类型"""
li.append(name)
print(li) info('a') # ['a']
info('b') # ['a', 'b']
区别其他语言：
package com.zzz
object Test {
def demo(name: String, list: List[String] = Nil): List[String] = {
return name :: list
}
def main(args: Array[String]): Unit = {
val a = demo("a")
val b = demo("b")
print(a, b) //(List(a),List(b))
}
}
动态参数
"""
动态参数：
按位置传值多余的参数都由args统一接收，保存成一个元组的形式
""" def to_sum(*args):
sum = 0
print(args)
for i in args:
sum += i
return sum a = to_sum(1, 2, 3)
print(a)
# (1, 2, 3)
#
b = to_sum(1, 2, 3, 4)
print(b) # (1, 2, 3, 4)
# # 接收k-v类型的参数 def info(**kwargs):
print(kwargs)
print(kwargs['name'], kwargs['sex']) info(name='a', sex='b')
# {'name': 'a', 'sex': 'b'}
# a b
5.命名空间及作用域
"""
1.python解释器开始执行之后，就在内存中开辟了一个空间
2.每当遇到一个变量的时候，就把变量名和值之间的对应关系记录下来
3.当遇到函数定义的时候解释器只是象征性的将函数名读入内存，表示知道这个函数的存在了，至于函数内部的变量和逻辑解释器根本不关心
4.等执行到函数调用的时候，python解释器会再开辟一块内存来存储这个函数里的内容，
这个时候，才关注函数里面有哪些变量，而函数中的变量会存储在新开辟出来的内存中。
函数中的变量只能在函数的内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。 创建的存储“变量名与值的关系”的空间叫做全局命名空间，在函数的运行中开辟的临时的空间叫做局部命名空间
"""
# globals和locals方法
print(globals())
print(locals()) # 这中情况下，两种是一样的 def func():
a = 12
b = 20
print(locals()) # {'b': 20, 'a': 12}
print(globals()) func()
#global 关键字
a = 10
def func():
global a
a = 20 print(a) #10
func()
print(a) #20
6.函数嵌套
def f1():
print("in f1")
def f2():
print("in f2") f2()
f1()
"""
nonlocal关键字
# 1.外部必须有这个变量
# 2.在内部函数声明nonlocal变量之前不能再出现同名变量
# 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效
""" def f1():
a = 1 def f2():
a = 2 f2()
print('a in f1 : ', a) f1() # a in f1 : 1 def f1():
a = 1 def f2():
nonlocal a
a = 2 f2()
print('a in f1 : ', a) f1() # a in f1 : 2
7.函数名的本质
"""函数名本质上就是函数的内存地址
1.可以被引用
2.可以被当作容器类型的元素
3.可以当作函数的参数和返回值
""" def f1():
return '' f = f1()
print(f) def f2():
return '' def f3():
return ['a', 'b'] li = [f1(), f2(), f3()]
a = li[2]
print(a) dict1 = {'f1': f1, 'f2': f2, 'f3': f3}
b = dict1['f1'] # <function f1 at 0x0000000001420378>
c = dict1['f1']() #
print(b, c) dict1 = {'f1': f1(), 'f2': f2(), 'f3': f3()}
d = dict1['f1'] #
print(d)
print('---------------') def f5():
return f1()
a = f5()
print(a) #
8.闭包
内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数
def func():
name = 'eva'
def inner():
print(name)
"""
想要拿到函数内部的变量和函数，返回变量跟函数
闭包函数用途
在函数外部调用函数内部的函数
""" def func():
name = 'zhangsan' def inner():
print(name) return inner f = func()
f()
判断是否是闭包函数方法__closure__
# 输出的__closure__有cell元素 ：是闭包函数
def f1():
name = 'zhangsan' def inner():
print(name) print(inner.__closure__) # (<cell at 0x0000000000E591C8: str object at 0x00000000008F37B0>,)
return inner f = f1()
f() # 输出的__closure__为None ：不是闭包函数
name = 'zhangsan' def f2():
def inner():
print(name) print(inner.__closure__) # 判断inner函数是不是闭包函数 None
return inner f2 = f2()
f2()
def f1():
money = 1000
def f2():
name = 'zhangsan'
def f3():
print(name,money)
return f3
return f2 f = f1()
i = f()
i()