006-Python函数

时间：2023-03-09 18:45:18
006-Python函数

Python函数(def)

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。函数能提高应用的模块性，和代码的重复利用率。

定义函数规则

  1. 函数代码块以def关键字开头，后接函数标识符名称和圆括号().
  2. 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
  3. 函数的第一行语句可以选择性的使用文档字符串，用于对函数说明。
  4. 函数内容以冒号起始，并且缩进。
  5. return【表达式】结束函数，选择性的返回一个值给调用方，不带表达式的return相当于返回 None。

变量

局部变量：作用域只在当前函数内部，外部变量默认不能被函数内部修改，只能引用；函数内部是可以修改列表，集合，实例（类）

全局变量：可以全局使用，函数内部也可以调用

  1. 函数内部修改列表，集合，实例
names = ["alex", "jack"]

info = {"name": "jack"}

def change():

    print(names, info)

    names[0] = "Mack"

    names.append("rain")

    info["age"] = 22

change()

print(names, info)

输出内容：

['alex', 'jack'] {'name': 'jack'}

['Mack', 'jack', 'rain'] {'age': 22, 'name': 'jack'}

2.局部变量修改全局变量，使用global（默认不建议修改）

n = "a"

def change():

    # global n

    n = "nihao"

    print(n)        ## 函数内部的n

change()

print(n)            ## 全局n

输出内容：

nihao            ## 函数内部的n

a                ## 全局的n

3.如果特定需要使用函数修改全局变量可以使用global（不建议修改全局变量)

n = "a"

def change():

    global n

    n = "nihao"

    print(n)

change()

print(n)

输出内容：

nihao            ## 函数内部的n

nihao            ## 全局被修改的n

语法：

Python定义函数使用def关键字，一般格式如下：

def 函数名(参数列表):

    函数体

函数名()

函数调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数和代码块结构，这个函数基本结构完成后，就可以通过另一个函数调用执行，也可以直接从Python命令提示符执行。

2参数

  1. 必须参数（按顺序，又叫位置参数）
  2. 关键字参数（必须放在位置参数后面）
  3. 默认参数 （必须放在位置参数后面）
  4. 不定长参数（*args等同于元组，依照位置参数形式传入；**kwargs等同于字典，依照于关键参数形式传入）

参数分为：实参和形参

实参：有确定值的参数，所有的数据类型都可以被当做参数传递给函数。

形参：只有在被调用时才会分配内存，调用结束后，立即释放内存；值仅在函数内部有效（局部变量，形参的作用域只在当前函数内部有效）

006-Python函数

必须参数：

必须参数须以正确的顺序传入函数，调用时的数量必须和声明时一样；否则出现语法错误；

def printhehe(hehe):      ##hehe就是必须参数"你好"就是hehe的值

    '''

    :param hehe:打印输入内容

    :return:none

    '''

    print(hehe)

printhehe("你好")

输出内容：

你好

关键字参数：

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值，使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。

def name_info(name, age):

    '''

    :param name:

    :param age:

    :return:

    '''

    print("名字：", name)

    print("年龄：", age)

    return

name_info(age=28, name="lin")

输出内容：

名字: lin

年龄: 28

默认参数（默认参数需要放在顺序参数后面）：

调用函数时，如果没有传递参数，则会使用默认参数；常见默认性别，默认国籍等值；

def name_info(name, age, sex="man"):

    '''

    :param name:打印任何传入的字符串

    :param age:

    :param sex:

    :return:

    '''

    print("名字：", name)

    print("年龄：", age)

    print("性别：", sex)

name_info("baolin", "28", "girl")

print("==============================")

name_info("baolin", "28")        ## 默认不输入sex性别时，会使用默认值“man”

输出内容：

名字： baolin

年龄： 28

性别： girl

==============================

名字： baolin

年龄： 28

性别： man

不定长参数：

在一些情况下，一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数；不定长参数声明时不会命名；

def stu_info(name, age, course, country="CN", hobbie="girl"):

    print("----------注册信息----------")

    print("姓名：", name)

    print("年龄：", age)

    print("国际：", country)

    print("课程：", course)

    print("爱好：", hobbie)

stu_info(course="linux", age=22, name="lin", hobbie="man")

默认输出如下：

----------注册信息----------

