1、函数的创建与调用

函数出了python中的内置函数外，我们也也可以根据需求，自己创建函数
创建函数语法格式

def functionname([parameterlist])
    ['''comments''']
    [functionbody]

调用函数语法格式

functionname([parameterlist])

小技巧：
在调用函数时，如果指定了“comment(注释)”参数，那么在调用函数时，输入函数名及其左侧小括号时，就会显示该函数的帮助信息（注释的内容）

例子：

def filterchar(string):
    '''
    功能：过滤危险字符，并将过滤后的结果输出
    about:要过滤的字符串
    没有返回值
    '''
    import re
    pattern = r'(黑客)|(抓包)|(监听)|(trojan)'
    sub = re.sub(pattern, "@_@", string)
    print(sub)
filterchar("黑客")

2、参数传递

2.1、形式参数与实际参数（形参与实参）

形式参数（形参）：在定义函数时，函数名后括号内的参数为形参
实际参数（实参）：在调用一个函数时，函数名后括号内的参数为实参，也就是调用函数时，我们给函数传入的参数。

根据实践参数类型的不同，可以分为值传递和应用传递。当实际参数为不可变对象时，就是值传递：当实际参数为可变对象时就是引用传递。

例子：
定义函数
def demo(obj):
print(“元值：”, obj)
obj += obj
调用函数

print("========值传递========")
mot = "唯有在被追赶的时候，你才能真正的奔跑。"
print("函数调用前：", mot)
demo(mot)   # 采用不可变量字符串
print("函数调用后：", mot)
print("========引用传递========")
list1 = ['apple', 'banana', 'orange', 'pear']
print("函数调用前：", list1)
demo(list1)   # 采用可对象列表
print("函数调用后：", list1)

输出

========值传递========
函数调用前： 唯有在被追赶的时候，你才能真正的奔跑。
元值： 唯有在被追赶的时候，你才能真正的奔跑。
函数调用后： 唯有在被追赶的时候，你才能真正的奔跑。
========引用传递========
函数调用前： ['apple', 'banana', 'orange', 'pear']
元值： ['apple', 'banana', 'orange', 'pear']
函数调用后： ['apple', 'banana', 'orange', 'pear', 'apple', 'banana', 'orange', 'pear']

可以看出，值传递改变形参的值，但是不改变实参的值。
引用传递改变形参的值，同时也改变实参的值。

2.2、位置参数

位置参数也称必备参数，必须按照正确的顺序传入函数中

1、数量必须与定义时的一样

在调用函数时，指定的实际参数的数量必须与形式参数一样一样，否则会抛出TypeError异常，提示缺少的位置参数

2、位置必须与定义时的一致

不一致会产生下面2种异常
（1）、抛出TypeErro异常
该种异常主要是实参与形参类型不一致，且在函数中，2种类型无法转换
（2）、产生的结果与预期的不符
就是位置错了，但是他们的类型一致，比如身高和体重的参数位置反了。
这其实是一种bug

2.3、关键字参数

关键字参数是指使用形参的名字来确定输入的参数值，使用该方法，实参的位置不需要一致。
如调用fun_bmi(persion,height,weight)函数，可以通过关键字参数

fun_mbi(height = 1.58, persion = 'john', weight = '50')

2.4、为参数设置默认值

语法格式：

def functionname(…，[parameter1 = defaultvaluel]):
    [functionbody]

查看函数的默认值参数的语法

函数名.__defaults__

使用可以变量作为参数的默认值时，多次调用，可能会产生意料之外的结果。
为了防止这种情况的产生，我们可以使用None作为可变对象的默认值，还要加上检验代码。

在定义函数时，为形式参数设置默认值时，默认参数必须指向不可变对象

2.5、可变参数

可变参数也称不定长参数。即传入函数的参数可以是0个，1个，2个等等。
主要有*parameter和**parameter 2种形式

1、*parameter
这种形式表示接收任意多个实际参数并将其放入一个元组中。
如

