函数 part3

匿名函数

含义：匿名函数就是没有名字的函数
作用：用于临时使用一次的场景，是个一种一次性函数
关键字：lanmbda

# 例1
def foo(x,y)
    return x + y 
# 将上面两行代码定义为匿名函数
# lambde x, y: x + y
res = (lambda x, y: x + y)(1, 2)  # lambda 自带return，不用写return
print res  # 3

# 例2,配合内置函数使用
salaries = {
    'axx': 5000,
    'cxx': 100000,
    'zxx': 200
}
# 取出薪资最大值
name = max(salaries)
print(name)  # zxx  比较key的首字母
# 用函数
def foo(name)
    return salaries[name]
name = max(salaries, key=foo)  # key，是max内置用法，将salaries的key遍历出来依次传给函数foo，比较得出薪水最大值的key
print(name)  # cxx
# 用匿名函数
name = max(salaries, key= lambda name:salaries[name])
print(name)  # cxx
# 同理
取最小值：min
    name = min(salaries, key= lambda name: salaries[name])
    print(name)  # zxx
排序：sorted
    name = sorted(salaries, key= lambda name: salaries[name])
    print(name)  # ['zxx', 'axx', 'cxx']
映射：map # 批量修改，映射新列表等
    names = ['xxx','aaa','sss']
    # res = [name + '_vip' for name in names]  # 列表生成式
    res = map(lambda name: name + '_vip', names)  # 迭代器
    print(res)  # <map object at 0x00000217F820F190> 
    print(list(res))  # ['xxx_vip', 'aaa_vip', 'sss_vip']
过滤：filter
    names = ['xxx','sss_vip','aaa_vip']
    # res = [name for name in names if name.endswith('vip')]
    res = filter(lambda name: name.endswith('_vip'), names) # 迭代器
    print(res)  # <filter object at 0x0000022D9B278700>
    print(list(res))  # ['sss_vip', 'aaa_vip']
归纳拼接：reduce
    from functools import reduce
    num = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])  # 求和
    print(num)  # 15
    res = reduce(lambda x, y: x + y, ['x', 'a', 'b'], 'sss')  # 拼接
    print(res)  # ssssxab

面向过程编程思想

就是按照流程编程，即先干什么再干什么后干什么，基于该思想写编程就好比设计一条条的流水线

优点：复杂的问题流程化，进而简单化
缺点：牵一发而动全身，扩展性差

模块

1.含义：模块就是一堆功能的集合体

2.模块三种来源
    1.python自带模块
        内置模块  time
        标准库模块   os、randam
    2.第三方库
        pip3 install 
    3.自定义模块
   
3.为何要用模块
    1）提升开发效率
    2）减少代码冗余

4.导入模块     
1）import 语法
    优点：不会和当前位置定义的名称冲突
    缺点：每次访问都要带前缀

    import sapm  # spam 产生在当前执行文件中
    spam.名字

    import spam as f # 函数名长可用as在当前位置为导入的模块起一个别名 
    f.名字
    import spam as as,sm,os,xxx
2）from ... import ...
    优点：不用加前缀
    缺点：会和当前位置定义的名称冲突
    
    from sapm import money as m,read1,read2,change  # 也可以取别名
    
    from sapm import money,read1,read2,change # 各自指向对应名称空间
    money = 20
    print(money)  # 200 确定函数位置，以函数定义为准执行
    read1()  # money = 1000 位置在spam模块
    def read2()
        print(money)
    read2()  # 20  
    
    from spam import * # 把spam中所有的名字都导入到当前执行文件的名称空间中，在当前位置直接可以使用这些名字，但是更容易与当前位置名称冲突
    __all__ = ['money','read1']可以控制*导入的范畴

    
# 首次导入自定义模块会发生两件事：导入多次不会重复执行代码，只在首次
    1）会触发sapm.py的运行，会产生一个模块的名称空间，来存放模块运行过程中产生的名字
    2）会在当前文件的名称空间中产生一个名字spam，该名字指向模块的名称空间

5.循环导入模块问题
'''
    在我们的程序中尽量避免出现循环导入模块的问题，如果有多个模块共享导入，可以将这些模块放进一个共享文件夹里
'''
m1.py
    from m2 import y

    x='111'
    # 执行报错 ImportError: cannot import name 'y'
    
m2.py
    from m1 import x

    y='222'

run.py
    import m1
    # 执行报错 ImportError: cannot import name 'x'

解决方案：
# 方案一：将导入语句放到最后，保证在导入时，所有名称都已经加载过
        
 m1.py
	x='111'

    from m2 import y

m2.py
    y='222'

    from m1 import x

run.py
    import m1
    print(m1,x)
    
# 方案二：将导入语句放入函数中，只有在调用时候才会执行其内部的代码

m1.py
    def f1():
        from m2 import y
        print('find y',y)

    x='111'
    
m2.py
    def f2():
        from m1 import x
        print('find x',x)
        
    y='222'

run.py
    import m1
    m1.f1()
     
# 共用的模块放入共享模块中,可以借助environ
 m1.py
    import os
	x='111'

    os.environ['y'] = str(y)

m2.py
    import os
    y='222'

    os.environ['x'] = str(x)

run.py
    import m1
    import os
    print(os.environ)
    print(os.environ['x'])
    
6.模块检索路径
优先级：从高到低
    1）内存
    2）内置
    3）sys.path（环境变量的一种）存放一堆文件夹
       第一个文件夹是当前执行文件的文件夹
       第一次加载到内存
       自定义模块放在sys.path
# 注意：自定义模块不要与内置模块重名

sys.path.append(r'    ')  # 临时添加文价夹
from aaa.bbb.ccc import spam  # 导入语句中出现的点，代表路径分隔符
spam.money  # 使用语句中出现的点，代表问某一个名称空间要名字
    
7.区分py文件的两种途径
1）直接运行，当作脚本执行
2）当模块导入
区别方法：每个py文件都内置了__name__变量，该变量在py文件被当做脚本执行时赋值为“__main__”,在py文件被当做模块导入时赋值为模块名
# 测试代码：当作脚本运行时执行，导入模块不用执行
def f1():
    pass
if __name__ == '__main__':
    f1()  # foo.py 被当作脚本执行
else：
    f1()  # foo.py 被当作模块导入

import m1

def start():
    pass

if __name__ = '__main__'
    # m1.f1()
    start()