函数的概念
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做自定义函数。
函数的定义
你可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号 : 起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。
- 在return关键字下边写的所有的代码将不会被运行
def hello() :
print("Hello World!")
hello()def 函数的名字(参数):
函数体def func1(a):
print("函数被调用"+a)
func1("aa")def max(a, b):
if a > b:
return a
else:
return b
a = 4
b = 5
print(max(a, b))函数的参数
形参与实参
形参：形式参数，在函数声明时，我们在括号当中写的参数就叫做形参
实参：实际参数，在函数调用时，我们实际往函数当中传的参数
def max(a, b): # 形参：在函数声明时，我们在括号当中写的参数就叫做形参
if a > b:
return a
else:
return b
a = 4
b = 5
print(max(a, b)) # 实参：函数调用时，我们实际往函数当中传的参数位置参数
又叫做必须参数，你必须在函数调用的时候进行参数传递，并且位置是一一对应的
关于位置参数，我们不能少传，也不能多传，位置也必须要一致
def printme( str ):
"打印任何传入的字符串"
print (str)
return
# 调用 printme 函数，不加参数会报错
printme()以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 10, in <module>
printme()
TypeError: printme() missing 1 required positional argument: 'str'
默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
注意：如果默认参数和位置参数共存的情况下，默认参数必须写在位置参数的后边，如果参数顺序反过来，会报错。
def printinfo( name, age = 35 ):
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )名字: runoob 年龄: 50 ------------------------ 名字: runoob 年龄: 35
关键字参数
关键字参数就是我们在调用函数的时候，把参数的名字同时也写上
特点是：如果我们使用了关键字参数的形式，那么函数参数的位置就可以任意写了
def printme( str ):
print (str)
return
#调用printme函数
printme( str = "4")def printinfo( name, age ):
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )名字: runoob 年龄: 50
不定长参数
在声明函数时，参数的名字前边要加一个星*
进入到函数内部的时候，函数会将不定长参数解析成为一个元组
def printinfo( arg1, *vartuple ):
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )70 (60, 50)
如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量
def printinfo( arg1, *vartuple ):
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return
# 调用printinfo 函数
printinfo( 10 ) # 10
printinfo( 70, 60, 50 ) # 70 60 50可变参数
还有一种就是参数带两个星号 **基本语法如下：
在声明函数时，参数的名字前边要加两个星**
调用函数的时候，我们必须以key=value,key=value的形式来进行参数传递
进入到函数内部的时候，函数内部会将所有的参数解析成为一个字典
def printinfo( arg1, **vardict ):
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
1
{'a': 2, 'b': 3}
强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
f(10, 20, 30, d=40, e=50, f=60)
f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式return 语句
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)
def demo(x, y):
sum = x + y
print("inside:", sum) # inside: 6
result = demo(1, 5)
print("outside: ", result) # outside: None函数的多个返回值
当我们一个函数返回多个值的时候，我们用一个参数去接收返回值得时候，那么这个参数就是一个元组，元组中包含了所有函数返回的值
def calc(a,b):
a += 1
b += 1
return a,b
r = calc(1,2)
print(r) # (2, 3) 返回的是一个元组
print(type(r)) # <class 'tuple'>当然，我们也可以使用多个值去一一对应的接收这些返回值
def calc(a,b):
a += 1
b += 1
return a,b
r1,r2 = calc(3,4)
print(r1,r2) # 4 5如果我们的函数的返回值是一个元组，它仍然具备多个返回值的特点，也可以使用多个值去接收函数的返回值，这些值必须与返回的值一一对应
def calc(a,b):
a += 1
b += 1
return (a,b)
r = calc(1,2)
print(r) # 返回一个元组 (2, 3)
print(type(r)) # <class 'tuple'>
r1,r2 = calc(5,6)
print(r1,r2) # 6 7当函数有多个返回值的时候，我们要么用一个值去接收函数的返回值，要么用多个值去接收函数的返回值，这里的多个值必须与函数返回值的数量相同
def calc(a,b):
a += 1
b += 1
return (a,b)
# r1,r2,r3 = calc1(5,6)
def calc1(a,b,c):
a += 1
b += 1
c += 1
return a,b,c
# r1,r2 = calc1(6,7,8)当我们在接收返回值的时候，有一些返回值我们不想要了，那么就用下划线_丢弃
def calc1(a,b,c):
a += 1
b += 1
c += 1
return a,b,c
r1,_,_= calc1(1,2,3)
print(r1) # 2
r1,r2,_ = calc1(3,4,5)
print(r1,r2) # 4 5
_,r1,r2 = calc1(7,8,9)
print(r1,r2) # 9 10
r1,_,r2 = calc1(7,8,9)
print(r1,r2) # 8 10函数名和系统函数重名
列表list_1的长度是3，而程序结果输出6，并没有正确的输出列表的长度。 说明:len()函数是Python内置函数，可以用于计算列表长度，程序中自定义了len()函数，与内置函数重名，对列表list_1应用len()函数，调用的是自定义函数，没有实现列表长度的计 算。
def len(x):
res = 1
for i in x:
res *= i
return res
list_1 = [1, 2, 3]
print(len(list_1))闭包
在一些语言中，在函数中可以（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包。
闭包可以用来在一个函数与一组“私有”变量之间创建关联关系。
在给定函数被多次调用的过程中，这些私有变量能够保持其持久性
嵌套函数，函数内部声明一个函数
def func1():
print("我是函数1")
def func2():
print("我是内部的函数")
func2()
func1()私有变量，变量的作用域
a = 1 # 暂时我们可以把a看成是全局变量
def func3():
print(a)
b = 2
print(b) # 函数内可以访问变量 b，但是出了这个函数，就访问不到变量 b 了
func3()
# print(b) # "b" is not defined 外面访问函数里面的变量 b 是访问不到的一个函数的返回值，也可以是一个函数的引用
def func1():
print("我是函数1")
def func2():
print("我是内部的函数")
return 1
return func2
f1 = func1()
print(f1) # 我是函数1 <function func1.<locals>.func2 at 0x104d2a8e0>
print(type(f1)) # <class 'function'>
f1() # 我是内部的函数如果我们有一个函数，让他可以任意的计算一个值的任意次幂
def exponent(a,b):
return a ** b自定义函数，使用闭包实现
def warpper(exponent):
def exponent_of(base):
return base ** exponent
return exponent_of
# 计算一个函数的平方
square = warpper(2)
print(square(2))
print(square(3))
print(square(4))
print(square(5))
