函数

函数

函数的定义：

def(define function)

def 函数的名称 ([参数])
#缩进 函数体
[return 返回值]
abs()
pass

参数的检查：
1、调用函数的时候，参数的个数不对，TypeError

2、参数的类型不对

3、可以返回多个值

坐标 位移 角度

import math

python 函数返回多个值的时候实则返回的是一个元组

总结：

1.定义函数的时候，需要确定函数的名称和参数个数
2.如果有必要的话，需要先对参数的类型做检查
3.函数的内部可以用return返回函数的结果
4.函数可以返回多个值，但是返回的结果实则是元组tuple

函数的调用

调用函数的时候，函数名称([参数])

abs(-99)

函数名称实则是指向函数对象的引用，可以吧函数名赋值给一个变量

函数的分类

• 以有没有参数来分类
  有参函数
  无参函数

• 以有没有返回值
  有返回值函数
  无返回值函数

• 定义者分类
  系统
  第三方

全局变量和局部变量

全局变量：

在Python中，定义py文件里面的变量就是全局变量

name = "zhangsan" #全局变量
age = 18

特点：
代码运行的时候，变量是始终有效的

局部变量：

def show(msg):
	gender = "男"  #局部变量

局部变量的作用域只在函数内有效

函数的内部是可以访问全局变量，但是不能改变（操作）全局变量

如果要操作全局变量？--------- global (全局)

def show(msg):
	gender="男" #局部变量
	global age
	print(msg)
	print(name)
	age += 1
	print(age)
	print(gender)
show("hahahahaha")

值传递：

def add(x,y):
	return x+y
x = float(input("请你输入第一个数："))
y = float(input("请你输入第二个数："))
print(add(x,y))

引用传递：

def info(fn,msg):
	fn()
	print(msg)
def print_msg():
	print("定义我的函数")
#引用传递
print(print_mag) #代表是内存的地址
print(print_msg())

函数的参数

位置参数

x的平方

def show(x):
	return x*x

show(x) x在这里就是位置参数

默认值参数：
定义函数的时候，可以给参数加上默认值，调用函数的时候，如果没有给这个参数赋值，也可以成功调用函数

注意：
1、默认值参数必须卸载必选参数后面
2、默认值参数可以有多个，变化范围小的参数要写在变化大的范围的参数前

注意：
默认值参数要指向一个不可变的对象 None -----对象

Python中不可变对象有哪些？
python中的不可变对象有：1、数字；2、字符串；3、元组；4、不可变集合。

可变参数

*变量表示的是可变参数

已经有一个列表或元组

*nums 表示的是nums这个list的所有元素作为可变参数传递给了num

关键字参数

将参数组装dict

用户登录注册

函数 用户名 密码 **参数名

电话号 地址

可扩展性

命名关键字参数

顺序：必选参数 默认值参数 命名关键字参数或者关键字参数

def f1(a,b,c=0,*args,**kw):
	print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
	
def f2(a,b,c=0,*,d,**kw):
	print("a=",a,"b=",b,"c=",c,"d=",d,"kw=",kw)
	
f1(1,2)
f1(1,2,c=3)
f1(1,2,3,"a","b")
f1(1,2,3,"a","b",x=99)
f2(1,2,d=99,ext=None)
f2(1,2,d=99)
f2(1,2)

def f1(a,b,c=0,*args,**kw):
	print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
args = (1,2,3,4)
>>> kw ={"d":"45","x":"23"}
>>> f1(*args,**kw)

a= 1 b= 2 c= 3 args= (4,) kw= {'d': '45', 'x': '23'}

def f2(a,b,c=0,*,d,**kw):
	print("a=",a,"b=",b,"c=",c,"d=",d,"kw=",kw)
>>> args = (1,2,3)
>>> kw ={"d":"45","x":"23"}
>>> f2(*args,**kw)

函数的递归

定义：在函数内部，可以调用其他函数，函数内部调用自己，就是递归

前提条件：

1、自己调用自己

2、有终止条件

利用递归求n的阶乘

递归会出现溢栈现象，怎么解决？？？

通过尾递归优化：

尾递归指的是函数返回的时候调用自己

注意:返回值不能是表达式

匿名函数

定义：没有名字的函数就是匿名函数

function 函数名（参数）{
函数体
return 返回值 }

function （参数）{
函数体
return 返回值}

def 函数名（参数）：
#缩进 函数体

lambda ---------- 箭头函数（javaScript）
lambda：代码

1、匿名函数和普通函数的对比

#求三个数和
def sum(a,b,c):
	return a+b+c
sum_lambda = lambda a,b,c : a+b+c
print(sum(2,3,4))
print(sum_lambda(2,3,4))

2、匿名函数的参数
无参数：

lambda_a = lambda:100
print(lambda_a())

一个参数
多个参数
表达式分支

lambda_b = lambda x : x if x % 2 == 0 else x+2
print(lambda_b(6))
print(lambda_b(7))

3.作为一个参数传递

def func(a,b,func):
	print("a=",a)
	print("b=",b)
	print("a-b=",func(a,b))
func(100,1,lambda a,b:a-b)

4. 作为函数的返回值

def func(a,b):
	return lambda c : a+b+c
return_func = func(1,1000) #匿名函数 lambda c : a+b+c
print(func)
print(return_func)
print(return_func(100)) #调用return_funct()

偏函数

定义：在Python中，我们想调用一个函数，需要把函数中的参数设定为一个固定的值，我们会用到偏函数

引用模块------functools

import functools

partial funcition (偏函数)

from functools import partial ---------------直接引入partial

partial (函数的名称，参数=固定值)

int() ----------- 将其他类型转换成int