函数

编程序语言中函数定义：函数是逻辑结构化和过程化的一种编程方法

 def func(i): 　　　　　　 # def :定义函数的关键字；func：函数名；()内可以定义形参

  　　i += 1 　　　　　　   # 代码块或程序处理逻辑

 　　 return i 　　　　    # 定义返回值

 f = func(10) 　　　　    # 函数调用，传参 传了一个10

 print(f) 　　　　　　     # 返回结果就是 10 += 1 也就是11

1.1 有返回值和无返回值

 def test1():

 　　print("in test1")

 def test2():

 　　print("in test2")

 　　return 1

 print(test1())

 print(test2())

结果

in test1
None
in test2
1

1.2 函数的参数

返回值：函数执行的结果

 def test1():

 　　return 0

 def test2():

 　　return 1,'hello',[1,2,3,4,5]

 print("test1:",test1())

 print("test2:",test2())

结果

test1: 0
test2: (1, 'hello', [1, 2, 3, 4, 5])

1.3 位置参数

 def test(x,y,z):

 　　print(x)

 　　print(y)

 　　print(z)

 test("hostname","port","IP")          #默认按顺序 ，也可以指定：test("hostname",z="port",y="IP")

结果

hostname
port
IP

1.4 默认参数

 def test(x,y=2):

 　　print(x)

 　　print(y)

 test(1)     #默认参数调用的时候，非必需传递，如果指定传递，按照指定的参数>默认参数优先级

结果

1.5 参数组

 def test(*x):

 　　print(x)

 test("bj","sh")

 test(*["bj","sh"])           #结果都是返回元组

('bj', 'sh')
('bj', 'sh')

1.6 动态参数*args 和**kwargs

*args 可以传各种类型：列表，字典，元组，集合，字符串，数字等

 def test(*args):

 　　print(args)

 test("","w","s","y")

 test(1,2,3,4,5,6)

 test(["name","age","sex"])

 test(("name",))

 test({"name":"boy","age":10})

结果

('1', 'w', 's', 'y')
(1, 2, 3, 4, 5, 6)
(['name', 'age', 'sex'],)
(('name',),)
({'name': 'boy', 'age': 10},)

**kwargs 传指定最后输出字典

 def test1(**kwargs):

 　　print(kwargs)

 test1(name="kk",age=18,sex="man") #传出来结果为字典

结果

{'name': 'kk', 'age': 18, 'sex': 'man'}

1.7 全局变量与局部变量

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时

在定义局部变量的子程序内，局部变量起作用，在其他地方全局变量起作用

global #定义新的全局变量

 home = "bj"

 name = "wang"

 def my_home(name):

 　　global home

 　　home = "hebei"

 　　name = "wsy"

 　　print("in func:",name,home)

 print(name)

 my_home(name)

 print(home)

1.8 递归

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

递归的特性：

　　1.必须有一个明确的结束条件

　　2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少

　　3.递归效率不高，递归层次过多导致栈溢出（在计算机中，函数调用是通过栈这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减少一层栈帧。由于栈的大小不是无限的，所有，递归调用次数过多，会导致栈溢出）

 递归实例：

 def num(x):

     print(x)

     y = int(x/2)

     if y > 0:

         return num(y)

     print("END:",x)

 num(20)

输出结果

20
10
5
2
1
END: 1

1.9 高阶函数和匿名函数

高阶函数

高阶函数的定义：一个函数接收另一个函数作为参数

 def add(a,b,c):

     return c(a) + c(b)

 res = add(6,-8,abs)     #abs 绝对值

 print(res)

结果为14

匿名函数

匿名函数：也叫lambda表达式

匿名函数的核心：一些简单的需要用函数去解决的问题，匿名函数的函数体只有一行
参数可以有多个，用逗号隔开
返回值和正常的函数一样可以是任意的数据类型

计算两个数字之和
a = lambda x,y:x+y     #x,y 为传入的两个参数

print(a(1,3))

a = lambda x,y,z,a:x+y+z+a    #可以定义多个参数

print(a(1,3,4,6))

将一个字典的key和value对调

dic = {'name': "wsy", 'Age': 20}

res = {dic[i]:i for i in dic}

dic = res

print(dic)

结果

{'wsy': 'name', 20: 'Age'}

2.0 闭包

闭包：

内部的函数

包含了对外部函数作用域中变量的引用

def test():

    name = "wsy"

    def index():

        print("func is index" ,name)

    return index()

test()

结果：

func is index wsy

判断闭包函数的方法：__closure__

def test():

    name = "wsy"

    def index():

        print("func is index" ,name)

    print(index.__closure__) #判断函数是否为闭包

    return index()

test()

结果：

(<cell at 0x000000000203DE88: str object at 0x00000000020AFF80>,)