Python学习笔记_1_基础_7：函数

 一、函数定义&特性&返回值

1、函数定义

　　函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

2、函数特性

　　1）减少重复代码

　　2）使程序编的可扩展

　　3）使程序变得易于维护

import time

def test1():
    time_format = '%Y-%m-%d %X'
    time_current = time.strftime(time_format)
    print(time_current)
    return 0

test1()
x= test1()
print(x)

3、函数返回值

#return：函数执行结果，为后续执行程序提供判断依据。

　　#无：返回None

　　#返回一个值，一个对象

　　#返回多个值，包装成元组

def test1():
    print('in the test1')

def test2():
    print('in the test2')
    return 0

def test3():
    print('in the test3')
    return 1,[1,2],{'a':'b'}

def test4():
    print('in the test4')
    return test2

x = test1()
y = test2()
z = test3()
#返回test2函数
v = test4()
#调用
v1 = v()

print(x,type(x))
print(y,type(y))
print(z,type(z))
print(v,type(v))
print(v1,type(v1))

二、函数参数

#函数参数
　　#形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。
　　　　　　# 因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
　　#实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，
　　　　　　# 以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。

1、简单参数

print('-'.center(50,'-'))
def test1(x,y,z):
    'aaaaa'   #函数说明
    print(x,y,z)

test1(1,3,5)       #位置参数调用：形参-实参一一对应。
test1(y=3,x=1,z=5)   #关键字调用：与形参顺序无关
#test1(y=3,1,5)     #报错
#test1(3,z=1,5)     #报错
test1(1,z=5,y=3)     #混合调用：关键参数必须在位置参数后面

2、默认参数

print('默认参数函数'.center(50,'-'))
#默认参数：默认参数可以多个，但必须在非默认参数后。
    #特点：函数调用时，默认参数非必须传递
    #用途：自己想
def test2(x,y,z=5,v=6):
    'aaaaa'
    print(x,y,z,v)

test2(1,2)
test2(1,2,v=7)

3、参数组

#参数组作用：为后期函数拓展做准备
print('不固长参数函数（参数组）：元组形式'.center(50,'-'))
def test3(x,y=2,*args):
    print(x,y)
    print(args)
#接收位置参数作，转化为元组
test3(1,2,3,4,5)
#test3(1,y=10,3,4,5)    #关键字参数必须在位置参数后
#test3(1,3,4,5,y=10)    #3被当做默认参数传递，y=10,再次传递，出错
test3(1,7,*(8,9))  #test3(1,*[7,8,9]) ,test3(1,*{7:1,8:2,9:3})  #转化为元组

print('不固长参数函数（参数组）：字典形式'.center(50,'-'))
def test4(x,y=2,**kwargs):
    print(x,y)
    print(kwargs)

#接收关键字参数作，转化为元组
test4(1,3,name='a',age=8)
test4(1,3,**{'name':'a','age':8})
test4(1,name='a',age=8,y=10)

4、各类型参数

#参数顺序：1)普通参数、默认参数、元组参数组、字典参数组，建议使用这种。
#           2)普通参数、元组参数组、默认参数、字典参数组
print('各类型参数'.center(50,'-'))
def test5(x,y=2,*args,**kwargs):
#def test5(x,*args,y=2,**kwargs):
    print(x,y)
    print(args)
    print(kwargs)

test5(1,3,4,5,6,name='a',age=8)
test5(1,name='a',age=8,y=10)    #除非元组参数组不定义值，否则只能按顺序赋值
test5(name='a',age=8,y=10,x=11)
#建议按照顺序，别搞那么多幺蛾子。。。。。

 

三、局部变量&全局变量

#全局与局部变量
    # 在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
    # 全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
    # 当全局变量与局部变量同名时：
        # 在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

school = 'gd'
sch_glo = 'gx'

def charge_name(name):
    print('before name: ',name)
    name = name.upper()
    print('after name: ',name)
    school = 'gddddddd'
    print('fnc school：',school)
    global sch_glo                      #申明为全局变量：不要这么干
    sch_glo = 'gxxxxxxx'
    print('fnc sch_glo：',sch_glo)
    global name_glo
    name_glo = 'czzzzzzzzzz'            #定义全局变量：永远永远永远不要这么干
    print('fnc name_glo：',name_glo)

name = 'cz'
print(name)
charge_name(name)
print(name)
print(school)
print(sch_glo)
print(name_glo)


print(''.center(50,'-'))
list_name = ['aa','bb','cc']

def charge_name2(list):
    list[0] = 'aaaaaa'
    print('in fnc: ',list)

charge_name2(list_name)
print(list_name)
#what the fuck...,被修改了。why？引用传递问题。

 

 

四、递归函数

#在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
#递归特性:
    # 1. 必须有一个明确的结束条件
    # 2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
    # 3. 递归效率不高，递归层次过多会导致栈溢出
    #     （在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，
    #       每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）


def n_factorial(n):
    print(n,'*',end='')
    if n-1 >0:
        return n*n_factorial(n-1)
    else:
        return n


a = n_factorial(5)
print('')
print(a)

 

五、高阶函数

#高阶函数：
    #1、把一个函数当做实参传递给另外一个函数
    #2、返回值是一个函数

def add(x,y,f):
    return f(x)+f(y)

res = add(3,-6,abs)

print(res)

六、匿名函数

def test(n):
    print(n)

test(3)

#用完就删除，改匿名函数
#只能处理简单数据统计或者三元运算符
#https://blog.csdn.net/zjuxsl/article/details/79437563
(lambda n:print(n)) (5)

calc = lambda n:print(n)

calc(5)

# lambda argument_list: expression
    #argument_list：参数列表
    #expression：关于参数的表达式。表达式中出现的参数需要在argument_list中有定义，并且表达式只能是单行的。

#三个特性
    #lambda函数是匿名的：所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。
    #lambda函数有输入和输出：输入是传入到参数列表argument_list的值，输出是根据表达式expression计算得到的值。
    #lambda函数一般功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。
        # 由于其实现的功能一目了然，甚至不需要专门的名字来说明。

七、内置函数

详见：https://docs.python.org/3/library/functions.html?highlight=built