内建函数，如print()用户自定义函数 一、函数定义法则
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
def 函数名（参数列表）:
函数体
- 函数内容以冒号 : 起始，并且缩进。return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。
函数实例
eg1:
def hello():
print("hello python")
hello()
eg2:(函数中带上参数变量）
def max(a,b):
if(a>b):
print(f"{a} is bigger than {b}")
elif(a==b):
print(f"{a} is same as {b}")
else:
print(f"{b} is bigger than {a}")
num1=int(input("请输入一个数："))
num2=int(input("请输入另一个数："))
max(num1,num2)
eg3（计算面积函数）:
def area(width,height):
return width*height
def welcome(name):
print(f"welcome {name}")
name1=str(input("请输入您的姓名："))
welcome(name1)
input_width=int(input("请输入长方形的宽："))
input_height=int(input("请输入长方形的长："))
print(f"长方形的面积是{area(input_width,input_height)}")
二、函数调用
定义了函数以后，可以通过另一个函数调用执行，也可以直接从python命令提示符执行。
如在上述计算面积函数中：
#定义函数
def area(width,height):
return width*height
#定义函数
def welcome(name):
print(f"welcome {name}")
name1=str(input("请输入您的姓名："))
#调用函数
welcome(name1)
input_width=int(input("请输入长方形的宽："))
input_height=int(input("请输入长方形的长："))
#调用函数
print(f"长方形的面积是{area(input_width,input_height)}")
三、参数传递
a=[1,2,3]
a=“Runoob”
[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，a是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 C++ 的值传递，如**整数、字符串、元组。**如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。可变类型：类似 C++ 的引用传递，如 **列表，字典。**如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
eg1(传不可变对象）:
def change(a):
print(id(a)) # 指向的是同一个对象
a=10
print(id(a)) # 一个新对象
a=1
print(id(a))
change(a)
结果：
1584096432
1584096432
1584096576
在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。
eg2（传可变对象实例）：
#!/usr/bin/python3
# 可写函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
结果：
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]
传入函数的和在末尾添加新内容的对象用的是同一个引用。
必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
#可写函数说明 def printme( str ): "打印任何传入的字符串" print (str) return # 调用 printme 函数，不加参数会报错 printme()
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
printinfo( name="runoob" )
结果：
名字: runoob
年龄: 50
printinfo( name=“runoob” )，未输入年龄，按照默认35输出
名字: runoob
年龄: 35
不定长参数
需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
def functionname([formal_args,] *var_args_tuple ):
“函数_文档字符串”
function_suite
return [expression]
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
结果：
70
(60, 50)
def functionname([formal_args,] **var_args_dict ):
“函数_文档字符串”
function_suite
return [expression]
加了两个星号 ** 的参数会以字典的形式导入。
# 可写函数说明
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
结果：
1
{‘a’: 2, ‘b’: 3}
使用 lambda 来创建匿名函数。
lambda [arg1 [,arg2,…argn]]:expression
eg1:
x = lambda a : a + 10 print(x(5))
结果：
15
eg2:
def myfunc(n): return lambda a : a * n mydoubler = myfunc(2) mytripler = myfunc(3) print(mydoubler(11)) print(mytripler(11))
结果：
22
33
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
