5.7 Python内置函数

1. 内置模块

Python可以直接使用一些内建函数, 而不用显式的导入它们, 如: print(), type(), len()等,
这些函数都是builtins模块中定义的函数, 而builtins模块在Python环境启动的时候就自动导入,
所以可以直接使用这些函数.

globals()函数可以查看当前状态下的全局变量:

print(globals())

# 部分名称解释:  
{'__name__': '__main__', 
# 指示当前py文件调用方式的方法, 值为"__main__"就表示是这个脚本是直接执行的.
'__doc__': '你好!',  
# py文件的注释, 三引号写的
'__package__': None, 
# 展示Python软件包的名称, 被导入后使用才显示.

'__builtins__': <module 'builtins' (built-in)>,
# 内置模块
'__file__': 'C:\\Users\\13600\\PycharmProjects\\test\\test.py', 
# 当前python脚本运行的路径
'__cached__': None}
# 表示缓存文件Python内部的优化机制, 当导入别的模块时, 会直接将生成的字节码文件导入.

builtins模块里有接近80个内置函数, 60多个内置异常, 还有几个内置常数, 特殊名称以及模块相关的属性.

import builtins

Pycharm 中按住Ctrl 点 builtins, 进入到builtins的源文件中.

内置函数
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

A

abs()

abs()函数: 返回参数的绝对值.
如果参数是一个复数, 则返回它的模.
参数可以是整数, 浮点数或任何有.__abs__()方法的对象. 
如果在对象中定义了.__abs__()方法的话, 这个对象作为abs()函数的参数, 则会调用对象的.__abs__()方法.

语法:
Python 2 --> abs(number) -> number
Python 3 --> abs(*args, **kwargs) -> number

参数:
number: 数字类型对象.

返回值: 返回参数的绝对值.

(*args, **kwargs)表示的意思是可以接受任意参数, 实际上只是使用了位置参数, 关键字参数忽略即可.
Python3的形参不直观, 后续使用Python2的.
下图为abs()的源码.
Python3中使用pass表示省略, 底层源码是使用C语言实现的.
Python2中提示一个返回值, 也不展示源码.

print(abs(-1))  # 1
print(1.1.__abs__())  # 1.1

# 自定义类.
class A:
    # 对象定义abs方法, 如果没有定义该方法的对象无法作为abs函数的参数.
    def __abs__(self):
        return 1


# 实例化对象.
a = A()
print(abs(a))

all()

all()函数: 判断可迭代对象的值是否全为真.
如果迭代对象的所有元素均为真(或可迭代对象为空)则返回True.

语法:
all(iterable) -> bool

参数:
iterable: 迭代器对象.

返回值: 返回一个布尔值.

print(all([]))  # True
print(all([1, 2, 3]))  # True
print(all([1, 0, 1]))  # False

# 等价于:
def all(iterable):
    for element in iterable:
        if not element:  # 所有的元素必须为真, 一个元素为假后每必要完后执行了.
            return False
    return True

any()

any()函数: 判断可迭代对象的值是否全为假.
如果迭代对象的所有元素均为假(或可迭代对象为空)则返回True.

语法:
any(iterable) -> bool

参数:
iterable: 迭代器对象.

返回值: 返回一个布尔值.

print(any([]))  # False
print(any([0, ]))  # False
print(any([1, 2, 3]))  # True

# 等价于:
def any(iterable):
    for element in iterable:
        if element:  # 所有的元素必须为假, 一个元素为真后每必要完后执行了.
            return True
    return False

ascii()

ascii()函数: 返回一个对象的ASCII编码的字符串表示形式,
非ASCII编码的字符将使用unicode编码, 以反斜杠'\u'形式表示的转义字符.
该函数在内部调用repr()函数来实现的, 并在输出前使用转义字符来转义非ASCII字符.
如果在对象中定义了__repr__()方法的话, 这个对象作为ascii()函数的参数则会调用对象的__repr__()方法.
* Python3 中添加.

语法:
ascii(*args, **kwargs)
因该为:
ascii(object)

参数:
object: 对象.

返回值: 返回对象的仅ASCII表示形式, 非ASCII编码的字符将使用以反斜杠'\'形式的转义字符表示.

print(ascii('haha'))  # 'haha'

# 不在ASCII范围内, 转为Unicode编码.
print(ascii('哈哈'))  # '\u54c8\u54c8'

# 自定义类.
class A:
    def __init__(self):
        self.name = '哈哈'


# 实例化对象.
a = A()
# 打印对象.
print(a)
# 对象没有定义__repr__方法展示的使对象本身.
print(ascii(a))


# 自定义类.
class B:
    # 定义init方法.
    def __init__(self):
        self.name = '哈哈'

    # 定义repr方法.
    def __repr__(self):
        return self.name


# 实例化对象.
b = B()
print(ascii(b))

B

bin()

bin()函数: 将十进制整数转变为以'0b'前缀的二进制字符串.
如果不是int对象, 它必须定义__index__()方法, 以便返回整数值.

语法:
bin(number) -> string

参数:
number: 整型对象.

返回值: 返回整数对象的的二进制表示形式.

print(bin(3))  # 0b11
print(bin(-10))  # -0b1010

# 若要控制是否显示前缀'0b', 可以采用以下两种方案:
print(format(3, '#b'), format(3, 'b'))  # 0b11 11
print(f'{-3:#b}', f'{-3:b}')  # -0b11 -11

# 自定义类.
class A:
    # 对象不int类型, 则将对象的index方法的返回值作为参数进行转换.
    def __index__(self):
        return 10


# 实例化对象.
a = A()

print(bin(a))  # 0b1010

bool()

class bool(int)类: 返回参数的布尔值形式, 当参数x为真时返回True, 否则返回False.
bool类是int的子类, bool类的仅有的两个内置实例True和False.

语法:
class bool([, x]) -> bool

参数:
x: 任意类型的对象.

返回值: 返回对象的布尔值形式.

print(bool('x'))  # True
print(bool())  # False

bytearra()

bytearray(object)类: 返回对象的字节数组.
由字节组成的有序的可变序列, 这个数组里的元素是可变的, 并且每个元素的值范围: 0 <= x < 256.

bytearray: 可以看作是一组二进制数值(0-255)的list序列(列表的元素可变).
bytes: 可以看作是一组二进制数值(0-255)的str序列(字符串的元素不可变).

语法:
class bytearray([source[, encoding[, errors]]])
这个的 [source[, encoding[, errors]]]表示的是类的.__init__()方法参数, 参数都为可选参数.
等价于: def __init__(self, source=None, encoding=None, errors='strict')

参数:
source: 用于初始化bytearray对象的数组元素, 其取值可以是字符串, 整型数或可迭代类.
encoding: 当source是字符串时, 用于指定字符串的编码模式.
errors: 用于参数source是字符串时, 编码失败时的处理方式, errors默认'strict', 严格模式.

如果source为整数, 则返回一个长度为source的初始化数组.
如果source为字符串, 则按照指定的encoding将字符串转换为字节序列.
如果source为可迭代类型, 则元素必须为[0, 255] 中的整数.
如果source为与buffer接口一致的对象, 则此对象也可以被用于初始化bytearray.
如果没有输入任何参数, 默认就是初始化数组为0个元素.


返回值: 返回对象的字节数组. 

a = bytearray([1, 255])
print(a)  # bytearray(b'\x01\xff')

# 错误示例
b = bytearray([1, 256])
print(b)  # ValueError: bytes must be in range(0, 256)

c = bytearray('哈哈', 'utf8')
print(c, type(c))  # bytearray(b'\xe5\x93\x88\xe5\x93\x88') <class 'bytearray'>

d = bytearray('sasasa', 'ascii')
print(d, type(d))  # bytearray(b'sasasa') <class 'bytearray'>

e = bytearray()
print(e)  # bytearray(b'')

a = bytearray([1, 255])
print(a)  # bytearray(b'\x01\xff')
# 对象可以看成是一个列表, 可以使用列表的方法.
print(a.pop())  # 255

print(a)  # bytearray(b'\x01')

bytes()

bytes(object)类: 返回对象的bytes对象, 该对象是一个 0 <= x < 256 区间内的整数不可变序列.
它是bytearray的不可变版本.

语法:
class bytes([source[, encoding[, errors]]])

参数:
source: 用于初始化bytearray对象的数组元素, 其取值可以是字符串, 整型数或可迭代类.
encoding: 当source是字符串时, 用于指定字符串的编码模式.
errors: 用于参数source是字符串时, 编码失败时的处理方式, errors默认'strict', 严格模式.

如果source为整数, 则返回一个长度为source的初始化数组.
如果source为字符串, 则按照指定的encoding将字符串转换为字节序列.
如果source为可迭代类型, 则元素必须为[0, 255] 中的整数.
如果source为与buffer接口一致的对象, 则此对象也可以被用于初始化bytearray.
如果没有输入任何参数, 默认就是初始化数组为0个元素.

返回值: 返回对象的bytes对象.

a = bytes([1, 255])
print(a)  # b'\x01\xff'

# 错误示例
b = bytes([1, 256])
print(b)  # b'\x01\xff' ValueError: bytes must be in range(0, 256)

c = bytes('sasasa', 'utf8')
print(c, type(c))  # b'sasasa' <class 'bytes'>

d = bytes('sasasa', 'ascii')
print(d, type(d))  # b'sasasa' <class 'bytes'>

e = bytes()
print(e)  # b''

C

callable()

callable()函数: 检查一个对象是否是可调用, 标识符+()则是调用.
返回True, 对象仍然可能调用失败.
返回False, 调用对象绝对不会成功.
对于函数, 方法, lambda, 类以及实现了__call__方法的类实例, 它都返回True.

