python学习（七）函数

1.函数的作用

显示的界面需要重复输出给用户；函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。函数在开发过程中，可更高效地实现代码重用。

注意：函数必须先定义后使用。如果没有调用函数，函数里面的代码不会执行。不同的需求，参数可有可无。 

函数的执行顺序：定义函数-调用函数-定义函数-执行定义函数里的代码

2.函数的使用步骤

        2.1定义函数

        def 函数名(参数):

                代码1

                代码2

                .........

        2.2调用函数

        函数名(参数)

#因为函数需要先定义再调用，所以步骤2和3要再步骤1的上面书写
#2.确定选择功能界面，显示余额，存款，取款 #3.封装函数
def a():
    print('余额还有120块')
def b():
    print('存款，还有110块')
def c():
    print('取款，取了10块钱')
#1.搭建整体框架
print('登录成功')
#显示功能界面# 4.在需要的位置调用函数
a()
print('查询余额完毕')
c()
print('取钱完毕，查询存款')
b()

#结果
登录成功
余额还有120块
查询余额完毕
取款，取了10块钱
取钱完毕，查询存款
存款，还有110块

3.函数的参数作用

        需求：计算任意指定两个数，使用函数来计算两个数字和

分析：用户在调用函数的时候指定具体数字，那么在定义函数的时候就需要接受用户指定的数字，函数调用时候指定的数字和定义函数时候接收的数字即是函数的参数。

#1.固定数字，做加法
def a():
    result=1+2
    print(result)
a()
#2.参数形式传入真实数据，做加法
def b(i,j):#定义函数时同时定义了接收用户数据的参数i和j，i和j是占位符,接收真实数据，是形参
    result=i+j
    print(result)
b(2,3)#调用函数时传入了真实的数据2和3，真实数据为实参
#结果
3
5

4.函数返回值作用

        在函数中，如果需要返回结果给用户，需要使用函数返回值

def a():
    return '饮料'
goods=a() #使用一个变量去接收函数调用的结果
print(goods)#输出变量的结果
#结果
饮料

#任意输入两个值相加，并获得返回值

#方法一
def a(i,j):
    result=i+j
    print(result)
a(1,2)
#方法二：使用return的返回方法
def a(i,j):
    return i+j
q=a(2,3)#调用函数，传入真实数据，获得的返回值存在一个变量q中
print(q)#打印输出q
#结果
3
5

return的注意事项： 代码块里，return后的代码都不再执行。

5.函数说明文档

        函数说明文档用help(函数名)来查看，显示的说明内容为在定义函数第一行的注释内容，其余的行的注释内容不会显示；且注释的只能用''''''或者""""""来，#不行

def a(i,j):
    '''计算求和'''
    """求和函数"""
    result=i+j
    print(result)
a(1,2)
help(a)        #查看函数说明
def a(i,j):
    '''求和函
    数啊'''
    return i+j
q=a(2,3)#调用函数，传入真实数据，获得的返回值存在一个变量q中
print(q)#打印输出q
help(a)        #查看函数说明
#结果
3
Help on function a in module __main__:

a(i, j)
    计算求和    #只显示第一行，第二行的不会显示

5
Help on function a in module __main__:

a(i, j)
    求和函
    数啊

6.函数嵌套调用

def a(i,j):
    result=i+j
    print(result)
a(1,2)
#函数嵌套调用：
def b():
    print('计算求和')
    a(3,4)  #嵌套调用了a()
b()
#结果    
3            #a()的结果
计算求和    #b()的输出内容
7            #调用b()函数，并将嵌套了的a()函数的结果一并输出

7.函数嵌套调用的案例

        7.1打印多条横线

#打印一条横线
def a():
    print('-'*20)
a()

#打印多条横线
#方法一：直接多次调用函数，要几行就调用几行
def b():
    a()
    a()
b()
#方法三：用循环的方法：while，后台代码写死几次，较不灵活
def c(num):
    i=1
    while i<=num:
        a()
        i+=1
c(3)
#方法四：根据实际场景，由用户直接输入，而不是后台代码限制，较灵活
x=int(input('请输入行数num：'))#input的类型是str，要将类型转为int，不然是会报错的
def d(num):
    i=1
    while i<=num:
        a()
        i+=1