姓名： lin

年龄： 22

国际： CN

课程： linux

爱好： man

不定长参数有*args(元组) 和 **kwargs（字典）

def stu_info(name, age, course, country, hobbie, *args, **kwargs):

    print("----------注册信息----------")

    print("姓名：", name)

    print("年龄：", age)

    print("国际：", country)

    print("课程：", course)

    print("爱好：", hobbie)

    print("多余元组：", args)    # args依照元组的形式输出

    print("多余字典：", kwargs)  # kwargs依照字典的形式输出

    print(type(args))

    print(type(kwargs))

    print("住址：", kwargs["addr"])    # 对字典进行调用

stu_info("lin", 22, "linux", "CN", "girl", "IT", "钱", id="stu0011", addr="回龙观")

输出如下：

----------注册信息----------

姓名： lin

年龄： 22

国际： CN

课程： linux

爱好： girl

多余元组： ('IT', '钱', '人民币')

多余字典： {'id': 'stu0011', 'addr': '回龙观'}

住址： 回龙观                # 调用输出"住址"

<class 'tuple'>

<class 'dict'>

return语句（返回函数的执行结果，同时也代表函数的结束）：

return【表达式】语句用于退出函数，选择性的向调用方返回一个表达式，不带参数值的return语句返回None；

def calc(a, b):

    return a**b

c = calc(10, 15)

print(c)

输出内容：

1000000000000000

递归函数（函数在内部调用自身本身，最多调用998次）：

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

例：使用递归函数实现二分算法，查找需要的数值是否在列表中；

data = range(100)

def efen(RanGeZhi, ChaZhi):

    if len(RanGeZhi) > 0:

        ZhongJian = int(len(RanGeZhi)/2)

        if RanGeZhi[ZhongJian] == ChaZhi:

            print("你要找的值为%s" % ChaZhi)

        elif RanGeZhi[ZhongJian] > ChaZhi:

            print("你要查找的值在左边", RanGeZhi[0:ZhongJian])

            efen(RanGeZhi[0:ZhongJian], ChaZhi)

        else:

            print("你要查找的值在右边", RanGeZhi[ZhongJian+1:])

            efen(RanGeZhi[ZhongJian+1:], ChaZhi)

    else:

        print("你要的值未找到")

efen(data, 10)

map是将“,”后面列表值，交给“,”前面的函数运算,并返回结果；

map()是 Python 内置的高阶函数，它接收一个函数 a 和一个 list，并通过把函数 a 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

例：使用map将['adam', 'LIN', 'BaO']转换为['Adam', 'Lin', 'Bao']

def format_name(s):

    s1 = s[0:1].upper()+s[1:].lower()

    return s1

for i in map(format_name, ['adam', 'LIN', 'BaO']):

    print(i)

输出结果：

Adam

Lin

Bao

匿名函数（lambda）

当我们在传入函数时，有些时候，不需要显式定义函数，直接传入匿名函数更方便。匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果；（lambda匿名函数最复杂的运算就是三元运算）

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

例1：关键字lambda表示匿名函数，冒号前面的"n"表示函数参数。

正常函数：

def a(n):

    return n**n

print(a(10))

匿名函数：

b = lambda n: n**n

print(b(10))

例2：将可循环的值分别取到"x"中运算并打印出来

for i in map(lambda x: x + 1, [1, 2, 3]):

    print(i)

输出结果：

2

3

4

例2：lambda使用三元运算（如果x大于5输出x*x,否则输出x）

lambda方法：

for i in map(lambda x: x*x if x > 5 else x, [1, 2, 3, 4, 5, 6, 7, 8]):

    print(i)

输出结果：

1

2

3

4

5

36

49

64

三元运算：

知识点插入：

# 普通运行

a = 4

b = 5

if a > 10:

    c = a

else:

    c = b

print(c)

# 三元运算

d = a if a > 10 else b

print(d)

输出结果：

5

5

高阶函数

  1. 把一个函数的内存地址，当做参数传给另外一个函数；
  2. 一个函数把另外一个函数，当做返回值返回。

    例：将内置函数"abs"当成参数传给函数“add”
def add(x, y, z):

    return z(x) + z(y)

print(add(3, -6, abs))

输出内容：

9

相关文章