语法:
callable(object) -> bool

参数:
object: 检测对象.

返回值: 返回对象是否可调用, 结果是一个布尔值.

# 判断0是否可调用
print(callable(0))  # False

# 0 调用报错
0()  # TypeError: 'int' object is not callable

# 自定义一个函数.
def add(x, y):
    return x + y


# 判断函数是否可调用.
print(callable(add))  # True

# 调用函数.
res = add(1, 2)
print(res)  # 3

# 自定义类.
class A(object):
    # 静态方法.
    @staticmethod
    def method():
        return 0


# 判断类是否可调用.
print(callable(A))  # True


# 实例化对象.
a = A()
# 判断对象是否可调用.
print(callable(a))  # False, 类中没有实现 __call__ 方法.

# 自定义类.
class B(object):
    # 定义__call__方法.
    def __call__(self):
        print('xxx')

        
# 实例化对象.
b = B()
# 判断对象是否可调用.
print(callable(b))  # True
# 对象调用执行__call__方法.
b()  # xxx

chr()

chr()函数: 返回参数对应的ASCII字符, 将一个整数作参数, 返回它对应的ASCII字符.
参数可以是10进制或16进制的数字, 数字范围为0到1,114,111, 16进制则为0x00到0x10FFFF.

语法:
chr(i) -> character

参数:
i: 序数, 0 <= i < 256.

返回值: 返回序数i对应的ASCII字符.

print(chr(65))  # A
print(chr(0x41))  # A

classmethod()

classmethod()函数: 搭配装饰器使用, 使用@classmethod为类的方法进行修饰符, 表示该方法是类的.

类的方法是默认是绑定给给对象使用的, 想要将方法绑定给类则可以通过@classmethod对方法进行装饰达到目的.
类方法的也需要接收参数, 第一个参数需要是表示自身类的cls参数, 而不是接收self参数. 

class A(object):
    value = 1

    def __init__(self):
        self.k1 = 'v1'

    # 方法默认是给对象使用的.
    def func1(self):
        print(self.k1)

    # 将方法绑定给类.
    @classmethod
    def func2(cls):
        # 打印类属性.
        print(cls.value)
        # 类加括号生成对象, 对象调用方法.
        cls().func1()  # 实例化对象调用方法.


# 实例化对象.
a = A()
# 对象调用方法.
a.func1()  

# 类调用对象的方法, 将对象作为第一个参数.
A.func1(a)

# 类调用类自己的方法.
A.func2()

运行终端窗口显示:
v1
v1
1
v1

compile()

compile()函数: 将符合Python编码规范的字符串类型代码, 编译成Python能识别或执行的代码. 
* 可以从文件中读取读转成字符串再编译.

语法:
compilecompile(source, filename, mode, flags=None, dont_inherit=None) -> code object

参数:
source   字符串或者AST(Abstract Syntax Trees)对象.
filename 代码文件名称, 如果不是从文件读取代码则传递一些可辨认的值.
mode     指定编译代码的种类, 可以指定为 exec, eval, single.
flags    变量作用域, 局部命名空间, 如果被提供, 可以是任何映射对象.
flags和dont_inherit是用来控制编译源码时的标志.

返回值: 返回一个代码对象.

# 字符串中使符合Python编码规范的Python语句.
str1 = 'for i in range(0, 10): print(i, end = " ")'

# str1变量  ''代码文件名称(不想写就写'', 是一个字符串类型即可) exec类型.
code1 = compile(str1, '', 'exec')

print(code1)  # <code object <module> at 0x0000017DFF7832F0, file "range(0, 10)", line 1>

# 通过exec函数执行代码.
exec(code1)  #  0 1 2 3 4 5 6 7 8 9 

complex()

complex(object)类: 将字符串或数字类型对象转换为复数类型.

对于一个普通Python对象x, complex(x) 会委托给x的__complex__()方法.
如果.__complex__()方法未定义则将回退至对象的.__float__()方法.
如果.__float__()方法未定义则将回退至对象的.__index__()方法.

注意点: 当从字符串转换时, 字符串在 + 或 - 的周围必须不能有空格.
例如: complex('1+2j') 是合法的, 但complex('1 + 2j') 会触发ValueError异常.

语法:
class complex([real[, imag]])

参数:
real: 复数的实部参数, 参数类可以是int, float, str.
imag: 复数的虚部参数, 参数的类型可以是int, float.
第一个形参是字符串, 则它被解释为一个复数, 并且函数调用时必须没有第二个形参.
第二个形参不能是字符串, 如果省略了imag, 则默认值为零, 构造函数会像int和float一样进行数值转换.
如果两个实参都省略, 则返回0j.

返回值: 返回一个复数.

print(complex(1, 2))  # (1+2j)
# 将纯数字的字符串转为复数.
print(complex('1'))  # (1+0j)
print(complex())  # 0j

# 将纯复数的字符串转为复数.
print(complex('1+2j'))  # (1+2j)

# 注意点
print(complex('1 + 2j'))
# 英: ValueError: complex() arg is a malformed string.
# 中: 值错误: complex() arg 是格式错误的字符串.

# 自定义类.
class A:
    c1 = 1 + 2j
    f1 = 2.0
    i1 = 3

    def __complex__(self):
        # __complex__的返回值必须是复数.
        return self.c1

    # def __float__(self):
    #     # __float__的返回值必须是浮点型.
    #     return self.f1

    # def __index__(self):
    #     # __index__的返回值必须是整型.
    #     return self.i1


# 实例化对.象
a = A()


# 以上三个方法都没有的话会报错.
# 英: TypeError: complex() first argument must be a string or a number, not 'A'.
# 中: 类型错误:complex() 第一个参数必须是字符串或数字, 而不是'a'.
print(complex(a))

D

delattr()

delattr函数: 删除对象的某个属性.

语法:
delattr(object, name)

delattr(x, 'foobar')相等于del x.foobar.

参数:
object: 对象.
name: 必须是对象中已经定义的属性.

返回值: None.

# 自定义类.
class A(object):
    # 定义类的属性.
    x = 1
    y = 2
    z = 3


# 实例化对象.
a = A()

# 对象没有定义属性会往上查, 找到类的属性.
print(a.x, a.y, a.z)  # 1 2 3

# 删除属性.
delattr(A, 'z')

print(a.z)
# 英: AttributeError: 'A' object has no attribute 'z'.
# 中 属性错误: 'A' 对象没有属性'z'.

dict()

dict()函数: 用于构造一个字典.

语法:
class dict([sep[, **kwarg]])

参数:
sep: 位置参数, 默认为None, 可以是mapping, iterable类型.
    mapping: 映射类型, 是一种关联式的容器类型, 它存储了对象与对象之间的映射关系.
    iterable: 可迭代对象.
**kwargs: 关键字参数.

字典(dict)是Python中唯一的映射类型, 映射字典 {'a': 1, 'b': 2}.

print(dict())  # {}  空字典

# 关键字参数构造字典.
print(dict(k1='v1', k2='v2'))  # {'k1': 'v1', 'k2': 'v2'}

# 使用映射类型对象作为参数构造字典 .
print(dict(zip(['k1', 'k2'], ['v1', 'v2'])))  # {'k1': 'v1', 'k2': 'v2'}

# 可迭代对象作为参数来构造字典.
print(dict([('k1', 'v1'), ('k2', 'v2')]))  # {'k1': 'v1', 'k2': 'v2'}

# 一个键对多个值.
print(dict(k1=[1, 2]))  # {'k1': [1, 2]}
print(dict(zip(['k1'], [[1, 2], ])))  # {'k1': [1, 2]}
print(dict([('k1', [1, 2])]))   # {'k1': [1, 2]}

dir()

dir()函数: 不带参数时, 返回当前范围内的变量, 方法和定义的类型列表.
带参数时, 返回参数的属性, 方法列表.
如果参数对象定义了__dir__()方法, 则调用该方法.
如果参数对象没有定义__dir__()方法, 该方法将最大限度地收集参数信息.

语法:
dir(object)

参数:
object  对象, 变量, 类型.

返回值: 返回模块的属性列表.

# 查看当前脚本中的可用名称.
print(dir())
"""
 ['__annotations__', '__builtins__', '__cached__', '__doc__',
 '__file__', '__loader__', '__name__', '__package__', '__spec__']
"""

# 查看列表对象的方法.
print(dir([]))  
"""
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
"""

# 自定义类.
class A(object):
    # 定义dir方法.
    def __dir__(self):
        return 'xxx'


# 实例化对象.
a = A()
# 返回一个列表, 列表的元素是返回对象的元素.
print(dir(a))  # ['x', 'x', 'x']

divmod()

