函数

1. 函数：就是对实现某一特定功能的代码块的封装
2. 作用：封装（将功能绑定在一个函数中，想要使用这个功能的时候，直接调用函数）
3. 怎么声明函数：

def 函数名(参数列表):
    '''函数说明'''
    函数体

• def：是python中声明函数的关键字
• 函数名：标识符。PEP8。见名知义（看到函数名要大概知道函数的功能）
• 函数说明：对函数的功能和参数以及返回值进行说明
• ()：是固定格式
• 参数列表：（形参列表） 参数名1，参数名2，参数名3...。
  参数的功能是用来接收从外部传到函数内部的数据
• 函数体：实现函数功能的代码块，可能会包含一个return语句

4. 初学者声明函数的步骤：
   a.确定函数的功能
   b.确定函数名
   c.确定参数
   确定需不需要参数
   确定需要几个参数
   （看实现函数的功能需不需要从外面传数据到函数里面）
   d.实现函数的功能
   e.确定返回值

5. 函数的调用
   函数名（实参列表）
   函数名：调用的函数一定是已经声明过的，想要使用什么功能就调用对应的函数
   实参列表：实参是用来给形参赋值的
   ***!!!函数的调用过程：

   1. 回到函数声明的地方
   2. 使用实参给形参赋值
   3. 执行函数体
   4. 函数体执行完成之后，回到函数调用的位置

注意：
1. 函数只有在调用的时候才会执行
2. 函数调用的时候一定要保证每个形参都有值
3. 一个函数可以调用多次

练习1：写一个函数，计算两个数的和

def my_sum(number1, number2):
    """
    (这里写函数的功能的描述) 求两个数的和
    :param number1:提供第一个数，int
    :param number2:提供第二个数，int
    :return:对返回值进行说明
    """
    print(number1, '+', number2, '=', end='')
    print(number1 + number2)
# 函数的调用一定是在函数的声明后
my_sum(1, 2)
运行结果：
1 + 2 =3

练习：声明一个函数，功能是打印十个*，然后调用这个函数

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

pri()
运行结果：
**********

参数的作用：

从函数的外面给函数传值

1. 位置参数
   传参的时候，实参按顺序给形参赋值

def func1(a, b, c):
    print(a, b, c)

func1(1, 2, 3)
运行结果：
1 2 3

2. 关键字参数

调用函数的时候：
函数名（参数=值）

func1(b=1, a=2, c=3)

# 说明：位置参数和关键字参数可以混着来
func1(10, c=2, b=1)

def func11(a, b='cc', c='ad', d='a'):
    print(a, b, c, d)
func11(10, d='12')
运行结果：
2 1 3
10 1 2
10 cc ad 12

3. 参数的默认值
   Python中函数声明的时候参数可以设置默认值，有默认值的参数必须放在参数列表的最后
   调用参数有默认值的函数，有默认值的参数可以传参，也可以不传参

def func2(a, b, c=3):
    print(a, b, c)

func2(2, 3, 4)
func2(1, 2)
运行结果：
2 3 4
1 2 3

4. 参数个数不定
   参数的个数不确定的时候，就在声明函数的时候，再形参的前面加一个 * ，将形参变成元组
   调用函数的时候，这个参数会将对应的实参作为元组的元素保存起来

# 写一个函数，求多个数的和
def my_sum(*numbers):
    sum1 = 0
    for i in numbers:
        sum1 += i
    print(sum1)

my_sum(1,2,3,4)
运行结果：
10

注意：参数个数不定，可以是形参中的一部分是不定的
个数不确定的参数要放到参数的最后

def func1(char, *numbers):
    print(char, numbers)

func1('a', 1, 2, 3)
# 参数个数不定，也可以不传参，对应的参数的值就是一个空的元组
func1('1')
运行结果：
a (1, 2, 3)
1 ()

作业：

1. 编写一个函数，求1+2+3+...+N

def sum1(*numbers):
    sum = 0
    for i in numbers:
        sum += i
    print(sum)

sum1(1, 2, 3)
运行结果：
6

2. 编写一个函数，求多个数中的最大值

def big_number(*numbers):
    print(max(numbers))
big_number(1, 2, 4, 8, 3)
运行结果：
8

3. 编写一个函数，实现摇色子的功能，打印n个色子的点数和

import random
def sum2(*times):
    sum1 = 0
    for i in times:
        number = random.randint(1, 6)
        sum1 += number
        print(number)
    print(sum1)
sum2(1,2,3)
运行结果：
5
6
3
14

4. 编写一个函数，交换指定字典的key和value。

dict1 = {'a': 1, 'b': 'aa', 'c': '23'}
def change():
    new_dict1 = {
    value:key for key, value in dict1.items()
    }
    print(new_dict1)
change()
运行结果：
{1: 'a', 'aa': 'b', '23': 'c'}

5. 编写一个函数，求三个数中的最大值

def max_number(a, b, c):
    print(max(a, b, c))
max_number(1, 2, 3)
运行结果：
3

6. 编写一个函数，提取指定字符串中的所有的字母，然后拼接在一起后打印出来

str1 = '12asd**aD.Ad342'
def get_letter():
    new_str1 = ''
    for i in str1:
        if 'A'<=i<='Z' or 'a'<=i<='z':
            new_str1 += i
    print(new_str1)
get_letter()
运行结果：
asdaDAd

7. 写一个函数，求多个数的平均值

def ave_number(*numbers):
    sum1 = 0
    ave = 0
    for i in numbers:
        sum1 += i
        ave = sum1 / len(numbers)
    print(ave)
ave_number(4,5,6)
运行结果：
5.0

8. 写一个函数，默认求10的阶乘，也可以求其他数的阶乘

def mul(a=10):
    fac = 1
    for _ in range(a):
        if a > 0:
            fac = fac * a
            a = a - 1
    print(fac)
mul(4)
运行结果：
24

9. 写一个函数，可以对多个数进行不同的运算
   例如: operation('+', 1，2，3) --->求1+2+3的结果
   operation( '-'，10，9) --->求10-9的结果
   operation( ''，2，4，8，10) --->求24* 8* 10的结构

def operation(char, *numbers):
    if char == '+':
        sum1 = 0
        for i in numbers:
            sum1 += i
    elif char == '-':
        sum1 = 0
        for i in numbers:
            sum1 -= i
        sum1 = sum1+2*numbers[0]
    elif char == '*':
        sum1 = 1
        for i in numbers:
            sum1 *= i
    print(sum1)

operation('+',1,2,3,4)
operation('-',1,2,3,4)
operation('*',1,2,3,4)
运行结果：
10
-8
24