python入门学习之函数

本节主要介绍python函数的定义、函数的参数（形参和实参）、定义形参可指定默认值、传递实参的方式、传递实参可以是任意类型的、在函数内部给变量重新赋值是否会影响外部变量的值（如果是给不可变对象重新赋值，则不会影响外部的值，如果是给可变对象重新赋值，则会影响外部的值）、不定长参数、参数的装包和解包、函数返回值、（break、continue、return）的区别、自定义函数时书写文档字符串

一、函数简介

• 函数也是一个对象
  - 对象是内存中专门用来存储数据的一块区域
  - 函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用.
  - 创建函数：
  def 函数名([形参1,形参2,…形参n]) :
  代码块
  - 函数名必须要符号标识符的规范
  （可以包含字母、数字、下划线、但是不能以数字开头）
  - 函数中保存的代码不会立即执行，需要调用函数代码才会执行
  - 调用函数：
  函数对象()
  - 定义函数一般都是要实现某种功能的

# 定义一个函数，求两个数的和
# 定义函数时，指定形参
def fn(a, b):
    print(a + b)

# 调用函数
# 调用函数时，来传递实参
fn(10, 20)

控制台输出结果：30

二、函数的参数

• 在定义函数时，可以在函数名后的()中定义数量不等的形参，
  多个形参之间使用,隔开
  - 形参（形式参数），定义形参就相当于在函数内部声明了变量，但是并不赋值
  - 实参（实际参数）
  - 如果函数定义时，指定了形参，那么在调用函数时也必须传递实参，

# 求任意三个数的乘积
def mul(a,b,c):
    print(a*b*c)
    
mul(1,2,3)     # 6

2、定义形参时，可以为形参指定默认值

指定了默认值以后，如果用户传递了参数则默认值没有任何作用
如果用户没有传递，则默认值就会生效

def fn(a=5, b=10, c=20):
    print('a =',  a,  'b = ',  b, 'c = ', c)

fn(60)  # a = 60 b =  10 c =  20

3、实参的传递方式
方式一：位置参数

位置参数就是将对应位置的实参复制给对应位置的形参
第一个实参赋值给第一个形参，第二个实参赋值给第二个形参 。。。
fn(1 , 2 , 3)

方式二：关键字参数

关键字参数，可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数
位置参数和关键字参数可以混合使用。
混合使用关键字和位置参数时，必须将位置参数写到前面。

def fn(a, b, c):
    print('a =', a, 'b = ', b, 'c = ', c)


fn(10, 20, 30)    # 位置传参
fn(c=30, a=10, b=20)  # 关键字传参
# 混合使用
fn(b=20, 10, 30)  # 会报错
fn(10, c=30, 20)  # 会报错
fn(10, c=30, b=20)

4、函数在调用时，解析器不会检查实参的类型
实参可以传递任意类型的对象.

def fn(a, b, c):
    print('a =', a, 'b = ', b, 'c = ', c)
    
def fn2(a):
    print('a =',a)

函数在调用时，解析器不会检查实参的类型
实参可以传递任意类型的对象
b = 123
b = True
b = 'hello'
b = None
b = [1,2,3]

# fn2(b)    
fn2(fn) # a= <function fn at 0x7f9de75c6e18>

5、在函数内给变量重新赋值

def fn4(a):
    # 在函数中对形参进行重新赋值，不会影响其他的变量
    a = 20
    print('a =', a)


c = 10
fn4(c)  
print('c =', c)

控制台打印：
c = 10
a = 20

def fn4(a):
    # a是一个列表，尝试修改列表中的元素
    # 如果形参执行的是一个对象，当我们通过形参去修改对象时
    #   会影响到所有指向该对象的变量
    a[0] = 30
    print('a =', a, id(a))


c = [1, 2, 3]
fn4(c)
print('c =', c, id(c))

控制台打印：
a = [30, 2, 3] 140311730616712
c = [30, 2, 3] 140311730616712

当传递的是一个可变对象的时候，又不希望在函数的内部操作影响外部的值，那么可选择传递对象的一个副本：

def fn4(a):
    # a是一个列表，尝试修改列表中的元素
    # 如果形参执行的是一个对象，当我们通过形参去修改对象时
    #   会影响到所有指向该对象的变量
    a[0] = 30
    print('a =', a, id(a))


c = [1, 2, 3]
#  传递副本
fn4(c.copy())  
# 或者是切片：fn4(c[:])
print('c =', c, id(c))

控制台打印：
a = [30, 2, 3] 140284417307656
c = [1, 2, 3] 140284417309064

三、不定长参数

1、不定长参数定义

在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参。他会将所有的实参保存到一个元组中。
例如：a,b,*c = (1,2,3,4,5,6)
a=1,b=2,c=(3,4,5,6)

2、装包：*a会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）
def fn(*a):

def fn(*a):
    print("a =", a, type(a))
    
fn()  # a = () <class 'tuple'>
fn(1,2)  # a = (1, 2) <class 'tuple'>

def sum(*nums):
    # 定义一个变量，来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加
    for n in nums :
        result += n
    print(result)