divmod()函数: 把除数和余数运算结果结合起来, 返回一个包含商和余数的元组(a // b 商, a % b 余数).

语法:
divmod(x, y) -> (quotient, remainder) == (x//y, x%y)
x//y 通过整除运算得到的结果.

参数:	
x: 被除数.
y: 除数.

返回值: 返回一个元组(商, 余数).

print(divmod(7, 2))  # (3, 1)
print(divmod(8, 2))  # (4, 0)

# 自定义类.
class A:
    # 定义类型的属性.
    num = 7

    # divmod方法必须传递连个参数.
    def __divmod__(self, other):
        # 商.
        quotient = self.num // other
        # 余数.
        remainder = self.num % other

        return quotient, remainder


# 实例化对象.
a = A()
print(divmod(a, 2))

E

enumerate()

enumerate()类: 将一个可遍历的数据对象(如列表, 元组或字符串)组合为一个索引序列, 
同时列出数据和数据下标, 通常搭配for循环使用.

语法:
enumerate([iterable[, start]])

参数:
iterable: 迭代器或其他支持的迭代的对象.
start: 下标, 起始位置, start默认为0.

返回值: 返回枚举对象.
枚举: 将对象可能存在的值一一列举出来.

list1 = ['a', 'b', 'c']

# 设置下标, 默认从0开始, 这里设置从1开始.
print(list(enumerate(list1, start=1)))  
# 返回的是一个枚举对象, 使用list转换处理才能显示值.
# [(1, 'a'), (2, 'b'), (3, 'c')]

# 一般情况下搭配for使用.
for x, y in enumerate(list1, start=1):
    print(x, y)
    
"""
1 a
2 b
3 c
"""

eval()

eval()函数: 执行一个字符串表达式, 并返回表达式执行的结果.

语法:
eval(source, globals, locals)

参数:
source: 源, 可以是一个字符串表达式.
globals: 变量作用域, 全局命名空间, 如果被提供, 则必须是一个字典对象.
locals: 变量作用域, 局部命名空间, 如果被提供, 可以是任何映射对象.

三个名称空间只有一个生效, 其它两个的名称空间的名称不能被使用.
优先顺序:
locals > globals > 全局


返回值: 返回表达式计算结果.

print(eval('2 + 2'))  # 4
print(eval('2  * 3'))  # 6

my_len = eval('len("123")')
print(my_len)  # 3

# 实现 str 与 int, list, dict, tuple 之间的转化.
list1 = eval('[1, 2, 3, 4,]')
dict1 = eval("{'k1': 'v1', 'k2': 'v2'}")
tuple1 = eval('(1, 2, 3)')

print(list1, type(list1))  # [1, 2, 3, 4] <class 'list'>
print(dict1, type(dict1))  # {'k1': 'v1', 'k2': 'v2'} <class 'dict'>
print(tuple1, type(tuple1))  # (1, 2, 3) <class 'tuple'>

# 名称查找.
a = 10

print(eval('a  * 3'))  # 30

# 优先顺序.
a = 10
b = 20
c = 30

# 没有设置globals与locals的参数, 使用全局名称.
print(eval('a + b + c'))  # 60

# globals参数出现, 以globals参数为主.
g = {'a': 1, 'b': 2, 'c': 3}  

print(eval('a + b + c', g))  # 6

# locals参数出现, 以locals参数为主.
l = {'a': 11, 'b': 22, 'c': 33}  

print(eval('a + b + c', g, l))  # 66

# eval无法执行多行语句.
eval("""for i in range(5):
    print(i, end= " ")""")  # 0 1 2 3 4

exec()

exec()函数: 执行储存在字符串或文件中的Python语句, 
相比于eval, exec可以执行更复杂的Python代码.

需要说明的是在Python2中exec不是函数, 而是一个内置语句(statement).
Python3中, exec()把statement和execfile()函数的功能整合了.

语法:
exec(source) -> None

参数:
source: 源, 可以是表示一个或多个Python语句的字符串, 也可以是compile()返回的代码对象.

返回值: None.

# 单行语句字符串.
exec('print("Hello World")')  # Hello World

# 多行语句字符串.
exec("""for i in range(5):
    print(i, end= " ")""")  # 0 1 2 3 4 

x = 10
# 将Python的表达写在字符串中.
expr = """
z = 30
sum = x + y + z
print(sum)
"""


y = 20
exec(expr)  # 60
exec(expr, {'x': 1, 'y': 2})  # 33
exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})  # 34

execfile()

execfile()函数: 执行文件中的Python语句, 返回表达式执行结果.
Python3中移除execfile()函数.

语法:
execfile(filename, globals, locals)

参数:
filename: 文件名.
globals: 变量作用域, 全局命名空间, 如果被提供, 则必须是一个字典对象.
locals: 变量作用域, 局部命名空间, 如果被提供, 可以是任何映射对象.

返回值: 返回表达式执行结果.

# 1.py 脚本文件.
print('hello word!')

# 2.py  在Python2.7下测试, 调用1.py脚本文件.
execfile('1.py')  # hello word!

# 同下
with open('1.py','r') as f:
    # 从文件中读取再执行.
    exec(f.read())  # hello word!
    

# Python3中移除execfile(), 代替方法如下:
# 获取文件句柄.
with open('1.py','r', encoding='utf8') as f:  # windows 一定要指定解码的格式.
    # 获取文件信息, 通过exec()函数执行.
    exec(f.read())  # hello word!
    

F

file()

file()类: 创建一个file对象.
* Python3改为open()函数.

语法:
file([name[, mode[, buffering]]])

参数:
name: 文件名.
mode: 打开模式.
buffering: 值为0, 表示不缓冲, 如果为1表示进行行缓冲, 大于1为缓冲区大小.

返回值: 文件对象.

# a.txt
hello word!

# python 2.7中使用.
f = file('a.txt')
print f.read()  # hello word!

filter()

filter()函数: 过滤序列, 过滤掉不符合条件的元素, 返回由符合条件元素组成的新列表.
该接收两个参数, 第一个为函数, 第二个为序列类型对象, 序列的每个元素作为参数传递给函数进行判断, 
然后返回判断的结果True或False, 最后将返回True的元素放到新列表中.

语法:
filter(function_or_none, sequence) ->  list, string or tuple.

参数:
function_or_none: 判断函数或None.
sequence: 序列对象.

返回值: 
Python2.x 如果可迭代对象是字符串或元组, 则结果也具有该类型, 否则它总是一个列表.
Python3.x 返回迭代器对象.

# 过滤 n % 2 == 0
iterable = filter(lambda n: n % 2 == 0, range(10))
# 过滤对象, 是一个迭代器.
print(iterable)  # <filter object at 0x000001AAED027760>
# 将迭代器转为列表.
print(list(iterable))  # [0, 2, 4, 6, 8]

float()

float()类: 将整数和纯数字字符串转换成浮点数.

语法:
class float([, x])

参数:
x: 整数和纯数字字符串对象.

返回值: 返回浮点数.

print(float(1))  # 1.0
print(float('1'))  # 1.0

format()

Python2.6开始, 新增了一种格式化字符串的函数str.format(), 它增强了字符串格式化的功能.
基本语法是通过{}和:来代替以前的%.
format()函数可以接受不限个参数, 位置可以不按顺序.

# 不设置指定位置, 按默认顺序.
print("{} {}".format("hello", "world"))  # hello world

# 设置指定位置.
print("{0} {1}".format("hello", "world"))  # hello world

# 设置指定位置.
print("{1} {0} {1}".format("hello", "world"))  # world hello world

# {{}}取消转义.
print ("{{0}}".format('hello'))  # 打印{0} 而不是hello

 # 关键字参数.
print("网站名:{name}, 地址 {url}".format(name="百度", url="www.baidu.com"))

# 通过字典设置参数.
url = {"name": "百度", "url": "www.baidu.com"}
print("网站名:{name}, 地址 {url}".format(**url))  # ** 将字典 解压成 关键字参数形式

# 通过列表索引设置参数.
list1 = ['百度', 'www.baidu.com']
print("网站名:{0[0]}, 地址 {0[1]}".format(list1))  # 0 是必须的,固定的格式
"""
网站名:百度, 地址 www.baidu.com
网站名:百度, 地址 www.baidu.com
网站名:百度, 地址 www.baidu.com
"""

class A(object):
    def __init__(self, age):
        self.age = age

        
