python基础——函数

函数：
一
概念：
具有特定功能代码的集合
这段代码用来解决一个问题，一类问题
把这段代码封装起来，也就是功能，过程。
当要重复使用一段代码，将其这段代码封装成函数，后面直接调用这个函数名即可。

一，无参函数的定义
格式

     def 函数名（） :    #括号里面什么都不写，表示无参
            函数体
     函数定义完成必须要调用。
     函数名（）

def information():
	"""
	这段函数的注释
	"""
	print("想要两颗西柚")

#调用函数，调用几次就执行几次

information()
information()

结果显示：

二，有参函数

格式

def   函数名（形式参数）
          函数体
调用
函数名（实参）

代码：

def information(name,age,gender):
	print("我叫",name)
	print("今年{}岁了".format(age))
	print("性别{}".format(gender))

#调用函数

information("xixi","18","女")

结果

三，有返回值的函数
当函数执行完成后，需要将某个结果显示给调用者，就需要return。
举个栗子
#如果我们需要函数运算，最后需要得到运算结果,此时我们就需要定义返回值

def add(x,y):
	sum = x + y
	#需要将返回
	return sum

a = float(input("please a num1:"))
b = float(input("please a num2:))

#调用
c = add(a,b)  
#return 需要接返回值
print("{} + {} = {}".format(a,b,c))

注：
当有return时，在调用函数时，若直接调用函数，就会报错，因此需要用对象将return接着，就是
对象名 = 函数名（实际参数）
运行结果：

四，全局变量在函数中的使用

a = float(input(“please a num1:”))
b = float(input(“please a num2:”))
这里的变量名称可以带定义为x,y
因为这里的变量的是全局变量（本地变量），而函数里定义的变量为局部变量，并不影响。

五，函数的调用过程
函数的初始化是在内存的堆中，在调用函数时会把整个函数压栈（先进后出），函数执行完成就会立刻出栈（弹栈），不在栈中。

msg = "hello"
index = 30     #全局变量
def show():
	a = 10     #局部变量

	print("start")
	print(msg)
	global index    
	
	index += 1
	print(index)
	print("ending")

show()

global   index 
如果注释掉这一行，你会发现报错
因为当调用函数时，里面的 index += 1，会改变全局变量，而index=30 是最初在栈中的值，但改变后，函数又被弹出。
全局变量这样是不能被改变的。
所以解决办法：
   就是声明全局函数
   格式
   global    全局变量

运行结果：

六，值传递

def test (a,b):
	a += 10
	b += 20
	print("over")
a=100
b=200
test(a,b)
print(a,b)

运行结果

七，引用传递

ef  test(msg):
	print("收到一个消息{}".format(msg))
	return "haha"
c = test     
print(c)     

运行结果：

出现的是test函数在堆中的地址，test函数存放在堆中，调用时出现test函数压栈，
此时c=test 可用赋值理解，将test的地址给c
所以c和test都指向test函数堆中的地址，因此结果为test函数地址
因此c也是函数，因此可调用

def  test(msg):
	print("收到一个消息{}".format(msg))
	return "haha"
c = test     
c1 = c("cute")
print(c1)
               #c1为返回值

运行结果：

八，函数的默认值
有的参数值是固定的，该值一个默认值。
当给定一个值（r，2），就按照给定的值算
没给就按默认的值算

def get_circle_area(r, PI=3.14):     #PI= 3.14 就是给定的默认值
	return PI * r * r

r = float(input("请输入圆的半径："))

area = get_circle_area(r, 2)         
print("半径为{}的圆，它的面试是{}".format(r, area))

r = float(input("请输入圆的半径："))
area = get_circle_area(r)
print("半径为{}的圆，它的面试是{}".format(r, area))

结果：

九，函数的递归
在递归中，如果无结束条件，递归是一个死循环。

def sum(n):
	if n == 1:
		return 1      #当n = 1 时，不在调用sum（）函数，直接返回1.
	return n + sum(n-1)
res = sum(100)
print("1-100的和{}".format(res))

十，
（1）可变参数
*变量名：
def test（x,y,z,*args）

def  test(x,y,z,*args):
	print(x+y+z)
	print(args)
	#print(args[1],args[2])  ：以下标取出参数
test(1,2,3,4,5,6,7,8)

超过普通参数，由可变参数接收
*args：以元组方式接收其他参数

运行结果：

（2）命名参数：
**变量名：以键值对方式存

def  test(x,y,z,*args,**kwargs):
	print(x+y+z)
	print(args)
	print(kwargs)
test(1,2,3,4,5,6,7,8,age=16,name="xixi")

运行

注：
参数的顺序
普通参数，默认参数，可变参数，命名参数
以上两个都是：需要保留扩展函数功能时使用
（3）匿名函数

def haha(hi):      # 函数引用传递，hi（）此时为一个函数，相当于xixi（）
	hi()
def xixi():
	print("nihao")
haha(xixi)

等价于

python默认不支持匿名函数，所以引入lambda表达式
格式

      lambda [参数1，参数2]：语句

def haha(hi):
	hi()
haha(lambda:print("nihao"))

运行

（4）全局函数

  eval     默认以逗号分隔元素

>>> a = eval(input("entar three number:"))
entar number:(1,2,3)     
>>> a
(1, 2, 3)
>>> x,y,z = eval(input("entar three number:"))
entar number:1,2,3
>>> x
1
>>> y
2
>>> z
3

（5）返回多个值

def function():
	a =1
	b =2
	c =3
	return a,b,c
#res = function()
#print(res)
x,y,z = function()    这是元素，  注释掉的两行与后两行等价，（x,y,z） = function()  ， 以元组
print(x,y,z)

运行