（转）python之函数介绍及使用

为什么要用函数？

　　1、减少代码量

　　2、保持一致性

　　3、易维护

一、函数的定义和使用

?

1 2 3 4 5 6

def test(参数):              ...     函数体     ...     return 返回值

函数的定义：

　　　　def：表示函数的关键字

　　　　函数名：以后可以根据函数名调用函数，test可以作函数名

　　　　函数体：中间可以做一系列的运算

　　　　参数：为函数提供数据

　　　　返回值（return）：当函数执行完毕后，可以给调用者返回数据。 多个返回元组形式，单个为原形式

 def test(x):       # x代表形参
     '''
     2*x+1
     :param x:整形数字
     :return:返回计算结果
     '''
     y = 2*x+1
     return y
 print(test)     # 打印test的内存地址
 p = test(3)     # test()表示运行，函数名加小括号，要重新赋值变量
 print(p)        

　　　　形参和实参

　　　　　　形参不占用内存空间，调用时才会占用内存，在调用结束后，才会被释放。实参是给实参进行赋值

 def test(x):       # x代表形参
     '''
     2*x+1
     :param x:整形数字
     :return:返回计算结果
     '''
     y = 2*x+1
     return y
 p = test(3)     # test()表示运行名为test函数，3代表实参，给x进行赋值
 print(p)

　　　　位置参数：位置要一一对应，不能缺也不能多且不能给同一个形参赋予多个值（会报错）

　　　　关键字参数：位置无需固定，但是缺一不行多一也不行　　

　　　　　 位置参数必须在关键字参数的左边

 def test(x,y,z):#x=1,y=2,z=3
     print(x)
     print(y)
     print(z)

 # 位置参数，必须一一对应，缺一不行多一也不行
 test(1,2,3)

 # 关键字参数，无须一一对应，缺一不行多一也不行
 test(y=1,x=3,z=4)

 # 位置参数必须在关键字参数左边
 test(1,y=2,3)#报错
 test(1,3,y=2)#报错
 test(1,3,z=2)
 test(1,3,z=2,y=4)#报错
 test(z=2,1,3)#报错

 位置参数和关键字参数一起也不能给同一参数赋多个值(会报错)
 不能缺也不能多

　　　　默认参数　　如果之前给了一个值一个参数，再赋予这个值一个参数，则这个值原有的参数会被覆盖掉

def handle(x, type='mysql'):
    print(x)
    print(type)

handle('hello')                # 调用handle函数，x赋值为hello，type有了默认参数

handle('hello', type='sqlite') # x赋值，type用关键字重新赋值   

handle('hello', 'sqlite')      # 用位置一一对应关系赋值，覆盖type原来的值



结果

hello

mysql                   

hello

sqlite

hello

sqlite    

　　　　参数组（*args列表，**kwargs字典） 非固定长度参数　　*args是以元祖的形式表达

def test(x, *args):
    print(x)
    print(args)

test(1)　　　　　　　　　　　　　　　　 # 只传入x的值，args默认为空，元组形式

test(1, 2, 3, 4, 5)　　　　　　　　   # 传入x的值后，位置关系对应后，2 3 4 5对应args以元组形式表达

test(1, {"name": "alex"})　　　　　  # 传入x的值后，有一个字典，整体传入

test(1, ["x", "y", "z"])　　　　　　 # 传入x的值后，有一个列表，整体传入

test(1,["x","y","z"])　　　　　　　  # 传入x的值后，列表前面加了个，则表示遍历，逐一出现表达

test(1,*("x","y","z"))　　　　　　　　# 同上，注意表现形式

结果

1　　　　　　　　　　　　
()　　　　　　　　　　　　　　
1
(2, 3, 4, 5)
1
({'name': 'alex'},)
1
(['x', 'y', 'z'],)
1
('x', 'y', 'z')
1
('x', 'y', 'z')

　　　　**kwargs

def test(x, **kwargs):
    print(x)
    print(kwargs)       以字典的形式表达

test(1, y=2, z=3)     #y，z为key 后面均为值

test(1,y=2,z=3,z=4)   #会报错：一个参数不能传俩个值



结果

1

{'y': 2, 'z': 3}     

　　　　*args，**kwargs同时存在，扩展性

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs.get('y'))
# test(1,1,2,1,1,11,1,x=1,y=2,z=3)   #报错，x传了多个值
test(1, 1, 2, 1, 1, 11, 1, y=2, z=3) #1传给x，中间位置参数给*args，关键字参数给**kwargs
test(1,*[1,2,3],**{'y':1})           #1传给x，*[1,2,3]传给*args遍历传，**{'y':1}传给**kwargs