d(x)
#结果
--------------------    #这个是调用a()函数的结果，打印一条横线
--------------------    #这是调用b()函数，嵌套了两个a()函数所打印的横线2条
--------------------
--------------------    #这是调用了c()函数，使用循环调用了num次a()函数所打印的3条横线
--------------------
--------------------
请输入行数num：4            x=4
--------------------#这是调用了d()函数，使用循环调用了用户输入的x次a()函数所打印的x条横线
--------------------
--------------------
--------------------

        7.2 计算求和与求平均值

#求任意三个数的和
def s(a,b,c):
    return a+b+c
i=s(1,3,5)
print(i)
#求任意三个数的平均值
def v(a,b,c):
    print('求任意三个数的平均值')
    #先求和，将s()函数的求和值获取，赋给变量q
    q=s(a,b,c)
    return q/3#返回q/3的值
w=v(1,2,3) #用变量w来接收调用v()函数的值
print(w)#打印输出w
#结果
9
求任意三个数的平均值
2.0

 8.函数：变量作用域

        变量作用域值得是变量生效的范围，主要分为：全局变量，局部变量

全局变量：函数体内外部都可以访问

i=200
def a():
    j=100
    print(i,j)
a()
print(i)#i变量是全局变量，没在任何一个函数里面，所以可以访问到
#结果
200 100    #i是全局变量，可以访问，而j是内部的，所以只能在函数体内部访问
200        #访问到全局变量i

局部变量：定义在函数体内部的变量，只在函数体内部生效。

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

def a():
    i=100
    print(i)
a()
print(i)#i变量是函数内部的变量，在函数外部是无法访问的
#结果
100
Traceback (most recent call last):
  File "D:\工作\python script\test0\函数.py", line 5, in <module>
    print(i)
NameError: name 'i' is not defined. Did you mean: 'id'?

        如何修改全局变量？

i=100#定义一个全局变量i=100
print(i)#结果输出为100
def a():
    print(i)#函数内部使用，输出也是100
a()
#修改全局变量100改为200
def b():
    global i    #声明i为全局变量
    i=200       #将i改为200
    print(i)    #函数内部，输出i，结果为200
b()
print(i)        #函数外部输出，得到结果i成功改变为200
#结果
100    #定义的全局变量i=100
100    #函数内部使用变量，结果为100
200    #声明全局变量改为200后的函数内部输出结果为200
200    #修改全局变量i=200之后，函数外部输出结果为200，即全局变量修改成功

9.多函数程序执行流程

         一个程序会由多个函数组成，并且多个函数共享某些数据

只要在访问之前修改成功了这个变量，则访问的结果是修改了的结果，否则仍是之前的变量值

i=100
def a():
    print(f'全局变量i={i}')
a()
def b():
    global i
    i=200
    print(f'全局变量i={i}')
#b()    #未调用b()，所以未修改
print(f'全局变量i={i}') #即，i仍旧是100
b() #调用了，所以修改为了200
#结果
全局变量i=100
全局变量i=100
全局变量i=200

10.返回值作为参数传递

def test1():
    return 100
def test2(num):
    print(f'这个调用后的值是{num}')
#result变量去接收test1（）函数的返回值
result=test1()
print(result)#返回值接收到了 是100
test2(result)#将这个返回值作为test2（）的参数进行传递
#结果：
100
这个调用后的值是100

        一个函数有多个返回值，程序该如何执行？

def test1():
    return 100,101
    #return [100,101]
    #return (1,2)写法可以return元组或列表
#result变量去接收test1（）函数的返回值
result=test1()
print(result)#返回值接收到了 是100,101
#结果：
(100, 101)

11.函数的参数

        11.1位置参数：调用函数时根据函数定义的参数位置来传递参数

        注意：传递和定义参数的顺序和个数必须是一致的

def test1(name,age,gender):
    print (f'您的名字是{name},您的年龄是{age},您的性别是{gender}')
test1('Jessica',10,'女')
#test1('Jessica','女')
#test1('Jessica','女',10)
#结果：
您的名字是Jessica,您的年龄是10,您的性别是女

        11.2关键字参数

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

def test1(name,age,gender):
    print (f'您的名字是{name},您的年龄是{age},您的性别是{gender}')
test1(age=10,gender='男',name='jessica')
#结果
您的名字是jessica,您的年龄是10,您的性别是男

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。 

