1.什么是函数

函数就是对实现某一特定功能的代码段的封装

2.函数的分类

内置函数(系统函数): python已经实现的函数，程序员直接用，
例如: print()、input()、max()、len()等。相当于系统造好的机器
自定义函数: 程序员自己定的函数，相当于自己造机器

3.函数的定义(声明) - 造机器

"""
1)语法:
def 函数名(参数列表):
    函数体   
   
2)说明:
def - 声明函数的关键字，固定写法  
函数名  -  要求: 标识符、不能是关键字  
          规范: 见名知义(看到函数名大概知道函数的功能)、所有字母都小写，多个单词用_隔开、不能和系统的函数名类名重名
()  -  固定写法  
参数列表  -  形参1,形参2,形参3,... --> 变量名1,变量名2,变量名3,... ; 这儿的参数叫形参，形参可以没有也可以有多个        
            形参的功能是将函数外面的数据传递到函数里面
:   -  固定写法  
函数体   -   和def保持一个缩进的代码段；
            函数体分为函数说明文档和实现函数功能的代码段两个部分

3)初学者声明函数的步骤:
第一步: 确定函数的功能
第二步: 根据功能确定函数的名字
第三步: 确定参数（就是确定需要不需要参数，需要几个参数）
       看实现函数的功能需不需要从函数外面给函数传值，如果需要需要几个？
第四步: 实现函数的功能
第五步: 确定返回值  (暂时不管)
"""

4.函数体在函数声明的时候不会执行, 调用函数的时候才会执行函数体(重要！)

5.函数调用 - 使用机器

"""
1) 语法:
函数名(参数列表/实参列表)  
2) 说明:
函数名  -  函数名对应的函数必须是已经声明过的函数
()     -  固定写法  
参数列表  -  这儿的参数叫实参; 实参是用来给形参赋值的
            值1,值2,值3  
"""

写一个函数，功能是计算两个数的和

def yt_sum(num1, num2):
    """
    函数功能的说明: 求两个数的和
    :param num1: 参数说明: int, 数字
    :param num2: 数字
    :return: 返回值说明: None
    """
    print('========')
    print(num1, num2)
    print(num1 + num2)

yt_sum(11, 222)
yt_sum(2, 8)

写一个函数，功能是求123...n

def yt_mul(n):
    """求1*2*3*...*n"""
    sum1 = 1
    for num in range(1, n+1):
        sum1 *= num
    print('乘积:', sum1)


yt_mul(4)

写一个函数，功能是打印10个*

def print_star():
    print('*'*10)


print_star()

1.函数的调用过程 (重要！！！)

"""
函数在声明的时候不执行函数体，调用的函数的时候才会执行函数体

函数的调用过程:
1）先回到函数声明的位置
2）用实参给形参赋值（传参） -- 传参要保证每个参数都有值
3）执行函数体
4）执行完函数体再回到函数调用的位置，接着往后执行
"""

def yt_sum(num1, num2):
# num1, num2 = 1, 2 --> num1 = 1, num2 = 2
# num1 = 20, num2 = 30
print(num1+num2) # print(1+2) print(3)

yt_sum(1, 2)
print('~~~~~')

yt_sum(20, 30)

2.函数的参数

1）根据实参的写法将参数分为位置参数和关键字参数

a.位置参数: 调用函数的时候实参的位置和形参一一对应，然后保证每个形参都有值

b.关键字参数: 实参列表以'形参名1=值1,形参名2=值2...'的方式来调用函数, 在这儿形参的顺序可以和声明的时候形参的顺序不同注意: 位置参数和关键字参数可以混合使用，但是使用的时候一定要保证位置参数在关键字参数的前面

def func1(a, b, c):
    print(a, b, c)
"""
# 位置参数
func1(10, 20, 30)
# 关键字参数
func1(a=10, b=20, c=30)
func1(c=30, b=20, a=10)
# 位置参数和关键字参数混合
func1(5, c=25, b=15)
# func1(b=10, a=0, 20)  
# SyntaxError: positional argument follows keyword argument
"""

2)参数默认值

声明函数的时候，函数的形参可以设置默认值。
注意: a.如果设置默认值的时候，是一部分参数有默认值，一部分没有默认值，那么没有默认值的参数一定要写在有默认值的参数的前面

b.有默认值的参数，调用的时候可以不用传参；没有默认值的参数，调用的时候必须传参

c.当我们传参的时候想要跳过某个或者某几个有默认值的参数，直接后面的参数传参的时候，后面的参数必须使用关键字参数传参

def func2(a, b=20, c=30):
    # a ;b = 20 ;c = 30
    # a = 100; b=200; c=300
    # a ;b = 20 ;c = 30
    # a=100
    print(a, b, c)


func2(100, 200, 300)
func2(100)
func2(100, 200)
func2(a=100, c=300)
func2(100, c=300)

3) 参数类型说明

a.给参数设置默认值，默认是什么类型，参数就是什么类型

b.以'参数名: 类型名'的方式说明参数类型

