Python 新版本有75个内置函数，你不会不知道吧(1)

Help on _Printer in module _sitebuiltins object:
copyright = class _Printer(builtins.object)
| copyright(name, data, files=(), dirs=())
|
| interactive prompt objects for printing the license text, a list of
| contributors and the copyright notice.

Help on _Printer in module _sitebuiltins object:
credits = class _Printer(builtins.object)
| credits(name, data, files=(), dirs=())
|
| interactive prompt objects for printing the license text, a list of
| contributors and the copyright notice.

Help on _Printer in module _sitebuiltins object:
license = class _Printer(builtins.object)
| license(name, data, files=(), dirs=())
|
| interactive prompt objects for printing the license text, a list of
| contributors and the copyright notice.

Help on Quitter in module _sitebuiltins object:
exit = class Quitter(builtins.object)
| exit(name, eof)

Help on Quitter in module _sitebuiltins object:
quit = class Quitter(builtins.object)
| quit(name, eof)

Help on class bool in module builtins:
class bool(int)
| bool(x) -> bool
|
| Returns True when the argument x is true, False otherwise.
| The builtins True and False are the only two instances of the class bool.
| The class bool is a subclass of the class int, and cannot be subclassed.

Help on class bytearray in module builtins:
class bytearray(object)
| bytearray(iterable_of_ints) -> bytearray
| bytearray(string, encoding[, errors]) -> bytearray
| bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
| bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
| bytearray() -> empty bytes array
|
| Construct a mutable bytearray object from:
| - an iterable yielding integers in range(256)
| - a text string encoded using the specified encoding
| - a bytes or a buffer object
| - any object implementing the buffer API.
| - an integer

Help on class bytes in module builtins:
class bytes(object)
| bytes(iterable_of_ints) -> bytes
| bytes(string, encoding[, errors]) -> bytes
| bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
| bytes(int) -> bytes object of size given by the parameter initialized with null bytes
| bytes() -> empty bytes object
|
| Construct an immutable array of bytes from:
| - an iterable yielding integers in range(256)
| - a text string encoded using the specified encoding
| - any object implementing the buffer API.
| - an integer

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.

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.

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)

Help on class enumerate in module builtins:
class enumerate(object)
| enumerate(iterable, start=0)
|
| Return an enumerate object.
|
| iterable
| an object supporting iteration
|
| The enumerate object yields pairs containing a count (from start, which
| defaults to zero) and a value yielded by the iterable argument.
|
| enumerate is useful for obtaining an indexed list:
| (0, seq[0]), (1, seq[1]), (2, seq[2]), …

Help on class filter in module builtins:
class filter(object)
| filter(function or None, iterable) --> filter object
|
| Return an iterator yielding those items of iterable for which function(item)
| is true. If function is None, return the items that are true.

Help on class float in module builtins:
class float(object)
| float(x=0, /)
|
| Convert a string or number to a floating point number, if possible.

Help on class frozenset in module builtins:
class frozenset(object)
| frozenset() -> empty frozenset object
| frozenset(iterable) -> frozenset object
|
| Build an immutable unordered collection of unique elements.

Help on class int in module builtins:
class int(object)
| int([x]) -> integer
| int(x, base=10) -> integer
|
| Convert a number or string to an integer, or return 0 if no arguments
| are given. If x is a number, return x.__int__(). For floating point
| numbers, this truncates towards zero.
|
| If x is not a number or if base is given, then x must be a string,
| bytes, or bytearray instance representing an integer literal in the
| given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded
| by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
| Base 0 means to interpret the base from the string as an integer literal.
| >>> int(‘0b100’, base=0)
| 4
|
| Built-in subclasses:
| bool

Help on class list in module builtins:
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.

Help on class map in module builtins:
class map(object)
| map(func, *iterables) --> map object
|
| Make an iterator that computes the function using arguments from
| each of the iterables. Stops when the shortest iterable is exhausted.

Help on class memoryview in module builtins:
class memoryview(object)
| memoryview(object)
|
| Create a new memoryview object which references the given object.

