python笔记05-----函数

函数

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

1 def func(i): 　　　　　　 # def :定义函数的关键字；func：函数名；()内可以定义形参
2  　　i += 1 　　　　　　   # 代码块或程序处理逻辑
3 　　 return i 　　　　    # 定义返回值
4 
5 f = func(10) 　　　　    # 函数调用，传参 传了一个10
6 print(f) 　　　　　　     # 返回结果就是 10 += 1 也就是11

1.1 有返回值和无返回值

1 def test1():
2 　　print("in test1")
3 
4 def test2():
5 　　print("in test2")
6 　　return 1
7 
8 print(test1())
9 print(test2())

结果

in test1
None
in test2
1

1.2 函数的参数

返回值：函数执行的结果

1 def test1():
2 　　return 0
3 
4 def test2():
5 　　return 1,'hello',[1,2,3,4,5]
6 
7 print("test1:",test1())
8 print("test2:",test2())

结果

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

1.3 位置参数

1 def test(x,y,z):
2 　　print(x)
3 　　print(y)
4 　　print(z)
5 
6 test("hostname","port","IP")          #默认按顺序 ，也可以指定：test("hostname",z="port",y="IP")

结果

hostname
port
IP

1.4 默认参数

1 def test(x,y=2):
2 　　print(x)
3 　　print(y)
4 
5 test(1)     #默认参数调用的时候，非必需传递，如果指定传递，按照指定的参数>默认参数优先级

结果

1.5 参数组

1 def test(*x):
2 　　print(x)
3 
4 test("bj","sh")
5 test(*["bj","sh"])           #结果都是返回元组

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

1.6 动态参数*args 和**kwargs

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

 1 def test(*args):
 2 　　print(args)
 3 
 4 
 5 test("1","w","s","y")
 6 test(1,2,3,4,5,6)
 7 test(["name","age","sex"])
 8 test(("name",))
 9 
10 test({"name":"boy","age":10})

结果

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

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

1 def test1(**kwargs):
2 　　print(kwargs)
3 
4 test1(name="kk",age=18,sex="man") #传出来结果为字典

结果

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

1.7 全局变量与局部变量

全局与局部变量

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

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

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

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

global #定义新的全局变量

 1 home = "bj"
 2 name = "wang"
 3 
 4 def my_home(name):
 5 　　global home
 6 　　home = "hebei"
 7 　　name = "wsy"
 8 　　print("in func:",name,home)
 9 print(name)
10 my_home(name)
11 print(home)

1.8 递归

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

递归的特性：

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

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

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

1 递归实例：
2 def num(x):
3     print(x)
4     y = int(x/2)
5     if y > 0:
6         return num(y)
7     print("END:",x)
8 
9 num(20)

输出结果

20
10
5
2
1
END: 1

1.9 高阶函数和匿名函数

高阶函数

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

1 def add(a,b,c):
2     return c(a) + c(b)
3 
4 res = add(6,-8,abs)     #abs 绝对值
5 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>,)