a = A(18)
# 参数是一个对象, 可以使用属性, 不可以使用方法!
print('age: {0.age}'.format(a))

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	{:b}.format(11)	1011	二进制
11	{:d}.format(11)	11	十进制
11	{😮}.format(11)	13	八进制
11	{:x}.format(11)	b	十六进制
11	{:#x}.format(11)	0xb	显示前缀
11	{:#X}.format(11)	0XB	大写

^, <, > 分别是居中, 左对齐, 右对齐, 后面带宽度. 
: 号后面带填充的字符, 只能是一个字符, 不指定则默认是用空格填充.

+ 表示在正数前显示 +, 负数前显示 -,  (空格)表示在正数前加空格

b, d, o, x 分别是二进制, 十进制, 八进制, 十六进制.

frozenset()

frozenset()类: 返回一个冻结的集合, 冻结后集合不能再添加或删除任何元素.

语法:
class frozenset([, seq]) -> frozenset object

参数:
seq: 可迭代的对象.

返回值: 返回冻结的集合对象, 如果不提供任何参数, 默认会生成空集合.

为什么需要冻结的集合(即不可变的集合)呢？
因为在集合的关系中, 有集合的中的元素是另一个集合的情况, 
但是普通集合(set)本身是可变的, 
那么它的实例就不能放在另一个集合中(set中的元素必须是不可变类型).

所以, frozenset提供了不可变的集合的功能, 当集合不可变时, 
它就满足了作为集合中的元素的要求, 就可以放在另一个集合中了.

list1 = [1, 2]
# 集合的元素必须是不可变类型.
set1 = {list1}  
# 英: TypeError: unhashable type: 'list' .
# 中: 类型错误:不可散列类型:'列表'.

# 创建不可变集合.
a = frozenset(range(10))
print(a)  # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

# 去重且无序的.
b = frozenset('hello') 
print(b)  # frozenset({'l', 'e', 'o', 'h'})

# 冻结集合作为集合的元素.
print({a, b})
# {frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}), frozenset({'o', 'e', 'l', 'h'})}

G

getattr()

getattr()函数: 返回一个对象属性值.
参数对象拥有.__getattr__()方法, 则会执行该方法.

语法:
getattr(object, name[, default]) -> value
[, default]这里表示可选形参, 默认值为None. 
','表示前面有参数, ','作为参数的分割符号, 前面没有参数则省略.

参数:
object: 对象.
name: 字符串类型, 对象属性.
default: 默认返回值, 如果不提供该参数, 在没有对应属性时, 将触发AttributeError异常.

返回值: 返回对象属性值.

# 自定义类.
class A(object):
    value = 1


# 实例化对象.
a = A()

# 获取对象的属性.
print(getattr(a, 'value'))  # 1

# 对象属性不存在, 使用设置的返回值.
print(getattr(a, 'value2', None))  # None

# 对象属性不存在, 不设置返回值, 则报错.
print(getattr(a, 'value3'))
# 英: AttributeError: 'A' object has no attribute 'value3'.
# 中: 属性错误:'A'对象没有属性'value3'.

# 自定义类.
class A(object):
    value = 1

    # getattr方法接收连个参数.
    def __getattr__(self, item):
        # 返回属性值.
        return self.item


# 实例化对象.
a = A()

# 获取对象的属性.
print(getattr(a, 'value'))

globals()

globals()函数: 以字典类型返回当前位置的全部全局变量.

语法:
globals() -> dictionary

参数: 无

返回值: 以字典类型返回当前位置的全部全局变量.

num = 1
print(globals())

"""
{'__name__': '__main__', '__doc__': None, '__package__': None, 
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020DB8D8D4A8>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
'__file__': 'F:/synchro/Project/测试/2.py', '__cached__': None, 'num': 1}
"""

H

hasattr()

hasattr()函数: 判断对象是否包含对应的属性.

语法:
hasattr(object, name)

参数:
object: 对象.
name: 字符串类型, 属性的名称.

返回值: 如果对象有该属性返回True, 否则返回False.

# 自定义类.
class A(object):
    value = 1

    
# 实例化对象.
a = A()

print(hasattr(a, 'value'))  # True
print(hasattr(a, 'value2'))  # False

hash()

hash()函数: 获取取一个对象(字符串或者数值等)的哈希值.
参数拥有.__hash__()方法, 则会执行该方法.

语法:
hash(object)

参数:
object: 对象.

返回值: 返回对象的哈希值.

# 数字
print(hash(123))  # 123

# 字符串
str1 = '123'
print(hash(str1))  # 2565105887977682760  每一次都不一样

# 自定义类.
class A:
    # 定义类的属性
    value = 1
	# 定义hash方法.
    def __hash__(self):
        return hash(self.value)


# 实例化对象.
a = A()
# 对象调用.__hash__()方法.
print(hash(a))

help()

help()函数: 查看函数或模块用途的详细说明.

语法:
help([object])
[object]这里表示可选位置参数.

参数:
object: 对象, 可选.

返回值: 返回对象帮助信息.

# 查看hash()函数的信息.
print(help(hash))
"""
hash()函数使用信息...
"""

hex()

hex()函数: 将10进制整数转换成16进制, 以字符串形式表示.

语法:
hex(number) -> string

参数:
number: 10进制整数.

返回值: 返回10进制整数的16进制数, 以字符串形式表示.

base = hex(255)
print(base, type(base))  # 0xff <class 'str'>

# hex只接受整型参数, 否则会报错: 
# 英: TypeError: 'A' object cannot be interpreted as an integer.
# 中: TypeError:“A”对象不能解释为整数.
# 那么自定义对象继承整型即可.
class A(int):
    value = 1

    # 定义hex方法.
    def __hex__(self):
        # 返回参数.
        h_str = hex(self.value)
        return h_str


# 实例化对象.
a = A()
# 调用.__has__()方法.
print(hex(a))

I

id()

id()函数: 返回对象的唯一标识符, 以整数形式表示.
CPython中id()函数用于获取对象的内存地址.

语法:
id(object) -> integer

参数:
object: 任意对象.

返回值: 返回对象的内存地址.

num = 1
num_id = id(num)
print(num_id)  # 2141816777008
print(hex(num_id))  # 0x1f2ae3a6930, 真正的内存地址.

input()

Python3.x 中:
	input()函数接受一个标准输入数据, 返回为str类型.
	注意:
	python3里input()默认接收到的是str类型.

Python2.x 中:
	input()相等于eval(raw_input(prompt)), 用来获取控制台的输入.
	raw_input()将所有输入作为字符串看待, 返回字符串类型.
	而input()在对待纯数字输入时具有自己的特性, 它返回所输入的数字的类型(int, float).
	
	注意:
	input()和raw_input()这两个函数均能接收字符串 , 
	但raw_input()直接读取控制台的输入(任何类型的输入它都可以接收)
	而对于input(), 它希望能够读取一个合法的python表达式, 	
	即你输入字符串的时候必须使用引号将它括起来, 否则它会引发一个SyntaxError.
	除非对input()有特别需要, 否则一般情况下我们都是推荐使用 raw_input() 来与用户交互.
	
* Python3.x中的input()等于Python2.x中的raw_input().

语法:
input([prompt]) -> value

参数:
prompt: 打印的参数.

返回值: 输入的值.

# python2下的input
a = input('input>>>:')
print(a, type(a))

b = input('input>>>:')
print(b, type(b))

c = input('input>>>:')
print(c, type(c))

f = input('input>>>:')
print(f, type(f))  

运行终端显示:
input>>>:1  # 输入数字1 绑定给变量a
(1, <type 'int'>)  
input>>>:'a'  # 输入字符a 绑定给变量b
('a', <type 'str'>)  
input>>>:a  # 没有带'' 被认为是变量名
(1, <type 'int'>)
input>>>:f  
Traceback (most recent call last):
....
英: NameError: name 'f' is not defined.
中: 名称错误:名称'f'未定义.

int()

int()类: 将一个存数字字符串或数字转换为整型, 复数不可以转.

语法:
class int([x[, base=10]])
int(x=0) -> int
int(x, base=10) -> int

参数:
x: 纯数字字符串或整型数字类型, 复数不可以转.
   如果参数对象有.__int__()方法, 则调用该方法, 对于浮点数, 则将向零截断.
base: 进制数, 默认十进制. 如果是带参数base的话, 参数x必须是字符串.

返回值: 返回整型数据.

print(int())  # 不传入参数时, 得到结果0, 源码设置的.
print(int(1.1))  # 1
print(int(True))  # 1
print(int(False))  # 0


print(int('10'))  # 10
print(int('10', base=2))  # 二进制 '10'  --> 十进制 2
print(int('10', base=8))  # 八进制 '8'   --> 十进制 8
print(int('10', base=16))  # 十六进制 '10' --> 十进制 16

# 自定义类.
class A:
    # 定义int方法
    def __int__(self):
        return 1


# 示例化对象.
a = A()
print(int(a))

isinstance()

isinstance()函数: 判断一个对象是否是一个已知的类型.
如果要判断两个类型是否相同推荐使用isinstance().

语法:
isinstance(x, A_tuple) -> bool

参数:
x: 实例对象.
A_tuple: 可以是直接或间接类名, 基本类型或者由它们组成的元组.

返回值: 如果对象的类型与参数二的类型相同则返回True, 否则返回False.

a = 0

print(isinstance(a, int))  # True

print(isinstance(a, str))  # False

print(isinstance(a, (int, float, str)))  # True

isinstance()与type()区别:

type()不会认为子类是一种父类类型, 不考虑继承关系.

isinstance()会认为子类是一种父类类型, 考虑继承关系.

如果要判断两个类型是否相同推荐使用isinstance().

# 自定义对象.
class A(object):
    pass


# 实例化对象.
a = A()


# 判断对象a是否为类A的实例.
print(isinstance(a, A))  # True
# 判断对象a的类是否是类A.
print(type(a) == A)  # True

# 自定义对象.
class B(A):
    pass


# 实例化对象.
b = B()
# 判断对象b是否为类B的实例.
print(isinstance(b, A))  # True
# 判断对象b的类是否是类B.
print(type(b) == A)  # False, 不考虑继承.

issubclass()

issubclass()函数: 判断某个类, 是否是为某个类的子类.

语法:
issubclass(x, A_tuple) -> bool

参数:
x: 类名, 子类.
A_tuple: 类名, 基类.

返回值: 如果x是A_tuple的子类则返回True, 否则返回False.

# 自定义类.
class A(object):
    pass


# 自定义类.
class B(A):
    pass


# 判断类B是否为类A的子类.
print(issubclass(B, A))  # True

# 判断类B是否为类object的子类.
print(issubclass(B, object))  # True

iter()

iter()函数: 将可迭代对象转为迭代器对象.

语法:
iter(source[, sentinel])

参数:
source: 来源, 一个迭代的集合对象.
sentinel: 当第二个参数提供时, 第一个参数必须是一个可被调用对象.
    创建的迭代对象, 在调用__next__方法的时候会调用这个可被调用对象,
    当返回值和sentinel值相等时, 将抛出StopIteration异常, 终止迭代.

返回值: 迭代器对象.

iterator = iter([1, 2, 3])
# 迭代取值
print(iterator.__next__())  # 1

for i in iterator:
    print(i)  # 2 3
    

# 自定义函数.
def a():
    return 123


# 可被调用对象.
callable_iterator = iter(a, None)
print(callable_iterator.__next__())  # 123
print(callable_iterator.__next__())  # 123

# 可调用迭代器, 不要使用for循环调用, 否则会出现死循环.

# 自定义类.
class IterTest:
    def __init__(self):
        self.start = 0
        self.end = 10

    def get_next_value(self):
        current = self.start
        if current < self.end:
            self.start += 1
        # 自定义异常, 限制迭代器只能取到9.
        else:
            raise StopIteration

        # 返回值.
        return current


# 实例化对象.
iterTest = IterTest()

# 可调用迭代器.
callable_iterator = iter(iterTest.get_next_value, 4)
print(next(callable_iterator))
print(next(callable_iterator))
print(next(callable_iterator))
print(next(callable_iterator))
# , 当返回值为第二个参数的值时, 报StopIteration异常.
print(next(callable_iterator))

L

len()

len()函数: 返回对象(字符, 列表, 元组等)的长度或项目的个数.
CPython中: 对于大于sys.maxsize的长度, 如range(2 ** 100)会引发OverflowError(溢出错误).
参数对象拥有.__len__()方法, 则会调用该方法.

语法:
len(object) -> integer

参数:
object: 对象.

返回值: 返回对象的长度或项目的个数.

str1 = "hello"
# 字符串的长度.
print(len(str1))  # 5

l1 = [1, 2, 3, 4, 5]
# 列表元素的个数.
print(len(l1))  # 5

import sys
print(sys.maxsize)  # 9223372036854775807
print((2 ** 100))  # 1267650600228229401496703205376

r1 = range(2 ** 100)
print(len(r1))  # 溢出错误: Python int 太大，无法转换为C ssize_t

# 自定类
class A:
	# 定义len方法, 设置为静态方法, 不需要使用self参数.
    @staticmethod
    def __len__():
        return 5


# 实例化对象.
a = A()
print(len(a))  # 5

list()

list()类: 将可迭代对象转换为列表.
注意点: 元组与列表是非常类似的, 区别在于元组的元素值不能修改, 元组是放在括号中, 列表是放于方括号中.

语法:
list([, seq])

参数:
seq: 要转换为列表的可迭代对象.
list(): 新的空列表列表
list(iterable): 从可迭代项初始化的新列表, 意思就是将可迭代对象转为列表, 每个项最为列表的元素.

返回值: 返回列表.

# 参数必须是一个迭代对象, 默认是(), ()是可迭代对象.
t0 = list(())
print(t0)  # []

str1 = 'hello'
t1 = (1, 2, 3, 4, 5)

print(list(str1))  # ['h', 'e', 'l', 'l', 'o']
print(list(t1))  # [1, 2, 3, 4, 5]

locals()

locals()函数: 以字典类型返回当前位置的全部局部变量.

语法:
locals() -> dictionary

参数: None.

返回值: 返回字典类型的局部变量.

# 自定义函数.
def func():
    a = 1
    print(locals())  # {'a': 1}


func()


# 自定义类.
class A(object):
    a = 2
    print(locals())
    # {'__module__': '__main__', '__qualname__': 'A', 'a': 2}


A()

long()

long()类: 将数字或字符串转换为一个长整型.
参数对应有.__long__()方法, 则会调用改方法.
Python3.x 版本已删除long()函数.

语法:
class long([x[, base=10]])

参数:
x: 纯数字的字符串或数字.
base: 可选, 进制数, 默认十进制.

返回值: 返回长整型数.

str1 = '1'
l1 = long(str1)
print l1  # 1
print type(l1)  # <type 'long'>

str1 = '1'
l1 = long(str1)

print long()  # 0
print l1  # 1
print type(l1)  # <type 'long'>

print long('0101', base=2)  # 5

# coding:UTF8
# Python2.7
class A(long):
    # Python2中, self没有使用不会提示.
    def __long__(self):
        return 1000


a = A()
# 让类继承long, 否则会不识别a的类型会高亮提示, 可省略提示.
print long(a)

M

map()

map()函数: 根据提供的函数对指定序列做映射.

语法:
map(function, sequence, *sequence_1)
map(function, sequence[, sequence, ...]) -> list
[, sequence, ...]这里表示是可选可变长位置参数, '...'表示可以接收更多参数.

参数:
function: 处理序列元素的函数.
sequence: 一个或多个序列.

第一个参数是一个函数, 第二个参数是一个序列, 序列中的每一个元素调用function函数, 
map函数返回的新列表元素是每次function函数的返回值.

返回值:
Python 2.x 返回列表.
Python 3.x 返回迭代器.

# 计算平方
def square(i):
    return i * i


# (一个函数, 一个可迭代对象.)
iterable1 = map(square, range(0, 10))
print(list(iterable1))  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# (一个匿名函数, 一个可迭代对象.)
iterable2 = map(lambda i: i * i, range(0, 10))
print(list(iterable2))  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# (一个匿名函数, 两个可迭代对象)
iterable3 = map(lambda x, y: x + y, range(0, 10), range(0, 10))
print(list(iterable3))  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

max()

max()函数: 返回给定参数的最大值, 参数可以为序列.

语法:	
max(*args, **kwargs)

使用方法:
max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value

参数:
args: 接收多个位置参数, 参数类型需要支持大于'>'符号比较(内部实现方式).

返回值: 返回给定参数的最大值.

print(max(1, 2, 3))  # 3
print(max('a', 'b', 'c'))  # c, 字符比较, 会转为对应的ASCII十进制进行比较.

min()

返回给定参数的最小值, 参数可以为序列.

语法:
min(*args, **kwargs)

使用方法:
min(iterable[, key=func]) -> value
min(a, b, c, ...[, key=func]) -> value

参数:
args: 接收多个位置参数, 参数类型需要支持小于'<'符号比较(内部实现方式).

返回值: 返回给定参数的最小值.

print(min(1, 2, 3))  # 1
print(min('a', 'b', 'c'))  # a, 字符比较, 会转为对应的ASCII十进制进行比较.

N

next()

next()函数: 返回迭代器的下一个项目, 函数会调用对象的.__next__()方法.
next()函数要和生成迭代器的iter()函数一起使用.

语法:
next(iterable[, default])

参数:
iterable: 可迭代对象.
default: 可选, 用于设置在没有下一个元素时返回该默认值, 
	如果不设置, 又没有下一个元素则会触发StopIteration异常.

返回值: 返回下一个项目.

it = iter([1, 2])
print(next(it))  # 1
print(next(it))  # 2

# 设置默认值
print(next(it, 'no'))  # no
# 不设置默认值
print(next(it))  # StopIteration

# 自定义类.
class A:
    # 定义类属性.
    end = 0
	
    # 定义next方法.
    def __next__(self):
        # 类属性自加.
        self.end = self.end + 1
        return self.end


# 实例化对象.
a = A()
# 迭代取值.
print(next(a))  # 1
print(next(a))  # 2
print(next(a))  # 3

O

object()

object()类: 返回一个新的无特征实例, 该实例没有实例属性, 不能被赋予任何属性.
您不能向这个对象添加新的属性或方法.
这个对象是所有类的基础, 它拥有所有类默认的内置属性和方法.

语法:
object()

参数: 无参数.

返回值: 返回一个新的无特征实例.

x = object()
print(x, type(x))  # <object object at 0x00000243C78DB0F0> <class 'object'>

oct()

oct()函数: 将一个整数转换成8进制字符串.

Python2.x版本的8进制以0作为前缀表示.
Python3.x版本的8进制以0o作为前缀表示.

语法:
oct(number) -> string

参数:
number: 整数.

返回值: 返回整型数字的8进制字符串.

# Python2
print(oct(11))  # 013

# Python3
print(oct(11))  # 0o13

open()

open()函数: 打开一个文件, 并创建一个file对象, 使用对象相关的方法对文件进行读写.

语法:
open(name[, mode[, buffering[...省略, 还有几个不怎么使用的参数]]])

参数:
name: 一个包含了你要访问的文件名称的字符串值.
mode: 决定了打开文件的模式, 例: 只读, 写入, 追加等.
	所有可取值见如下的完全列表.这个参数是非强制的, 默认文件访问模式为只读(r).

buffering : 如果 buffering 的值被设为 0, 就不会有寄存.
    如果buffering的值取1, 访问文件时会寄存行.
    如果将buffering的值设为大于1的整数, 表明了这就是的寄存区的缓冲大小.
    如果取负值, 寄存区的缓冲大小则为系统默认.

模式	描述
t	文本模式 (默认).
x	写模式, 新建一个文件, 如果该文件已存在则会报错.
b	二进制模式.
+	打开一个文件进行更新(可读可写).
U	通用换行模式(不推荐).
r	以只读方式打开文件.文件的指针将会放在文件的开头.这是默认模式.
rb	以二进制格式打开一个文件用于只读.文件指针将会放在文件的开头.这是默认模式.一般用于非文本文件如图片等.
r+	打开一个文件用于读写.文件指针将会放在文件的开头.
rb+	以二进制格式打开一个文件用于读写.文件指针将会放在文件的开头.一般用于非文本文件如图片等.
w	打开一个文件只用于写入.如果该文件已存在则打开文件, 并从开头开始编辑, 即原有内容会被删除.如果该文件不存在, 创建新文件.
wb	以二进制格式打开一个文件只用于写入.如果该文件已存在则打开文件, 并从开头开始编辑, 即原有内容会被删除.如果该文件不存在, 创建新文件.一般用于非文本文件如图片等.
w+	打开一个文件用于读写.如果该文件已存在则打开文件, 并从开头开始编辑, 即原有内容会被删除.如果该文件不存在, 创建新文件.
wb+	以二进制格式打开一个文件用于读写.如果该文件已存在则打开文件, 并从开头开始编辑, 即原有内容会被删除.如果该文件不存在, 创建新文件.一般用于非文本文件如图片等.
a	打开一个文件用于追加.如果该文件已存在, 文件指针将会放在文件的结尾.也就是说, 新的内容将会被写入到已有内容之后.如果该文件不存在, 创建新文件进行写入.
ab	以二进制格式打开一个文件用于追加.如果该文件已存在, 文件指针将会放在文件的结尾.也就是说, 新的内容将会被写入到已有内容之后.如果该文件不存在, 创建新文件进行写入.
a+	打开一个文件用于读写.如果该文件已存在, 文件指针将会放在文件的结尾.文件打开时会是追加模式.如果该文件不存在, 创建新文件用于读写.
ab+	以二进制格式打开一个文件用于追加.如果该文件已存在, 文件指针将会放在文件的结尾.如果该文件不存在, 创建新文件用于读写.

file对象方法:

file.read([size]): size 未指定则返回整个文件, 如果文件大小 >2 倍内存则有问题, 
f.read()读到文件尾时返回""(空字串).

file.readline():返回一行.

file.readlines([size]) : 返回包含size行的列表, size 未指定则返回全部行.

for line in f: print line : 通过迭代器访问.

f.write("hello\n"):如果要写入字符串以外的数据,先将他转换为字符串.

f.tell():返回一个整数,表示当前文件指针的位置(就是到文件头的字节数).

f.seek(偏移量,[起始位置]):用来移动文件指针.

偏移量: 单位为字节, 可正可负
起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
f.close() 关闭文件

# 1.txt
hello word!

f = open('1.txt')
print(f.read())  # hello word!
f.close() 

ord()

ord()函数: 返回参数对应的ASCII数值, 或者Unicode数值, 
如果所给的Unicode字符超出了你的Python定义范围, 则会引发一个TypeError的异常.

语法:
ord(c) -> integer

参数:
c: 长度为1的字符, ord('')是不可以的!.

返回值: 返回值是对应的十进制整数.

print(ord('你'))  # 20320
print(ord('好'))  # 22909
print(ord(''))  # 报错
# 英: TypeError: ord() expected a character, but string of length 0 found.
# 中: 类型错误: ord()应为字符, 但找到了长度为0的字符串.

P

pow()

pow()函数: 计算幂次方.

内置pow()函数语法:
pow(x, y[, z])

参数:
x: 底数.
y: 指数.
z: 求模被除数.
没有参数z, 计算x的y次方, 如果z在存在, 则再对结果进行取模, 其结果等效于pow(x, y) % z.

返回值: 返回x的y次方的值.

math模式pow方法语法:
import math
math.pow(x, y)

参数:
x: 底数.
y: 指数.

返回值: 返回x的y次方的值.

内置pow()函数会把参数作为整型, 而math模块的pow方法则会把参数转换为float类型.

import math

print(math.pow(2, 8))  # 256.0

print(pow(2, 8))  # 256

# 求模 256 % 5 
print(pow(2, 8, 5))  # 1

# 自定义类.
class A:
    # 定义init方法, num为底数.
    def __init__(self, num):
        self.num = num

    # 定义pow方法, power为指数, modulo为求模被除数.
    def __pow__(self, power, modulo=None):
        # 判断是否求模.
        if modulo:
            return self.num ** power % modulo

        # 求幂
        return self.num ** power


# 实例化对象.
a = A(2)

# 调用pow方法.
print(pow(a, 8))  # 256
print(pow(a, 8, 5))  # 1

print()

print()函数: 用于打印输出, 最常见的一个函数.
在Python3.3版增加了flush关键字参数.
print在Python3.x是一个函数, 但在Python2.x版本不是一个函数, 只是一个关键字.

语法:
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

参数:
objects: 复数, 表示可以一次输出多个对象.输出多个对象时, 需要用','分隔.
sep: 用来间隔多个对象, 默认值是一个空格.
end: 用来设定以什么结尾.默认值是换行符'\n', 可以换成其他字符串.
file: 要写入的文件对象.
flush: 输出是否被缓存通常决定于file参数, 如果是文件看不到任何效果.
	参数默认为False, 如果为True, 就会被强制刷新. 

返回值: None.

# 多个字符串没用使用分割符号, 看起来像是合并的.
print('a''b')  # ab
# 默认间接符号为空格.
print('a', 'b')  # a b
# 设置间隔符为点.
print('a', 'b', sep='.')  # a.b
# 设置结束符为空, 就是没有的意思.
print('a', end='')  # ab
print('b')

# file参数使用.
with open('test.txt', mode='wt', encoding='utf8') as wf:
    print('写入文件中.', end='', file=wf)

# flush参数使用.
import time

print('加载中', end='')
for i in range(10):
    # 在交互模式下才能看出flush参数的作用, 设置为True的区别.
    print('.', end='', flush=True)  # 加载中.......... 一个点一个点的出现.
    time.sleep(0.5)
    

property()

property()类: 返回新式类的属性值, 继承object的类都是新式类.

语法:
class property([fget[, fset[, fdel[, doc]]]])

参数:
fget: 获取属性值的函数.
fset: 设置属性值的函数.
fdel: 删除属性值函数.
doc: 属性描述信息.

返回值: 返回新式类属性.

# 自定义类.
class A(object):
    # 初始化方法.
    def __init__(self):
        self._x = 1

    # 查
    def get_x(self):
        """
        帮助文档: ...
        函数介绍: ...
        "I'm the 'x' property."
        return self._x
        """
        return self._x

    # 改
    def set_x(self, value):
        self._x = value

    # 删
    def del_x(self):
        del self._x

    # 顺序必须是 查 改 删  属性
    x = property(get_x, set_x, del_x, "I'm the 'x' property.")


# 实例化对象.
a = A()
# 触发get_x方法.
print(a.x)  # 1

a.x = 2  # c.x = value 触发set_x方法.

print(a.x)  # 2

del a.x  # 触发 del_x方法.

# 查看类的x属性介绍. a.__class__ 获取到类.
print(a.__class__.x.__doc__)  # I'm the 'x' property.

如果给定doc参数, 其将成为这个属性值的docstring, 
否则property函数就会复制fget函数的docstring(如果有的话).
docstring --> 帮助文档.

property的getter, setter和deleter方法同样可以用作装饰器.
这个代码和上个例子完全相同, 但要注意这些额外函数的名字和property下的一样, 例如这里的 x.

class C(object):
    def __init__(self):
        self._x = 1

    @property
    def x(self):
        """
        帮助文档: ...
        函数介绍: ...
        "I'm the 'x' property."
        return self._x
        """
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x


c = C()
#  触发getter装饰的方法, 获取属性值.
print(c.x)  # 显示 1  

# 触发setter装饰的方法, 修改属性值.
c.x = 2  # c.x = value 

print(c.x)  # 2

# 触发 @deleter装饰的方法.
del c.x  

# 显示帮助文档的信息
print(c.__class__.x.__doc__)  

""""        
        帮助文档: ...
        函数介绍: ...
        "I'm the 'x' property."
        return self._x
""""

R

range()

Python2.x中range()函数: 返回一个整数序列列表.
Python3.x中range()函数: 返回一个可迭代对象.

语法:
range(start, stop[, step])

参数:
start: 起始值. 默认是从0开始, 例如range(5)等价于range(0,  5).
stop: 结束值, 但不包括stop, 例如:range(0,  5)值为[0, 1, 2, 3, 4]没有5.
step: 步长, 默认为1, 例如: range(0,  5)等价于range(0, 5, 1).

返回值:
python2.x  整数序列列表.
python3.x  可迭代对象.

r1 = range(0, -10, -1)
print(r1)  # range(0, -10, -1)
print(list(r1))  # [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

print(list(range(0)))  # []

print(list(range(10, 0)))  # []

print(list(range(10, 0, -1)))  # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

reduce()

reduce()函数: 对序列参数中的元素进行累积.

Python3.x中将reduce()函数移到functools模块, 导入方式: from functools import reduce.

语法:
reduce(function, sequence[, initial]) -> value

参数:
function: 函数, 接收两个参数, 先对集合中的第 1, 2 个元素进行操作, 得到的结果再与第三个数据计算.
sequence: 可迭代对象, 对这个对象的元素累加.
initial: 初始参数, 可选.

返回值: 返回函数计算结果.

# -*- coding: UTF-8 -*- Python2.7

# 两数相加.
def add(x, y):  
    return x + y

# 计算列表和:1+2+3+4+5.
sum1 = reduce(add, [1, 2, 3, 4, 5])
# 使用 lambda 匿名函数.
sum2 = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])  
print(sum1)  # 15
print(sum2)  # 15

