Python7：函数

1. 函数概述

• 如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织成为一个小模块，这就是函数。

• 参数- ->函数- ->返回值：
  
  

2. 函数的创建和调用

2.1 常用内置函数

常用的内置函数 max,min,sum,divmod
函数必须有输入和输出

eg：
max_num = max(2,5,9)
print(max_num)      #9
num_divmod = divmod(17,3)
print(num_divmod)   #(5, 2)

2.2 创建和调用函数

定义一个什么事也不做的空函数,可以用 pass 语句；pass 可以用来作为占位符,还没想好怎么写函数的代码,就可以先放一个 pass ,让代码能运行起来。

定义函数，也就是创建一个函数，可以理解为创建一个具有某些通途的工具。定义函数需要用def关键字实现：

调用函数也就是执行函数，如果把创建的函数理解为具有某种用途的工具，那么调用函数就相当于使用该工具。

返回值：就是程序中函数完成一件事情后，最后给调用者的结果，没有返回值，默认返回None。

函数的专业输入叫参数，函数的输出叫返回值
重点:
 - 形参:形式参数，不是真实的值(定义函数时的参数)
 - 实参:实际存在的参数，是真实的值(调用函数时的参数)

eg:
def get_max(num1,num2):  #形参
    result = num1 if num1>num2 else num2
    return result

max_num = get_max(33,65) #实参
print(max_num)   #65

3. 变量作用域

可变数据类型:list,字典,集合
不可变数据类型:数值,str,tuple

1.全局变量：全局生效的变量
def login():
    print(name)
name = 'admin'
login()


2.局部变量：局部生效的变量，函数内部的变量
def logout():
    age = 19    #局部变量
    print(age)
logout()
print(age)  #NameError: name 'age' is not defined


3.函数内部修改全局变量
 money是全局变量还是局部变量？全局
 如果在函数中修改全局变量，不能直接修改，需要用关键字global关键字声明变量是全局变量
 可变数据类型修改全局变量一定要global声明,可变数据类型不需要。

def hello():
    global money
    money += 1
    users.append('user1')
    print(money,users)
money = 100   #不可变数据类型
users = []    #可变数据类型
hello()       #101 ['user1']

4. 函数参数传递

4.1 形参和实参

形参：定义时小括号中的参数，用来接收参数用的。
实参：调用时小括号中的参数，用来传递参数的。

4.2 参数检查

调用函数时：
如果参数个数不对,Python 解释器会自动检查出来,并抛出 TypeError；
如果参数类型不对,Python 解释器就无法帮我们检查。
数据类型检查可以用内置函数 isinstance 实现

参数检查：
isinstance(var,int)  判断变量var的类型是否为整型

eg:
def get_max(num1:int,num2:int)->int:
    if isinstance(num1,int) and isinstance(num2,int):
        return num1 if num1>num2 else num2
    else:
        return 0
result = get_max(20,7.6)   ##会有提示说明参数类型
print(result)   #0

4.3 常见的四种形参

1.必选参数:必须要传递的参数
2.默认参数
3.可变参数:元组
4.关键字参数:字典

1.必选参数：必须要传递的参数
def get_max(num1:int,num2:int) -> int:
    return num1 if num1>num2 else num2
result = get_max(20,4.6)    #会有提示说明参数类型
print(result)   #20


2.默认参数：可传可不传的参数
def pow(x,y=2):
    return x**y
result = pow(2)     #x=2,y=2
print(result)       #4
result = pow(2,4)   #x=2,y=4
print(result)       #16


3.可变参数：参数的个数会变化，可传1,2,3...n个值
  args=arguments
  args是元组

def my_sum(*args):
    return sum(args)
result = my_sum(2,6,9)
print(result)   #17


4.关键字参数：可以传递key和value
  kwargs存储在字典中

def enroll(name,age=18,**kwargs):
    print(f"""
    入学信息：
    1.姓名：{name}
    2.年龄:{age}
    3.其他:{kwargs}
    """)
enroll('张三',country='china',enhlish='gre',sports=['篮球','羽毛球'])

