python基础---函数

一、函数

　　通过函数，可以对特定的代码功能进行封装，实现代码的复用。

1、函数的声明（定义）

　　def 函数名（参数列表）:

　　　　代码

　　不带参数的函数定义:

　　　　def printInfo():

　　　　　　print('Hello world!!')

　　带参数的函数定义：

　　　　def print(a,b):

　　　　　　return a+b

2、函数的调用

　　调用方式： 函数名(实参列表)

　　　printInfo()

　　　sumV = add(10,20)  ## 这里传入的是实参

3、函数的返回值

　　通过return返回函数的返回值

　　函数中，默认return返回None，不写return也是返回None  ，return None也可以简写为return

　　在函数中，无论在return后面是否有语句，遇到return整个函数就直接结束

　　continue：结束本次循环，进入下一次循环

　　break：

特别的地方：

　　在python中可以一次返回多个值

def move(x, y):
    return x+10,y+10

##定义两个变量接受返回值：
x,y=move(12,20)
print('x=%d,y=%d'%(x,y))

##定义一个变量接收返回值，返回值为元组类型：
point=move(20,30)
print(point)
print(point[0])

4、参数传递

　　python的所有变量的内容都是内存地址，也就是说变量指向内存的对象的一个指针

　　都是值的引用，其类型分都是对象决定的

　(1) id函数：获取变量的地址

　　　a = 10

　　　print(id(a))  ##输出：1231232314

　(2)值类型：

　　　值类型对象本身不允许修改，数值的修改实际上让变量指向一个新的对象

　　　(也是就是数值本身的内容变成了另外一个新的内存地址)

　　不可变对象包含：字符串、元祖、数值---- 这些都不允许修改 ，做参数传递的时候，在内部改变量的值，不能影响外部变量的值

a = 10
b = 20
def swap(x, y): ##传递的是值类型，函数内部修改参数的值，外部的变量没有作用
temp = x
x = y
y = temp
swap(a, b)
print(a, b) ##输出 :10 20

　(3)引用类型

　　可变对象：列表、字典等，本身允许修改

　　如果函数传递的是引用类型，在函数内操作直接影响到外部的变量

　5、局部变量全局变量

　　1）函数内部使用的变量称为局部变量

　　2）函数外定义的变量称为全局变量

　　　　全局变量能够在所有的函数中进行访问

　　　　如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错

　　　　如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量（所谓强龙不压地头蛇）

 1 def test3():
 2     global b #使用global后，就可以对全局变量进行修改
 3     b = 100
 4     
 5 test3()
 6 print(b)
 7 
 8 li = [1,]
 9 def f2():
10     li.append(1)#如果全局变量是可变类型，函数内可以直接修改其内容
11     print(li)
12 f2()

 二、函数的参数

　　1、位置参数

　　　　传入的时候，按照定义的时候的位置依次传入。

def pow(x)
    return x*x

p = pow(10)
print(p)
#传参时，还可以指定参数名称，必须与函数定义中的一样
print(pow(x = 100))

　　2、默认参数

　　　　在定义函数的时候，可以设定默认参数。但是默认参数，要放在后面，否追报语法错误

def  pow(x,n=3)：
        xxx

pow(10)  ## 这样x=10，n默认就等于3

　　3、可变参数-

　　　　传入的参数组成元祖！！

　　　　允许你传入任意个参数，这些参数再掉用的时候，组装成了一个元祖（tuple）！！！

def sum2(*args):## *args 任意长度,把接收到的全部数据最为元祖
    print(type(args))  ##args是元祖!!!
    sumV = 0
    for v in args: ## 可变参数
        sumV+=v
    print(sumV)

sum2(1,2,3,4,5,6,7,8,9,0)

l = [2,3,4]
sum2(l[0],l[1],l[2]) ##这样不方便
sum2(*l) ###把列表中的元素，给sum2    
         ### *[2,3,4] 将列表中的元素取出来，作为可变参数传给函数
         ### 同样元祖也可以
l2 = (1,2,3)
sum2(*l2)
sum2(*[1,2,3,4,5])

　　4、关键字参数

　　　　允许你传入任意个参数，这些参数再调用的时候，组装成了一个字典（dict）！！！

def person(**kw): ##内部处理成字典
    print(kw)        ##kw是一个字典
    # print(type(kw))
    # print(kw['name'])## 输出zhangsan

person(name='zhangsan',age= '10')

d = {'name':'zhangsan','age':11}
person(**d) ## 把字典取出来，一个个传递进去
            ## **d 相当于name='zhangsan',age= '11'

## 可以接收任意参数！！
## 不方便写逻辑，不知道怎么处理
def test(*args,**kw): ##声明 args处理成元祖--包装
    print(args)
    print(kw)
    #test1(*(10,20))
test1(*args,**kw)##调用-- 解开！！

def test1(a,b):
    print(a+b)

# test(10,20)   ##输出：(10,20)
# test(10,a=20) ##输出：(10,)
                ##     {'a': 20}

test(10,20)

三、递归

　　函数内部自己调用自己，但是一定要有结束条件！！

求4的阶乘，4!=4*3! ,  3! = 3*2!, ...
def jiecheng(n):
    if n==1:  ## 结束条件
        return 1
    return n * jiecheng(n - 1) ##n一定要改变

s = jiecheng(3)
print(s)

四、匿名函数

　　没有名字的函数叫匿名函数，也叫lambda函数

　　语法: lambda 参数：表达式

　　　　左边的参数可以有多个，但是右边的表达式只能有一个

　　　　使用lambda函数时，需要一个变量接收结果