# 两数相加.
def add(x, y):  
    return x + y

# 计算列表和:1+2+3+4+5.
sum1 = reduce(add, [1, 2, 3, 4, 5])  
# 使用 lambda 匿名函数.
sum2 = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])  
print(sum1)  # 15
print(sum2)  # 15

reload()

reload()函数: 重新载入之前载入的模块.
在Python2.x ~ Python3.3版本移到 imp 包中(Python2.x 也可以导入 imp 包使用),
Python3.4 之后到版本移到了 importlib 包中.

语法:
reload(module)

参数:
module  模块对象.

返回值: 返回模块对象.

# -*- coding: UTF-8 -*- Pytohn2.7
import sys

# 获取python编辑器当前使用的编码
print sys.getdefaultencoding()  # ascii

reload(sys)
# 使用 reload重新载入模块, 执行这个代码后sys可以使用setdefaultencoding方法设置编码格式否则
# AttributeError: 'module' object has no attribute 'setdefaultencoding'
# 属性错误:'模块'对象没有属性'setdefaultencoding'


sys.setdefaultencoding('utf8')  # 设置编码
print sys.getdefaultencoding()  # utf8

在桌面下新建test文件, 在test文件下新建test1.py文件.

# test1.py
def func():
    print(123)
    

启动命令行窗口, 切换路径到test目录下, 进入Python的交互模式.

