Python学习日记（四）

五、函数和模块

Python中，定义一个函数使用def保留字，语法形式如下：

def <函数名>(<参数列表>):
	[return <返回值列表>]

如果函数的 return 语句直接返回多个值，是把它们封装为元组

if __name__ == '__main__':下面的按顺序执行：

def print_1():
    print("1")
def main():
    print("2")
    print_1()
if __name__ == '__main__':
    print_1()
    main()

1.函数的参数以及默认值参数：

• 位置参数，数量对应，位置也要对应
• 默认值参数必须出现在函数参数列表的最右端，任何一个默认值参数右边不能有非默认值

def printinfo(name,age = 11):
    print("姓名",name)
    age = age - 1
    print("年龄",age)

printinfo("张三")
printinfo("李四",21)

2.可变参数：

def value(a,b,*c):
    if b == "-":
        for i in c:
            a = a - i
    elif b == "+":
        for i in c:
            a = a + i
    return a

print(value(20,"-",4,5,6))
print(value(20,"+",4,5,6))

3.关键字参数
**parameter接受关键参数并存放到字典中

def person(name ,age, **kw):
    print('name:',name,' age:',age,'other:',kw)
#传入任意的其他参数，满足注册的需求
person('Bob',35,city= 'NanNing' )
person('Peter',45, gender= 'M',job='Engineer')
#封装为字典，再传入参数
extra = {'city':'NanNing','job':'Engineer'}
person('Jack',24, **extra)

4.命名关键字

• 如果希望确定关键字参数的名字，则需要命名关键字参数
• 用特殊符合.分隔，“后面的视为命名关键字参数

def person(name ,age, *,city,job):
    print('name:',name,' age:',age,'city:',city,'job:',job)
person('Peter',45, city= 'guilin',job='Engineer')

5.传参机制

def swap(a,b):
    a,b = b,a
    print("swap函数里面a，b的值分别是",a,b)

a,b = 3,4
swap(a,b)
print("swap函数里面a，b的值分别是",a,b)

正确的操作应该是：

def swap(mydict):
    mydict['a'],mydict['b'] = mydict['b'],mydict['a']
    print("swap函数里面a，b的值分别是",mydict['a'],mydict['b'])

mydict = {'a':3,'b':4}
swap(mydict)
print("swap函数里面a，b的值分别是",mydict['a'],mydict['b'])

可以观察地址：

def swap(mydict):
    print("swap函数里面mydict的值",id(mydict))
    mydict['a'],mydict['b'] = mydict['b'],mydict['a']
    print("swap函数里面a，b的值分别是",mydict['a'],mydict['b'])

mydict = {'a':3,'b':4}
print("swap函数之前里面mydict的值",id(mydict))
swap(mydict)
print("swap函数里面a，b的值分别是",mydict['a'],mydict['b'])
print("swap函数之后里面mydict的值",id(mydict))

6.lambda表达式

• python使用lambda来创建匿名函数
• lambda只是一个表达式，而且只能是单行表达式。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda par ameters:expression
等价:
def < function>( parameters):
	return expression

sum = lambda x,y : x+y
print(sum(1,2))

def sum2(x,y):
    return x*y

print(sum2(1,2))

高级特性

5.1函数生成器

def fib2(num):
    n,a,b=0,0,1
    while n < num:
        yield b
        a,b=b,a+ b
        n+1
print(fib2(6))
g=fib2(6)
print(next(g))
print(next(g))
print(next(g))
print(next(g))

可控制的斐波那契函数生成器：

def fib4():
    n,a,b=0,0,1
    while True:
        yield b
        a,b=b,a+ b
        n+1
g = fib4()
for i in range(10):
    print(g.__next__(),end='\t')

• yield语句与returm语句的作用相似，都是用来从函数中返回值。与retum语句不同的是，returm语句一旦执行会立刻结束函数的运行，而每次执行到yield语句并返回一个值之后会暂停或挂起后面代码的执行，并发送数据，下次通过生成器对象的next （）方法、内置函数next（）. for循环遍历生成器对象元素或其他方式显式"索要”数据时恢复执行

5.2高阶函数

• map
• reduce
• fiter

map为惰性计算，要一个给一个，而不是全算完
map(func, *iterables) -> map object

• 接收两个参数，一个是函数，一个是Iterable可迭代的对象，
• 作用:函数作用于序列中的每个元素
• 返回值:一个iterator迭代器， map对象。注意: map返回的iterator是情性序列)

def fun(x):
    return pow(x,2)
print(list(map(fun,[1,2,3,4,5])))

reduce(func, iterable[ initializer)

• 函数func接收两个参数
• iterable可迭代对象
• 作用:对序列中的第1、2个元素进行操作，得到的结果再与第三个数据用func函数运算，最后得到个结果，

import functools
from functools import reduce
print(reduce(lambda x,y:x+y,[1,2,3,4,5])) #((((1+2)+3+4+5)

import functools
import operator
print(functools.reduce(operator.add,[1,2,3,4,5]))
print(functools.reduce(operator.mul,[1,2,3]))
print(functools.reduce(operator.concat,['A','BB','C']))

flter(func or None, iterable) --> filter object

• 两个参数，参数func,参数iterable可迭代对象
• 作用: 函数依次作用于每个元素， 然后根据返回值是True还是False决定保留还是丢弃该元素: 第个参数没有， 则返回iterable
• 返回值: filter对象
• 这个也是惰性计算

print(list(filter ( lambda x : x%2 == 1,[1,2,3,4,5,6,7,8,9,10])))

5.3偏函数partial
使用偏函数去固定函数的某个参数值

import functools
def log(message,subsystem):
    print("%s:%s"%(subsystem,message))

server_log = functools.partial(log,subsystem='server')
server_log("Unable to open socket")

5.4修饰器(装饰器)
通过修饰器可为现有函数或类添加新功能。

• 修饰器是在程序开发中经常使用到的功能。可以使用修饰器(Decorator) 为现有的代码添加功能。
• 这种使用一部分程序在编译时改变剩余部分程序的技术，被称为元编程(Metaprogramming)
• 为了理解修饰器，我们必须再次强调个概念，即Python中 切都是对象，包括函数。所以函数也可以作为另一个函数的返回值或参数。
• 任何实现了call方法的对象都是可调用对象。函数和方法通常被称为可调用对象(Callable)
• 一个基本的修饰器接收一个函数，然后向其添加功能，最后返回这个函数。

#可以通过把@符号加修饰器的名称放在斋费修饰的函数上方来实现
def make_pretty( func):
    def inner( ):
        print("I got decorated")
        func( )
    return inner
#ordinary=make_pretty(ordinary)
@make_pretty
def ordinary():
    print("I am ordinary")
ordinary( )

5.6模块化编程

• 内置模块
• 第三方模块
• 自定义模块

5.7PyInstaller打包
在创建了独立应用( 自包含该应用的依赖包)之后，希望将Python 程序生成可直接运行的程序，这样可以分发到对应的Windows或Mac0SX平台上运行，而不依赖于解释器和相应的包
1.打开cmd
2.输入pip install pyinstaller
3.输入pyinstaller - 文件路径\xxx.py
4.生成exe文件