python3_内置函数__全部内置函数及使用_all/repr/bytearray/exec/compile/filter/map/format/property

痛定思痛。 2022-05-16 08:21 141阅读 0赞

# 1.内置函数列表如下： #

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>&nbsp;</th> 
   <th>内</th> 
   <th>置</th> 
   <th>函</th> 
   <th>数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>abs()</td> 
   <td>dict()</td> 
   <td>help()</td> 
   <td>min()</td> 
   <td>setattr()</td> 
  </tr> 
  <tr> 
   <td>all()</td> 
   <td>dir()</td> 
   <td>hex()</td> 
   <td>next()</td> 
   <td>slice()</td> 
  </tr> 
  <tr> 
   <td>any()</td> 
   <td>divmod()</td> 
   <td>id()</td> 
   <td>object()</td> 
   <td>sorted()</td> 
  </tr> 
  <tr> 
   <td>ascii()</td> 
   <td>enumerate()</td> 
   <td>input()</td> 
   <td>oct()</td> 
   <td>staticmethod()</td> 
  </tr> 
  <tr> 
   <td>bin()</td> 
   <td>eval()</td> 
   <td>int()</td> 
   <td>open()</td> 
   <td>str()</td> 
  </tr> 
  <tr> 
   <td>bool()</td> 
   <td>exec()</td> 
   <td>isinstance()</td> 
   <td>ord()</td> 
   <td>sum()</td> 
  </tr> 
  <tr> 
   <td>bytearray()</td> 
   <td>filter()</td> 
   <td>issubclass()</td> 
   <td>pow()</td> 
   <td>super()</td> 
  </tr> 
  <tr> 
   <td>bytes()</td> 
   <td>float()</td> 
   <td>iter()</td> 
   <td>print()</td> 
   <td>tuple()</td> 
  </tr> 
  <tr> 
   <td>callable()</td> 
   <td>format()</td> 
   <td>len()</td> 
   <td>property()</td> 
   <td>type()</td> 
  </tr> 
  <tr> 
   <td>chr()</td> 
   <td>frozenset()</td> 
   <td>list()</td> 
   <td>range()</td> 
   <td>vars()</td> 
  </tr> 
  <tr> 
   <td>classmethod()</td> 
   <td>getattr()</td> 
   <td>locals()</td> 
   <td>repr()</td> 
   <td>zip()</td> 
  </tr> 
  <tr> 
   <td>compile()</td> 
   <td>globals()</td> 
   <td>map()</td> 
   <td>reversed()</td> 
   <td>__import__()</td> 
  </tr> 
  <tr> 
   <td>complex()</td> 
   <td>hasattr()</td> 
   <td>max()</td> 
   <td>round()</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>delattr()</td> 
   <td>hash()</td> 
   <td>memoryview()</td> 
   <td>set()</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

# 2.内置函数讲解 #

> 1. **abs()**: 返回数字绝对值

> 2. **all()**: 判断给定的可迭代对象iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。**元素除了0，** 
> 
> **    NULL， False为全部为True。**
> 
>     **any()**: 判断给定的可迭代参数 iterable 是否全部为 False，全为False返回 False，如果有一个为 True，则返回 True。
> 
> 元素除了是 0、空、FALSE 外都算 TRUE。

print(all([0, 1, -1]))     # False
    print(all([-3, 1, -1]))    # True
    print(all([-3, "", -1]))   # False
    
    print(any([0, 0, 0]))      # False
    print(any([1, 0, 0]))      # True
    print(any([-1, 0, 0]))     # True
    print(any([]))             # False

> 3. **ascii()**: 类似 repr() 函数, **返回一个表示对象的字符串**, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \\x, \\u 或 \\U 编码的字符。生成字符串类似 Python2 版本中 repr() 函数的返回值。
> 
>     **repr()**: 返回对象的规范字符串表示形式。对于许多对象类型，包括大多数内置函数，**eval（repr（obj））== obj**

# ascii()
    # \x为utf-8的编码格式
    # \u为Unicode编码格式
    print(ascii(12612345567789999))     # '12612345567789999'
    print(ascii("abcfg"))               # 'abcfg'
    print(ascii([1, 2, 3]))             # '[1, 2, 3]'
    print(ascii({"name": "mx"}))        # '{"name": "mx"}'
    print(ascii("我"))                  # '\u6211'
    
    
    # repr()
    # 返回对象的规范字符串表示形式。对于许多对象类型，包括大多数内置函数，eval（repr（obj））== obj
    a = [1, 2]
    b = eval(repr(a))
    print(a, b, type(a), type(b))       # [1, 2] [1, 2] <class 'list'> <class 'list'>

