Function
函数是一段组织好的能够实现特定功能或者逻辑的代码块,函数代码在文件执行时读入内存并不执行,在调用函数时执行,简单来说是把一段代码封装给一个函数名(可以用变量的概念去理解,即把一段代码赋值给一个函数名),当使用函数名加执行标记时才运行这段内存中的代码.函数的作用可以减少重复代码,在不同的地方要使用相同的代码块,我们就可以把这段代码封装成函数.同时当多处相同的代码需要修改时,只需要修改函数定义时一处即可扩展性好.
#定义函数
def func_name(parameters):
name = parameters
print('exec code with %s' %name)
return 'some code'
#函数的调用
func_name('sylar')
a = func_name()
print(a)参数
函数在定义和调用的时候是可以传入参数,在定义时申明的参数称为形参,在函数调用时传入的参数称为实参.一般来说形参只在函数内生效,但是当传入的是list(列表),dict(字典),func(函数)由于这些复杂数据类型传入是对象的内存地址,所以在函数内做了修改,在函数外也会产生响应的修改.因此参数可以分为可变参数和不可变参数.但我们通常在使用中一般将函数的参数使用传入的方式来分类:
- 位置参数
根据定义函数时的形参位置一一对应的传入参数,形参和实参顺序必须一致.
def fun1(name, age, post):
print('My name is %s' % name)
print('At the age of %s' % age)
print('The position is %s' % post)
fun1('sylar',18,'IT')- 关键字参数
使用形参的关键字确定传入实参的值,此时不需要关注参数的顺序
def fun1(name, age, post):
print('My name is %s' % name)
print('At the age of %s' % age)
print('The position is %s' % post)
fun1(name='sylar',post='IT',age=18,)
fun1('tom',post='IT',age=19,)关键字参数和位置参数的方式可以混用,但是记住不能在关键字参数前传入位置参数
#错误的调用
fun1(name='sylar',age=18,'IT')- 默认参数
在定义形参的时候,给参数设置一个默认值.在调用函数时不传入这个参数就使用默认值.
def fun1(name, age, post='IT'):
print('My name is %s' % name)
print('At the age of %s' % age)
print('The position is %s' % post)
fun1(name='sylar',age=18)默认参数也可以和其它参数混搭使用,但是默认参数只能定义在所有参数的尾部.传入参数的时候只需要遵循放在位置参数之后传入
#错误的定义
def fun1(post='IT',name, age):- 不定长参数
在定义一个函数时,会出现我们并不知道我们使用函数时会传入多少个参数的情况,这时候就可以使用不定长参数.使用*args和**kwargs
#*args会将收到的参数组合为一个元组
def fun1(name,age,*args,):
print('My name is %s' % name)
print('At the age of %s' % age)
print(args)
hope_list= ','.join(args)
print('He hopes list is:%s'%hope_list)
fun1('sylar',18,'IT','travel','movie')#kwargs会将传入的参数组合为字典,在函数内调用需要函数内代码去获取字典的key才可以取到对应的值
def fun2(**kwargs):
print(kwargs)
name = kwargs['name']
age = kwargs['age']
print('My name is %s' % name)
print('At the age of %s' % age)
fun2(name='sylar',age=18)局部变量和全局变量
首先需要理解名称空间和作用域,名称空间是指对某段代码进行命名的操作,例如变量名,函数名.全局变量是在整个文件顶部定义,对整个文件都生效.局部变量是相对而论的,我们先来看一个例子(这几个概念,我也不能很好的阐述)
g_var = 'this is global var'
def foo():
l_var = 'in the foo!this is local var'
print(g_var)
print(l_var)
def foo1():
l_var = 'in the other foo !this is local var'
print(g_var)
print(l_var)
foo()
foo1()
print(g_var)
print(l_var)在这个例子中,g_var是在整个代码块中都生效的,那么g_var就是这个代码块的全局变量,而l_var只在函数foo中生效,那么l_var就是foo的局部变量.而在foo1的l_var又是它自己内部定义的局部变量
当局部变量和全局变量同名时,局部变量只在他所属的代码块内生效.并不能影响代码块外的全局变量.同时需要注意的是,局部变量优先.
some_var = 'this is global var'
print(some_var)
def foo():
some_var = 'this is local var'
print(some_var)
foo()
print(some_var)返回值
在函数中使用ruturn语句,让函数返回一个结果给函数外的调用.如果没有定义ruturn,函数会返回一个None.当函数执行了return将会跳出函数,不再继续执行函数中的代码
#没有ruturn的返回值
def foo():
print('welcome')
a = foo()
print(a)#定义return的返回值和return后的代码不会执行
def foo(x,y):
z = x + y
return z
print('welcome')
a = foo(1,2)
print(a)嵌套函数
在函数中嵌套一层函数
def first_func():
print('in the first')
def second_func():
print('in the second')
second_func()
first_func()
second_func() #此时在外面是不能调用嵌套内的函数补充,使用嵌套函数去试试局部变量能更好的理解局部变量的使用
匿名函数
lamba主体通常就是一个表达式,是函数的一个高级用法,在某些特定场景需要使用函数时使用
sum = lambda arg1, arg2: print(arg1 + arg2);
sum(1,2)
def func(arg1,arg2):
print(arg1+arg2)
func(1,2)
列表生成式:
列表生成式表现方式类似于三元运算和匿名函数lambda函数.通过简化代码执行一个教复杂的运算逻辑.这算是函数的一个扩展场景吧
#普通代码
def func(i):
if i < 5:
i=i+1
else:
i=i*2
return i
a = []
for i in range(10):
num = func(i)
a.append(num)
#通过列表生成式来完成相同的功能
def func(i):
if i < 5:
i=i+1
else:
i=i*2
return i
a = [func(i) for i in range(10)]补充 三元运算表达式: 为真时的结果 if 判定条件 else 为假时的结果
a = 2 if 1>3 else 6
print(a)
a = 2 if 1>3 else 6
print(a)