def func3(nums: list, a: int, b=0):
    nums.append('abc')
    print(a+b, nums)


func3([], 10, 0)

练习: 写一个函数，函数的功能是统计一个列表中指定元素的个数(类似count()方法的功能)

def yt_count(list1: list, item):
    """统计一个list1中item的个数"""
    count = 0
    for item1 in list1:
        if item1 == item:
            count += 1
    print(count)


yt_count([1, 34, 56, 778, 1], 1)
yt_count([1, 34, 56, 778, 1], 0)
nums = [1, 23, 4, 2, 2, 4, 1, 4]
yt_count(nums, 2)

4)不定长参数

a. 声明函数的时候，在形参前加一个*, 可以将这个形参变成元祖，然后同时接受多个位置参数的值

b. 声明函数的时候，在形参前加，可将这个形参变成字典，然后可以同时接受多个关键字参数的值(这儿的关键字自己随便命名)注意: 原则上一个函数的参数中既可以有定长的，也可以有待一个的不定长和带两个的不定长；如果同时存在带一个参数和带两个*的参数，带一个的要放在带两个的前面

和*混合

def func(*args, **kwargs):
    print(args, kwargs)


func(1, 2, 3, 4)
func(a=1, b=2, c=3)
func(1, 2, 3, a=10, b=20, c=30)

**

def func(a, **num):
    print('不定长参数2：')
    print(a, num)


func(10, name=10, age=23, tel=90)

写一个函数，功能是求多个数的和假设你实现的函数是yt_sum, yt_sum(10) == 10 yt_sum(1, 2) == 3 yt_sum(1, 2, 3, 4) == 10

def yt_sum1(*num):
    print(sum(num))


yt_sum1()
yt_sum1(1)
yt_sum1(1, 2)
yt_sum1(1, 2, 3, 4)

注意: 一个函数中可以同时又不定长参数和定长参数，一般情况下不定长参数要放在后面；如果出现定长参数放在不定长参数的后面，那么在不定长参数后面的定长参数调用的时候需要使用关键字参数传参

def func1(a, *nums, b='abc'):
    print(nums, a, b)


func1(1, 2, 3, 4, 5, b='hello')


def func2(a, *b, c):
    print(a, b, c)


func2(1, 23, 34, 56, 67, c=200)

练习: 写一个函数求多个数的和，要求调用函数的时候既可以使用位置参数传参，也可以用关键字参数传参。yt_sum2(1, 2, 3) == 6 yt_sum2(num1=10, num2=20) == 30,yt_sum2(1, 2, num3=100, num4=200) == 303

def yt_sum2(*nums1, **nums2):
    sum1 = 0
    for num in nums1:
        sum1 += num
    for key in nums2:
        sum1 += nums2[key]

    print(sum1)


yt_sum2(1, 2, 3)
yt_sum2(num1=10, num2=20)
yt_sum2(1, 2, num3=100, num4=200)

1.什么是返回值

返回值的作用是将函数体中产生的数据传递到函数外面
返回值就是函数调用表达式的值，就是return关键字后面的值
注意: 函数调用表达式 - 调用函数的语句； 它的结果就是这个的函数的返回值；
通过函数调用表达式获取函数的返回值

2.return关键字

return只能出现在函数体中；
当执行函数体的时候遇到return，函数直接结束；并且会将return后面的值作为函数的返回值返回;
如果在执行函数体的时候没有遇到return，函数的返回值是None

3.函数的调用过程(完整版) 记！！！！！！

"""
1) 先回到函数声明的位置
2) 用实参给形参赋值 - 传参 (保证每个参数都有值)
3) 执行函数体
4) 执行完函数体，确定返回值
  （执行完函数体中所有的语句没有遇到return,函数的返回值是None;
   执行过程中遇到return，函数的返回值就是return后面的值）
5) 回到函数调用的位置，接着往后执行。（此时函数调用表达式的值才是函数的返回值）
"""

def func1(n):
    # n = 10
    # n = 100
    # n = 100
    print(n)
    return n*2    # return 20; return 200; return 200


print(10)
print(func1(10))   # print(20)

a = 10
a = func1(100)    # a = 200
print('a:', a)

list1 = [10, func1(100)]   # list1 = [10, 200]
print(list1)
"""
10
10
20
100
a: 200
100
[10, 200]
"""

4.什么时候函数需要有返回值

给初学者的建议: 只要实现函数的功能产生了新的数据，就可以把这个数据用返回值返回

写一个函数，求两个数的和：

def yt_sum(n1, n2):
    return n1+n2


score1 = 10
score2 = 20
print(yt_sum(score1, score2))
total = yt_sum(score1, score2)
person = {'name': '小明', 'scores': total}

print([1, 2, 3].count(1))
list1 = [1, 2, 3]
print('===:', list1.append(4))

python中一个函数可以有多个返回值；return后给多个值，用逗号隔开

def func2():
    return 10, 20


x, y = func2()     # x, y = 10, 20
print(x)