• 包, 日志模块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
  • 相关阅读:
    curl命令学习笔记
    IOS安全测试思维导图
    Hello World
    Hive SQL使用和数据加载的一点总结
    采用最低松弛度优先调度的实时系统调度程序
    MongoDB Map Reduce速度提升20倍的优化宝典
    释放时间不同可中断平行机问题在线算法
    RPC框架系列——Avro
    Solr 3.6.2索引MySQL数据库配置过程
    IKAnalyzer 独立使用 配置扩展词库
  • 原文地址:https://www.cnblogs.com/xiejintao0914/p/9204032.html
Copyright © 2020-2023  润新知