python全栈学习总结三:函数学习

一函数基本概念

1 函数定义

　　def 函数名（参数1，参数2，参数3，......）:

　　　　"""

　　　　功能：

　　　　参数1：

　　　　参数2：

　　　　参数3：

　　　　......

　　　　返回值：

　　　　"""

　　　　函数体（处理方法，执行过程）

　　　　return    返回值

　　只要是函数开头就用def定义，后面紧跟函数名，在括号中加入需要传递的形参，用冒号后面表示函数体，表示具体实现的方法，处理过程，最后返回值。函数参数可以没有，也可以有一个或多个，没有具体数量限制。以下是我对函数的理解：函数名是整个函数代码段的入口地址，在内存中存储时，是一个实时内存的地址，一个函数我们也可以看成一个变量，一个函数名即一个变量地址，函数名加上小括号表示函数执行。找到内存中的入口地址，执行相关的代码段，函数使用遵循的原则是先定义后调用，若是没有定义，提前调用，系统会报错，python解释器在解释代码时，实时运行传入的变量，运行到没有定义的函数变量，必然会报错。函数返回值在没有任何返回时返回None,一个或以元组的形式返回多个值。

2 函数参数

　　函数传递的参数即形参变量只能在函数内部有效，主要有这么几种：

　　位置参数：调用函数时，按照固定位置（固定顺序）一个也不落的全部传递。

　　关键字参数：调用函数时，可以给相关关键字（即形参的命名）来传递，只要关键字都对上，打乱顺序无所谓不影响函数调用。

　　默认参数：在函数定义时，可以预先给形参赋值参数，在函数调用时，可以不用赋值，使用默认的参数，也可以重新赋值，针对特殊场合使用方便。

　　参数数组：若是传递的参数不固定，则可以使用参数数组的形式，*args表示以元组的形式传递参数，**kwarg表示以字典的形式传递参数。

*arg形式传递数组

def foo(x,y,*args):
    print(x,y)
    print(args)
foo(1,2,3,4,5)

def foo(x,y,*args):
    print(x,y)
    print(args)
foo(1,2,*[3,4,5])


def foo(x,y,z):
    print(x,y,z)
foo(*[1,2,3])

**kwarg传递形参数组

def foo(x,y,**kwargs):
    print(x,y)
    print(kwargs)
foo(1,y=2,a=1,b=2,c=3)

def foo(x,y,**kwargs):
    print(x,y)
    print(kwargs)
foo(1,y=2,**{'a':1,'b':2,'c':3})


def foo(x,y,z):
    print(x,y,z)
foo(**{'z':1,'x':2,'y':3})

3局部变量与全局变量

简单的来说，局部变量就是顶格来定义，局部变量在子程序中定义的。变量使用原则，先从内部找起，逐渐向外部扩。引用外部全局变量是，可以使用关键字global来引用，表示使用全局变量，使用上一级变量时，可以使用nonlocal。

name = '骑驴追车'

def test1():
    name = '赢在大四'
    def test2():
        nonlocal  name  #引用上一级变量
        name = '扬帆起航'
    print(name)
    test2()
    print(name)
def test2():
    name = '在路上'
    def test3():
        global  name
        name = '若水三千'
    print(name)
    test3()
    print(name)
print(name)
test1()
test2()
print(name)

输出结果：

4嵌套函数总结

重点：函数即变量（python中变量即对象），变量的要求是先定义，后使用，那么函数也是如此，函数：先定义后引用！

name = "若水三千"
def foo():
    name ='在路上'
    def bar():
        print(name)
    return bar
a = foo()  #函数调用，函数返回值为函数名（函数首地址即变量）
print(a)  #产看变量类型
a()  #函数名保存在变量a中，加括号即可调用函数

5 递归函数

  简单的来说：函数自己调用函数自己，特点：不断的用栈来分配内存，所占内存很大。

要求：有个明确的结束条件

　　    每执行一次递归，函数规模有所减小

　　　递归效率不高

def test(n):
    if n > 1:
        sum = test(n-1)+n
        return sum
    else:
        return 1
num = test(100)
print(num)

 

6 函数式编程

（1） 匿名函数

　　lambda:变量：函数体

　　fun1 = lambda r:2*3.14*r   #定义一个求周长的匿名函数

