Python-函数（笔记）

函数(一）

2018-05-03

---

自定义函数

（1）定义函数

def 函数名（）

（2）调用函数
函数名（）

---

函数参数

必备参数 创建与调用时都要有参数，而且数量相等

def name(arg1,arg2...)     #形参，可以多个，不用声明
#调用函数时，传给函数的数据就是实参

关键字参数

def test1(name,age):
    print(name,age)
test1(25,"张三")
test1(age=25,name="张三")

25 张三
张三 25

缺省参数 缺省参数只能放在最后

def test1(x,y,z=2):   #缺省参数只能放在最后
    print(x+y+z)
test1(1,3)         #如果没有给z传值，就使用原来的z=2
test1(1,3,4)       #有给z传值，就使用传入的值4

6
8

不定长参数

def test1(x,y,*z):
    print(x)
    print(y)
    print(z)
    sum=x+y
    for i in z:
        sum+=i
    print("和为：%s"%sum)
test1(1,3,4,5,6,7)

1 
3
(4, 5, 6, 7)
和为：26

一个*创建元组，两个创建字典

 def test1(x,*args,**kwargs):
    print(x)
    print(args)
    print(kwargs)
    # for i in z:
    #     sum+=i
    # print("和为：%s"%sum)
test1(1,3,4,5,num1=6,num2=7)

1
(3, 4, 5)
{'num1': 6, 'num2': 7}

---

函数返回值 return

def A(a,b):
    sum=a+b
def B(a,b):
    sum=a+b
    return sum    #return执行后，后面不管有什么代码都不执行
    print("bc")   #不执行
num1=2
num2=9
s1=A(num1,num2)
s2=B(num1,num2)
print(s1)
print(s2)

None
11

判断a是否为数字

if isinstance(a,(int,float))

---

局部变量和全局变量

参数传递分为值传递和引用传递
可变类型的为引用传递
不可变类型为值传递
可变类型：list 、dict
不可变类型：string 、tuples 、numbers

1. 全局变量在后面的代码都可以修改
2. 局部变量只能在该函数中使用

a=400
def test1():
    a=200
    a=a+1
    print("a的值为：%s"%a)
    return a
def test2(a): #a的值为形参，只是个代表
    print("test2中a的值为：%s"%a)
b=test1()
test2(b) #传入的是b值，是从test1中算出来的，不要看函数中的a，那只是一个形参
print(a)

a的值为：201
test2中a的值为：201
400

函数中全局变量的修改
1、如果是可变类型，可以修改

list1=['a','f','h','g']
dict1={"name":"张三","age":23}
a="word"
def test1():
    print("全局变量list1：%s"%list1)
    print("全局变量dict1：%s"%dict1)
    list1[2]="hello"
    dict1["age"]=18
    a="qqqqq"
test1()
print(list1)
print(dict1)
print(a)

全局变量list1：['a', 'f', 'h', 'g']
全局变量dict1：{'name': '张三', 'age': 23}
['a', 'f', 'hello', 'g']                      #被修改
{'name': '张三', 'age': 18}                   #被修改
word                                          #没修改

2、不可变类型的修改（需要加global）

a="word"
def test1():
    global  a         #修改不可变类型
    a="hello"
    print(a)
test1()
print(a)

hello
hello

---

#注意！！！ 对于可变类型，如果整个列表替换，也是需要 global ，否则视为新定义的局部变量

list1=['a','f','h','g']
def test1():
    list1=["as"]                         #整个列表修改
    print("全局变量list1：%s"%list1)
test1()
print(list1)

#全局变量没被修改：如果整个列表替换，那么程序认为函数里面的list1是重新定义的一个列表，视为局部变量，与全局变量list1没有关系，所以不存在修改

全局变量list1：['as']
['a', 'f', 'h', 'g']

list1=['a','f','h','g']
def test1():
    global list1
    list1=["as"]
    print("全局变量list1：%s"%list1)
test1()
print(list1)

#加 global list1 后就改变了，程序就会识别为引用了全局变量
全局变量list1：['as']
['as']

---

函数（二）

标签（空格分隔）： 2018-05-07

---

匿名函数：定义函数中没有给定名称的函数，Python中常用lambda来表示
lambda

1. 只是一个表达式，比def简单，不是代码块，不能写太多逻辑
2. 有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数
3. 返回值就是表达式的值，不需要return
4. 主要应用场景就是赋值给变量，作为参数传入给其他函数
5. 表达式规则：lambda 参数列表：表达式

无参

a=lambda :"hello"
print(a())

带参数

#匿名函数
a=lambda x:x**2
print(a(10))

#定义函数
def a(x):
    return x**2
print(a(10))

结合推导式使用，更简单

a=lambda x:[i for i in x if i%2==0]
print(a([1,2,3,4,5,6,7,8]))

传入多个参数

a=lambda num1,num2:num1+num2

a=lambda *arg:sum(*arg)
print(a([1,2,3,4,5]))

在函数中使用

def action(x):
    return lambda y:x+y
aa=action(5)               #函数返回的就是lambda，所以action(5) 就是lambda y:5+y
sum=aa(25)
print(sum)

action1=lambda x:lambda y:x+y
sum1=action(2)                  #返回到lambda y:2+y
result=sum1(22)
print(result)

filter 函数用于过滤序列
filter(function,iterable)
function 判断函数
iterable 可迭代对象

#奇数列表
def a(x):
    return x%2==1
list1=[1,2,3,4,5,6,7,8]
list2=filter(a,list1)
print(list(list2))

#lambda
print(list(filter(lambda x:x%2==1,list1)))

[1, 3, 5, 7]

map函数
根据提供函数对指定序列做批量处理
map（function，seq[seq …])