C:\Users\13600\Desktop\test>python3
Python 3.9.4 ...
Type "help", "copyright", "credits" or "license" for more information.
# 导入test1模块
>>> import test1
# 执行func函数.
>>> test1.func()
123
# 修改test1.py的print(123)为print(456)
# 执行func函数, 文件没有刷新...
>>> test1.func()
123

# 导入reload模块.
from importlib import reload
# 重载模块, 刷新文件.
>>> reload(test1)
<module 'test1' from 'C:\\Users\\13600\\Desktop\\test\\test1.py'>
# 执行func函数.
>>> test1.func()
456

repr()

repr()函数: 将对象转化为供解释器读取的形式.

str()函数用于将值转化为适于人阅读的形式, 而repr()转化为供解释器读取的形式.

语法:
repr(object) -> string

参数:
object: 对象.

返回值: 返回一个对象的str格式.

# 交互模式.
>>> s = 'hello world'
>>> repr(s)
"'hello world'"
>>> s = 123
>>> repr(s), type(repr(s))
('123', <type 'str'>)

repr()函数得到的字符串通常对python比较友好, 也可以用来重新获得该对象, 
通常情况下obj==eval(repr(obj))这个等式是成立的.

>>> obj='I love Python'
>>> obj==eval(repr(obj))
True

