包, 日志模块logging ,函数总结, 模块

1、包
什么是包:包就是一个含有__init__.py文件的文件夹
包是模块的一种形式,即包是用来被导入的,但包的本质就是一个文件夹(文件夹的作用就是用来存放文件的,包内所有的文件都是用来被导入使用的)
import 包
包.名字

导入方式:
1、绝对导入: 相对于执行文件所在的文件夹
2、相对导入:相对于当前被导入的文件(只能用于模块直接的互相导入)
.
..
2、日志模块logging
1、logger:产生日志
2、filter
3、handler:接收logger对象传来的日志,控制输出到不同的位置
4、formatter:控制handler对象输出日志的格式

debug 10
info 20
warning 30
error 40
critical 50

函数总结
1、什么是函数
    函数就是具备某一特定功能的工具
2、为什么用函数
    减少重复代码
    增强程序的扩展性
    增强可读性
3、如何用函数
    1、函数的使用原则:先定义后调用(*****)
        定义阶段:只检测语法不执行代码
        调用阶段:执行函数代码
    2、定义阶段与调用阶段:
        2.1:语法 (*****def func(参数1,参数2,...):
                """文档注释"""
                code1
                code2
                code3
                return 返回值
        2.2 形参与实参 (*****)
            形参本质就是变量名
            实参本质就是变量的值

            形参:
                位置形参
                    def foo(x,y):
                        pass
                默认形参
                    def foo(x,y=1):
                        pass
                *args
                    def foo(x,*args):
                        pass
                **kwargs
                    def foo(x,**kwargs):
                        pass
            实参:
                位置实参
                    foo(1,2,3,4)
                关键字实参
                    foo(x=1,y=2,z=3)
                    foo(x=1,1) # 错误
                    foo(1,x=1) #错误
                *可迭代的对象
                    foo(*'hello')
                **字典
                    foo(**{'x':1,'y':2})

        2.3 返回值(*****)

            return是函数结束的标志,函数内可以有多个return,但只要执行一次函数就立刻结束
            并且把return后的值当作本次调用结果返回

            def foo(x,y):
                return x+y

            res=foo(1,2)

            注意:
                1、返回值可以是任意类型
                2、返回值没有个数限制
                    函数内没有return:默认返回None
                    return 值1:返回该值
                    return 值1,值2,值3:返回(值1,值2,值3)

    3、函数对象(*****def foo():
            pass
        函数可以被当作数据去处理
        1、引用
            f=foo
        2、当作参数
            print(foo)
        3、当作返回值
            def bar():
                def wrapper()
                    pass
                return wrapper

            f=bar()
        4、当作容器类类型的元素
            def f1():
                pass
            def f2():
                pass

            l=[f1,f2]
            l[0]()

            func_dic={
                'f1':f1,
                'f2':f2
            }

    4、函数嵌套(*****4.1 函数的嵌套调用
            def foo()
                bar()
                f1()
                f2()
            foo()
        4.2 函数的嵌套定义
            def f1():
                def f2():
                    pass
                f2()

    5、名称空间与作用域(******)
        内置名称空间
        全局名称空间
        局部名称空间
            def foo(x,y): #x=1,y=2
                pass
            foo(1,2)

        加载顺序:内置->全局-》局部
        查找名字的顺序:从当前位置往上查找
            如果当前位置在局部
            局部—》全局-》内置

        x=1
        def outter():
            def wrapper():
                print(x)
            return wrapper
        f=outter()

        def bar():
            x=111111
            f()

        全局作用域:全局存活,全局有效
            内置+全局
        局部作用域:临时存活,临时有效
            局部

        l=[]
        n=100
        def foo():
            l.append(1111)
            global n
            n=1


        def f1():
            x=1
            def f2():
                def f3():
                    nonlocal x
                    x=10

        globals()
        locals()
    6、闭包函数(****)
        x=1
        def outter():
            x=10
            def wrapper():
                print(x)
            return wrapper
        f=outter()

    7、装饰器(****def deco(func):
            def wrapper(*args,**kwargs):
                res=func(*args,**kwargs)
                retutrn res
            return wrapper


        def deco1(x=1,y=2):
            def deco(func):
                def wrapper(*args,**kwargs):
                    res=func(*args,**kwargs)
                    retutrn res
                return wrapper
            return deco


        @deco
        def index():
            pass

    8  迭代器(****for
        max
        min
        sorted
        filter
        map

    9  生成器(***10 三元表达式、列表推导式,字典生成式,生成器表达式(*****)

        res=条件成立的结果 if 条件 else 条件成立的结果
        l=[表达式 for i in 可迭代对象 if 条件]
        g=(表达式 for i in 可迭代对象 if 条件)
        d={k:v for i in 可迭代对象 if 条件}

    11 匿名函数(*****lambda 参数1,参数2:表达式

        max
        min
        sorted
        map
        filter

    12 内置函数

    13 函数递归(****)
View Code

  模块

1、什么是模块
        模块的一系列功能的集合体
    2、为何用模块
        拿来(内置或第三方的模块)主义,提升开发效率
        自定义模块可以让程序的各部分组件重用模块内的功能
    3、如何用模块
        大前提:模块是被执行文件导入使用,模块的导入必须搞明白谁是执行文件,谁是被导入的模块

        import
            首次import m1导入模块都发生三件事:
            1、先创建一个模块的名称空间
            2、执行m1.py,将执行过程中产生的名称都放入模块的名称空间中
            3、在当前执行文件中拿到一个名字m1,该名字是指向模块的名称空间的

            使用方法:指名道姓地访问m1名称空间中的名字func,优点是不会与当前名称空间中的名字冲突,缺点是每次访问都需要加上前缀
                m1.func

        from ... import
            首次from m1 import func导入模块都发生三件事:
            1、先创建一个模块的名称空间
            2、执行m1.py,将执行过程中产生的名称都放入模块的名称空间中
            3、在当前执行文件中直接拿到一个功能名func,该名字是直接指向模块名称空间中的某一个功能的


            使用方法:直接使用功能即可,优点是无需加任何前缀,缺点是容易与当前名称空间中的名字冲突
                def func():
                    pass
                func()


    4、模块的搜索路径
        内存-》内置模块-》sys.path
View Code

 

posted @ 2018-06-20 15:30  谢金涛  阅读(283)  评论(0编辑  收藏  举报