def test1(name,age,gender):
    print (f'您的名字是{name},您的年龄是{age},您的性别是{gender}')
test1('jessica',gender='男',age=10)#与位置参数，且位置参数与定义的参数一致，关键字参数不分顺序
test1('男',name ='jessica',age=10)#虽然位置参数在前面，但是和定义的参数顺序不一致，也会报错
#结果：
您的名字是jessica,您的年龄是10,您的性别是男
Traceback (most recent call last):
  File "D:\工作\python script\test0\函数.py", line 4, in <module>
    test1('男',name ='jessica',age=10)
TypeError: test1() got multiple values for argument 'name'

        11.3缺省参数

缺省参数也叫做默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。

def test1(name,age,gender='男'):
    print (f'您的名字是{name},您的年龄是{age},您的性别是{gender}')
test1('jessica',age=10)
#结果：
您的名字是jessica,您的年龄是10,您的性别是男

注意：函数调用时，如果为缺省函数传值则修改默认参数值；否则使用这个默认值 

def test1(name,age=10,gender='女'):
    print (f'您的名字是{name},您的年龄是{age},您的性别是{gender}')
test1('jessica',gender='男')
#结果：
您的名字是jessica,您的年龄是10,您的性别是男

        11.4不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。此时，可以用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

        （1）包裹位置传递

注意：传进的所有参数都会被args变量收集，他会根据传进参数的位置，合并为一个元组，args是元组类型，这就是包裹位置传递

def test1(*args):
    print(args)
test1()
test1('tom',10)
#结果：
()#不传参数的时候，返回空元组
('tom', 10)

        （2）包裹关键字参数传递

        返回的是一个字典类型

def test1(**a):
    print(a)
test1()
test1(name='jessica',age=10,gender='女')
#结果：
{}
{'name': 'jessica', 'age': 10, 'gender': '女'}

综上，无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。收集所有零散数据返回一个整体数据

12.拆包和交换变量值

        12.1拆包

        拆包：元组

def test1():
    return 1,2
a,b=test1()
print(a)
print(b)
#结果：
1
2

        拆包：字典

dict={'name':'jessica','age':10}
a,b=dict
print(a)#对字典进行拆包，取出来的是字典的key
print(b)

print(dict[a])#要找字典对应的值，不能根据下标查找，是根据key来查找的，a是key为name
print(dict[b])
#结果：
name
age

jessica
10

        12.2 交换变量值

        （1）借助第三变量存储数据，即定义中间变量

a=10
b=20
c=0
c=a
a=b
b=c
print(a,b)
#结果：
20 10

        （2）

a,b=10,20
a,b=b,a
print(a,b)
#结果：
20 10

13.引用

        在python中，值是靠引用来传递的

        （1）引用之不可变类型

可以用id()来判断两个变量是否为同一个值的引用。id值理解为那块内存的地址的标识。

a=1
b=a
print(id(a))
print(id(b))
a=2
print(id(a))
print(id(b))
#结果：
2108005548272
2108005548272
2108005548304
2108005548272

        （2）引用之可变类型

a=[10,20]
b=a
print(id(a))
print(id(b))
print(a,b)
a.append(30)
print(id(a))
print(id(b))
print(a,b)
#结果：
2100277072384
2100277072384
[10, 20] [10, 20]
2100277072384
2100277072384
[10, 20, 30] [10, 20, 30]

        13.1引用当作实参

'''
1.定义函数：有形参
    1.1访问打印形参，看是否有数据
    1.2访问形参的id
    1.3改变形参的数据，查看这个形参并打印id，看id的值是否相同
2.调用函数，把可变和不可变两种类型依次当作实参传入
'''
#不可变传入
def test1(a):
    print(a)
    print(id(a))
    a+=a
    print(a)
    print(id(a))
b=10
test1(b)
#结果：
10
1877820637712
20
1877820638032

#可变传入
def test1(a):
    print(a)
    print(id(a))
    a+=a
    print(a)
    print(id(a))
c=[3,4]
test1(c)
#结果：
[3, 4]
1973451739648
[3, 4, 3, 4]
1973451739648

14.可变类型和不可变类型

所谓可变类型与不可变类型：数据能够直接进行修改，如果能直接修改那么就是可变，否则就是不可变。

可变类型：

        列表、字典、集合。

不可变类型：

        整型、浮点型、字符串、元组