python函数基础（基础知识）

1.函数作用

写程序的时候会出现这样的情况：有一个功能需要在多个地方使用，如果没有函数需要在每次使用这个功能的时候把实现这个功能的代码写一遍；
如果有函数可以提前将实现指定功能的代码封装成函数，然后在所有需要这个功能的位置调用函数

例子

#左移2次右移3次左移3次右移3次
print('----------------左移-----------------')
print('打左转向灯')
print('向左打方向盘')
# print('踩油门')
print('回正方向盘')
print('----------------左移-----------------')
print('打左转向灯')
print('向左打方向盘')
# print('踩油门')
print('回正方向盘')
print('----------------右移-----------------')
print('打右转向灯')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')
print('----------------右移-----------------')
print('打右转向灯')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')
print('----------------右移-----------------')
print('打右转向灯')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')
print('----------------左移-----------------')
print('打左转向灯')
print('向左打方向盘')
# print('踩油门')
print('回正方向盘')
print('----------------左移-----------------')
print('打左转向灯')
print('向左打方向盘')
# print('踩油门')
print('回正方向盘')
print('----------------左移-----------------')
print('打左转向灯')
print('向左打方向盘')
# print('踩油门')
print('回正方向盘')
print('----------------右移-----------------')
print('打右转向灯')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')
print('----------------右移-----------------')
print('打右转向灯')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')
print('----------------右移-----------------')
print('打右转向灯')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')

def left():
    print('----------------左移-----------------')
    print('打左转向灯')
    print('向左打方向盘')
    # print('踩油门')
    print('回正方向盘')


def right():
    print('----------------右移-----------------')
    print('打右转向灯')
    print('向右打方向盘')
    print('踩油门')
    print('回正方向盘')


left()
left()
right()
right()
right()
left()
left()
left()
right()
right()
right()


def sum100():
    sum1 = 0
    for x in range(1, 101):
        sum1 += x
    print(sum1)


def max_score():
    scores = [98, 78, 90, 100, 78]
    max1 = scores[0]
    for x in scores[1:]:
        if x > max1:
            max1 = x
    print(max1)

明显看出来，不同写法，结果相同，用函数写出来会便利很多

2.函数的定义

1.概念： 函数就是实现某一特定功能的代码的封装。

函数就是将实现某一个功能的所有代码打成一个包(封装起来)，那以后在需要这段代码对应的功能的时候就不需要重复写这段代码了，而是直接调用函数。

2. 函数的分类

根据函数由谁创建的可以将函数分为：系统函数和自定义函数
1.系统函数 - 由系统创建好的函数: print、input、type、chr、ord、max、sum等
2.自定义函数 - 由程序员自己创建的函数

3.定义函数(创建函数 - 造机器)

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

说明：
1）函数名 - 名字由程序员自己决定
两个要求：是标识符；不能是关键字
三个规范：见名知义(看到函数名就大概知道这个函数的功能是什么)；字母都小写多个单词之间使用下划线隔开；
不使用系统函数名、类名或者模块名
2）(): - 固定写法
3）形参列表 - 以’变量名1, 变量名2, 变量名3,…'的形式存在，这儿的每一个变量就对应一个形参(形参可以没有也可以有多个);
形参可以将函数外部的数据传递到函数的内部；
定义函数的时候需不需要形参需要几个形参就看实现函数的功能的时候需不需要额外的数据，需要几个额外的数据
4）函数说明文档 - 本质就是和def保持一个缩进的多行注释
5）函数体 - 结构上就是和def保持一个缩进的一条或者多条语句(至少一条)；
逻辑上函数体就是实现函数功能的代码。

4.函数调用

定义函数的时候不会执行函数体，调用函数的时候才会执行函数体(调用多少次就执行多少次)

语法：
函数名(实参列表)

说明：
函数名 - 任何已经定义过的函数的函数名
() - 固定写法
实参列表 - 以"数据1, 数据2, 数据3,…"的形式存在，这儿的每一个数据就是一个实参。
实参是用来给形参赋值（实参才是真正从函数外部传递到函数内部的数据），实参必须和形参一一对应

def func1():
    # print(10 + 'a')
    print('======')
    print('------')
    print('++++++')


func1()

函数调用过程
第一步：回到函数定义的位置
第二步：传参（用实参给形参赋值）
第三步：执行函数体
第四步：确定函数返回值
第五步：回到函数调用的位置，接着往后执行

def sum2(num1, num2):
    # num1 = 100, num2 = 200
    print(num1 + num2)


sum2(100, 200)
print('end!')

5.函数的参数

1. 位置参数和关键字参数

根据调用函数的时候实参的提供方式不同来分类的
1）位置参数：以’数据1,数据2,数据3,…'形式存在，通过位置来和形参一一对应
2）关键字参数：以’形参1=数据1,形参2=数据2, 形参3=数据3,…'形式存在（交换关键字参数的顺序不影响结果）

注意：
a.位置参数和关键字参数可以一起使用，但是位置参数必须放在关键字参数的前面
b.不管以什么样的形式传参，都必须保证每个参数都有值

def func1(a, b, c):
    print(f'a:{a}, b:{b}, c:{c}')


func1(10, 20, 30)
func1(20, 10, 30)
func1(a=100, b=200, c=300)
func1(b=200, a=100, c=300)
func1(c=30, a=10, b=20)
func1(100, b=200, c=300)
func1(100, c=300, b=200)
func1(100, 200, c=300)

# func1(100, a=200, c=300)      # 报错！
# func1(a=100, 200, c=300)      # 报错！