Help on class object in module builtins:
class object
| The base class of the class hierarchy.
|
| When called, it accepts no arguments and returns a new featureless
| instance that has no instance attributes and cannot be given any.
|
| Built-in subclasses:
| anext_awaitable
| async_generator
| async_generator_asend
| async_generator_athrow
| … and 89 other subclasses

Help on class property in module builtins:
class property(object)
| property(fget=None, fset=None, fdel=None, doc=None)
|
| Property attribute.
|
| fget
| function to be used for getting an attribute value
| fset
| function to be used for setting an attribute value
| fdel
| function to be used for del’ing an attribute
| doc
| docstring
|
| Typical use is to define a managed attribute x:
|
| class C(object):
| def getx(self): return self._x
| def setx(self, value): self._x = value
| def delx(self): del self._x
| x = property(getx, setx, delx, “I’m the ‘x’ property.”)
|
| Decorators make defining new properties or modifying existing ones easy:
|
| class C(object):
| @property
| def x(self):
| “I am the ‘x’ property.”
| return self._x
| @x.setter
| def x(self, value):
| self._x = value
| @x.deleter
| def x(self):
| del self._x

Help on class range in module builtins:
class range(object)
| range(stop) -> range object
| range(start, stop[, step]) -> range object
|
| Return an object that produces a sequence of integers from start (inclusive)
| to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, …, j-1.
| start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3.
| These are exactly the valid indices for a list of 4 elements.
| When step is given, it specifies the increment (or decrement).

Help on class reversed in module builtins:
class reversed(object)
| reversed(sequence, /)
|
| Return a reverse iterator over the values of the given sequence.

Help on class set in module builtins:
class set(object)
| set() -> new empty set object
| set(iterable) -> new set object
|
| Build an unordered collection of unique elements.

Help on class slice in module builtins:
class slice(object)
| slice(stop)
| slice(start, stop[, step])
|
| Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).

Help on class staticmethod in module builtins:
class staticmethod(object)
| staticmethod(function) -> method
|
| Convert a function to be a static method.
|
| A static method does not receive an implicit first argument.
| To declare a static method, use this idiom:
|
| class C:
| @staticmethod
| def f(arg1, arg2, …):
| …
|
| It can be called either on the class (e.g. C.f()) or on an instance
| (e.g. C().f()). Both the class and the instance are ignored, and
| neither is passed implicitly as the first argument to the method.
|
| Static methods in Python are similar to those found in Java or C++.
| For a more advanced concept, see the classmethod builtin.

Help on class str in module builtins:
class str(object)
| str(object=‘’) -> str
| str(bytes_or_buffer[, encoding[, errors]]) -> str
|
| Create a new string object from the given object. If encoding or
| errors is specified, then the object must expose a data buffer
| that will be decoded using the given encoding and error handler.
| Otherwise, returns the result of object.__str__() (if defined)
| or repr(object).
| encoding defaults to sys.getdefaultencoding().
| errors defaults to ‘strict’.

Help on class super in module builtins:
class super(object)
| super() -> same as super(__class__, )
| super(type) -> unbound super object
| super(type, obj) -> bound super object; requires isinstance(obj, type)
| super(type, type2) -> bound super object; requires issubclass(type2, type)
| Typical use to call a cooperative superclass method:
| class C(B):
| def meth(self, arg):
| super().meth(arg)
| This works for class methods too:
| class C(B):
| @classmethod
| def cmeth(cls, arg):
| super().cmeth(arg)

Help on class tuple in module builtins:
class tuple(object)
| tuple(iterable=(), /)
|
| Built-in immutable sequence.
|
| If no argument is given, the constructor returns an empty tuple.
| If iterable is specified the tuple is initialized from iterable’s items.
|
| If the argument is a tuple, the return value is the same object.

Help on class type in module builtins:
class type(object)
| type(object) -> the object’s type
| type(name, bases, dict, **kwds) -> a new type

