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等同于字典，依照于关键参数形式传入）

参数分为：实参和形参

实参：有确定值的参数，所有的数据类型都可以被当做参数传递给函数。
形参：只有在被调用时才会分配内存，调用结束后，立即释放内存；值仅在函数内部有效（局部变量，形参的作用域只在当前函数内部有效）

必须参数：

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

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