> 4. **bin()**: 返回一个整数的二进制表示形式。（python3中全部为整形，没有长整型）

# bin()
    
    print(bin(1))    # 0b1
    print(bin(2))    # 0b10
    print(bin(255))  # 0b11111111
    print(bin(256))  # 0b100000000

> 5. **bytearray()**: 返回一个新字节数组。这个**数组里的元素是可变的**，并且每个元素的值范围: 0 <= x < 256
> 
>     **注意**：数组为可变数组。以a3为例，想要修改第一个字母t为a, a\[0\] = 97。（此时可修改，别忘了字符串本身不可修改）
> 
>     **bytes()**: bytearray()的**不可变**版本。

# bytearray()
    # 返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
    # (1) 如果没有输入任何参数，默认就是初始化数组为0个元素。
    # (2) 如果 source 为整数，则返回一个长度为source且初始化元素为\x00的初始化数组
    # (3) 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列
    # (4) 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数
    # (5) 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
    
    a1 = bytearray()                                  # bytearray(b'')
    a2 = bytearray(10)                                # a2: bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
    a3 = bytearray("test", encoding="utf-8")          # bytearray(b'test')
    a4 = bytearray([1, 3, 255])                       # bytearray(b'\x01\x03\xff')

> 6. **callable()**: 用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。**函数, lambda 匿名函数, 类, 以及实现了 \_\_call\_\_ 方法的类实例, 它都返回 True。**

def test():
        pass
    
    
    class A(object):
        def produce(self):
            pass
    
    
    class B(object):
        def __call__(self, *args, **kwargs):
            pass
    
    
    if "__main__" == __name__:
        a = A()
        b = B()
        print(callable(test))          # True
        print(callable(lambda x: x))   # True
        print(callable(a.produce()))   # False
        print(callable(A))             # True
        print(callable(B))             # True
        print(callable(a))             # False
        print(callable(b))             # True

> 7. **classmethod()**: 修饰符对应的函数不需要实例化，**不需要 self 参数**，但第一个参数需要是表示自身类的 **cls 参数**，可以来调用类的属性，类的方法，实例化对象等

# classmethod
    class C(object):
    
        bar = "bar"
        def __init__(self):
            print("this is init")
    
        @classmethod
        def test(cls):
            print("this is test()")
            print(cls)
            print(cls.bar)
            print(cls().__init__())
    
    
    c = C()
    C.test()
    c.test()

> 8. **exec()**: 执行储存在**字符串**或**文件**中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码
> 
>     **eval()**: 执行一个**字符串**表达式，并返回表达式的值。
> 
>   【注意】：globals=\{\}和locals=\{\}相当于对expression中的变量进行赋值。

# eval()
    # 执行一个字符串表达式，并返回表达式的值。
    # eval(expression, globals, locals)
    # expression -- 表达式
    # globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
    # locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
    print(eval("1+2"))          # 3
    print(eval("3*8"))          # 24
    print(eval("pow(2, 4)"))    # 16
    a = 520
    expr = "a + 1"
    print(eval(expr))           # 521
    
    def test():
        print(eval(expr, {"a": 520}, {"a": 1}))  # 2
    
    test()
    
    
    
    # exec()
    # 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码
    # exec(object, globals, locals)
    # object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
    # globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
    # locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
    exec("""for i in range(5):
                      print ("iter time: %d" % i)
                      """)
    
    x = 10
    expr = """
    z = 30
    sum = x + y + z
    print(sum)
    """
    
    def func():
        y = 20
        exec(expr)                                       # 60
        exec(expr, {'x': 1, 'y': 2})                     # 33
        exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})   # 34
    
    func()

> 9. **compile()**: 将一个字符串编译为字节代码。
> 
>     **complex()**: 创建一个值为 **real + imag \* j 的复数**或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。real(实部)： int, float, str  ----  imag(虚部): int, float

