day11- 函数基础

day11- 函数基础

1.认识函数

"""
1)概念：函数就是对实现某一特定功能的代码的封装 - 机器
2）函数的分类：
系统函数（系统造好的机器）- 由Python创建好的函数，例如：print、input、type、max、min、id等
自定义函数（自己造机器） - 由程序员自己创建的函数
"""

2.定义函数（创建函数）

"""
语法：
def 函数名(形参列表):
	函数说明文档
	函数体

说明：
a.def - 关键字；固定写法
b.函数名 - 由程序员自己命名
		  要求：是标识符；不能是关键字
		  规范：1）见名知义（看到函数名大概就知道这个函数的功能是什么）；
		  	   2）所有的字母都小写，多个单词之间用下划线隔开；
		  	   3）不能使用系统的函数名、类命、模块名
c.() - 固定写法
f.函数说明文档 - 可有可无，本质就是一个文档注释
g.函数体 - 和def保持一个缩进的一条或者多条语句；
		  函数体就是实现函数功能的代码
"""

# 练习1：定义一个函数，求任何两个数的和
def sum1(num1, num2):
    print(num1 + num2)
sum1(12, 34)   # 46

# 练习2：定义一个函数，求N的阶乘
def factorial(N):
    result = 1
    for x in range(1,N+1):
        result *= x
    print(result)
factorial(10)  #  3628800

3调用函数（使用机器）

"""
1)重要结论
定义函数的时候不会执行函数体，调用函数的时候才会执行函数体（重要）
2）调用函数
语法：
函数名(实参列表)
说明：
a.函数名 - 需要使用的函数的名字。（函数名必须是已经定义过的函数的函数名）
b.() - 固定写法
c.实参列表 - 多个数据用逗号隔开：数据1，数据2，数据3，...
			原则上定义函数的时候有多少个形参，调用函数就需要多少个实参
3）函数调用过程
当代码执行到函数调用表达式的时候：
第一步：回到函数定义的位置，用实参给形参赋值（传参）
第二步：执行函数体
第三步：确定函数的返回值
第四步：回到函数调用的位置，接着往后执行
"""

# 1)调用函数会执行函数体（调用多少次就执行多少次）
def func1():
    print('---------')
    print('+++++++++++')
func1()

def func2():
    pass
func2(10)    # 报错 TypeError: func1() takes 0 positional arguments but 1 was given

def func3(x):
    pass
func3()   # 报错 TypeError: func2() missing 1 required positional argument: 'x'

# 3)每个实参可以是任何有结果的表达式
def func1(x):
    pass
func1(10)
a = 10
func1(a)
func1(200-100*2 + 3)
func1('abc')
str1 = 'hello'
func1(str1[1:])
func1(str1.upper())  # func1('HELLO')
func1(str1.upper() + '123')  # func1('HELLO123')

4返回值

返回值 - 将函数内部的数据传递到函数外部

"""
1)怎样将一个数据作为函数的返回值
语法：
return 需要返回的数据（需要从函数内部传递到函数外部的数据）

2）怎样在函数外部获取函数的返回值
获取函数调用表达式的值，就是获取函数的返回值。（函数调用表达式的值就是函数的返回值）
返回值能做的事，函数调用表达式都可以做
"""

def sum1(num1, num2):
    return num1+num2
sum2(10, 30)

# 练习:执行以下代码后控制台的打印结果是？
def func(x, y):
    x.append(y*2)
    return x
list1 = [func([10, 20], 30), 'abc']
print(list1[0][-1])
# 分析：
# 第一步：func([10, 20], 30)  -> [10, 20,60]
# 第二步：list1 = [[10, 20, 60], 'abc']
# 第三步：list[0][-1] -> 60

5return关键字

"""
return的作用有两个：
1）确定函数返回值（将函数内部的数据传递到函数的外部）
2）提前结束函数（在执行函数体的时候，如果遇到return,那么函数直接结束）
"""

def odevity(num):
    if num % 2:
        return '奇数'
    return '偶数'
print(odevity(5))  # 奇数

6函数的参数

1.位置参数和关键字参数 - 根据实参提供的方式分的类

"""
1)位置参数 - 直接将多个数据用逗号隔开，让实参和形参从位置上一一对应（第一个实参给第一个形参赋值，第二个实参给第二个形参赋值...）
2)关键字参数 - 以‘形参 = 实参’ 的形式传参
3）位置参数和关键字参数混用 - 位置参数必须在关键字参数的前面
"""

def func1(x, y,z):
    print(f'x:{x}, y:{y}, z:{z}')
# 1)位置参数
func1(10, 20, 30)
# 2)关键字参数
func1(x=10, y=20, z=30)
func1(y=20, x=10, z=30)
# 3)位置参数和关键字参数混用
func1(10, 20,z=30)
func1(10, z=30, y=20)
func1(12, 24, z=34)

2.参数默认值

"""
定义函数的时候可以通过‘形参 = 数据’给参数赋默认值，调用函数的时候有默认值可以不用传参
定义函数的时候可以只给部分参数赋默认值，那么这个时候没有默认值的参数必须在有默认值参数的前面
"""

def func2(x=10, y=20, z=30):
    print(f'x:{x},y:{y},z:{z}')
func2()
func2(100)
func2(100, 200)
func2(100, 200, 300)
func(y=200)

3.参数类型说明和返回值类型说明

"""
参数类型说明：
1)无默认值参数:类型名
2）参数赋默认值（默认值是什么类型，参数值就是什么类型）
返回值类型说明：-> 类型名
"""

def func4(x:list, y='') -> list:
    return [10, 20, 30]

4.不定长参数 - 一个形参可以同时接受多个实参

"""
1)在参数名前加*，那么这个参数可以同时接受多个实参（必须是位置参数）
原理：带*的参数会变成一个元组，接受到的实参会变成元组中的元素
注意：带*的不定长参数在传参的时候只能用位置参数

结论：定义函数的时候，如果参数中有一个独立的*，它的作用是让你在调用这个函数的时候，*后面的参数必须用关键字传参

（掌握）重要结论：定义函数的时候，如果参数中有一个独立的*，它的作用是让你在调用这个函数的时候，*后面的参数必须用关键字传参

2）在参数名前加**，那么这个参数可以同时接受多个实参（必须是关键字参数）
原理：带**的参数会变成一个字典，接受到的实参会变成字典中的键值对
"""

def func5(x, y,*z):
    print(f'x:{x}, y:{y}, z:{z}')
func5(10, 20)  # x:10, y:20, z:()
func5(10, 20, 30, 40)  # x:10, y:20,z:(30, 40)

# (掌握)重要结论：定义函数的时候，如果参数中有一个独立的*，它的作用是让你在调用这个函数的时候，*后面的参数必须用关键字传参
def func8(x, *, y):
    pass
func8(10, y=20)
# 2）在参数名前加**，那么这个参数可以同时接受多个实参（必须是关键字参数）
# 原理：带**的参数会变成一个字典，接受到的实参会变成字典中的键值对
def func9(**x):
    print(x)
# 以下四种都可以
func9(x=20, y=30, z=20)  # {'x': 20, 'y': 30, 'z': 20}
func9(x=20, y=30)  # {'x': 20, 'y': 30}
func9(x=20)  # {'x': 20}
func9()  # {}

# *和**混用
def func10(*args, **kwargs):
    pass
func10()
func10(10, 20)
func10(x=10, y=20)
func10(10, 20, x=10, y=30)