>>> obj='I love Python'
>>> obj==eval(str(obj))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    I love Python
         ^
# 英: SyntaxError: invalid syntax.
# 中: 语法错误：无效语法.

reverse()

reverse()方法: 对象列表的元素进行反向排序.

语法:
list.reverse()

参数: None.

返回值: 该方法没有返回值, 但是会对列表的元素进行反向排序.

l1 = [1, 2, 3, 4, 5]
l1.reverse()
print(l1)  # [5, 4, 3, 2, 1]

# 自定义方法.
class A:
    def __init__(self):
        self.l1 = [1, 2, 3]

    def __reversed__(self):
        return self.l1.reverse()


# 实例化对象.
a = A()
# reversed 没有封装成单独的函数.
a.__reversed__()
print(a.l1)  # [3, 2, 1]

round()

round()函数: 返回浮点数x的四舍五入值.

语法:
round(number[, ndigits]) -> floating point number

参数:
number: 数值表达式.
ndigits: 数值表达式, 表示从小数点位数.

返回值: 返回浮点数x的四舍五入值.

print(round(3.1415926, 1))  # 3.1
print(round(3.1415926, 2))  # 3.14
print(round(3.1415926, 3))  # 3.142

S

set()

set()类: 创建一个无序不重复元素集, 可进行关系测试, 删除重复数据, 还可以计算交集, 差集, 并集等.

语法:
class set([sep])

使用方法:
set() -> new empty set object, 新的空集合对象.
set(iterable) -> new set object, 新的集合对象.

参数说明:
sep: 可迭代对象对象, 不可以支持存放可变类型的数据, 可以放可变类型的变量.

返回值: 返回新的集合对象.

l1 = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
print(set(l1))

# 这样的写个会出现提示: 函数调用可被替换为集合文字, 
# 意思就是说这样写{1, 2, 3, 4, 5, 1, 2, 3, 4, 5} 得了, 之前那样写费事.
print(set([1, 2, 3, 4, 5, 1, 2, 3, 4, 5]))

l1 = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
l2 = [4, 5, 6, 7, 8, 9]

# 去重
s1 = set(l1)
print(s1)  # {1, 2, 3, 4, 5}

s2 = set(l2)

# 交集
print(s1 & s2)  # {4, 5}

# 并集
print(s1 | s2)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}

# 差集
print(s1 - s2)  # {1, 2, 3}

setattr()

setattr()函数: 设置对象的属性值, 如果属性不存在会创建一个新的对象属性, 并对属性赋值.

语法:
setattr(object, name, value)

参数:
object: 对象.
name: 字符串, 对象属性.
value: 属性值.

返回值: None.

# 自定义类.
class A(object):
    value = 1


# 初数化对象.
a = A()

# 获取属性值, value.
print(getattr(a, 'value'))

# 设置属性, value.
setattr(a, 'value', 5)

print(getattr(a, 'value'))  # 5

# 自定义类.
class A(object):
    # 定义属性值.
    value = 1


# 初始化对象.
a = A()

# 获取属性值, value.
print(getattr(a, 'value'))

# 设置属性, value.
setattr(a, 'value', 5)

print(getattr(a, 'value'))  # 5

slice()

slice()类: 实现对象切片, 主要用在切片操作函数里的参数传递.

语法: 
class slice(step)
这里的step是__init__的参数, 必须传递.

使用方法:
slice(stop) 设置一个参数是默认是stop.
slice(start, stop[, step])

参数:
start: 起始位置.
stop: 结束位置.
step: 间距.

返回值: 返回一个切片对象.

# 切片对象.
my_slice = slice(1, 5, 2)

print(my_slice, type(my_slice))  # slice(1, 5, 2) <class 'slice'>

# 生成一个序列对象.
arr = range(10)

# 切片操作.
arr_slice = arr[my_slice]
print(arr_slice, type(arr_slice))  # range(1, 5, 2) <class 'range'>

# 切片后还是一个迭代器, 使用list转换下.
print(list(arr_slice))  # [1, 3]

sorted()

sorted()函数: 对可迭代的对象进行排序操作.

sort与sorted 区别:
sort是应用在list上的方法, sorted可以对所有可迭代的对象进行排序操作.
list的sort方法返回的是对已经存在的列表进行操作, 无返回值, 
而内置函数sorted方法返回的是一个新的list, 而不是在原来的基础上进行的操作.

语法:
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

参数:
iterable: 可迭代对象.

cmp: 比较的函数, 这个具有两个参数, 参数的值都是从可迭代对象中取出, 
	此函数必须遵守的规则为, 大于则返回1, 小于则返回-1, 等于则返回0. Python3这个参数移除.
	      
key: 主要是用来进行比较的元素, 只有一个参数, 具体的函数的参数就是取自于可迭代对象中, 
	指定可迭代对象中的一个元素来进行排序.
	      
reverse: 排序规则, 默认为False, 升序, reverse = True降序.

返回值: 返回重新排序的列表.

a = [5, 7, 6, 3, 4, 1, 2]

# 升序
print(sorted(a))  # [1, 2, 3, 4, 5, 6, 7]

# 降序
print(sorted(a, reverse=True))
# [7, 6, 5, 4, 3, 2, 1]

# -*- coding: UTF-8 -*- Pytohn2.7

L = [{1: 5}, {1: 3}, {1: 1}, {1: 9}]

def f2(a, b):
    print(a, b)  # 两两比较, 值大的继续和后面的值继续比较大小, 小的往前排.
    print(a[1], b[1])
    return a[1] - b[1]

L.sort(cmp=f2)
print L

# 利用key.
new_L = sorted(L, key=lambda x: x[1])  

print new_L  # [{1: 1}, {1: 3}, {1: 5}, {1: 9}]

# -*- coding: UTF-8 -*- Pytohn2.7

L = [(100, 1), (300, 3), (200, 2),  (400, 4)]
# 设置cmp参数, 自定义规则.
print sorted(L, cmp=lambda x, y: cmp(x[1], y[1]))  
# [(100, 1), (200, 2), (300, 3), (400, 4)] 按 1324 的大小顺序排序

# -*- coding: UTF-8 -*- Pytohn2.7

students = [('kid', 'A', 15), ('qz', 'B', 12), ('qq', 'C', 10)]

# 按等级排序.
new_students1 = sorted(students, key=lambda s: s[1])  
# 按年龄排序.
new_students2 = sorted(students, key=lambda s: s[2])  

print new_students1  # [('kid', 'A', 15), ('qz', 'B', 12), ('qq', 'C', 10)]
print new_students2  # [('qq', 'C', 10), ('qz', 'B', 12), ('kid', 'A', 15)]

staticmethod()

staticmethod()函数: 返回函数的静态方法.
该方法不强制要求传递参数.
使用装饰器@staticmethod.参数随意, 没有'self'和'cls'参数, 
但是方法体中不能使用类或实例的任何属性和方法.

语法:
staticmethod(function)

参数: None.

# 自定义类.
class A(object):
    # 设置方法为静态方法, 可以不接受默认参数self.
    @staticmethod
    def func():
        print('123')



# 类可是使用静态方法.
A.func()  # 123 

# 实例化对象.
obj = A()
# 对象可是使用静态方法.
obj.func()  # 123 

str()

str()类: 将对象转化str格式.

语法:
class str(object='') -> string

参数:
object: 对象.

返回值: 返回一个对象的str格式.

s = str(123)
print(s, type(s))  # 123 <class 'str'>

sum()

sum()函数: 对序列进行求和计算.

语法:
sum(iterable[, start]) -> value

参数:
iterable: 可迭代对象, 如:列表, 元组, 集合.
start: 指定相加的参数, 如果没有设置这个值, 默认为0.

返回值: 返回计算结果.

print(sum([0, 1, 2]))  # 3

# 元组计算总和后再加 1.
print(sum((2, 3, 4), 1))  # 10

# 列表计算总和后再加 2.
print(sum([0, 1, 2, 3, 4], 2))  # 12

super()

super()类: 用于调用父类(超类)的一个方法.
是用来解决多重继承问题的, 直接用类名调用父类方法在使用单继承的时候没问题, 
但是如果使用多继承, 会涉及到查找顺序(MRO), 重复调用(菱形继承)等种种问题.