结果
1
(1, 2, 1, 1, 11, 1) 1
{'y': 2, 'z': 3} 2
1
(1, 2, 3) 3
{'y': 1} 1

　　　　全局变量(大写)

　　　　定义：没有缩进的变量

　　　　局部变量(小写)

　　　　定义：子程序下定义的变量

name = 'lhf'                 # 这里就指全局变量

def change_name():

name = '帅了一比'      # 这里就指局部变量

print('change_name', name)

change_name()

print(name)

结果

change_name 帅了一比

lhf

　　　　 global声明是全局变量，nolocal指定上一级变量

　　　　　　如果函数的内容无global关键字

　　　　　　- 有声明局部变量

NAME = ["产品经理","廖波湿"]
def qupengfei():
    NAME = "自己"
    print('我要搞', NAME)
qupengfei()

结果

我要搞 自己

　　　　　　- 无声明局部变量

 NAME = ["产品经理","廖波湿"]
 def qupengfei():
     NAME.append('XXOO')
     print('我要搞', NAME)
 qupengfei()

　　　　　　　　如果函数的内同有global关键字

　　　　　　- 有声明局部变量

NAME = ["产品经理","病毒尖儿"]
def qupengfei():
    global NAME
    NAME = "自己"
print('我要搞', NAME)
qupengfei()
结果
我要搞 ['产品经理', '病毒尖儿']
# 错误示例
NAME = ["产品经理","病毒尖儿"]
def qupengfei():
    NAME = "自己"            # 有局部变量，报错
    global NAME               # 不能在下面
print('我要搞', NAME)
qupengfei()        

NAME = ["产品经理","病毒尖儿"]
def qupengfei():
    global NAME
    NAME = "自己"
print('我要搞', NAME)
qupengfei()
结果
我要搞 ['产品经理', '病毒尖儿']
# 错误示例
NAME = ["产品经理","病毒尖儿"]
def qupengfei():
    NAME = "自己"            # 有局部变量，报错
    global NAME               # 不能在下面
print('我要搞', NAME)
qupengfei()        

　　　　　　- 无声明局部变量

NAME = ["产品经理", "病毒尖儿"]

def qupengfei():

global NAME

NAME = ["三毛"]

NAME.append('XXOO')

print('我要搞', NAME)

qupengfei()

结果

我要搞 ['三毛', 'XXOO']

　　　　　　优先读取局部变量，能读取全局变量，但无法对全局变量重新赋值NAME=“fff”，但是对于可变类型，可以对内部元素进行操作

　　　　　 如果函数中有glabal关键字，变量本质上就是全局的那个变量，可读取可赋值 NAME=“fff”

　　递归函数

　　　　自己调用自己的函数，则为递归

　　　　特性：必须有一个明确的结束条件

　　　　　　　每次进入深一层递归时，问题规模都应有所减少

def calc(n):
    print(n)
    if int(n / 2) == 0:
        return n # 当上面的条件成立后一个真值，返回到函数
    res = calc(int(n / 2))
    print(n,res)
    return res # 返回res的值，要将真值一层一层传递回去

calc(10)                                                

　　　　匿名函数   用lambda去定义

例1：

 def calc(x):
     return x+1
 res=calc(10)
 print(res)          # 输出结果
 print(calc)         # 输出calc这个函数的内存地址
 print(lambda x:x+1)# 输出lambda这个表达式的内存地址
 func = lambda x:x+1# x代表形参，x+1为返回值
 print(func(10))     # 给lambda表达式传入值，输出结果

 """
 结果
 11
 11
 <function <lambda> at 0x000001F6D84897B8>
 11
 """

例2：

name = "alex"
def change_name(x):
    return name+"_sb"
res = change_name(name)
print(res)

func = lambda x:x+"_sb"

res = func(name)

print(res)

　　　　函数式编程

　　　　　　函数接收的参数是一个函数名

　　　　高阶函数

　　　　　　1、把函数当作一个参数传给另一个函数

　　　　　　2、返回值中包含参数

 def bar():
     print('from bar')
 def foo():
     print('from foo')
     return bar
 n = foo()
 n()

返回值中包含函数

转自：

python之函数介绍及使用 - 病毒尖er - 博客园

http://www.cnblogs.com/leguan1314/articles/6116928.html