　　fun2 = lambda x,y,z:(x+1,y+1,z+1) #定义一个匿名函数，返回多个值

（2）函数式编程特点

　　不可变：不用变量保存状态，不修改变量

　　函数即变量：函数名可以当做参数传递，也可以返回函数名（函数）

　　尾调用：在函数的最后一步调用另一个函数（最后一行不一定是函数的最后一步）

（3）map函数推导过程

　　map函数主要用在对一堆可迭代序列处理上，处理列表中的每一个元素，得到的结果是一个列表，列表中位置与个数与原来列表一样

"""
对一个列表进行自增一，求平方，求周长
"""
nums = [3,7,23,18,51]
#列表中的值自增一
num_s = []
for num in nums:
    num_s.append(num+1)
print(num_s)
#列表中的值求平方
num_s = []
for num in nums:
    num_s.append(num**2)
print(num_s)
#列表中的值求周长
num_s = []
for num in nums:
    num_s.append(num*2*3.14)
print(num_s)

nums = [3,7,23,18,51]
def add_one(x):
    return x+1
def suq_value(x):
    return x**2
def cricle_value(x):
    return 2*3.14*x
def calc_map(func,arry):
    num_l = []
    for i in arry:
        num_l.append(func(i))
    return num_l
print(calc_map(add_one,nums))
print(calc_map(suq_value,nums))
print(calc_map(cricle_value,nums))

nums = [3,7,23,18,51]
def calc_map(func,arry):
    num_l = []
    for i in arry:
        num_l.append(func(i))
    return num_l
print(calc_map(lambda x:x+1,nums))
print(calc_map(lambda x:x**2,nums))
print(calc_map(lambda x:x*2*3.14,nums))
"""
map函数输入两个对象，第一个为函数，第二个为可迭代对象列表元组字符串 返回值为内存对象的首地址，需要转化
"""
nums = [3,7,23,18,51]
print(list(map(lambda x:x+1,nums)))
print(list(map(lambda x:x**2,nums)))
print(list(map(lambda x:x*2*3.14,nums)))

（4）filter函数推导过程

filter函数功能：遍历列表中的每一个元素，判断每一个元素得到一个布尔值，如果为真，则留下来

"""
过滤掉列表中的某些字符
"""
name_lst = ['yz_zhg','yz_dx','yz_ds','zailushang','yz_ls']

name_new =[]
for n in name_lst:
    if not n.startswith('yz'):
        name_new.append(n)
print(name_new)

name_lst = ['yz_zhg','yz_dx','yz_ds','zailushang','yz_ls']

def show_yz(x):
    return x.startswith('yz')
def filter_test(func,arry):
    name_new =[]
    for n in arry:
        if not func(n):
            name_new.append(n)
    return  name_new
print(filter_test(show_yz,name_lst))

name_lst = ['yz_zhg','yz_dx','yz_ds','zailushang','yz_ls']
def filter_test(func,arry):
    name_new =[]
    for n in arry:
        if not func(n):
            name_new.append(n)
    return  name_new
print(filter_test(lambda x:x.startswith('yz'),name_lst))

name_lst = ['yz_zhg','yz_dx','yz_ds','zailushang','yz_ls']
print(list(filter(lambda x:not x.startswith('yz'),name_lst)))

（5）reduce函数推导过程

　　首先要使用from functools import reduce   导入

　　功能：处理一个序列，然后进行合并操作

#求一个列表中所有值
num_l = [1,2,3,4,100]
res = 0
for i in num_l:
    res += i
print(res)
#去列表中所有数的乘积
res = 1
for i in num_l:
    res *= i
print(res)

#求一个列表中所有值
num_l = [1,2,3,4,100]
def sum_value(x,y):
    return  x+y
def vol_value(x,y):
    return  x*y
def reduce_test(func,arry,init_value = None):
    if init_value is None:
        res = arry.pop(0)
    else :
        res = init_value
    for i in num_l:
        res = func(res,i)
    return  res
print(reduce_test(sum_value,num_l,10))
print(reduce_test(vol_value,num_l,10))

from functools import reduce
num_l = [1,2,3,4,100]
print(reduce(lambda x,y:x+y,num_l))
print(reduce(lambda x,y:x*y,num_l))

　　

　　

转载于:https://www.cnblogs.com/qilvzhuiche/p/9293805.html