结果:
入学信息：
1.
姓名：张三
2.
年龄: 18
3.
其他: {
    
    'country': 'china', 'enhlish': 'gre', 'sports': ['篮球', '羽毛球']}

4.4 参数组合

参数组合是指可以必选参数、 默认参数、 可变参数和关键字参数一起使用。
参数定义的顺序必须是:必选参数、 默认参数、可变参数和关键字参数

5. 匿名函数

匿名函数指一类无须定义标识符的函数或子程序。
Python用lambda语法定义匿名函数，只需用表达式而无需申明。(省略了用def声明函数的标准步骤)
lambda函数能接收任何数量的参数但只能返回一个表达式的值

# def get_max(num1:int,num2:int) -> int:
#     return num1 if num1>num2 else num2

get_max =lambda num1,num2: num1 if num1>num2 else num2
print(get_max(10,20)) #20

应用场景1：函数作为参数传递
def fun(a,b=2,myfun=pow):
    print('a=',a,end=';')
    print('b=',b,end=';')
    print('result=',myfun(a,b))
fun(5)
fun(5,3)
fun(5,3,lambda x,y:x**y)
fun(5,3,lambda x,y:x+y)

结果：
a= 5;b= 2;result= 25
a= 5;b= 3;result= 125
a= 5;b= 3;result= 125
a= 5;b= 3;result= 8

应用场景2：作为内置函数的参数
import prettytable as pt
def show(goods):
    """友好的显示商品信息"""
    #实例化表格对象
    table = pt.PrettyTable()
    #表头信息设置
    table.filed_names=["Name","Count","Price"]
    #依次添加每一行信息到表格中
    for good in goods:
        table.add_row(good)
    print(table)

goods = [
    ('aaa',23,45.5),
    ('bbb',67,57.9),
    ('ccc',31,89.0),
    ('ddd',50,89.4),
]

# 1.按照商品数量排序
print("按照商品数量进行排序")
goods.sort(key=lambda x:x[1])
show(goods)

# 2.按照商品价格排序
print("按照商品价格进行排序")
goods.sort(key=lambda x:x[2])
show(goods)

结果:
按照商品数量进行排序
+---------+---------+---------+
| Field 1 | Field 2 | Field 3 |
+---------+---------+---------+
|   aaa   |    23   |   45.5  |
|   ccc   |    31   |   89.0  |
|   ddd   |    50   |   89.4  |
|   bbb   |    67   |   57.9  |
+---------+---------+---------+
按照商品价格进行排序
+---------+---------+---------+
| Field 1 | Field 2 | Field 3 |
+---------+---------+---------+
|   aaa   |    23   |   45.5  |
|   bbb   |    67   |   57.9  |
|   ccc   |    31   |   89.0  |
|   ddd   |    50   |   89.4  |
+---------+---------+---------+

Process finished with exit code 0

练习：

"""
问题描述：(2018-携程-春招题)
    给定一个整形数组， 将数组中所有的0移动到末尾， 非0项保持不变；
    在原始数组上进行移动操作， 勿创建新的数组;
        输入: 数组的记录;0 7 0 2
        输出: 调整后数组的内容; 7 2 0 0

0 7 0 2    #
1 0 1 0    #(1 if num==0  else 0)  #0 1是下标
0 0 1 0    #排序
"""

nums = [0,7,0,2]
nums.sort(key=lambda num:1 if num==0 else 0)
print(nums)


#需求:将所有的偶数排前面,所有的奇数排后面
nums = [0,7,0,2]
nums.sort(key=lambda num: 0 if num%2==0 else 1)
print(nums)

nums = [0,7,0,2]
nums.sort(key=lambda num: 1 if num%2==0 else 0,reverse=True)
print(nums)

结果:
[7, 2, 0, 0]
[0, 0, 2, 7]
[0, 0, 2, 7]

6. 递归函数

一个函数在内部调用自己本身,这个函数就是递归函数

求n的阶乘 n!=n*(n-1)*(n-2)*...*1

1.for循环
res = 1
n = 3
for i in range(1,n+1):
    res=res*i
print(res)  #6

2.递归
n = 3
def f(n):
    if n==1:
        return 1
    return n*f(n-1)
print(f(5))   #120