Help on class zip in module builtins:
class zip(object)
| zip(*iterables, strict=False) --> Yield tuples until an input is exhausted.
|
| >>> list(zip(‘abcdefg’, range(3), range(4)))
| [(‘a’, 0, 0), (‘b’, 1, 1), (‘c’, 2, 2)]
|
| The zip object yields n-length tuples, where n is the number of iterables
| passed as positional arguments to zip(). The i-th element in every tuple
| comes from the i-th iterable argument to zip(). This continues until the
| shortest argument is exhausted.
|
| If strict is true and one of the arguments is exhausted before the others,
| raise a ValueError.

01. abs()
Help on built-in function abs in module builtins:
abs(x, /)
Return the absolute value of the argument.

Help on built-in function aiter in module builtins:
aiter(async_iterable, /)
Return an AsyncIterator for an AsyncIterable object.

Help on built-in function all in module builtins:
all(iterable, /)
Return True if bool(x) is True for all values x in the iterable.

Help on built-in function anext in module builtins:
anext(…)
async anext(aiterator[, default])

Help on built-in function any in module builtins:
any(iterable, /)
Return True if bool(x) is True for any x in the iterable.

Help on built-in function ascii in module builtins:
ascii(obj, /)
Return an ASCII-only representation of an object.

Help on built-in function bin in module builtins:
bin(number, /)
Return the binary representation of an integer.

Help on built-in function breakpoint in module builtins:
breakpoint(…)
breakpoint(*args, **kws)

Help on built-in function callable in module builtins:
callable(obj, /)
Return whether the object is callable (i.e., some kind of function).

Help on built-in function chr in module builtins:
chr(i, /)
Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.

Help on built-in function compile in module builtins:
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1, *, _feature_version=-1)
Compile source into a code object that can be executed by exec() or eval().

Help on built-in function delattr in module builtins:
delattr(obj, name, /)
Deletes the named attribute from the given object.

Help on built-in function dir in module builtins:
dir(…)
dir([object]) -> list of strings

Help on built-in function divmod in module builtins:
divmod(x, y, /)
Return the tuple (x//y, x%y). Invariant: div*y + mod == x.

Help on built-in function eval in module builtins:
eval(source, globals=None, locals=None, /)
Evaluate the given source in the context of globals and locals.

Help on built-in function exec in module builtins:
exec(source, globals=None, locals=None, /, *, closure=None)
Execute the given source in the context of globals and locals.

Help on built-in function getattr in module builtins:
getattr(…)
getattr(object, name[, default]) -> value

Help on built-in function globals in module builtins:
globals()
Return the dictionary containing the current scope’s global variables.

Help on built-in function hasattr in module builtins:
hasattr(obj, name, /)
Return whether the object has an attribute with the given name.

Help on built-in function hash in module builtins:
hash(obj, /)
Return the hash value for the given object.

Help on built-in function hex in module builtins:
hex(number, /)
Return the hexadecimal representation of an integer.

Help on built-in function id in module builtins:
id(obj, /)
Return the identity of an object.

Help on built-in function input in module builtins:
input(prompt=None, /)
Read a string from standard input. The trailing newline is stripped.

Help on built-in function isinstance in module builtins:
isinstance(obj, class_or_tuple, /)
Return whether an object is an instance of a class or of a subclass thereof.

Help on built-in function issubclass in module builtins:
issubclass(cls, class_or_tuple, /)
Return whether ‘cls’ is derived from another class or is the same class.

Help on built-in function iter in module builtins:
iter(…)
iter(iterable) -> iterator
iter(callable, sentinel) -> iterator

Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.

Help on built-in function locals in module builtins:
locals()
Return a dictionary containing the current scope’s local variables.

Help on built-in function max in module builtins:
max(…)
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value

Help on built-in function min in module builtins:
min(…)
min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value

Help on built-in function next in module builtins:
next(…)
next(iterator[, default])

Help on built-in function oct in module builtins:
oct(number, /)
Return the octal representation of an integer.

Help on built-in function open in module io:
open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
Open file and return a stream. Raise OSError upon failure.

Help on built-in function ord in module builtins:
ord(c, /)
Return the Unicode code point for a one-character string.

Help on built-in function pow in module builtins:
pow(base, exp, mod=None)
Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments

Help on built-in function print in module builtins:
print(*args, sep=’ ‘, end=’\n’, file=None, flush=False)
Prints the values to a stream, or to sys.stdout by default.