# compile()
    # compile(source, filename, mode, flags, dont_inherit)
    # 将一个字符串编译为字节代码。
    # source -- 字符串或者AST（Abstract Syntax Trees）对象。
    # filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。("")
    # mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
    # flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
    # flags和dont_inherit是用来控制编译源码时的标志
    
    str = "for i in range(0,10): print(i)"
    c = compile(str, "", "exec")
    exec(str)
    exec(c)
    
    
    # complex()
    # class complex(real, imag)
    print(complex(1))
    print(complex(1.0))
    print(complex("1.0"))
    print(complex(1, 2))
    print(complex(1, 2.0))
    print(complex("1 + 2j"))

> 10. **delattr()**: 删除类实例化对象的**属性**。
> 
>       **getattr()**: 返回一个对象的**属性值**。
> 
>       **hasattr():** 判断对象、类，是否包含对应的**属性**。
> 
>       **setattr()**: 用于**设置属性值**，且该属性必须存在。

# delattr()
    # delattr(object, name)
    # 删除类实例化对象的属性
    class Cooperation(object):
        a = 1
        b = 2
        c = 3
    
        @staticmethod
        def test():
            print("this is test")
    
    p = Cooperation()
    print("a:", p.a, "b:", p.b, "c:", p.c)
    Cooperation.test()
    print("----------删除c属性后----------")
    delattr(Cooperation, "c")
    # delattr(Cooperation, "test")  # error
    print(getattr(Cooperation, "b"))
    print(getattr(p, "b"))
    
    
    # ---------------------------------------------------------------------------------------
    # hasattr()
    # 判断对象、类是否包含对应的属性
    # hasattr(object, name)
    # name: 属性名（字符串）
    class Coordinate(object):
        a = 1
    
        def __init__(self):
            self.b = 2
    
        def test(self):
            print("this is test function")
    
    p = Coordinate()
    print(hasattr(p, "a"))              # True
    print(hasattr(p, "b"))              # True
    print(hasattr(p, "test"))           # True
    print(hasattr(Coordinate, "a"))     # True
    print(hasattr(Coordinate, "b"))     # False
    print(hasattr(Coordinate, "test"))  # True
    
    # ---------------------------------------------------------------------------------------
    # setattr()
    # 设置对象属性值
    # setattr(object, name, value)
    setattr(p, "a", 44)
    setattr(p, "b", 55)
    print(getattr(p, "a", "error"))     # 44
    print(getattr(p, "b", "error"))     # 55

