python3基础(七)函数基础

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)