callable() 是可调用对象？
内置函数 callable()，Python 官方文档描述如下：
help(callable)
Help on built-in function callable in module builtins:
callable(obj, /)
Return whether the object is callable (i.e., some kind of function).
Note that classes are callable, as are instances of classes with a
__call__() method.
如果 obj 是可调用对象就返回 True，否则返回 False。如果返回 True，调用仍可能失败，但如果返回 False，则调用将肯定不会成功。
函数、方法、类以及实现了 __call__() 方法的类的实例是可调用的。
callable(1)
False
callable(int)
True
class Myint(int):
def __call__(self):
pass
num = Myint(1)
num
1
callable(num)
True
callable(lambda: 1)
True
chr() 返回 Unicode 码位值对应字符
内置函数 chr()，Python 官方文档描述如下：
help(chr)
Help on built-in function chr in module builtins:
chr(i, /)
Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
返回 Unicode 码位对应的字符的字符串格式。码位范围是 0~1114111（16 进制表示是 0x10FFFF），超过这个范围，会触发 ValueError 异常。该函数是 ord() 的逆函数。
chr(97)
'a'
ord('a')
97
chr(1114111)
'\U0010ffff'
chr(1114112)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-5-4857faf08086> in <module>
----> 1 chr(1114112)
ValueError: chr() arg not in range(0x110000)
classmethod 封装函数为类方法
内置函数（类）classmethod，Python 官方文档描述如下：
help(classmethod)
Help on class classmethod in module builtins:
class classmethod(object)
| classmethod(function) -> method
|
| Convert a function to be a class method.
|
| A class method receives the class as implicit first argument,
| just like an instance method receives the instance.
| To declare a class method, use this idiom:
|
| class C:
| @classmethod
| def f(cls, arg1, arg2, ...):
| ...
|
| It can be called either on the class (e.g. C.f()) or on an instance
| (e.g. C().f()). The instance is ignored except for its class.
| If a class method is called for a derived class, the derived class
| object is passed as the implied first argument.
|
| Class methods are different than C++ or Java static methods.
| If you want those, see the staticmethod builtin.
|
| Methods defined here:
|
| __get__(self, instance, owner, /)
| Return an attribute of instance, which is of type owner.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
|
| __func__
|
| __isabstractmethod__
把一个函数封装成类方法。一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。
可将函数作为参数来声明类方法，但请用习惯的装饰器形式（@classmethod）来声明类方法。
type(classmethod)
type
class A:
print_itself = classmethod(print)
A.print_itself()
<class '__main__.A'>
class A:
@classmethod
def print_itself(cls):
print(cls)
A.print_itself()
<class '__main__.A'>
compile() 创建代码对象
内置函数 compile()，Python 官方文档描述如下：
help(compile)
Help on built-in function compile in module builtins:
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
Compile source into a code object that can be executed by exec() or eval().
The source code may represent a Python module, statement or expression.
The filename will be used for run-time error messages.
The mode must be 'exec' to compile a module, 'single' to compile a
single (interactive) statement, or 'eval' to compile an expression.
The flags argument, if present, controls which future statements influence
the compilation of the code.
The dont_inherit argument, if true, stops the compilation inheriting
the effects of any future statements in effect in the code calling
compile; if absent or false these statements do influence the compilation,
in addition to any features explicitly specified.
将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。
参数说明：
- source，要编译的资源，可以是字符串、字节或 AST 对象。
- filename，源所来自的文件的名称。如果代码不需要从文件中读取，可以传入一些可辨识的值（经常会使用字符串）。
- mode，指定了编译代码必须用的模式。如果 source 是语句序列，可以是 'exec'；如果是单一表达式，可以是 'eval'；如果是单个交互式语句，可以是 'single'。
- flags 和 dont-inherit，控制在编译 source 时要用到哪个 future 语句。
- optimize，指定编译器的优化级别；默认值 -1 选择与解释器的 -O 选项相同的优化级别。
source = 'for i in range(3):print(i)'
code = compile(source,'null','exec')
code
<code object <module> at 0x000001E999B07780, file "null", line 1>
exec(code)
0
1
2
eval(code)
0
1
2
complex 创建复数
内置函数（类）complex，Python 官方文档描述如下：
help(complex)
Help on class complex in module builtins:
class complex(object)
| complex(real=0, imag=0)
|
| Create a complex number from a real part and an optional imaginary part.
|
| This is equivalent to (real + imag*1j) where imag defaults to 0.
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| self != 0
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __format__(...)
| complex.__format__() -> str
|
| Convert to a string according to format_spec.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(...)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __int__(self, /)
| int(self)
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __repr__(self, /)
| Return repr(self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| conjugate(...)
| complex.conjugate() -> complex
|
| Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| imag
| the imaginary part of a complex number
|
| real
| the real part of a complex number
返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。
- 如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。
- 第二个形参不能是字符串。
- 每个实参都可以是任意的数值类型（包括复数）。
- 如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。
- 如果两个实参都省略，则返回 0j。
- 当从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。
type(complex)
type
complex('1')
(1+0j)
complex('1+2j')
(1+2j)
complex(1j, 2j)
(-2+1j)
complex(1j)
1j
complex()
0j
complex('1 + 2j')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-7-fd0fa4b53d7c> in <module>
----> 1 complex('1 + 2j')
ValueError: complex() arg is a malformed string
delattr() 删除对象属性
内置函数 delattr()，Python 官方文档描述如下：
help(delattr)
Help on built-in function delattr in module builtins:
delattr(obj, name, /)
Deletes the named attribute from the given object.
delattr(x, 'y') is equivalent to ``del x.y''
实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。delattr(x, 'y') 等价于 del x.y。
class A:
y = 0
x = A
x.y
0
delattr(x,'y')
x.y
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-12-3552434a3e61> in <module>
----> 1 x.y
AttributeError: type object 'A' has no attribute 'y'
dict 创建字典
内置函数（类）dict，Python 官方文档描述如下：
help(dict)
Help on class dict in module builtins:
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Methods defined here:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
| If key is not found, d is returned if given, otherwise KeyError is raised
|
| popitem(...)
| D.popitem() -> (k, v), remove and return some (key, value) pair as a
| 2-tuple; but raise KeyError if D is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| fromkeys(iterable, value=None, /) from builtins.type
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
创建一个新字典。参数说明：
- 不传参数创建空字典；
- 传递一个映射对象；
- 传递一个可迭代对象；
- 传递关键字参数。
type(dict)
type
dict()
{}
dict({'a':1})
{'a': 1}
d = zip('abc',[1,2,3])
dict(d)
{'a': 1, 'b': 2, 'c': 3}
dict([('a', 1), ('b', 2)])
{'a': 1, 'b': 2}
dict(a=1,b=2)
{'a': 1, 'b': 2}
dir() 返回对象属性列表
内置函数 dir()，Python 官方文档描述如下：
help(dir)
Help on built-in function dir in module builtins:
dir(...)
dir([object]) -> list of strings
If called without an argument, return the names in the current scope.
Else, return an alphabetized list of names comprising (some of) the attributes
of the given object, and of attributes reachable from it.
If the object supplies a method named __dir__, it will be used; otherwise
the default dir() logic is used and returns:
for a module object: the module's attributes.
for a class object: its attributes, and recursively the attributes
of its bases.
for any other object: its attributes, its class's attributes, and
recursively the attributes of its class's base classes.
如果没有实参，则返回当前作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。
dir()
['In',
'Out',
'_',
'__',
'___',
'__builtin__',
'__builtins__',
'__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_dh',
'_i',
'_i1',
'_i2',
'_ih',
'_ii',
'_iii',
'_oh',
'exit',
'get_ipython',
'quit']
如果对象有一个名为 __dir__() 的方法，那么该方法将被调用，并且必须返回一个属性列表。这允许实现自定义 dir() 来报告它的属性。
class A:
def __dir__(self):
return ['area', 'perimeter', 'location']
a = A()
dir(a)
['area', 'location', 'perimeter']
如果对象不提供 __dir__()，默认的 dir() 机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：
- 如果对象是模块对象，则列表包含模块的属性名称;
- 如果对象是类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性;
- 如果对象是实例对象，则列表包含实例的属性名称，它的类的属性名称，并且递归查找它的类的所有基类的属性。
import string
dir(string)
['Formatter',
'Template',
'_ChainMap',
'_TemplateMetaclass',
'__all__',
'__builtins__',
'__cached__',
'__doc__',
'__file__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_re',
'_string',
'ascii_letters',
'ascii_lowercase',
'ascii_uppercase',
'capwords',
'digits',
'hexdigits',
'octdigits',
'printable',
'punctuation',
'whitespace']
dir(int)
['__abs__',
'__add__',
'__and__',
'__bool__',
'__ceil__',
'__class__',
'__delattr__',
'__dir__',
'__divmod__',
'__doc__',
'__eq__',
'__float__',
'__floor__',
'__floordiv__',
'__format__',
'__ge__',
'__getattribute__',
'__getnewargs__',
'__gt__',
'__hash__',
'__index__',
'__init__',
'__init_subclass__',
'__int__',
'__invert__',
'__le__',
'__lshift__',
'__lt__',
'__mod__',
'__mul__',
'__ne__',
'__neg__',
'__new__',
'__or__',
'__pos__',
'__pow__',
'__radd__',
'__rand__',
'__rdivmod__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__rfloordiv__',
'__rlshift__',
'__rmod__',
'__rmul__',
'__ror__',
'__round__',
'__rpow__',
'__rrshift__',
'__rshift__',
'__rsub__',
'__rtruediv__',
'__rxor__',
'__setattr__',
'__sizeof__',
'__str__',
'__sub__',
'__subclasshook__',
'__truediv__',
'__trunc__',
'__xor__',
'bit_length',
'conjugate',
'denominator',
'from_bytes',
'imag',
'numerator',
'real',
'to_bytes']
dir(1)
['__abs__',
'__add__',
'__and__',
'__bool__',
'__ceil__',
'__class__',
'__delattr__',
'__dir__',
'__divmod__',
'__doc__',
'__eq__',
'__float__',
'__floor__',
'__floordiv__',
'__format__',
'__ge__',
'__getattribute__',
'__getnewargs__',
'__gt__',
'__hash__',
'__index__',
'__init__',
'__init_subclass__',
'__int__',
'__invert__',
'__le__',
'__lshift__',
'__lt__',
'__mod__',
'__mul__',
'__ne__',
'__neg__',
'__new__',
'__or__',
'__pos__',
'__pow__',
'__radd__',
'__rand__',
'__rdivmod__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__rfloordiv__',
'__rlshift__',
'__rmod__',
'__rmul__',
'__ror__',
'__round__',
'__rpow__',
'__rrshift__',
'__rshift__',
'__rsub__',
'__rtruediv__',
'__rxor__',
'__setattr__',
'__sizeof__',
'__str__',
'__sub__',
'__subclasshook__',
'__truediv__',
'__trunc__',
'__xor__',
'bit_length',
'conjugate',
'denominator',
'from_bytes',
'imag',
'numerator',
'real',
'to_bytes']
divmod() 求两个数的商和余
内置函数 divmod()，Python 官方文档描述如下：
help(divmod)
Help on built-in function divmod in module builtins:
divmod(x, y, /)
Return the tuple (x//y, x%y). Invariant: div*y + mod == x.
它将两个（非复数）数字作为实参，返回两个数字的（商,余数）元组。对于混合操作数类型，适用二元算术运算符的规则。
divmod(1,2)
(0, 1)
divmod(3.14, 2)
(1.0, 1.1400000000000001)