> 11. **dir()**: 不带参数时，返回当前范围内的变量、函数、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法\_\_dir\_\_()，该方法将被调用。如果参数不包含\_\_dir\_\_()，该方法将最大限度地收集参数信息。
> 
>      **divmod()**: 把**除数和余数运算结果结合起来**，返回一个包含商和余数的元组(a // b, a % b)。python 2.3 版本之前不允许处理复数。

# dir()
    # dir(object)
    # 不带参数时，返回当前范围内的变量、函数、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
    # 如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
    a = 1
    
    
    class D(object):
        b = 2
    
        def __init__(self):
            self.c = 3
            print("dir1:\n", dir())  # ['self']
    
        print("dir2:\n", dir())      # ['__dir__', '__init__', '__module__', '__qualname__', 'b']
    
    
    def test2():
        d = 2
    
    
    d1 = D()
    
    
    print("dir3:\n", dir())           # ['D', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'd1', 'test2']
    
    
    
    # divmod()
    # divmod(num1, num2)
    # 把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。python 2.3 版本之前不允许处理复数。
    dm = divmod(7, 2)
    dm = divmod(7.5, 2)
    print(dm, type(dm))
    print("divisor:", dm[0], "\nremainder:", dm[1])

> 12. **enumerate()**: 用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，**同时列出数据和数据下标**，一般用在 for 循环当中。重要应用：文件的高效读取（生成器）。

# enumerate()
    # 用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
    # 重要应用：文件的高效读取（生成器）
    # enumerate(sequence, start)
    # sequence:  一个序列、迭代器或其他支持迭代对象
    # start: 下标开始编号的起始位置
    f = open("test.txt", "r", encoding="utf-8")
    print(type(f))
    
    for index, line in enumerate(f):
        print(index, line)
    
    f.close()

> 13. **filter()**: **用于过滤序列，过滤掉不符合条件的元素**，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中
> 
>       **map()**: 将**函数依次作用于可迭代对象的每一个元素**，每次作用的结果储存于返回的迭代器中。（python3中返回迭代器）。function可以有多个参数， 同时对应相加的可迭代对象也应增加。**停止的条件以最短的可迭代对象为准**。
> 
>       **两者的区别**：filter是通过生成True和False组成的迭代器将可迭代对象中不符合条件的元素过滤掉；而map返回的则是True和False组成的迭代器。

# filter()
    # 用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
    # 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中
    # filter(function, iterable)
    itb = filter(lambda x: x%2 == 0, range(10))
    
    # for item in itb:
    #     print(item)
    newlist = list(itb)
    print(newlist)
    
    
    # map()
    # 将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表re中
    # map(function, iterable)
    res1 = map(lambda n: n > 5, range(10))
    lt1 = list(res1)
    print(lt1)          # [False, False, False, False, False, False, True, True, True, True]
    
    res3 = map(lambda x, y: x+y, range(10), range(10))
    for i in res3:
        print(i)
    
    res4 = map(lambda x, y: x+y, range(10), range(5))
    for i in res4:
        print(i)
    
    # ----------------------------------------区  别-------------------------------------- #
    res2 = filter(lambda n: n > 5, range(10))
    lt = list(res2)
    print(lt)           # [6, 7, 8, 9]

> 14. **format()**: python2.6 开始，新增了一种**格式化字符串**的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 **\{\} 和 : 来代替以前的 %**。format 函数可以接受不限个参数，位置可以不按顺序。str.format() **格式化数字**也有多种方法。
> 
>      **注意：格式化数字的常用方式**
> 
> <table> 
>  <tbody> 
>   <tr> 
>    <th>数字</th> 
>    <th>格式</th> 
>    <th>输出</th> 
>    <th>描述</th> 
>   </tr> 
>   <tr> 
>    <td>3.1415926</td> 
>    <td>{:.2f}</td> 
>    <td>3.14</td> 
>    <td>保留小数点后两位</td> 
>   </tr> 
>   <tr> 
>    <td>3.1415926</td> 
>    <td>{:+.2f}</td> 
>    <td>+3.14</td> 
>    <td>带符号保留小数点后两位</td> 
>   </tr> 
>   <tr> 
>    <td>-1</td> 
>    <td>{:+.2f}</td> 
>    <td>-1.00</td> 
>    <td>带符号保留小数点后两位</td> 
>   </tr> 
>   <tr> 
>    <td>2.71828</td> 
>    <td>{:.0f}</td> 
>    <td>3</td> 
>    <td>不带小数</td> 
>   </tr> 
>   <tr> 
>    <td>5</td> 
>    <td>{:0&gt;2d}</td> 
>    <td>05</td> 
>    <td>数字补零 (填充左边, 宽度为2)</td> 
>   </tr> 
>   <tr> 
>    <td>5</td> 
>    <td>{:x&lt;4d}</td> 
>    <td>5xxx</td> 
>    <td>数字补x (填充右边, 宽度为4)</td> 
>   </tr> 
>   <tr> 
>    <td>10</td> 
>    <td>{:x&lt;4d}</td> 
>    <td>10xx</td> 
>    <td>数字补x (填充右边, 宽度为4)</td> 
>   </tr> 
>   <tr> 
>    <td>1000000</td> 
>    <td>{:,}</td> 
>    <td>1,000,000</td> 
>    <td>以逗号分隔的数字格式</td> 
>   </tr> 
>   <tr> 
>    <td>0.25</td> 
>    <td>{:.2%}</td> 
>    <td>25.00%</td> 
>    <td>百分比格式</td> 
>   </tr> 
>   <tr> 
>    <td>1000000000</td> 
>    <td>{:.2e}</td> 
>    <td>1.00e+09</td> 
>    <td>指数记法</td> 
>   </tr> 
>   <tr> 
>    <td>13</td> 
>    <td>{:10d}</td> 
>    <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;13</td> 
>    <td>右对齐 (默认, 宽度为10)</td> 
>   </tr> 
>   <tr> 
>    <td>13</td> 
>    <td>{:&lt;10d}</td> 
>    <td>13</td> 
>    <td>左对齐 (宽度为10)</td> 
>   </tr> 
>   <tr> 
>    <td>13</td> 
>    <td>{:^10d}</td> 
>    <td>&nbsp;&nbsp;&nbsp;&nbsp;13</td> 
>    <td>中间对齐 (宽度为10)</td> 
>   </tr> 
>   <tr> 
>    <td>11</td> 
>    <td> <pre><code>'{:b}'.format(11)
> '{:d}'.format(11)
> '{:o}'.format(11)
> '{:x}'.format(11)
> '{:#x}'.format(11)
> '{:#X}'.format(11)</code></pre> </td> 
>    <td> <pre><code>1011
> 11
> 13
> b
> 0xb
> 0XB</code></pre> </td> 
>    <td>进制</td> 
>   </tr> 
>  </tbody> 
> </table>

# format()
    # Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
    # 基本语法是通过 {} 和 : 来代替以前的 %
    # format 函数可以接受不限个参数，位置可以不按顺序
    # str.format() 格式化数字也有多种方法
    
    # 1.不设置制定位置，按照默认顺序
    print("{} {}".format("my", "brother"))
    
    # 2.设置指定位置
    print("{1} {0}".format("my", "brother"))
    
    # 3.关键词参数设置
    dt = {"name": "maxin", "age": 23}
    lt = ["maxin", 23]
    tp = ("maxin", 23)
    print("姓名：{name}, 年龄：{age}".format(**dt))
    print("姓名：{0[0]}, 年龄：{0[1]}".format(lt))  # 0是必须的
    print("姓名：{0[0]}, 年龄：{0[1]}".format(tp))  # 0是必须的
    
    # 4.format()可传入对象
    class FmTest(object):
        def __init__(self, value=24):
            self.value = value
    my_value = FmTest(250)
    print("value：{0.value}".format(my_value))     # 0是必须的
    
    # 5.format()格式化数字
    print("{:.2f}".format(2.1463456))
    print("{:0>5d}".format(2))
    print("{:0<5d}".format(2))
    print("{:0^5d}".format(2))

> 15. **globals()**: 以字典类型返回**当前位置的全部全局变量**
> 
>       **locals()**: 以字典类型返回**当前位置的全部局部变量**。对于函数, 方法, lambda 函式, 类, 以及类实例, 它都返回 True。

# globals()
    # locals()
    
    a = 1
    
    def test():
        b = 2
        print("test locals():", locals())
        def test_in():
            print("test_in locals():", locals())
    
    c = lambda x: x+5
    
    class Ta(object):
        d = 4
        print("Ta locals():", locals())
        def __init__(self):
            self.e = 5
            print("__init__ locals():", locals())
    
    test()
    ta = Ta()
    print(globals())
    print("locals():", locals())

> 16. **hash()**: 获取一个对象、字符串、数值的**哈希值**。在 **hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。**

# hash()
    # hash(object)
    # 可以应用于数字、字符串和对象，不能直接应用于 list、dictionary、set。
    # 在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。
    class Test(object):
        def __init__(self, i):
            self.i = i
    
    
    for i in range(10):
        t = Test(i)
        print(hash(t), id(t))
    
    print(hash(str([1, 2])))
    print(hash((1, 2)))
    print(hash(str({"name": "maxin"})))
    print(hash(str(set([1, 2]))))

> 17. **isinstance()**: 判断一个对象是否是一个已知的类型，类似 type()。
> 
>       **type()**: 如果你只有一个参数则返回对象的类型。三个参数返回新的类型对象。
> 
>       **两者区别**：isinstance()考虑子类与父类之间的继承关系；type()并不考虑子类与父类之间的继承关系。若**判断两个类型是否相同最好使用isinstance()函数。**
> 
> **      issubclass()**: 判断类A是否是类B的**子类**

# isinstance()
    # 判断一个对象是否是一个已知的类型，类似 type()
    # isinstance(object, classinfo)
    # object: 实例对象
    # classinfo: 可以是直接或间接类名、基本类型或者由它们组成的元组。
    a = 2
    print(isinstance(a, str))
    print(isinstance(a, int))
    print(isinstance(a, (str, int)))
    
    
    # type()
    # 如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
    # class type(name, bases, dict)
    # name: 类名称
    # bases: 基类元组((object))
    # dict: 字典，类内定义的命名空间变量。
    # 1.一个参数
    print(type(1))
    print(type([]))
    print(type({}))
    print(type(()))
    # 2.三个参数
    Te = type("Te", (object,), dict(a=1))  # 产生一个新的类型 X
    print(Te)
    
    
    # ---------------------------------------两者区别----------------------------------------#
    class A(object):
        pass
    class B(A):
        pass
    
    print(isinstance(A(), A))  # True
    print(type(A()) == A)      # True
    print(isinstance(B(), A))  # True
    print(type(B()) == A)      # False
    
    
    # issubclass()
    # issubclass(class, classinfo)
    # 判断class（类）是否是classinfo（类）的子类
    
    print(issubclass(B, A))  # True
    print(issubclass(B, B))  # True
    print(issubclass(A, B))  # False

> 18. **iter()**: **生成迭代器**。如果传递了第二个参数，则object对象必须是一个可调用的对象（实现了\_\_call\_\_方法）。
> 
>       **list()**: 将可迭代对象转化为列表。

# iter()
    # 生成迭代器
    # iter(object, sentinel)
    # 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
    a = [1, 2]                        # <class 'list_iterator'>
    b = (1, 2)                        # <class 'tuple_iterator'>
    c = {"name": "maxin", "age": 23}  # <class 'dict_keyiterator'>
    d = set(a)                        # <class 'set_iterator'>
    # res = iter(a)
    # res = iter(b)
    # res = iter(c)
    # res = iter(d)
    # print(type(res))
    # for item in res:
    #     print(item)
    
    def e():
        pass
    res = iter(e, "test")             # <callable_iterator object at 0x0000026CCBB2E0B8>
    print(res)
    for i in res:
        print(i)

> 19. **memoryview()**: **返回给定参数的内存查看对象**(Momory view)。所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

# memoryview()
    # 返回给定参数的内存查看对象(Momory view)。
    # 所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
    v = memoryview(bytearray("abcdef", "utf-8"))
    print(v[0])
    print(v[-1])
    print(v[1:4])
    print(type(v))           # <class 'memoryview'>
    print(v[0:3].tobytes())  # b'abc'

> 20. **property()**: 在新式类（继承自object）中返回属性值。
> 
>       [property详细讲解][property]

> 21.**range()**: python3中range()返回的是一个**整数序列的对象**，而并非列表，但可通过list函数进行转换。
> 
>     ** round()**: 对round函数进行近似取值，保留几位小数。但是，**[这个函数也有一些坑][Link 1]**。

# range()
    # 可创建一个整数序列对象，一般用在 for 循环中。
    print(type(range(10)))
    
    # Return an object that produces a sequence of integers from start (inclusive) to stop (exclusive) by step.
    help(range)
    
    range(100, 19, -5)

> 22. **slice()**: **实现切片对象**，主要用在切片操作函数里的传递参数
> 
>       **super()**:子类**调用父类的构造函数**（减少代码量，方便修改）

# slice()
    # class slice(start, stop, step)
    # 实现切片对象，主要用在切片操作函数里的参数传递
    myslice = slice(1, 3, 1)
    print(type(myslice))      # <class 'slice'>
    arr = range(10)
    print(list(arr))          # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    new_arr = arr[myslice]
    print(type(new_arr))      # <class 'range'>
    print(list(new_arr))      # [1, 2]
    
    
    # super()
    # diao用继承的父类的构造函数
    class Person(object):
        def __init__(self, name, sex, age):
            self.name = name
            self.sex = sex
            self.age = age
    
    class Man(Person):
        def __init__(self, name, sex, age, character):
            super(Man, self).__init__(name, sex, age)
            self.character = character

> 23. **zip()**: 用于将可迭代的对象作为参数，**将对象中对应的元素打包成一个个元组**，然后返回由这些元组组成的对象，这样做的好处是**节约了不少的内存**。我们可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 **\* 号操作符，可以将元组解压为列表**。

# zip()
    # zip(iterable)
    # 将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象
    a = [1, 2, 3]
    b = [4, 5, 6]
    c = [4, 5, 6, 7, 8]
    zipped = zip(a, b)
    print(zipped)             # <zip object at 0x0000020DE6FD1088>
    print(list(zipped))       # [(1, 4), (2, 5), (3, 6)]
    
    print(list(zip(a, c)))    # [(1, 4), (2, 5), (3, 6)]
    
    a1, a2 = zip(*zip(a, b))  # 解压之后返回的是元组tuple
    print(a1)
    print(a2)

> 24. **\_\_import\_\_()**: 用于**动态加载类和函数** 。如果一个模块经常变化就可以使用 \_\_import\_\_() 来动态载入。

# atest.py
    class Testclass(object):
        def func(self):
            print 123
    
    # test.py
    a=__import__('atest')     #等于 import atest
    
    b=getattr(a,'Testclass')  #根据类名获得类对象
    c=b()                     #实例化
    c.func()

[property]: https://blog.csdn.net/admin_maxin/article/details/81978069
[Link 1]: http://www.cnblogs.com/anpengapple/p/6507271.html