sum(123,346)  # 469
sum(123,456,789,10,20,30,40) # 1468

3、不定长参数特点

带星号的形参只能有一个
带星号的参数，可以和其他参数配合使用
第一个参数给a，第二个参数给b，剩下的都保存到c的元组中
def fn2(a,b,*c):
print(‘a =’,a)
print(‘b =’,b)
print(‘c =’,c)
可变参数不是必须写在最后，但是注意，带 * 的参数后的所有参数，必须以关键字参数的形式传递，否则会报错
第一个参数给a，剩下的位置参数给b的元组，c必须使用关键字参数

def fn2(a, *b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)

fn2(1,2,3,4,5) # TypeError: fn2() missing 1 required keyword-only argument: 'c'
fn2(1, 2, 3, 4, c=5)
控制台打印：
a = 1
b = (2, 3, 4)
c = 5


所有的位置参数都给a，b和c必须使用关键字参数
def fn2(*a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
  fn2(3,4，5，6，b=10,c=50)
# 如果在形参的开头直接写一个*,则要求我们的所有的参数必须以关键字参数的形式传递
def fn2(*,a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
  fn2(a=3,b=4,c=5)

4、** 两个星定义不定长参数

一个* 定义
# *形参只能接收位置参数，而不能接收关键字参数
def fn3(*a) :
     print('a =',a)
     
fn3(b=1,d=2,c=3,e=10,f=20)   # TypeError: fn3() got an unexpected keyword argument 'b'

这时用 **

**形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中
字典的key就是参数的名字，字典的value就是参数的值
**形参只能有一个，并且必须写在所有参数的最后

def fn3(**a):
    print('a =', a)

fn3(b=1, d=2, c=3, e=10, f=20)   # a = {'b': 1, 'd': 2, 'c': 3, 'e': 10, 'f': 20} <class 'dict'>

#形参只能有一个，并且必须写在所有参数的最后
def fn3(b, c, **a):
    print('a =', a, type(a))
    print('b =', b)
    print('c =', c)

fn3(b=1, d=2, c=3, e=10, f=20) 
控制台打印：
a = {'d': 2, 'e': 10, 'f': 20} <class 'dict'>
b = 1
c = 3

5、参数的解包
将一个序列当中的值拆出来，作为实参进行传递

def fn4(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

# 创建一个元组
t = (10,20,30)
fn4(*t)    
控制台打印：
a = 10
b = 20
c = 30

# 传递实参时，也可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
# 这里要求序列中元素的个数必须和形参的个数的一致

def fn4(a, b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)


# 创建一个字典
d = {'a': 100, 'b': 200, 'c': 300}
# 通过 **来对一个字典进行解包操作
fn4(**d)
控制台打印：
a = 100
b = 200
c = 300

四、返回值

1、返回值定义

返回值，返回值就是函数执行以后返回的结果。
可以通过 return 来指定函数的返回值。
可以之间使用函数的返回值，也可以通过一个变量来接收函数的返回值。

def fn():
    # 函数嵌套函数
    def fn2() :
        print('hello')

    return fn2 # 返回值也可以是一个函数
r = fn()
print(r)  #<function fn.<locals>.fn2 at 0x7ff4cccc66a8>

#如果仅仅写一个return 或者 不写return，则相当于return None
def fn2() :
    a = 10
    return
r2 = fn2()  
print(r2) # None


# 在函数中，return后的代码都不会执行，return 一旦执行函数自动结束
def fn3():
    print('hello')
    return
    print('abc')

fn3()  # hello

2、berak、continue、return在函数中掉用的区别

# 使用break
def fn4():
    for i in range(5):
        if i == 3:
             break  #用来退出当前循环
        print(i)
    print('循环执行完毕！')
   控制台打印结果：
   0
   1
   2
   循环执行完毕！


# 使用continue
def fn4():
    for i in range(5):
        if i == 3:
            continue  #用来跳过当次循环
        print(i)
    print('循环执行完毕！')

fn4()
   控制台打印结果：
   0
   1
   2
   4
   循环执行完毕！

#使用return
def fn4():
    for i in range(5):
        if i == 3:
            return  # 用来结束函数
        print(i)
    print('循环执行完毕！')

fn4()
控制台打印结果：
0
1
2

3、fn5和fn5()的区别

def fn5():
    return 10

# fn5 和 fn5()的区别
print(fn5) # fn5是函数对象，打印fn5实际是在打印函数对象 <function fn5 at 0x05771BB8>
print(fn5()) # fn5()是在调用函数，打印fn5()实际上是在打印fn5()函数的返回值 10

五、定义函数时书写文档字符串

文档字符串（doc str）
在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明
当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明
文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串

1、通过help查看系统自带函数的文档字符串
help(print) # 获取print()函数的使用说明
2、自定义函数时书写文档字符串

def fn(a:int,b:bool,c:str='hello') -> int:
    '''
    这是一个文档字符串的示例

    函数的作用：。。。。。
    函数的参数：
        a，作用，类型，默认值。。。。
        b，作用，类型，默认值。。。。
        c，作用，类型，默认值。。。。
    '''
    return 10