Python函数简介及相关操作

函数简介

在python中我们经常需要多次使用同一段代码，每次用的时候在写一次是比较麻烦的，那么有什么更简便的方法吗？

所以，出现了函数。函数可以把一段代码封装起来，等到我们需要用的时候再去调用它，这样就减少了程序员的工作量。而且在编写大型程序时，我们可以用函数来把它分成多个小部分，从而减少程序整体的复杂性。

1.函数的格式

格式： def 函数名（参数，....）：

                  代码

 代码部分放的就是重复的内容。

 例如：

import random


def generate_code():
    # 生成验证码
    s = '1234567890zxcvbnmasdfghjklqwertyuiopZXCVBNMASDFGHJKLQWERTYUIOP'
    code = ''
    for i in range(4):
        r = random.choice(s)
        code += r
    print(code)

那么怎么使用函数呢？或者说怎么检验函数是否可用呢？所以我们就要调用它，

调用的格式为：

函数名（）

例如：

generate_code()

运行结果为

043S

 可以看到运行成功了。证明函数可用而且是正确的。

2.函数的参数

在定义函数时，可以有参数，也可以没有参数。

2.1无参数的函数

无参数的函数定义格式：

def 函数名（）：

      代码

 例如：

def print_str():
    print('hello  world')

无参数的函数在调用时也不需要写入参数，直接调用就行。

例如：

print_str()

运行结果为：

hello  world

 2.2有参数的函数

有参数的函数定义格式：

def 函数名（参数1，参数2...）：

       代码

 参数的位置可以是一个参数也可以是多个参数

例如：

def get_sum(a, b):
    s = a + b
    print(s)

有参数的函数在调用时要向参数传值。如：

get_sum(1, 2)

运行结果就为：

3

 2.3默认值参数

 什么是默认值函数呢？

在定义函数的时候，有一个或者多个参数已经赋好值。就叫默认值函数。

定义格式：

def 函数名（参数1，参数2，参数3，参数4=值，参数5=值）;
      函数体

 调用格式为：

函数名（值1，值2，值3）

 在调用时函数时，默认值参数可以传参，也可以不传参。

注意：1.在定义函数的时候，普通参数要位于默认值参数的前面

           2.默认参数的顺序时固定的， 若要是不想按照顺序传参，则调用时使用关键字参数赋值

def get_sum(a, b, i=2):
    s = a + b + i
    print(s)


get_sum(2,4)           #不给默认值参数传参
get_sum(2,4,3)         #给默认值传参
get_sum(a=2,i=3,b=4)   #不按顺序传参

 输出结果为：

8
9
9

2.4可变参数

上面我们说到了给函数传参，传参的时候参数个数是固定的，但是有时候我们不知道他会传多少个参数，那么这时候我们应该怎么办呢？

那么这时候就需要可变参数来解决这个问题。

*args和**kwargs

*args（封包为元组传入）

格式：

def get_sum(*args):   

       print(args)

（ *)后面的字符是可以自定义的。

在调用时函数的括号里就可以输入多个参数。

例如：

def get_sum(*args):  
    number = 0
    for arg in args:
        number += arg
    print(number)


get_sum(1, 2, 3, 4, 5)

输出结果为：

15

 其实可变参数的传值方式是把传的数放入一个元组里面（装包）然后传给函数。

def get_sum(*args):  

    print(args)


get_sum(1, 2, 3, 4, 5)

 这里可以看到我们传入了1，2，3，4，5，五个参数，那么传入的是什么呢？

运行程序得到的结果是：

(1, 2, 3, 4, 5)

**kwargs（封包为字典传入）

这个是用来传递不定长的键对值的参数的。

例如：

def show_book(**kwargs):
    print(kwargs)


show_book(name="as",num='a')

在函数调用的时候必须传递关键字参数，才可以将其转化成key:value,装入字典中。

运行结果为：

{'name': 'as', 'num': 'a'}

 3.函数的返回值

参数：外界向里面传值 。

返回值: 里面的内容向外界传送。

格式：

def 函数名(参数，.....):
    ...
    ...
    return xxxx