　　lambda函数可以作为实参，传递给函数

'''简单用法'''
## 匿名函数无法调用
## 通过赋值的方式，相当于给了名字
add1 = lambda a, b :a+b
print(add(10,20))

''' 匿名函数作为函数的参数传递'''

def mul(a,b):
    return a*b

def calcute(a,b,func): ## 第三个参数表示传入函数变量
    return func(a,b)

## 通过函数名传递函数！！！--普通！！
print(calcute(12,3,mul))
print(calcute(12,3,add))

## 传入lambda表达式 相当于func = lambda x,y:x+y 
print(calcute(10,50,lambda x,y:x+y))

　　小例子：

1 = [(2,12),(6,23),(4,24)]
l.sort(key = lambda x :x[1],reverse=True)
print(l)
'''
    sort(key=None,reverse=None) ##自带默认参数默认从小到达排序
    key： 表示排序的条件，指定按照哪个排
    
    so, 匿名函数就是，把元祖的第二个取出来排
    ##  l.sort()  已经把列表元素取出来了，只需要再取元祖的第二个元素即可
'''

五、闭包

　　一句话，内部函数调用外部函数的变量（一般是要装饰的函数名），返回内部函数的函数名！！(相关参数和变量都保存在返回的函数中)

　 函数闭包的要素
　　1、外部函数和内部函数
　　2、内部函数使用外部函数的变量
　　3、内部函数返回函数名()
　　其他逻辑视情况而定!!

## 闭包实例!!
def sum_out(*args):
    ## 定义内部函数
    def sum_in():
        ##使用外部函数的变量
        sumV = sum(args) ##元祖求和
        return sumV  # 返回结果
    return sum_in    ##返回函数

print(sum_out(1,2,3,4)())

ss =sum_out(1,2,3,4) 
print(ss())  ## z真正调用的是sum_in()

六、装饰器

　　就是在闭包的基础上，参数改为函数，该函数就是我们传递进来并且要装饰的对象。

# 装饰器其实就是一个以函数作为参数并返回
# 一个替换函数的可执行函数

import time
def add():
    # print('调用时间:%s' %time.strftime('%Y-%m-%d %H:%M:%s'))
    print('add')
add()

print('-----------')
## 装饰器的实现
def log(func):
    def wrapper():
        # print('调用时间:%s' %time.strftime('%Y-%m-%d %H:%M:%s'))
        # print('调用%s时间:%s' %(func.__name__,time.strftime('%Y-%m-%d %H:%M:%s')))
        print('调用:%s' %func.__name__)
        func()
    return wrapper

add_warp = log(add)
add_warp()

print('--------------')
def mul():
    print('mul')

mul_warp = log(mul)
mul_warp()


add = log(add)
add() ##这个已经不是原来的add    
      ##已经被装饰了一回


## 借助add语法，作用到指定函数
@log  ##装饰这个函数 相当于sub = log(sub)
def sub():
    print('sub')

sub() ## 实际上不是原来的sub，已经被装饰过一回！！

##带参数的装饰器
import functools

def log(func):
    ## 接受任意的参数
    ## 作用：wrapper变成了add wrapper.__name__=func.__name__
    ### @functools.wraps(func) ##工具--- 加了这个原执行的表面wrapper 变成了add真实函数
    def wrapper(*args,**kw): ##可变参数--任意参数
        print('调用!!')    
        # print('args=',args)
        # print('kw=',kw)       ##若是没有就会返回None
        return func(*args,**kw) ##通用写法 得到返回值 
    return wrapper        

@log   ##相当于 add = log(add)
def add(a,b):
    return a+b 

# add = log(add)  log(add)() =wrapper()

print(add(10,30))
print(id(add))
add()

print('----------------------------')

aaa = log(add) 
print(aaa.__name__)  ##真正执行的函数是wrapper!!!!

def add(a,b)
    return 

def aa(func):
    def ssb():
        return a+b
    return ssb

add()

*七、偏函数--- 基本没啥用

　　把一个函数的某些参数给固定住（就是设置默认值），得到一个新的函数

八、高阶函数

　　定义：一个函数接收另外一个函数作为参数，称之为高阶函数

　　1、map() 函数

　　　　将传入的函数作用到列表的每一个元素

　　　　map(函数，可迭代对象)   一般搭配lambda或者自己定义函数

def f(x):
    return x*x
## 1、2、3、4、.... 相当于f(1)、f(2)。。。。
m = map(f,range(1,9)) ## map对象 ---可以被遍历
for v in m:
    print(v) ##输出结果

##map和匿名函数
m = map(lambda x:x+3,range(1,5))
for j in m:
    print(j)

　　2、reduce()函数

　　　　对传入序列（作用于每一个元素）做累积运算

　　　　格式：reduce(函数，可迭代对象)，搭配lambda使用

from functools import reduce ##引入函数
def add(x,y):
    return x+y
'''
简单写法
'''
r = reduce(add,[1,2,3])
print(r)   # 输出：6

'''
reduce 搭配lambda ，更简单的写法
'''

r2 = reduce(lambda x,y:x+y,[1,2,3])
print(r2)    ##输出：6

　　3、filter()函数---过滤

　　　　用于过滤序列，他把传入的函数作用于每一个元素，如果是True就保留该元素，Flase去掉该元素

##得到列表中的偶数

'''
普通写法
'''
z= [3,2,12,4,23,57,13]

def t(x):
    return x%2==0

b = filter(t,z)
print(b)

''''
高级写法
''''
a = filter(lambda x:x%2==0,z)
print(a)