list1=[1,2,3,4,5,6,7,8]
def sum(x):
    return x**2
list2=map(sum,list1)
print(list(list2))

#lambda
print(list(map(lambda x:x**2,list1)))

[1, 4, 9, 16, 25, 36, 49, 64]
[1, 4, 9, 16, 25, 36, 49, 64]

两个列表。相同位置数据进行操作，以短的为准

list1=[1,2,3,4,5]
list2=[6,7,8,9,10,11]
sum=map(lambda x,y:x+y,list1,list2)
print(list(sum))

reduce函数
对参数序列中元素进行总体计算，累加
reduce（function，seq[])

from functools import reduce
def a(x,y):
    return x+y
sum=reduce(a,[1,2,3,4,5])
print(sum)

sum1=reduce(lambda x,y:x+y,[1,2,3,4,5])
print(sum1)

15

---

函数对象与闭包

一、函数对象

def a(x,y):
    return x+y
a.age=24        #给函数添加属性
print(a(2,4))
print(a.age)

二、函数闭包

def outer(x):
    y=10
    def inner(z):
        return x+y+z
    return inner
cele1=outer(15)      #给x传参
print(cele1(20))     #给z传参

装饰器

本质是一个Python函数，可以让其他函数不需要做任何代码变动时增加额外功能

#第一种方法
import time
def func():
    starttime=time.time()
    print("hello")
    time.sleep(1)
    print("world")
    endtime=time.time()
    se=(endtime-starttime)*1000
    print("time is %d ms"%(se))
func()

#第二种，以函数为做参数调入另一个函数
def func():
    print("hello")
    time.sleep(1)
    print("world")

def deco(aa):
    starttime=time.time()
    func()
    endtime=time.time()
    se=(endtime-starttime)*1000
    print("time is %d ms" % (se))
deco(func)      
#调用时传参必须使用函数名，不能更改

无参装饰器

import time
def deco(fanc):
    def war():
        starttime=time.time()
        fanc()
        endtime=time.time()
        se=(endtime-starttime)*1000
        print("time is %d ms"%se)
    return war
@deco
def func():
    print("hello")
    time.sleep(1)
    print("word")
func()

有参装饰器

import time
def deco(bb):
    def war(a,b):
        starttime=time.time()
        bb()
        endtime=time.time()
        se=(endtime-starttime)*1000
        print("result is %d"%(a+b))
        print("time is %d"%se)
    return war
@deco
def func():
    print("hello")
    time.sleep(1)
    print("word")
func(3,5)

不定参数装饰器

import time
from functools import reduce
def deco(bb):
    def warpper(*a,**b):
        starttime = time.time()
        bb(*a,**b)
        endtime = time.time()
        se = (endtime - starttime) * 1000
        print("time is %d ms"%(se))
    return warpper
@deco
def func(*a):
    print("hello")
    time.sleep(1)
    print("world")
    num=0;
    for i in a:
        num+=i
    print("result is %d" % (num))
func(4,5,6)

支持多个装饰器

import time
def deco01(func):
    def wrapper(*args, **kwargs):
        print("this is deco01")
        startTime = time.time()
        func(*args, **kwargs)
        endTime = time.time()
        msecs = (endTime - startTime)*1000
        print("time is %d ms" %msecs)
        print("deco01 end here")
    return wrapper

def deco02(func):
    def wrapper(*args, **kwargs):
        print("this is deco02")
        func(*args, **kwargs)
        print("deco02 end here")
    return wrapper
@deco01
@deco02
def func(a,b):
    print("hello，here is a func for add :")
    time.sleep(1)
    print("result is %d" %(a+b))
f = func
f(3,4)