def printfruit(*fruitname):
    print('\n我喜欢的水果有：')
    for i in fruitname:
        print(i)   # 输出水果名称

printfruit('apple')
printfruit('apple', 'banana', 'pear')

输出

我喜欢的水果有：
apple

我喜欢的水果有：
apple
banana
pear

如果想要用一个已经存在的列表作为函数的可变参数，可以在列表名称前加个’*‘。
如

a = ['apple', 'banana', 'pear']
printfruit(*a)

2、**parameter
这种形式表示可以接收任意多个类似关键字一样的显示赋值的实际参数
如

def printsign(**sign):
    print()
    for key, value in sign.items():    # 遍历字典
        print(key + "的星座是：" + value)
printsign(a='水瓶')
printsign(a='水瓶', b='狮子')

输出

a的星座是：水瓶

a的星座是：水瓶
b的星座是：狮子

如果想要用一个已经存在的字典作为函数的可变参数，可以在字典名称前加个’**‘。

3、返回值

在python中无论return语句在什么位置，只有得到执行，就会直接结束函数的执行
语法格式：

result =return [value]

说明
value为一个可选参数，用于指定要返回的值（可以是一个值，也可以是多个值，值可以是任意类型）

当函数中没有return语句，，或者省略return语句的参数时，将返回None(空值)

4、变量的作用域

4.1、局部变量

局部变量就是在函数内部定义并使用的变量。（在函数外部使用会抛出NameError异常）

4.2、全部变量

1、在函数外部定义
值得注意的事，当全局变量与局部变量重名时，对函数体内的变量进行赋值后，不影响函数体外的变量。

2、在函数内定义
在函数体内定义全局变量，需要使用global关键字
语法格式

global 变量

5、匿名函数

匿名函数就是没有名字的函数，一般只使用一次。使用lambda关键字
语法格式

result = lambda [arg1 [,arg2,...,argn]]：expression

参数说明：
result：用于调用lambda表达式
[arg1 [,arg2,…,argn]]：可选参数，用于指定的要传递的参数列表
expression: 必选参数，用于指定一个实现具体功能的表达式。

注意：使用lambda关键字只能有一个返回值和出现其他非表达式语句（如for或while）
如：

import math
r = 10
result = lambda r: math.pi*r*r
print("半径为", r, "的圆的面积为", result(r))

lambda的首页用途是指定短小的回调函数。

6、牛刀小试

6.1、输出第几天

请编写一个程序，实现输入任意的年月日就可以计算出是这一年的第几天，如输入20190203，就可以输出这是2019年的第34天。

def data(y, m, d):
    if m <= 2:
        return "这是"+str(y)+"年的第"+str((m-1)*31+d)+"天"
    elif m in (3, 5, 7, 9, 10, 11, 12):
        return "这是" + str(y) + "年的第" + str((m - 1) * 31 + d - m//2 - 1 + y % 4 - 1) + "天"
    elif m in (4, 6, 8):
        return "这是" + str(y) + "年的第" + str((m - 1) * 31 + d - m//2 - 1 + y % 4) + "天"

if name == ‘main‘:
a = data(2017, 1, 1)
print(a)

6.2、找出重复IP

下面list 中提供了几组IP地址，编写一个函数，将list中重复出现的IP地址找出来。
list=[‘192.168.1.1’,’10.192.66.72’,’10.199.88.132’, ‘192.168.1.1’,’1.192.168.163’]

def main():
    a=['192.168.1.1','10.192.66.72','10.199.88.132', '192.168.1.1','192.168.163']
    b=[]
    c=[]
    for i in range (0,len(a)):
        if a[i] not in b:
            b.append(a[i])
        else:
            c.append(a[i])

    print (c)
if __name__ == '__main__':
    main()

6.3、大写模式

编写-一个函数，把输入的字母统一成大写模式，如输入“go big or go home”,输出为“60BIG OR G0 HOME”。

def demo(a):
    a = a.upper()
    return a
if __name__ == '__main__':
    b = demo('go big or go home')
    print(b)