MRO: 是类方法解析顺序表, 继承父类方法时的顺序表.
Python3可以使用直接使用super().xxx 代替 super(Class, self).xxx .

语法:
super(type1 [, object-or-type])

参数:
type: 类名称.
object-or-type: 对象或类, 一般是self.

返回值: None.

# 自定义类.
class A:
    def add(self, x):
        y = x + 1
        print(y)

        
# 自定义类, 继承A.
class B(A):
    def add(self, x):
        # 子类调用父类的方法.
        super().add(x)  # 执行A类中的add方法, 把参数x传递给方法.


# 实例化对象.
b = B()
b.add(2)  # 3

# -*- coding: UTF-8 -*- Python2.7
# 自定义类, Python2.x记得继承object, Python3.x默认继承object.
class A(object): 
    # 定义add方法.
    def add(self, x):
        y = x + 1
        print(y)

        
# 自定义类.
class B(A):
    # 定义add方法.
    def add(self, x):
        # 调用父类的方法.
        super(B, self).add(x)


# 实例化对象.
b = B()
b.add(2)  # 3

# -*- coding: UTF-8 -*-

class FooParent(object):  # 父
    def __init__(self):
        self.parent = '5'
        print ('1')

    def bar(self, message):
        print (message)


class FooChild(FooParent):  # 子
    def __init__(self):
        # 首先找到FooChild的父类FooParent, 然后把类FooChild的对象替换FooParent的对象.
        super(FooChild, self).__init__()
        print ('2')

    def bar(self, message):
        super(FooChild, self).bar(message)
        print ('4')
        print (self.parent)


fooChild = FooChild()  # 打印 1 2
fooChild.bar('3')  # 打印 3 4 5

T

tuple()

tuple()类: 将序列类型转换为元组.

语法:
class tuple([, sep])

使用方法:
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items

参数:
sep: 要转换为元组的可迭代序列.

返回值: 返回元组.

print(tuple())  # () 空元组
print(tuple([1, 2, 3, 4]))  # (1, 2, 3, 4)
print(tuple({1: 2, 3: 4}))  # 针对字典, 会返回字典的key组成的元组.

type()

type()函数: 只有第一个参数则返回对象的类型, 三个参数返回新的类型对象.

isinstance()与type()区别:
type()不会认为子类是一种父类类型, 不考虑继承关系.
isinstance() 会认为子类是一种父类类型, 考虑继承关系.
如果要判断两个类型是否相同推荐使用isinstance().

语法:
type(object)
type(name, bases, dict)

参数:
name: 类的名称.
bases: 基类的元组.
dict: 字典, 类内定义的命名空间变量.

返回值: 一个参数返回对象类型, 三个参数, 返回新的类型对象.

print(type(1))  # <class 'int'>

print(type('hello'))  # <class 'int'>

# 产生一个新的类型 X.
X = type('X', (object,), dict(a=1))  

print(X)  # <class '__main__.X'>

# 实例化对象.
x = X()
print(x.a)  # 1


# 等同于↓
class X(object):
     a = 1

# 自定义类.
class A(object):
    pass


# 自定义类.
class B(A):
    pass


# 判断A的实例对象, 是否为类A的派生类.
print(isinstance(A(), A))  # True
# 判断A的实例对象类型是否为类A.
print(type(A()) == A)  # True
# 判断B的实例对象, 是否为类A的派生类.
print(isinstance(B(), A))  # True
# 判断B的实例对象类型是否为类A.
print(type(B()) == A)  # False

U

unichr()

unichr() 函数和chr()函数功能基本一样,  只不过返回的是unicode字符.
Python3不支持unichr(), 改用chr()函数.

语法:
unichr(i) -> Unicode character

参数:
i: 可以是10进制也可以是16进制的形式的数字.

返回值: 返回unicode字符.

# Python 2.7
print unichr(97)  # a

unicode()

unicode()函数: 从给定的编码字符串创建一个新的Unicode对象, 默认序数范围128位.
Python3.x移除.

语法:
unicode(string[, encoding[, errors]]) 

参数:
string: 从给定的编码字符串创建一个新的 Unicode 对象.
encoding: 默认为当前默认的字符串编码.
errors: 错误可以是'严格, strict', '替换, replace'或'忽略, ignore', 默认为'严格'.

返回值: 返回unicode字符.

# -*- coding: UTF-8 -*- Python2
s1 = unicode('哈哈', encoding='utf8')
print s1, type(s1)  # <type 'unicode'>

V

vars()

vars()函数: 返回对象的属性和属性值的字典对象.

语法:
vars([object])

参数:
object: 对象, 可选.

返回值: 返回对象object的属性和属性值的字典对象, 
如果没有参数, 就打印当前调用位置的属性和属性值 类似 locals().

print(vars())

"""
{'__name__': '__main__', '__doc__': None, '__package__': None,
 '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000024C788FD4A8>, 
 '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 
 '__file__': 'C:\\Users\\13600\\PycharmProjects\\test\\test.py, '__cached__': None}
"""


# 自定义类.
class A(object):
    value = 1


# 查看类的属性值.
print(vars(A))
"""
{'__module__': '__main__', 'value': 1, '__dict__': <attribute '__dict__' of 'A' objects>, 
'__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
"""

# 查看对象的属性值.
a = A()
print(vars(a))  # {}

X

xrange()

xrange()函数用法与range完全相同, 所不同的是生成的不是一个数组, 而是一个生成器.
Python3.x移除.

语法:
xrange(stop)
使用方法:
xrange(stop) -> xrange object
xrange(start, stop[, step]) -> xrange object

参数:
start: 开始值, 默认是从0开始. 例如 xrange(5)等价于xrange(0,  5)
stop: 结束值, 但不包括stop. 例如:xrange(0,  5)是[0, 1, 2, 3, 4] 没有 5
step: 步长, 默认为1. 例如:xrange(0,  5)等价于xrange(0, 5, 1)

返回值: 返回生成器.

l1 = xrange(10)
print l1, type(l1)  # xrange(10) <type 'xrange'>
print list(l1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Z

zip()

zip()函数: 将可迭代的对象作为参数, 将对象中对应的元素打包成一个个元组, 
然后返回由这些元组组成的列表.

如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同, 
利用*号操作符, 可以将元组解包为列表.

zip()函数在Python2和Python3中的不同: 
在Python3.x中为了减少内存, 返回的是一个对象, 如需展示列表, 需手动list()转换.

语法:
zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

参数:
seq: 一个或多个迭代器.

返回值: 返回元组列表.

# -*- coding: UTF-8 -*-
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]

# # 打包为元组的列表.
zipped1 = zip(a, b)
print(list(zipped1))  # [(1, 4), (2, 5), (3, 6)]

# 元素个数与最短的列表一致.
zipped2 = zip(a, c)
print(list(zipped2))  # [(1, 4), (2, 5), (3, 6)]

# 与zip相反, *zipped可理解为解包, 返回二维矩阵式.
print(zip(*zipped1))  # [(1, 2, 3), (4, 5, 6)] Python3这里得到的结果是一个zip对象.

-

__ import __()

 __import__()函数: 用于动态加载类和函数.
 如果一个模块经常变化就可以使用__import__()来动态载入.

语法:
__import__(name, globals=None, locals=None, fromlist=(), level=0) -> module

参数:
name: 模块名称, 必填.
globals: 全局变量集合, 默认为None, 几乎不设置, 如果设置的话, 常用globals().
locals: 局部变量集合, 默认为None, 几乎不设置, 如果设置的话, 常用locals().
fromlist: 是否导入子模块, 看上去是导入模块的列表.
	但实际上目前它只是一个判断条件, 只要设置为非空的值, 且模块名称是带有子模块的, 将导入子模块.
	例如: sys.path. 当不设置时, 返回sys, 如果设置为非空值, 则返回ntpath(path模块).
level: 绝对或者相对导入。

返回值: 返回元组列表.

# 静态导入.
import time
print(time, type(time))  # <module 'time' (built-in)> <class 'module'>
print(time.time())  # 1674176126.0117664

# 对于一些有特殊需求的或者需要将模块名称赋值给变量后再导入, 静态导入是会报错的, 例如:

t = 'time'
# 将变量名称作为模块名称进行导入, 而不是将变量值作为名称导入, 这时就要用到动态导入.
import t  # 报错
# 英: ModuleNotFoundError: No module named 't'.
# 中: 找不到模块错误：没有名为“t”的模块.

t = 'time'
# 动态导入.
t = __import__(t)
print(t, type(t))  # <module 'time' (built-in)> <class 'module'>
print(t.time())  # 1674176508.805265

# 导入子模块.
# 在未设置fromlist参数时, 无论模块名称如何设置, 它都将导入最左边名称的模块模块.
os = __import__('os.path')
print(os)  # <module 'os' from 'C:\\programming\\python3.9.4\\lib\\os.py'>

# 设置fromlist参数, 导入子模块.
# 如果设置了fromlist为非空(包括None), 将导入最右边的模块, 也就是子模块.

# 第一个参数必须有子模块名称, fromlist参数也指定子模块名称.
path = __import__('os.path', fromlist=['path'])
print(path)  # <module 'ntpath' from 'C:\\programming\\python3.9.4\\lib\\ntpath.py'>


path = __import__('os.path', fromlist=['None'])
print(path)  # <module 'ntpath' from 'C:\\programming\\python3.9.4\\lib\\ntpath.py'>


# 导入子模块.
import importlib
path = importlib.import_module('os.path')
print(path)  # <module 'ntpath' from 'C:\\programming\\python3.9.4\\lib\\ntpath.py'>