首页 > 代码库 > python 函数

python 函数

函数的定义

函数最重要的目的是方便我们重复使用相同的一段程序。

将一些操作隶属于一个函数,以后你想实现相同的操作的时候,只用调用函数名就可以,而不需要重复敲所有的语句。

 

创建函数

def 函数名 (参数列表) 
函数体

例如: 

def sum1(a,b): 
c = a + b 
return c 
e=1 
f=2 
print (sum1(e,f))

首先def 是定义函数名 sum1是函数名 
括号中的a, b是函数的参数,是对函数的输入。参数可以有多个,也可以完全没有(但括号要保留)。 
c = a + b 函数体的内部运算 
return c # 返回c的值,也就是输出的功能。Python的函数允许不返回值,也就是不用return。 
print (sum1(e,f)) 调用函数并进行打印

 

形参和实参

形参:虚拟变量,在定义函数和函数体的时候使用形参。目的是在函数调用时接收实参,实参个数、类型要与形参一一对应。 
实参:调用函数时传给函数的参数。可以是常量、变量、表达式、函数。

def print_twice(bruce): 
print bruce 
print bruce #python 函数返回值可以用return 
这个函数的作用是:在调用的时候会把实参的值,给形参bruce,并将其输出2次。

 

默认参数

定义函数时,设定默认参数。当调用函数时,缺省参数如果没有值传入,则使用默认参数设定的值。

def a(x = []):
    print(id(x))
    x.append(1)
    print(x)
    print(id(x))
b=[1,2,3]
a(b)
2157718614216
[1, 2, 3, 1]
2157718614216

不定长参数

def it(*args):
    print(args,type(args))
b={a:1,b:[1,2,3]}
it(b)
({a: 1, b: [1,2,3]},) <class tuple>

两个**动态参数

def it(**kargs):
    print(kargs,type(kargs))
b={a:1,b:[1,2,3]}
it(c=b,d=b)
{c: {a: 1, b: [1,2,3]}, d: {a: 1, b: [1,2,3]}} <class dict>

一个的动态参数会将输入转换成元组 
两个*
的动态参数会将输入转换成字典,传参的时候要‘k‘:‘v‘的方式传输。

注意区别

def show(*arg,**xukq):
    print(arg,type(arg))
    print(xukq,type(xukq))
l = [1,2,3]
d = {a:333,b:iteemo}
show(*l,d)
输出:
(1, 2, 3, {a: 333, b: iteemo}) <class tuple>
{} <class dict>
def show(*arg,**xukq):
    print(arg,type(arg))
    print(xukq,type(xukq))
l = [1,2,3]
d = {a:333,b:iteemo}
show(l,d)
输出:
(1, 2, 3, {a: 333, b: iteemo}) <class tuple>
{} <class dict>
def show(*arg,**xukq):
    print(arg,type(arg))
    print(xukq,type(xukq))
l = [1,2,3]
d = {a:333,b:iteemo}
show(*l,**d)
输出:
(1, 2, 3) <class tuple>
{a: 333, b: iteemo} <class dict>

return

return的作用:

(1)结束函数

(2)返回某个对象

注意点:

如果不加return,默认返回None。

如果return有个对象,那么会将多个对象封装成一个元组。

遇到return语句,就会停止执行并返回结果。

 

局部变量

你在函数定义中声明的变量,他们与在函数外使用的其它同名变量没有任何关系,即变量名称对函数来说是局部的。这叫变量的范围。所有变量都有它们被声明的块的范围,从名称定义的点开始。

x = 50
def func(x):
    print(x等于, x)
    x = 2
    print(局部变量x改变为, x)
func(x)
print(x一直是, x)
x等于 50
局部变量x改变为 2
x一直是 50

global 声明全局变量

x = 50
def func():
    global x
    print(x的值是, x)
    x = 2
    print(全局变量x改为, x)
func()
print(x的值是, x)
x的值是 50
全局变量x改为 2
x的值是 2

内置函数

 

lambda

lambda作为一个表达式,定义了一个匿名函数例子:

def funb(a):
    b = a + 1
    return b
c = funb(4)
print(c)
func = lambda a:a+1
ret =func(99)
print(ret)
5
100

map函数

它接收一个函数和一个 list,并通过把函数依次作用在 list 的每个元素上,得到一个新的 list 并返回。

>>> li = [1,2,3,4]
>>> new_li = map(lambda x:x*10,li)
>>> print(new_li)
[10, 20, 30, 40]
>>> li = [1,2,3,4]
>>> def funa(x):
...     return x*10
... 
>>> new_li2 = map(funa,li)
>>> print(new_li2)
[10, 20, 30, 40]

filter

和map()类似,filter()也接收一个函数和一个list。和map()不同的时,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。

>>> li = [1,2,3,4]
>>> def funb(x):        
...     if x > 2:       
...             return True
...     else:
...             return False
... 
>>> new_li = filter(funb,li)
>>> print(new_li)          
[3, 4]

 

python 函数