精华内容
下载资源
问答
  • Python知识点汇总

    2020-06-29 11:32:03
    Python知识点汇总 无意中浏览到此博文,原作者总结的很全面,我重新做了下排版,新补充的部分内容,放在这里,留给需要的人。...

    Python知识点汇总

    无意中浏览到此博文,原作者总结的很全面,我重新做了下排版,新补充的部分内容,放在这里,留给需要的人。在此十分感谢原作者!


    一:类型和运算

    1.1 寻求帮助:

        dir(obj)            # 简单的列出对象obj所包含的方法名称,返回一个字符串列表
        help(obj.func)      # 查询obj.func的具体介绍和用法
    
    • 1
    • 2

    1.2 测试类型的三种方法,推荐第三种

        if type(L) == type([]): print("L is list")
        if type(L) == list: print("L is list")
        if isinstance(L, list): print("L is list")
    
    • 1
    • 2
    • 3

    1.3 Python数据类型:哈希类型、不可哈希类型

        # 哈希类型,即在原地不能改变的变量类型,不可变类型。可利用hash函数查看其hash值,也可以作为字典的key
    
        <span class="token string">"数字类型:int, float, decimal.Decimal, fractions.Fraction, complex"</span>
        <span class="token string">"字符串类型:str, bytes"</span>
        <span class="token string">"元组:tuple"</span>
        <span class="token string">"冻结集合:frozenset"</span>
        <span class="token string">"布尔类型:True, False"</span>
        <span class="token string">"None"</span>
    <span class="token comment"># 不可hash类型:原地可变类型:list、dict和set。它们不可以作为字典的key。</span>
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    1.4 数字常量

        1234, -1234, 0, 999999999                    # 整数
        1.23, 1., 3.14e-10, 4E210, 4.0e+210          # 浮点数
        0o177, 0x9ff, 0X9FF, 0b101010                # 八进制、十六进制、二进制数字
        3+4j, 3.0+4.0j, 3J                           # 复数常量,也可以用complex(real, image)来创建
        hex(I), oct(I), bin(I)                       # 将十进制数转化为十六进制、八进制、二进制表示的“字符串”
        int(str, base)                               # 将字符串转化为整数,base为进制数
        # 2.x中,有两种整数类型:一般整数(32位)和长整数(无穷精度)。可以用l或L结尾,迫使一般整数成为长整数
        float('inf'), float('-inf'), float('nan')    # 无穷大, 无穷小, 非数
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1.5 数字的表达式操作符

        yield x                                      # 生成器函数发送协议
        lambda args: expression                      # 生成匿名函数
        x if y else z                                # 三元选择表达式
        x and y, x or y, not x                       # 逻辑与、逻辑或、逻辑非
        x in y, x not in y                           # 成员对象测试
        x is y, x is not y                           # 对象实体测试
        x<y, x<=y, x>y, x>=y, x==y, x!=y             # 大小比较,集合子集或超集值相等性操作符
        1 < a < 3                                    # Python中允许连续比较
        x|y, x&y, x^y                                # 位或、位与、位异或
        x<<y, x>>y                                   # 位操作:x左移、右移y位
        +, -, *, /, //, %, **                        # 真除法、floor除法:返回不大于真除法结果的整数值、取余、幂运算
        -x, +x, ~x                                   # 一元减法、识别、按位求补(取反)
        x[i], x[i:j:k], x(……)                        # 索引、分片、调用
        int(3.14),  float(3)                         # 强制类型转换
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    1.6 整数可以利用bit_length函数测试所占的位数

        a = 1;       a.bit_length()    # 1
        a = 1024;    a.bit_length()    # 11
    
    • 1
    • 2

    1.7 repr和str显示格式的区别

        """
        repr格式:默认的交互模式回显,产生的结果看起来它们就像是代码。
        str格式:打印语句,转化成一种对用户更加友好的格式。
        """
    
    • 1
    • 2
    • 3
    • 4

    1.8 数字相关的模块

        # math模块
        # Decimal模块:小数模块
            import decimal
            from decimal import Decimal
            Decimal("0.01") + Decimal("0.02")        # 返回Decimal("0.03")
            decimal.getcontext().prec = 4            # 设置全局精度为4 即小数点后边4位
        # Fraction模块:分数模块
            from fractions import Fraction
            x = Fraction(4, 6)                       # 分数类型 4/6
            x = Fraction("0.25")                     # 分数类型 1/4 接收字符串类型的参数
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    1.9 集合set

        """
        set是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。
        set支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算。
        set支持x in set, len(set), for x in set。
        set不记录元素位置或者插入点, 因此不支持indexing, slicing, 或其它类序列的操作
        """
        s = set([3,5,9,10])                                  # 创建一个数值集合,返回{3, 5, 9, 10}
        t = set("Hello")                                     # 创建一个唯一字符的集合返回{}
        a = t | s          t.union(s)                        # t 和 s的并集
        b = t & s         t.intersection(s)                  # t 和 s的交集
        c = t – s         t.difference(s)                    # 求差集(项在t中, 但不在s中)  
        d = t ^ s          t.symmetric_difference(s)         # 对称差集(项在t或s中, 但不会同时出现在二者中)
        t.add('x')         t.remove('H')                     # 增加/删除一个item
         t.update([10,37,42])                                # 利用[......]更新s集合
        x in s,  x not in s                                  # 集合中是否存在某个值
        s.issubset(t)                                       #测试是否 s 中的每一个元素都在 t 中  
        s.issuperset(t)                                #测试是否 t 中的每一个元素都在 s 中   s.copy()  
        s.discard(x)                                  如果在 set “s”中存在元素 x, 则删除
        s.clear()
        s.remove(x)
        s.pop()
        {x**2 for x in [1, 2, 3, 4]}                         # 集合解析,结果:{16, 1, 4, 9}
        {x for x in 'spam'}                                  # 集合解析,结果:{'a', 'p', 's', 'm'}
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    1.10 集合frozenset,不可变对象

        """
        set是可变对象,即不存在hash值,不能作为字典的键值。同样的还有list、tuple等
        frozenset是不可变对象,即存在hash值,可作为字典的键值
        frozenset对象没有add、remove等方法,但有union/intersection/difference等方法
        """
        a = set([1, 2, 3])
        b = set()
        b.add(a)                     # error: set是不可哈希类型
        b.add(frozenset(a))          # ok,将set变为frozenset,可哈希
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    1.11 布尔类型bool

        type(True)                   # 返回<class 'bool'>
        isinstance(False, int)       # bool类型属于整形,所以返回True
        True == 1, True is 1         # 输出(True, False)
    
    • 1
    • 2
    • 3

    1.12 动态类型简介

       """
        变量名通过引用,指向对象。
        Python中的“类型”属于对象,而不是变量,每个对象都包含有头部信息,比如"类型标示符" "引用计数器"等
        """
        #共享引用及在原处修改:对于可变对象,要注意尽量不要共享引用!
        #共享引用和相等测试:
            L = [1], M = [1], L is M            # 返回False
            L = M = [1, 2, 3], L is M           # 返回True,共享引用
        #增强赋值和共享引用:普通+号会生成新的对象,而增强赋值+=会在原处修改
            L = M = [1, 2]
            L = L + [3, 4]                      # L = [1, 2, 3, 4], M = [1, 2]
            L += [3, 4]                         # L = [1, 2, 3, 4], M = [1, 2, 3, 4]
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    1.13 常见字符串常量和表达式

        S = ''                                  # 空字符串
        S = "spam’s"                            # 双引号和单引号相同
        S = "s\np\ta\x00m"                      # 转义字符
        S = """spam"""                          # 三重引号字符串,一般用于函数说明
        S = r'\temp'                            # Raw字符串,不会进行转义,抑制转义
        S = b'Spam'                             # Python3中的字节字符串
        S = u'spam'                             # Python2.6中的Unicode字符串
        s1+s2, s1*3, s[i], s[i:j], len(s)       # 字符串操作
        'a %s parrot' % 'kind'                  # 字符串格式化表达式
        'a {0} parrot'.format('kind')           # 字符串格式化方法
        for x in s: print(x)                    # 字符串迭代,成员关系
        [x*2 for x in s]                        # 字符串列表解析
        ','.join(['a', 'b', 'c'])               # 字符串输出,结果:a,b,c
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    1.14 内置str处理函数:

        str.upper()  str.lower()  str.swapcase()  str.capitalize()  str.title()     # 全部大写,全部小写、大小写转换,首字母大写,每个单词的首字母都大写
        str.ljust(width)                        # 获取固定长度,右对齐,左边不够用空格补齐
        str.rjust(width)                        # 获取固定长度,左对齐,右边不够用空格补齐
        str.center(width)                       # 获取固定长度,中间对齐,两边不够用空格补齐
        str.zfill(width)                        # 获取固定长度,右对齐,左边不足用0补齐
        str.find('t',start,end)                 # 查找字符串,可以指定起始及结束位置搜索
        str.rfind('t')                          # 从右边开始查找字符串
        str.count('t')                          # 查找字符串出现的次数
        #上面所有方法都可用index代替,不同的是使用index查找不到会抛异常,而find返回-1
        str.replace('old','new')                # 替换函数,替换old为new,参数中可以指定maxReplaceTimes,即替换指定次数的old为new
        str.strip()  str.lstrip()  str.rstrip()  str.strip('d')  str.lstrip('d')  str.rstrip('d')
        str.startswith('start')                 # 是否以start开头
        str.endswith('end')                     # 是否以end结尾
        str.isalnum()  str.isalpha()  str.isdigit()   str.islower()   str.isupper()  # 判断字符串是否全为 字母和数字、字符、数字、大写、小写
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    1.15 三重引号编写多行字符串块,并且在代码折行处嵌入换行字符\n

        mantra = """hello world
                hello python
                hello my friend"""
        # mantra为"""hello world \n hello python \n hello my friend"""
    
    • 1
    • 2
    • 3
    • 4
    • 5

    1.16 索引和分片:

    S[0], S[len(S) – 1], S[-1]               # 索引
    S[1:3], S[1:], S[:-1], S[1:10:2]         # 分片,第三个参数指定步长
    
    • 1
    • 2
    ## 1.17 字符串转换工具:
    ```python
        int('42'),  str(42)                      # 返回(42, '42')
        float('4.13'),  str(4.13)                # 返回(4.13, '4.13')
        ord('s'),  chr(115)                      # 返回(115, 's')
        int('1001', 2)                           # 将字符串作为二进制数字,转化为数字,返回13
        bin(13), oct(13), hex(13)                # 将整数转化为二进制/八进制/十六进制字符串,返回('1001', '0o15', '0xd')
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1.18 另类字符串连接

    name = "wang" "hong"                     #单行,name = "wanghong"
    name = "wang" \
            "hong"                           #多行,name = "wanghong"
    
    • 1
    • 2
    • 3
    ## 1.19 Python中的字符串格式化实现1(字符串格式化表达式)
    ```python
        """
        基于C语言的'print'模型,并且在大多数的现有的语言中使用。
        通用结构:%[(name)][flag][width].[precision]typecode
        """
        "this is %d %s bird" % (1, 'dead')                          # 一般的格式化表达式
        "%s---%s---%s" % (42, 3.14, [1, 2, 3])                      # 字符串输出:'42---3.14---[1, 2, 3]'
        "%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234)         # 对齐方式及填充:"1234...  1234...1234  ...001234"
        x = 1.23456789
        "%e | %f | %g" % (x, x, x)                                  # 对齐方式:"1.234568e+00 | 1.234568 | 1.23457"
        "%6.2f*%-6.2f*%06.2f*%+6.2f" % (x, x, x, x)                 # 对齐方式:'  1.23*1.23  *001.23* +1.23'
        "%(name1)d---%(name2)s" % {"name1":23, "name2":"value2"}    # 基于字典的格式化表达式
        "%(name)s is %(age)d" % vars()                              # vars()函数调用返回一个字典,包含了所有本函数调用时存在的变量
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    1.20 Python中的字符串格式化实现2(字符串格式化调用方法)

        # 普通调用
        "{0}, {1} and {2}".format('spam', 'ham', 'eggs')            # 基于位置的调用
        "{motto} and {pork}".format(motto = 'spam', pork = 'ham')   # 基于Key的调用
        "{motto} and {0}".format(ham, motto = 'spam')               # 混合调用
        # 添加键 属性 偏移量 (import sys)
        "my {1[spam]} runs {0.platform}".format(sys, {'spam':'laptop'})                 # 基于位置的键和属性
        "{config[spam]} {sys.platform}".format(sys = sys, config = {'spam':'laptop'})   # 基于Key的键和属性
        "first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C'])                       # 基于位置的偏移量
        # 具体格式化
        "{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159)   # 输出'3.141590e+00, 3.142e+00, 3.14159'
        "{fieldname:format_spec}".format(......)
        # 说明:
        """
            fieldname是指定参数的一个数字或关键字, 后边可跟可选的".name"或"[index]"成分引用
            format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
            fill        ::=  <any character>              #填充字符
            align       ::=  "<" | ">" | "=" | "^"        #对齐方式
            sign        ::=  "+" | "-" | " "              #符号说明
            width       ::=  integer                      #字符串宽度
            precision   ::=  integer                      #浮点数精度
            type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
        """
        # 例子:
            '={0:10} = {1:10}'.format('spam', 123.456)    # 输出'=spam       =    123.456'
            '={0:>10}='.format('test')                    # 输出'=      test='
            '={0:<10}='.format('test')                    # 输出'=test      ='
            '={0:^10}='.format('test')                    # 输出'=   test   ='
            '{0:X}, {1:o}, {2:b}'.format(255, 255, 255)   # 输出'FF, 377, 11111111'
            'My name is {0:{1}}.'.format('Fred', 8)       # 输出'My name is Fred    .'  动态指定参数
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    1.21 常用列表常量和操作

        L = [[1, 2], 'string', {}]                        # 嵌套列表
        L = list('spam')                                  # 列表初始化
        L = list(range(0, 4))                             # 列表初始化
        list(map(ord, 'spam'))                            # 列表解析
        len(L)                                            # 求列表长度
        L.count(value)                                    # 求列表中某个值的个数
        L.append(obj)                                     # 向列表的尾部添加数据,比如append(2),添加元素2
        L.insert(index, obj)                              # 向列表的指定index位置添加数据,index及其之后的数据后移
        L.extend(interable)                               # 通过添加iterable中的元素来扩展列表,比如extend([2]),添加元素2,注意和append的区别
        L.index(value, [start, [stop]])                   # 返回列表中值value的第一个索引
        L.pop([index])                                    # 删除并返回index处的元素,默认为删除并返回最后一个元素
        L.remove(value)                                   # 删除列表中的value值,只删除第一次出现的value的值
        L.reverse()                                       # 反转列表
        L.sort(cmp=None, key=None, reverse=False)         # 排序列表
        a = [1, 2, 3], b = a[10:]                         # 注意,这里不会引发IndexError异常,只会返回一个空的列表[]
        a = [], a += [1]                                  # 这里实在原有列表的基础上进行操作,即列表的id没有改变
        a = [], a = a + [1]                               # 这里最后的a要构建一个新的列表,即a的id发生了变化
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    1.22 用切片来删除序列的某一段

        a = [1, 2, 3, 4, 5, 6, 7]
        a[1:4] = []                                       # a = [1, 5, 6, 7]
        a = [0, 1, 2, 3, 4, 5, 6, 7]
        del a[::2]                                        # 去除偶数项(偶数索引的),a = [1, 3, 5, 7]
    
    • 1
    • 2
    • 3
    • 4
    • 5

    1.23 常用字典常量和操作

        D = {}
        D = {'spam':2, 'tol':{'ham':1}}                   # 嵌套字典
        D = dict.fromkeys(['s', 'd'], 8)                  # {'d': 8, 's': 8}
        D = dict(name = 'tom', age = 12)                  # {'age': 12, 'name': 'tom'}
        D = dict([('name', 'tom'), ('age', 12)])          # {'age': 12, 'name': 'tom'}
        D = dict(zip(['name', 'age'], ['tom', 12]))       # {'age': 12, 'name': 'tom'}
        D.keys()    D.values()    D.items()               # 字典键、值以及键值对
        D.get(key, default)                               # get函数
        D.update(D_other)                                 # 合并字典,如果存在相同的键值,D_other的数据会覆盖掉D的数据
        D.pop(key, [D])                                   # 删除字典中键值为key的项,返回键值为key的值,如果不存在,返回默认值D,否则异常
        D.popitem()                                       # pop字典中的一项(一个键值对)
        D.setdefault(k[, d])                              # 设置D中某一项的默认值。如果k存在,则返回D[k],否则设置D[k]=d,同时返回D[k]。
        del D                                             # 删除字典
        del D['key']                                      # 删除字典的某一项
        if key in D:   if key not in D:                   # 测试字典键是否存在
        # 字典注意事项:(1)对新索引赋值会添加一项(2)字典键不一定非得是字符串,也可以为任何的不可变对象
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    1.24 字典解析

        D = {k:8 for k in ['s', 'd']}                     # {'d': 8, 's': 8}
        D = {k:v for (k, v) in zip(['name', 'age'], ['tom', 12])}
    
    • 1
    • 2
    • 3

    1.25 字典的特殊方法_missing_:当查找找不到key时,会执行该方法

        class Dict(dict):
            def __missing__(self, key):
                self[key] = []
                return self[key]
        dct = Dict()
        dct["foo"].append(1)    # 这有点类似于collections.defalutdict
        dct["foo"]              # [1]
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1.26 元组和列表的唯一区别在于元组是不可变对象,列表时可变对象

        a = [1, 2, 3]           # a[1] = 0, OK
        a = (1, 2, 3)           # a[1] = 0, Error
        a = ([1, 2])            # a[0][1] = 0, OK
        a = [(1, 2)]            # a[0][1] = 0, Error
    
    • 1
    • 2
    • 3
    • 4
    • 5

    1.27 元组的特殊语法: 逗号和圆括号

        D = (12)                # 此时D为一个整数 即D = 12
        D = (12, )              # 此时D为一个元组 即D = (12, )
    
    • 1
    • 2
    • 3

    1.28 文件基本操作

        output = open(r'C:\spam', 'w')          # 打开输出文件,用于写
        input = open('data', 'r')               # 打开输入文件,用于读。打开的方式可以为'w', 'r', 'a', 'wb', 'rb', 'ab'等
        fp.read([size])                         # size为读取的长度,以byte为单位
        fp.readline([size])                     # 读一行,如果定义了size,有可能返回的只是一行的一部分
        fp.readlines([size])                    # 把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长。
        fp.readable()                           # 是否可读
        fp.write(str)                           # 把str写到文件中,write()并不会在str后加上一个换行符
        fp.writelines(seq)                      # 把seq的内容全部写到文件中(多行一次性写入)
        fp.writeable()                          # 是否可写
        fp.close()                              # 关闭文件。
        fp.flush()                              # 把缓冲区的内容写入硬盘
        fp.fileno()                             # 返回一个长整型的”文件标签“
        fp.isatty()                             # 文件是否是一个终端设备文件(unix系统中的)
        fp.tell()                               # 返回文件操作标记的当前位置,以文件的开头为原点
        fp.next()                               # 返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。
        fp.seek(offset[,whence])                # 将文件打操作标记移到offset的位置。whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。
        fp.seekable()                           # 是否可以seek
        fp.truncate([size])                     # 把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。
        for line in open('data'): 
            print(line)                         # 使用for语句,比较适用于打开比较大的文件
        open('f.txt', encoding = 'latin-1')     # Python3.x Unicode文本文件
        open('f.bin', 'rb')                     # Python3.x 二进制bytes文件
        # 文件对象还有相应的属性:buffer closed encoding errors line_buffering name newlines等
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    1.29 其他

        # Python中的真假值含义:1. 数字如果非零,则为真,0为假。 2. 其他对象如果非空,则为真
        # 通常意义下的类型分类:1. 数字、序列、映射。 2. 可变类型和不可变类型
    
    • 1
    • 2

    二:语法和语句

    2.1 赋值语句的形式

        spam = 'spam'                          # 基本形式
        spam, ham = 'spam', 'ham'              # 元组赋值形式
        [spam, ham] = ['s', 'h']               # 列表赋值形式
        a, b, c, d = 'abcd'                    # 序列赋值形式
        a, *b, c = 'spam'                      # 序列解包形式(Python3.x中才有)
        spam = ham = 'no'                      # 多目标赋值运算,涉及到共享引用
        spam += 'b'                             # spam会新开辟空间存储数据,不涉及到共享引用,此处与可变类型list不同
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    2.2 序列赋值 序列解包

        [a, b, c] = (1, 2, 3)                  # a = 1, b = 2, c = 3
        a, b, c, d = "spam"                    # a = 's', b = 'p'
        a, b, c = range(3)                     # a = 0, b = 1
        a, *b = [1, 2, 3, 4]                   # a = 1, b = [2, 3, 4]
        *a, b = [1, 2, 3, 4]                   # a = [1, 2, 3], b = 4
        a, *b, c = [1, 2, 3, 4]                # a = 1, b = [2, 3], c = 4
        # 带有*时 会优先匹配*之外的变量 如
        a, *b, c = [1, 2]                      # a = 1, c = 2, b = []
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2.3 print函数原型

        print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
        # 流的重定向
        print('hello world')                   # 等于sys.stdout.write('hello world')
        temp = sys.stdout                      # 原有流的保存
        sys.stdout = open('log.log', 'a')      # 流的重定向
        print('hello world')                   # 写入到文件log.log
        sys.stdout.close()
        sys.stdout = temp                      # 原有流的复原
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2.4 Python中and或or总是返回对象(左边的对象或右边的对象) 且具有短路求值的特性

        1 or 2 or 3                            # 返回 1
        1 and 2 and 3                          # 返回 3
    
    • 1
    • 2
    • 3

    2.5 if/else三元表达符(if语句在行内)

        A = 1 if X else 2
        A = 1 if X else (2 if Y else 3)
        # 也可以使用and-or语句(一条语句实现多个if-else)
        result = (a > 20 and "big than 20" or a > 10 and "big than 10" or a > 5 and "big than 5")
    
    • 1
    • 2
    • 3
    • 4
    • 5

    2.6 Python的while语句或者for语句可以带else语句 当然也可以带continue/break/pass语句

        while a > 1:
            ......
        else:
            ......
        # else语句会在循环结束后执行,除非在循环中执行了break,同样的还有for语句
        for i in range(5):
            ......
        else:
            ......
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    2.7 for循环的元组赋值

        for (a, b) in [(1, 2), (3, 4)]:                   # 最简单的赋值
        for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]:    # 自动解包赋值
        for ((a, b), c) in [((1, 2), 3), ("XY", 6)]:      # 自动解包 a = X, b = Y, c = 6
        for (a, *b) in [(1, 2, 3), (4, 5, 6)]:            # 自动解包赋值
    
    • 1
    • 2
    • 3
    • 4
    • 5

    2.8 列表解析语法

        M = [[1,2,3], [4,5,6], [7,8,9]]
        res = [sum(row) for row in M]                     # G = [6, 15, 24] 一般的列表解析 生成一个列表
        res = [c * 2 for c in 'spam']                     # ['ss', 'pp', 'aa', 'mm']
        res = [a * b for a in [1, 2] for b in [4, 5]]     # 多解析过程 返回[4, 5, 8, 10]
        res = [a for a in [1, 2, 3] if a < 2]             # 带判断条件的解析过程
        res = [a if a > 0 else 0 for a in [-1, 0, 1]]     # 带判断条件的高级解析过程
        # 两个列表同时解析:使用zip函数
        for teama, teamb in zip(["Packers", "49ers"], ["Ravens", "Patriots"]):
            print(teama + " vs. " + teamb)
        # 带索引的列表解析:使用enumerate函数
        for index, team in enumerate(["Packers", "49ers", "Ravens", "Patriots"]):
            print(index, team)                            # 输出0, Packers \n 1, 49ers \n ......
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    2.9 生成器表达式

    	M = ([6], [15], [24])
        G = (sum(row) for row in M)                       # 使用小括号可以创建所需结果的生成器generator object
        next(G), next(G), next(G)                         # 输出(6, 15, 24)
        G = {sum(row) for row in M}                       # G = {6, 15, 24} 解析语法还可以生成集合和字典
        G = {i:sum(M[i]) for i in range(3)}               # G = {0: 6, 1: 15, 2: 24}
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.10 文档字符串:出现在Module的开端以及其中函数或类的开端 使用三重引号字符串

        """
        module document
        """
        def func():
            """
            function document
            """
            print()
        class Employee:
            """
            class document
            """
            print()
        print(func.__doc__)         # 输出函数文档字符串
        print(Employee.__doc__)     # 输出类的文档字符串
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    2.11 命名惯例:

        """
        以单一下划线开头的变量名(_X)不会被from module import*等语句导入
        前后有两个下划线的变量名(__X__)是系统定义的变量名,对解释器有特殊意义
        以两个下划线开头但不以下划线结尾的变量名(__X)是类的本地(私有)变量
        """
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.12 列表解析 in成员关系测试 map sorted zip enumerate内置函数等都使用了迭代协议

        'first line' in open('test.txt')   # in测试 返回True或False
        list(map(str.upper, open('t')))    # map内置函数
        sorted(iter([2, 5, 8, 3, 1]))      # sorted内置函数
        list(zip([1, 2], [3, 4]))          # zip内置函数 [(1, 3), (2, 4)]
    
    • 1
    • 2
    • 3
    • 4
    • 5

    2.13 del语句: 手动删除某个变量

        del X
    
    • 1
    • 2

    2.14 获取列表的子表的方法:

        x = [1,2,3,4,5,6]
        x[:3]                              # 前3个[1,2,3]
        x[1:5]                             # 中间4个[2,3,4,5]
        x[-3:]                             # 最后3个[4,5,6]
        x[::2]                             # 奇数项[1,3,5]
        x[1::2]                            # 偶数项[2,4,6]
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    2.15 手动迭代:iter和next

        L = [1, 2]
        I = iter(L)                        # I为L的迭代器
        next(I)                           # 返回1
        next(I)                           # 返回2
        next(I)                           # Error:StopIteration
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.16 Python中的可迭代对象

        1.range迭代器
        2.mapzipfilter迭代器
        3.字典视图迭代器:D.keys()), D.items()4.文件类型
    
    • 1
    • 2
    • 3
    • 4

    三:函数语法规则

    3.1 函数相关的语句和表达式

        myfunc('spam')                     # 函数调用
        def myfunc():                      # 函数定义
        return None                        # 函数返回值
        global a                           # 全局变量
        nonlocal x                         # 在函数或其他作用域中使用外层(非全局)变量
        yield x                            # 生成器函数返回
        lambda                             # 匿名函数
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.2 Python函数变量名解析:LEGB原则,即:

        """
        local(functin) --> encloseing function locals --> global(module) --> build-in(python)
        说明:以下边的函数maker为例 则相对于action而言 X为Local N为Encloseing
        """
    
    • 1
    • 2
    • 3
    • 4
    • 5

    3.3 嵌套函数举例:工厂函数

        def maker(N):
            def action(X):
                return X ** N
            return action
        f = maker(2)                       # pass 2 to N
        f(3)                               # 9, pass 3 to X
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3.4 嵌套函数举例:lambda实例

        def maker(N):
            action = (lambda X: X**N)
            return action
        f = maker(2)                       # pass 2 to N
        f(3)                               # 9, pass 3 to X
    
    • 1
    • 2
    • 3
    • 4
    • 5

    3.5 nonlocal和global语句的区别

        # nonlocal应用于一个嵌套的函数的作用域中的一个名称 例如:
        start = 100
        def tester(start):
            def nested(label):
                nonlocal start             # 指定start为tester函数内的local变量 而不是global变量start
                print(label, start)
                start += 3
            return nested
        # global为全局的变量 即def之外的变量
        def tester(start):
            def nested(label):
                global start               # 指定start为global变量start
                print(label, start)
                start += 3
            return nested    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    3.6 函数参数,不可变参数通过“值”传递,可变参数通过“引用”传递

        def f(a, b, c): 
            print(a, b, c)
    
    f<span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">)</span>                                   <span class="token comment"># 参数位置匹配</span>
    f<span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">,</span> c <span class="token operator">=</span> <span class="token number">3</span><span class="token punctuation">,</span> b <span class="token operator">=</span> <span class="token number">2</span><span class="token punctuation">)</span>                           <span class="token comment"># 参数关键字匹配</span>
                              
    <span class="token keyword">def</span> <span class="token function">f</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span> b <span class="token operator">=</span> <span class="token number">1</span><span class="token punctuation">,</span> c <span class="token operator">=</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">:</span> 
        <span class="token keyword">print</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span> b<span class="token punctuation">,</span> c<span class="token punctuation">)</span>
        
    f<span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">)</span>                                         <span class="token comment"># 默认参数匹配</span>
    f<span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">)</span>                                      <span class="token comment"># 默认参数匹配</span>
    f<span class="token punctuation">(</span>a <span class="token operator">=</span> <span class="token number">1</span><span class="token punctuation">,</span> c <span class="token operator">=</span> <span class="token number">3</span><span class="token punctuation">)</span>                              <span class="token comment"># 关键字参数和默认参数的混合</span>
    <span class="token comment"># Keyword-Only参数:出现在*args之后 必须用关键字进行匹配</span>
    <span class="token keyword">def</span> <span class="token function">keyOnly</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span> <span class="token operator">*</span>b<span class="token punctuation">,</span> c<span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">''</span><span class="token punctuation">)</span>             <span class="token comment"># c就为keyword-only匹配 必须使用关键字c = value匹配</span>
    <span class="token keyword">def</span> <span class="token function">keyOnly</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span> <span class="token operator">*</span><span class="token punctuation">,</span> b<span class="token punctuation">,</span> c<span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>              <span class="token comment"># b c为keyword-only匹配 必须使用关键字匹配</span>
    <span class="token keyword">def</span> <span class="token function">keyOnly</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span> <span class="token operator">*</span><span class="token punctuation">,</span> b <span class="token operator">=</span> <span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">:</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>             <span class="token comment"># b有默认值 或者省略 或者使用关键字参数b = value</span>
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    3.7 可变参数匹配: * 和 **

        def f(*args): print(args)                    # 在元组中收集不匹配的位置参数
        f(1, 2, 3)                                   # 输出(1, 2, 3)
        def f(**args): print(args)                   # 在字典中收集不匹配的关键字参数
        f(a = 1, b = 2)                              # 输出{'a':1, 'b':2}
        def f(a, *b **c): print(a, b, c)             # 两者混合使用
        f(1, 2, 3, x = 4, y = 5)                     # 输出1, (2, 3), {'x':4, 'y':5}
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3.8 函数调用时的参数解包: * 和 ** 分别解包元组和字典

        func(1, *(2, 3))  <==>  func(1, 2, 3)
        func(1, **{'c':3, 'b':2})  <==>  func(1, b = 2, c = 3)
        func(1, *(2, 3), **{'c':3, 'b':2})  <==>  func(1, 2, 3, b = 2, c = 3)
    
    • 1
    • 2
    • 3

    3.9 函数属性:(自己定义的)函数可以添加属性

        def func():.....
        func.count = 1                      # 自定义函数添加属性
        print.count = 1                     # Error 内置函数不可以添加属性
    
    • 1
    • 2
    • 3
    • 4

    3.10 函数注解: 编写在def头部行 主要用于说明参数范围、参数类型、返回值类型等

        def func(a:'spam', b:(1, 10), c:float) -> int :
            print(a, b, c)
        func.__annotations__                # {'c':<class 'float'>, 'b':(1, 10), 'a':'spam', 'return':<class 'int'>}
        # 编写注解的同时 还是可以使用函数默认值 并且注解的位置位于=号的前边
        def func(a:'spam'='a', b:(1, 10)=2, c:float=3) -> int :
            print(a, b, c)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3.11 匿名函数:lambda

        f = lambda x, y, z : x + y + z      # 普通匿名函数,使用方法f(1, 2, 3)
        f = lambda x = 1, y = 1: x + y      # 带默认参数的lambda函数
        def action(x):                      # 嵌套lambda函数
            return (lambda y : x + y)
        f = lambda: a if xxx() else b       # 无参数的lambda函数,使用方法f()
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    3.12 lambda函数与map filter reduce函数的结合

        list(map((lambda x: x + 1), [1, 2, 3]))              # [2, 3, 4]
        list(filter((lambda x: x > 0), range(-4, 5)))        # [1, 2, 3, 4]
        functools.reduce((lambda x, y: x + y), [1, 2, 3])    # 6
        functools.reduce((lambda x, y: x * y), [2, 3, 4])    # 24
    
    • 1
    • 2
    • 3
    • 4
    • 5

    3.13 生成器函数:yield VS return

        def gensquare(N):
            for i in range(N):
                yield i** 2                 # 状态挂起 可以恢复到此时的状态
        for i in gensquare(5):              # 使用方法
            print(i, end = ' ')             # [0, 1, 4, 9, 16]
        x = gensquare(2)                    # x是一个生成对象
        next(x)                             # 等同于x.__next__() 返回0
        next(x)                             # 等同于x.__next__() 返回1
        next(x)                             # 等同于x.__next__() 抛出异常StopIteration
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    3.14 生成器表达式:小括号进行列表解析

        G = (x ** 2 for x in range(3))      # 使用小括号可以创建所需结果的生成器generator object
        next(G), next(G), next(G)           # 和上述中的生成器函数的返回值一致
        #(1)生成器(生成器函数/生成器表达式)是单个迭代对象
        G = (x ** 2 for x in range(4))
        I1 = iter(G)                        # 这里实际上iter(G) = G
        next(I1)                            # 输出0
        next(G)                             # 输出1
        next(I1)                            # 输出4
        #(2)生成器不保留迭代后的结果
        gen = (i for i in range(4))
        2 in gen                            # 返回True
        3 in gen                            # 返回True
        1 in gen                            # 返回False,其实检测2的时候,1已经就不在生成器中了,即1已经被迭代过了,同理2、3也不在了
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    3.15 本地变量是静态检测的

        X = 22                              # 全局变量X的声明和定义
        def test():
            print(X)                        # 如果没有下一语句 则该句合法 打印全局变量X
            X = 88                          # 这一语句使得上一语句非法 因为它使得X变成了本地变量 上一句变成了打印一个未定义的本地变量(局部变量)
            if False:                       # 即使这样的语句 也会把print语句视为非法语句 因为:
                X = 88                      # Python会无视if语句而仍然声明了局部变量X
        def test():                         # 改进
            global X                        # 声明变量X为全局变量
            print(X)                        # 打印全局变量X
            X = 88                          # 改变全局变量X
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    3.16 函数的默认值是在函数定义的时候实例化的 而不是在调用的时候 例子:

        def foo(numbers=[]):                # 这里的[]是可变的
            numbers.append(9)    
            print(numbers)
        foo()                               # first time, like before, [9]
        foo()                               # second time, not like before, [9, 9]
        foo()                               # third time, not like before too, [9, 9, 9]
        # 改进:
        def foo(numbers=None):
            if numbers is None: numbers = []
            numbers.append(9)
            print(numbers)
        # 另外一个例子 参数的默认值为不可变的:
        def foo(count=0):                   # 这里的0是数字, 是不可变的
            count += 1
            print(count)
        foo()                               # 输出1
        foo()                               # 还是输出1
        foo(3)                              # 输出4
        foo()                               # 还是输出1
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    四:函数例子

    4.1 数学运算类

        abs(x)                              # 求绝对值,参数可以是整型,也可以是复数,若参数是复数,则返回复数的模
        complex([real[, imag]])             # 创建一个复数
        divmod(a, b)                        # 分别取商和余数,注意:整型、浮点型都可以
        float([x])                          # 将一个字符串或数转换为浮点数。如果无参数将返回0.0
        int([x[, base]])                    # 将一个字符串或浮点数转换为int类型,base表示进制
        long([x[, base]])                   # 将一个字符串或浮点数转换为long类型
        pow(x, y)                           # 返回x的y次幂
        range([start], stop[, step])        # 产生一个序列,默认从0开始
        round(x[, n])                       # 四舍五入
        sum(iterable[, start])              # 对集合求和
        oct(x)                              # 将一个数字转化为8进制字符串
        hex(x)                              # 将一个数字转换为16进制字符串
        chr(i)                              # 返回给定int类型对应的ASCII字符
        unichr(i)                           # 返回给定int类型的unicode
        ord(c)                              # 返回ASCII字符对应的整数
        bin(x)                              # 将整数x转换为二进制字符串
        bool([x])                           # 将x转换为Boolean类型
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    4.2 集合类操作

        basestring()                        # str和unicode的超类,不能直接调用,可以用作isinstance判断
        format(value [, format_spec])       # 格式化输出字符串,格式化的参数顺序从0开始,如“I am {0},I like {1}”
        enumerate(sequence[, start=0])      # 返回一个可枚举的对象,注意它有第二个参数
        iter(obj[, sentinel])               # 生成一个对象的迭代器,第二个参数表示分隔符
        max(iterable[, args...][key])       # 返回集合中的最大值
        min(iterable[, args...][key])       # 返回集合中的最小值
        dict([arg])                         # 创建数据字典
        list([iterable])                    # 将一个集合类转换为另外一个集合类
        set()                               # set对象实例化
        frozenset([iterable])               # 产生一个不可变的set
        tuple([iterable])                   # 生成一个tuple类型
        str([object])                       # 转换为string类型
        sorted(iterable[, cmp[, key[, reverse]]])             # 集合排序
        L = [('b',2),('a',1),('c',3),('d',4)]
        sorted(L, key=lambda x: x[1], reverse=True)      # 使用Key参数和reverse参数
        sorted(L, key=lambda x: (x[0], x[1]))             # 使用key参数进行多条件排序,即如果x[0]相同,则比较x[1]
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    4.3 逻辑判断

        all(iterable)                       # 集合中的元素都为真的时候为真,特别的,若为空串返回为True
        any(iterable)                       # 集合中的元素有一个为真的时候为真,特别的,若为空串返回为False
    
    <span class="token triple-quoted-string string">"""IO操作"""</span>
    <span class="token builtin">file</span><span class="token punctuation">(</span>filename <span class="token punctuation">[</span><span class="token punctuation">,</span> mode <span class="token punctuation">[</span><span class="token punctuation">,</span> bufsize<span class="token punctuation">]</span><span class="token punctuation">]</span><span class="token punctuation">)</span> <span class="token comment"># file类型的构造函数。</span>
    <span class="token builtin">input</span><span class="token punctuation">(</span><span class="token punctuation">[</span>prompt<span class="token punctuation">]</span><span class="token punctuation">)</span>                     <span class="token comment"># 获取用户输入,推荐使用raw_input,因为该函数将不会捕获用户的错误输入</span>
    <span class="token builtin">raw_input</span><span class="token punctuation">(</span><span class="token punctuation">[</span>prompt<span class="token punctuation">]</span><span class="token punctuation">)</span>                 <span class="token comment"># 设置输入,输入都是作为字符串处理</span>
    <span class="token builtin">open</span><span class="token punctuation">(</span>name<span class="token punctuation">[</span><span class="token punctuation">,</span> mode<span class="token punctuation">[</span><span class="token punctuation">,</span> buffering<span class="token punctuation">]</span><span class="token punctuation">]</span><span class="token punctuation">)</span>     <span class="token comment"># 打开文件,与file有什么不同?推荐使用open</span>
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    4.4 其他

        callable(object)                    # 检查对象object是否可调用
        classmethod(func)                   # 用来说明这个func是个类方法
        staticmethod(func)                  # 用来说明这个func为静态方法
        dir([object])                       # 不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。
        help(obj)                           # 返回obj的帮助信息
        eval(expression)                    # 计算表达式expression的值,并返回
        exec(str)                           # 将str作为Python语句执行
        execfile(filename)                  # 用法类似exec(),不同的是execfile的参数filename为文件名,而exec的参数为字符串。
        filter(function, iterable)          # 构造一个序列,等价于[item for item in iterable if function(item)],function返回值为True或False的函数
            list(filter(bool, range(-3, 4)))# 返回[-3, -2, -1, 1, 2, 3], 没有0
        hasattr(object, name)               # 判断对象object是否包含名为name的特性
        getattr(object, name [, defalut])   # 获取一个类的属性
        setattr(object, name, value)        # 设置属性值
        delattr(object, name)               # 删除object对象名为name的属性
        globals()                           # 返回一个描述当前全局符号表的字典
        hash(object)                        # 如果对象object为哈希表类型,返回对象object的哈希值
        id(object)                          # 返回对象的唯一标识,一串数字
        isinstance(object, classinfo)       # 判断object是否是class的实例
            isinstance(1, int)              # 判断是不是int类型
            isinstance(1, (int, float))     # isinstance的第二个参数接受一个元组类型
        issubclass(class, classinfo)        # 判断class是否为classinfo的子类
        locals()                            # 返回当前的变量列表
        map(function, iterable, ...)        # 遍历每个元素,执行function操作
            list(map(abs, range(-3, 4)))    # 返回[3, 2, 1, 0, 1, 2, 3]
        next(iterator[, default])           # 类似于iterator.next()
        property([fget[, fset[, fdel[, doc]]]])           # 属性访问的包装类,设置后可以通过c.x=value等来访问setter和getter
        reduce(function, iterable[, initializer])         # 合并操作,从第一个开始是前两个参数,然后是前两个的结果与第三个合并进行处理,以此类推
            def add(x,y):return x + y 
            reduce(add, range(1, 11))                     # 返回55 (注:1+2+3+4+5+6+7+8+9+10 = 55)
            reduce(add, range(1, 11), 20)                 # 返回75
        reload(module)                      # 重新加载模块
        repr(object)                        # 将一个对象变幻为可打印的格式
        slice(start, stop[, step])          # 产生分片对象
        type(object)                        # 返回该object的类型
        vars([object])                      # 返回对象的变量名、变量值得字典
            a = Class();                    # Class为一个空类
            a.name = 'qi', a.age = 9
            vars(a)                         # {'name':'qi', 'age':9}
        zip([iterable, ...])                # 返回对应数组
            list(zip([1, 2, 3], [4, 5, 6])) # [(1, 4), (2, 5), (3, 6)]
            a = [1, 2, 3],  b = ["a", "b", "c"]
            z = zip(a, b)                   # 压缩:[(1, "a"), (2, "b"), (3, "c")]
            zip(*z)                         # 解压缩:[(1, 2, 3), ("a", "b", "c")]
        unicode(string, encoding, errors)   # 将字符串string转化为unicode形式,string为encoded string。
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    五:模块Moudle

    5.1 Python模块搜索路径:

        """
        (1)程序的主目录    (2)PYTHONPATH目录 (3)标准链接库目录 (4)任何.pth文件的内容
        """
    
    • 1
    • 2
    • 3
    • 4

    5.2 查看全部的模块搜索路径

        import sys
        sys.path
    
    • 1
    • 2
    • 3

    5.3模块的使用代码

        import module1, module2             # 导入module1 使用module1.printer()
        from module1 import printer         # 导入module1中的printer变量 使用printer()
        from module1 imoprt *               # 导入module1中的全部变量 使用不必添加module1前缀
    

    >重载模块reload: 这是一个内置函数 而不是一条语句
    from imp import reload
    reload(module)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    5.4 模块的包导入:使用点号(.)而不是路径(dir1\dir2)进行导入

        import dir1.dir2.mod                # d导入包(目录)dir1中的包dir2中的mod模块 此时dir1必须在Python可搜索路径中
        from dir1.dir2.mod import *         # from语法的包导入
    

    >_init_.py包文件:每个导入的包中都应该包含这么一个文件
    “”"
    该文件可以为空
    首次进行包导入时 该文件会自动执行
    高级功能:在该文件中使用__all__列表来定义包(目录)以from*的形式导入时 需要导入什么
    “”"

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    5.5 包相对导入:使用点号(.) 只能使用from语句

        from . import spam                  # 导入当前目录下的spam模块(错误: 当前目录下的模块, 直接导入即可)
        from .spam import name              # 导入当前目录下的spam模块的name属性(错误: 当前目录下的模块, 直接导入即可,不用加.)
        from .. import spam                 # 导入当前目录的父目录下的spam模块
    
    • 1
    • 2
    • 3
    • 4

    5.6 包相对导入与普通导入的区别

        from string import *                # 这里导入的string模块为sys.path路径上的 而不是本目录下的string模块(如果存在也不是)
        from .string import *               # 这里导入的string模块为本目录下的(不存在则导入失败) 而不是sys.path路径上的
    
    • 1
    • 2
    • 3

    5.7 模块数据隐藏:最小化from*的破坏

        _X                                  # 变量名前加下划线可以防止from*导入时该变量名被复制出去
        __all__ = ['x', 'x1', 'x2']         # 使用__all__列表指定from*时复制出去的变量名(变量名在列表中为字符串形式)
    

    >可以使用_name__进行模块的单元测试:当模块为顶层执行文件时值为’_main,当模块被导入时为模块名
    >
    if name == main:
    doSomething
    # 模块属性中还有其他属性,例如:
    doc # 模块的说明文档
    file # 模块文件的文件名,包括全路径
    name # 主文件或者被导入文件
    package # 模块所在的包

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    5.8 import语句from语句的as扩展

        import modulename as name
        from modulename import attrname as name
    
    • 1
    • 2
    • 3

    5.9 得到模块属性的几种方法 假设为了得到name属性的值

        M.name
        M.__dict__['name']
        sys.modules['M'].name
        getattr(M, 'name')
    
    • 1
    • 2
    • 3
    • 4

    六:类与面向对象

    6.1 最普通的类

        class C1(C2, C3):
            spam = 42                       # 数据属性
            def __init__(self, name):       # 函数属性:构造函数
                self.name = name
            def __del__(self):              # 函数属性:析构函数
                print("goodbey ", self.name)    
        I1 = C1('bob')
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    6.2 Python的类没有基于参数的函数重载

        class FirstClass:
            def test(self, string):
                print(string)
            def test(self):                 # 此时类中只有一个test函数 即后者test(self) 它覆盖掉前者带参数的test函数
                print("hello world")
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    6.3 子类扩展超类: 尽量调用超类的方法

        class Manager(Person):
            def giveRaise(self, percent, bonus = .10):
                self.pay = int(self.pay*(1 + percent + bonus))     # 不好的方式 复制粘贴超类代码
                Person.giveRaise(self, percent + bonus)            # 好的方式 尽量调用超类方法
    
    • 1
    • 2
    • 3
    • 4
    • 5

    6.4 类内省工具

        bob = Person('bob')
        bob.__class__                       # <class 'Person'>
        bob.__class__.__name__              # 'Person'
        bob.__dict__                        # {'pay':0, 'name':'bob', 'job':'Manager'}
    

    >返回1中 数据属性spam是属于类 而不是对象

    I1 <span class="token operator">=</span> C1<span class="token punctuation">(</span><span class="token string">'bob'</span><span class="token punctuation">)</span><span class="token punctuation">;</span> I2 <span class="token operator">=</span> C2<span class="token punctuation">(</span><span class="token string">'tom'</span><span class="token punctuation">)</span>      <span class="token comment"># 此时I1和I2的spam都为42 但是都是返回的C1的spam属性</span>
    C1<span class="token punctuation">.</span>spam <span class="token operator">=</span> <span class="token number">24</span>                        <span class="token comment"># 此时I1和I2的spam都为24</span>
    I1<span class="token punctuation">.</span>spam <span class="token operator">=</span> <span class="token number">3</span>                         <span class="token comment"># 此时I1新增自有属性spam 值为2 I2和C1的spam还都为24</span>
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    6.5 类方法调用的两种方式

        instance.method(arg...)
        class.method(instance, arg...)
    
    • 1
    • 2
    • 3

    6.6 抽象超类的实现方法

        # (1)某个函数中调用未定义的函数 子类中定义该函数
            def delegate(self):
                self.action()               # 本类中不定义action函数 所以使用delegate函数时就会出错
        # (2)定义action函数 但是返回异常
            def action(self):
                raise NotImplementedError("action must be defined")
        # (3)上述的两种方法还都可以定义实例对象 实际上可以利用@装饰器语法生成不能定义的抽象超类
            from abc import ABCMeta, abstractmethod
            class Super(metaclass = ABCMeta):
                @abstractmethod
                def action(self): pass
            x = Super()                     # 返回 TypeError: Can't instantiate abstract class Super with abstract methods action
    

    >OOP和继承: "is - a"的关系

    <span class="token keyword">class</span> <span class="token class-name">A</span><span class="token punctuation">(</span>B<span class="token punctuation">)</span><span class="token punctuation">:</span>
        <span class="token keyword">pass</span>
    a <span class="token operator">=</span> A<span class="token punctuation">(</span><span class="token punctuation">)</span>
    <span class="token builtin">isinstance</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span> B<span class="token punctuation">)</span>                    <span class="token comment"># 返回True, A是B的子类 a也是B的一种</span>
    <span class="token comment"># OOP和组合: "has- a"的关系</span>
    <span class="token keyword">pass</span>
    <span class="token comment"># OOP和委托: "包装"对象 在Python中委托通常是以"__getattr__"钩子方法实现的, 这个方法会拦截对不存在属性的读取</span>
    <span class="token comment"># 包装类(或者称为代理类)可以使用__getattr__把任意读取转发给被包装的对象</span>
    <span class="token keyword">class</span> <span class="token class-name">wrapper</span><span class="token punctuation">:</span>
        <span class="token keyword">def</span> <span class="token function">__init__</span><span class="token punctuation">(</span>self<span class="token punctuation">,</span> <span class="token builtin">object</span><span class="token punctuation">)</span><span class="token punctuation">:</span>
            self<span class="token punctuation">.</span>wrapped <span class="token operator">=</span> <span class="token builtin">object</span>
        <span class="token keyword">def</span> <span class="token function">__getattr</span><span class="token punctuation">(</span>self<span class="token punctuation">,</span> attrname<span class="token punctuation">)</span><span class="token punctuation">:</span>
            <span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">'Trace: '</span><span class="token punctuation">,</span> attrname<span class="token punctuation">)</span>
            <span class="token keyword">return</span> <span class="token builtin">getattr</span><span class="token punctuation">(</span>self<span class="token punctuation">.</span>wrapped<span class="token punctuation">,</span> attrname<span class="token punctuation">)</span>
    <span class="token comment"># 注:这里使用getattr(X, N)内置函数以变量名字符串N从包装对象X中取出属性 类似于X.__dict__[N]</span>
    x <span class="token operator">=</span> wrapper<span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token number">1</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">]</span><span class="token punctuation">)</span>
    x<span class="token punctuation">.</span>append<span class="token punctuation">(</span><span class="token number">4</span><span class="token punctuation">)</span>                         <span class="token comment"># 返回 "Trace: append" [1, 2, 3, 4]</span>
    x <span class="token operator">=</span> wrapper<span class="token punctuation">(</span><span class="token punctuation">{</span><span class="token string">'a'</span><span class="token punctuation">:</span><span class="token number">1</span><span class="token punctuation">,</span> <span class="token string">'b'</span><span class="token punctuation">:</span><span class="token number">2</span><span class="token punctuation">}</span><span class="token punctuation">)</span>
    <span class="token builtin">list</span><span class="token punctuation">(</span>x<span class="token punctuation">.</span>keys<span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span>                      <span class="token comment"># 返回 "Trace: keys" ['a', 'b']</span>
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    6.7 类的伪私有属性:使用__str

        class C1:
            def __init__(self, name):
                self.__name = name          # 此时类的__name属性为伪私有属性 原理 它会自动变成self._C1__name = name
            def __str__(self):
                return 'self.name = %s' % self.__name
        I = C1('tom')
        print(I)                            # 返回 self.name = tom
        I.__name = 'jeey'                   # 这里无法访问 __name为伪私有属性
        I._C1__name = 'jeey'                # 这里可以修改成功 self.name = jeey
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    6.8 类方法是对象:无绑定类方法对象 / 绑定实例方法对象

        class Spam:
            def doit(self, message):
                print(message)
            def selfless(message)
                print(message)
        obj = Spam()
        x = obj.doit                        # 类的绑定方法对象 实例 + 函数
        x('hello world')
        x = Spam.doit                       # 类的无绑定方法对象 类名 + 函数
        x(obj, 'hello world')
        x = Spam.selfless                   # 类的无绑定方法是函数 在3.0之前无效
        x('hello world')
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    6.9 获取对象信息: 属性和方法

        a = MyObject()
        dir(a)                              # 使用dir函数
        hasattr(a, 'x')                     # 测试是否有x属性或方法 即a.x是否已经存在
        setattr(a, 'y', 19)                 # 设置属性或方法 等同于a.y = 19
        getattr(a, 'z', 0)                  # 获取属性或方法 如果属性不存在 则返回默认值0
        #这里有个小技巧,setattr可以设置一个不能访问到的属性,即只能用getattr获取
        setattr(a, "can't touch", 100)      # 这里的属性名带有空格,不能直接访问
        getattr(a, "can't touch", 0)        # 但是可以用getattr获取
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    6.10 为类动态绑定属性或方法: MethodType方法

        # 一般创建了一个class的实例后, 可以给该实例绑定任何属性和方法, 这就是动态语言的灵活性
        class Student(object):
            pass
        s = Student()
        s
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,405
精华内容 562
关键字:

python知识点汇总

python 订阅