2. 参数默认值

在定义函数的时候，可以以’变量名=数据’的方式给参数赋默认值；
调用函数的时候有默认值的参数可以不用传参。

注意：定义函数的时候如果有的参数有默认值有的没有，没有默认值的参数必须在有默认值参数的前面。

def func2(a=1, b=2, c=3):
    print(f'a:{a}, b:{b}, c:{c}')


func2()
func2(10)
func2(10, 20)
func2(10, 20, 30)
func2(c=300)


def func3(a, b=2, c=3):
    print(f'a:{a}, b:{b}, c:{c}')


# 案例：定义一个函数都10的阶乘
def factorial(num=10):
    s = 1
    for x in range(1, num+1):
        s *= x
    print(s)


factorial()
factorial(5)

3. 参数类型说明

可以让形参在函数体中使用的时候有相关的代码提示

1. 没有默认值的参数直接在参数名后加’: 类型名’
2. 有默认值的参数默认值的类型就是说明的类型

def func4(a: list, b='abc'):
    pass


list1 = [
    {'a': 10, 'b': 20},
    {'a': 100, 'b': 'abc'}
]
# 补充：通过类型注释对变量进行类型说明
c = list1[-1]['b']      # type: str

4. 不定长参数(了解) - 参数个数不确定

“”"
1)带*的不定长参数：

定义函数的时候在某个参数前加*，就可以让这个参数同时接受多个实参(只能是位置参数)。
带*的不定长参数的本质是一个元组，它接收到的所有的实参会成为这个元组的元素。

注意：
a.带的不定长参数只能用位置参数传参
b.带的不定长参数前面的定长参数也只能用位置参数传参
c.在带*后面的定长参数只能使用关键字参数传参

2)带**的不定长参数

定义函数的时候再某个参数前加**，就可以让这个参数同时接收多个实参(只能是关键字参数)。
带**的不定长参数的本质是一个字典，它接收到的所有的关键字参数会成为这个字典的元素。

def sum2(*nums):
    s = 0
    for x in nums:
        s += x
    print(s)

sum2()
sum2(10, 20)
sum2(10, 20, 30)
sum2(1, 23, 4, 5, 90)

def func9(**x):
    print(x)


func9()
func9(a=10)
func9(a=10, b=20, c=30)
func9(c=90, m=100, e=87, h=56)

6.函数的返回值

1. 什么是返回值

返回值就是从函数内部传递到函数外部的数据（每次函数只能传一个数据到函数外部）

1)在函数内部怎么确定函数返回值 - return后面的值就是函数的返回值
在函数体实现函数功能的时候，可以在任何你需要的地方(一般在最后)通过return关键字，将需要传递到函数外部的数据作为返回值返回。

return使用方法： return 需要返回的数据

注意：
a. return除了可以返回数据，还会提前结束函数(执行函数体的时候只要遇到return整个函数直接结束)
b. 如果执行函数体的时候没有遇到return，这个函数的返回值就是None

2)在函数外部怎么使用函数返回值
使用函数调用表达式的值就是使用函数的返回值（函数调用表达式有结果，这个结果就是这次调用函数的时候获得的返回值）；
返回值能做的事情，函数调用表达式都可以做。
“”"

return会提前结束函数

def func1():
    print('======')
    for x in range(5):
        print(x, '!!!!!!')
        return
    print('++++++')
    print('-------')


func1()

案例：定义函数求任意两个数的和以及乘积

def sum3(num1, num2):
    return num1 + num2, num1 * num2


print(sum3(10, 20))

案例：定义函数求任意两个数的和

def sum2(num1, num2):
    return num1 + num2


print(sum2(10, 20))
print(sum2(3, 4))

返回的值能做的，函数调用表达式都可以做

print(300)
print(sum2(100, 200))

a = 300
b = sum2(100, 200)
print(a, b)

list1 = [300, sum2(100, 200)]
print(list1)

print(300 * 3)
print(sum2(100, 200) * 3)


def func2():
    return 'abc'


print(func2()[-1])          # print('abc'[-1])
print(func2().upper())

result = max([19, 23, 40, 50])
# name = input('请输入姓名:')

7.变量作用域

根据变量作用域（可使用范围）不同，可以将变量分为全局变量和局部变量两种

1. 全局变量

全局变量指的是没有定义在函数或者类中的变量，
全局变量的作用域是从定义开始到程序结束。

# a是全局变量
a = 10

print(f'在外面使用a:{a}')

for x in range(3):
    print(f'在循环中使用a:{a}')


def func1():
    print(f'在函数中使用a:{a}')


func1()

# x和b都是全局变量
for x in range(3):
    b = 20
    print(f'循环中使用x和b：{x}, {b}')


print(f'循环外面使用x和b：{x}, {b}')


def func2():
    print(f'函数中使用x和b：{x}, {b}')


func2()

2. 局部变量

定义在函数中的变量就是局部变量，局部变量的作用域是从定义开始到函数结束。（形参是局部变量）

# m和n都是局部变量
def func3(m):
    n = 100
    print(f'在函数里面使用m和n：{m}, {n}')


func3(5)

# print(f'在函数外面使用m和n：{m}, {n}')         # 报错！

3.关键字global

如果想要在函数里面定义一个全局变量或者修改一个全局变量的值，需要在函数中使用这个变量前加global进行说明。

num = 19


def func4():
    global num
    num = 20
    print(f'函数内部：{num}')

    global name
    name = input('请输入用户名：')


func4()
print(f'函数外部：{num}')
print(f'函数外部：{name}')