当函数调用时通过return向外反出值

注意：只要函数有返回值，则需要接收， return 后面的值可以是一个，也可以是多个值。

如果是多个值 类似：return z,x,c

会将多个数封装到一个元组中，将元组作为整体返回

结果：（z,x,c）

例如：

def get_sum(*args):  
    number = 0
    for arg in args:
        number += arg
    return number， args


s = get_sum(1, 2, 3)
print(s)

输出结果为：

(6, (1, 2, 3))

4.全局变量和局部变量

全局变量：声明在函数外面的称作全局变量。

局部变量：声明在函数里面的变量，称作局部变量。

注意：局部变量的作用范围仅限函数內部。

函数內部可以直接使用全局变量，但是不能直接修改全局变量。

例如：

i = 1  # 全局变量


def test1():
    a = 0  # 局部变量
    a = a + i
    print('a=', a)

test1()

输出结果为：

a= 1

 上面的框说明在函数内部不能修改全局变量，下面的框说明在函数外面不能使用函数内的局部变量。

 如果加入图中那两行代码，则会报错

 如果在函数内部想修改全局变量的值，则需要使用关键字global 变量名

i = 1  # 全局变量


def test1():
    global i
    a = 0  # 局部变量
    a = a + i
    i = a + 1
    print('a=', a)


test1()
print(i)

输出结果为：

a= 1
2

 global 关键字的添加

只有不可变的数据类型才需要添加global ，可变的数据类型不需要添加global。

5.可变数据类型与不可变数据类型

不可变数据类型：当改变变量的值时，地址发生了改变。

例如：int str float bool tuple

可变数据类型：里面的内容发生了改变，但是地址没有发生改变。

例如：list dict set

如列表不需要添加关键字global,在函数里面也可以修改函数外变量的值，例如：

list1 = ['牛奶', '面包', '火腿肠', '辣条']


def test1():
    list1.append('米饭')
    

test1()
print(list1)

运行结果为：

['牛奶', '面包', '火腿肠', '辣条', '米饭']

 6.函数的注释

函数的注释可以分为两种，一种是基本注释，另一种是高级注释。

函数的注释：

def 函数名（参数1，...）

      基本注释 "注释内容"

      高级注释

       """

         函数的说明

        参数说明：

        :param username: 用户名 

        :param password: 密码

        返回值的说明

        :return

       """

例如：

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    Prints the values to a stream, or to sys.stdout by default.
    
      sep
        string inserted between values, default a space.
      end
        string appended after the last value, default a newline.
      file
        a file-like object (stream); defaults to the current sys.stdout.
      flush
        whether to forcibly flush the stream.
    """
    pass

7.闭包

要满足以下条件：
1.嵌套函数

2.内部函数引用了外部函数的变量

3.返回值是内部函数

locals（）可以查看函数中的局部变量，以字典的形式返回

 例如：

def outer(n):
    a = 10

    def inner():
        nonlocal a  # 修改前使用nonlocal关键字对变量进行说明
        b = a + n
        a = 100
        print('内部函数：', b)
    return inner


r = outer(5)
print(r)

r()

 如果在一个内部函数里，对在外作用域（但部署全局作用域）的变量进行引用，那么內部函数就被认为是闭包

闭包里默认不能修改外部变量 ，但是可以使用nonlocal关键字修改

 8.匿名函数

lambda关键字创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句。

匿名函数定义格式：

lambda 参数列表：运算表达式

 例如：

sums = lambda arg1, arg2: arg1 + arg2
# 调用 sums函数
print('两数和为', sums(10, 20))

执行结果为：

两数和为 30

9.递归函数

如果一个函数在内部不调用其他的函数，而是自己本身的话，这个函数就是递归函数。

写递归使要遵循的原则：

1.必须要有出口

2.每次递归向出口靠近

用递归打印1-10之间的数字

def test(i):
    if i == 10:
        print('10')
    else:
        print(i)
        i+=1
        test(i)
test(1)

输出结果为：

1
2
3
4
5
6
7
8
9
10