python内置函数详解

内置函数

---

python一共为我们提供了69个内置函数

		内置函数
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	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()

• abs(x)

  返回数字的绝对值。参数可以是整数或浮点数。如果参数为复数，则返回其大小。

• all(iterable)

  如果 iterable 的所有元素为真（或迭代器为空），返回 True 。

  检查 iterable 中是否含有空字符，只要有一个空字符就返回False

  # 等价于
  def all(iterable):
      for element in iterable:
          if not element:
              return False
      return True
  

• any(iterable)

  如果 iterable 的任一元素为真则返回 True。 如果迭代器为空，返回 False。

  # 等价于
  
  def any(iterable):
      for element in iterable:
          if element:
              return True
      return False
  

• ascii(object)

  返回一个对象可打印的 ASCII 编码的字符，生成的字符串和 Python 2 的 repr()返回的结果相似。

• bin(x)

  将一个整数转变为一个前缀为“0b”的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 __index__()方法返回一个整数。

• bool([x])

  返回一个布尔值，True 或者 False。如果 x 是假的或者被省略，返回 False；其他情况返回 True。

• breakpoint(*args, **kwargs)

  此函数会在调用时将你陷入调试器中。具体来说，它调用 sys.breakpointhook() ，直接传递 args 和 kws 。默认情况下， sys.breakpointhook() 调用 pdb.set_trace() 且没有参数。在这种情况下，它纯粹是一个便利函数，因此您不必显式导入 pdb 且键入尽可能少的代码即可进入调试器。但是， sys.breakpointhook() 可以设置为其他一些函数并被 breakpoint() 自动调用，以允许进入你想用的调试器。3.7 新版功能.

• class bytearray([source[, encoding[, errors]]])

  返回一个新的 bytes 数组。 bytearray 类是一个可变序列，包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法，见 可变序列类型 的描述；同时有 bytes 类型的大部分方法，参见 bytes 和 bytearray 操作。

  可选形参 source 可以用不同的方式来初始化数组：

  • 如果是一个 string，您必须提供 encoding 参数（errors 参数仍是可选的）；bytearray() 会使用 str.encode() 方法来将 string 转变成 bytes。
  • 如果是一个 integer，会初始化大小为该数字的数组，并使用 null 字节填充。如果是一个符合 buffer 接口的对象，该对象的只读 buffer 会用来初始化字节数组。
  • 如果是一个 iterable 可迭代对象，它的元素的范围必须是 0 <= x < 256 的整数，它会被用作数组的初始内容。
  • 如果没有实参，则创建大小为 0 的数组。

• class bytes([source[, encoding[, errors]]])

  返回一个新的“bytes”对象， 是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes 是 bytearray 的不可变版本 - 它有其中不改变序列的方法和相同的索引、切片操作。

  因此，构造函数的实参和 bytearray() 相同。字节对象还可以用字面值创建

• callable(object)

  如果实参 object 是可调用的，返回 True，否则返回 False。如果返回真，调用仍可能会失败；但如果返回假，则调用 object 肯定会失败。

• chr(i)

  返回 Unicode 码位为整数 i 的字符的字符串格式。

  例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。这是 ord() 的逆函数。

  实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError异常。

• @classmethod

  把一个方法封装成类方法。

  一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。

  # 用以下习惯来声明类方法
  class C:
      @classmethod
      def f(cls, arg1, arg2, ...): ...
  

  类方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。

• compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

  将 source编译成代码或 AST 对象。代码对象可以被 exec()或 eval() 执行。

  • source 可以是常规的字符串、字节字符串，或者 AST 对象。
  • filename 实参需要是代码读取的文件名；如果代码不需要从文件中读取，可以传入一些可辨识的值（经常会使用 ''）。
  • mode 实参指定了编译代码必须用的模式。如果 source 是语句序列，可以是 'exec'；如果是单一表达式，可以是 'eval'；如果是单个交互式语句，可以是 'single'。
  • 可选参数 flags 和 dont_inherit 控制在编译 source 时要用到哪个 future 语句。如果两者都未提供（或都为零）则会使用调用 compile()的代码中有效的 future 语句来编译代码。 如果给出了 flags 参数但没有 dont_inherit (或是为零) 则 flags 参数所指定的 以及那些无论如何都有效的 future 语句会被使用。 如果 dont_inherit 为一个非零整数，则只使用 flags 参数 – 在调用外围有效的 future 语句将被忽略。
  • optimize 实参指定编译器的优化级别；默认值 -1 选择与解释器的 -O选项相同的优化级别。显式级别为 0（没有优化；__debug__ 为真）、1 （断言被删除， __debug__ 为假）或 2 （文档字符串也被删除）。

• class complex([real[, imag]])

  返回值为real+ imag*1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。

• delattr(object,name)

  setattr()相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。

• class dict(**kwargs)

  class dict(mapping, **kwarg)

  class dict(iterable, **kwarg)

  创建一个新的字典。dict 对象是一个字典类。

• dir([object])

  如果没有实参，则返回当前本地作用域模块中的属性列表。如果有实参，它会尝试返回该对象的有效属性列表。

  # 返回的列表按字母表排序
  
  import struct
  dir()   # 获得当前模块的属性列表 
  >>> ['__builtins__', '__name__', 'struct']
  dir(struct)   # show the names in the struct module 
  >>> ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
   '__initializing__', '__loader__', '__name__', '__package__',
   '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
   'unpack', 'unpack_from']
  
  dir([ ])    # 查看列表的方法
  >>> ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
  

• divmod(a, b)

  它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。

  对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。

  对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。

• enumerate(iterable, start=0)

  返回一个枚举对象。

  enumerate()返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。

  iterable 必须是一个序列，或 迭代器，或其他支持迭代的对象。

  # 等价于：
  def enumerate(sequence, start=0):
      n = start
      for elem in sequence:
          yield n, elem
          n += 1
  

  例子：

  >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
  >>> list(enumerate(seasons))
  [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
  >>> list(enumerate(seasons, start=1))
  [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
  

• eval(expression[, globals[, locals]])

  eval() 函数用来执行一个字符串表达式，并返回表达式的值。

  expression – 表达式。

  globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

  locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

  >>>x = 7
  >>> eval( '3 * x' )
  21
  >>> eval('pow(2,2)')
  4
  >>> eval('2 + 2')
  4
  >>> n=81
  >>> eval("n + 4")
  85
  

• exec(object[, globals[, locals]])

  exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码

  exec 返回值永远为 None。

  • object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
  • globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
  • locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。

  >>>exec('print("Hello World")')
  Hello World
  # 单行语句字符串
  >>> exec("print ('runoob.com')")
  runoob.com
   
  #  多行语句字符串
  >>> exec ("""for i in range(5):
  ...     print ("iter time: %d" % i)
  ... """)
  iter time: 0
  iter time: 1
  iter time: 2
  iter time: 3
  iter time: 4
  

• filter(function, iterable)

  filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

  • function – 判断函数。
  • iterable – 可迭代对象。

  # 过滤出列表中的所有奇数
  def is_odd(n):
      return n % 2 == 1
   
  tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
  newlist = list(tmplist)
  print(newlist)
  
  >>> [1, 3, 5, 7, 9]
  
  # 过滤出1~100中平方根是整数的数
  import math
  def is_sqr(x):
      return math.sqrt(x) % 1 == 0
   
  tmplist = filter(is_sqr, range(1, 101))
  newlist = list(tmplist)
  print(newlist)
  
  >>> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  

• class float([x])

  返回从数字或字符串 x 生成的浮点数。

  >>> float('+1.23')
  1.23
  >>> float('   -12345\n')
  -12345.0
  >>> float('1e-003')
  0.001
  >>> float('+1E6')
  1000000.0
  >>> float('-Infinity')
  -inf
  

• format(value[, format_spec])

  一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

  基本语法是通过 {} 和 : 来代替以前的 % 。

  format 函数可以接受不限个参数，位置可以不按顺序。

  # 实例
  "{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
  >>> 'hello world'
   
  "{0} {1}".format("hello", "world")  # 设置指定位置
  >>> 'hello world'
   
  "{1} {0} {1}".format("hello", "world")  # 设置指定位置
  >>> 'world hello world'
  

  print("学校名：{name}, 地址 {addr}".format(name="工大", addr="杭州"))
   
  # 通过字典设置参数
  site = {"name": "工大", "addr": "杭州"}
  print("学校名：{name}, 地址 {addr}".format(**site))
   
  # 通过列表索引设置参数
  my_list = ['工大', '杭州']
  print("学校名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
  
  # 三个输出都是 学校名：工大，地址：杭州
  

• class frozenset([iterable])

  返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素。 frozenset 是一个内置的类。有关此类的文档，请参阅 frozenset 和 集合类型 — set, frozenset。请参阅内建的 set、list、tuple 和 dict 类，以及 collections 模块来了解其它的容器。

• getattr(object, name[, default])

  返回对象命名属性的值。

  name 必须是字符串。

  如果该字符串是对象的属性之一，则返回该属性的值。

  例如， getattr(x, 'foobar') 等同于 x.foobar。如果指定的属性不存在，且提供了 default 值，则返回它，否则触发 AttributeError。

• globals()

  返回表示当前全局变量表的字典。

• hasattr(object, name)

  该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。（此功能是通过调用 getattr(object, name) 看是否有 AttributeError 异常来实现的。）

• hash(object)

  返回该对象的哈希值（如果它有的话）。哈希值是整数。

  它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。

• help([object])

  启动内置的帮助系统（此函数主要在交互式中使用）。

  如果没有实参，解释器控制台里会启动交互式帮助系统。

  如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。

  如果实参是其他任意对象，则会生成该对象的帮助页。

• hex(x)

  将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int 对象，则必须定义返回整数的 __index__() 方法。

  >>> hex(255)
  '0xff'
  >>> hex(-42)
  '-0x2a'
  

  如果要将整数转换为大写或小写的十六进制字符串，并可选择有无“0x”前缀，

  >>> '%#x' % 255, '%x' % 255, '%X' % 255
  ('0xff', 'ff', 'FF')
  >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
  ('0xff', 'ff', 'FF')
  >>> f'{255:#x}', f'{255:x}', f'{255:X}'
  ('0xff', 'ff', 'FF')
  

• id(object)

  返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id()值。

• input([prompt])

  如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。

• class int([x])

  返回一个使用数字或字符串 x 生成的整数对象，或者没有实参的时候返回 0 。

• isinstance(object, classinfo)

  判断object对象是不是classinfo类

  如果 object 实参是 classinfo 实参的实例，或者是（直接、间接或 虚拟）子类的实例，则返回 true。

  如果 object 不是给定类型的对象，函数始终返回 false。

  如果 classinfo 是对象类型（或多个递归元组）的元组，如果 object 是其中的任何一个的实例则返回 true。

  如果 classinfo 既不是类型，也不是类型元组或类型的递归元组，那么会触发 TypeError 异常。

• issubclass(class, classinfo)

  判断class是否是classinfo的子类

  如果 class 是 classinfo 的子类（直接、间接或 虚拟 的），则返回 true。classinfo 可以是类对象的元组，此时 classinfo 中的每个元素都会被检查。其他情况，会触发 TypeError 异常。

• iter(object[, sentinel])

  返回一个 iterator 对象。

  迭代器 = iter(可迭代) 等于 迭代器 = 可迭代的.__iter__()

  根据是否存在第二个实参，第一个实参的解释是非常不同的。

  如果没有第二个实参，object 必须是支持迭代协议（有 __iter__() 方法）的集合对象，或必须支持序列协议（有 __getitem__() 方法，且数字参数从 0 开始）。如果它不支持这些协议，会触发 TypeError。

  如果有第二个实参 sentinel，那么 object 必须是可调用的对象。这种情况下生成的迭代器，每次迭代调用它的 __next__() 方法时都会不带实参地调用 object；如果返回的结果是 sentinel 则触发 StopIteration，否则返回调用结果。

• len(s)

  返回对象的长度（元素个数）。

  实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

• class list([iterable])

  将iterable转换成列表，虽然被称为函数，list 实际上是一种可变序列类型

• locals()

  获取执行本方法所在命名空间内的局部变量的字典。

  在函数代码块但不是类代码块中调用 locals() 时将返回自由变量。 请注意在模块层级上，locals() 和 globals() 是同一个字典。

• map(function, iterable, ...)

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

  返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。

  >>>def square(x) :            # 计算平方数
         return x ** 2
   
  >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
  [1, 4, 9, 16, 25]
  >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
  [1, 4, 9, 16, 25]
   
  # 提供了两个列表，对相同位置的列表数据进行相加
  >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
  [3, 7, 11, 15, 19]
  

• max(iterable, ***[, key, default])

  max(arg1, arg2, *args[, key])

  返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

• memoryview(obj)

  返回由给定实参创建的“内存视图”对象。

• min(iterable, ***[, key, default])

  min(arg1, arg2, *args[, key])

  返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

• next(iterator[, default])

  通过调用 iterator 的 __next__() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。

• class object

  返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。注解 由于 object 没有 __dict__，因此无法将任意属性赋给 object 的实例。

• oct(x)

  将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。

• open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

  open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

  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() 关闭文件

• ord(c)

  对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。

  例如 ord('a') 返回整数 97， ord('€') （欧元符号）返回 8364 。这是 chr() 的逆函数。

• pow(x, y[, z])

  返回 x 的 y 次幂；如果 z 存在，则对 z 取余（比直接 pow(x, y) % z 计算更高效）。两个参数形式的 pow(x,y) 等价于幂运算符： x**y。

• print(objects, sep=' ', end='\n', file=sys.stdout, flush=False)

  将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。

  sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。

  所有非关键字参数都会被转换为字符串，就像是执行了 str() 一样，并会被写入到流，以 sep 且在末尾加上 end。 sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。

  如果没有给出 objects，则 print() 将只写入 end。

• class property(fget=None, fset=None, fdel=None, doc=None)

  返回 property 属性。

  fget – 获取属性值的函数

  fset – 设置属性值的函数

  fdel – 删除属性值函数

  doc – 属性描述信息

  class C(object):
      def __init__(self):
          self._x = None
   
      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.")
  

  如果 c 是 C 的实例化,

  c.x 将触发 getter,

  c.x = value 将触发 setter ，

  del c.x 触发 deleter。

• range(stop)

  range(start, stop[, step])

  • start: 计数从 start 开始。默认是从 0 开始。

    例如range（5）等价于range（0， 5）;

  • stop: 计数到 stop 结束，但不包括 stop。

    例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

  • step：步长，默认为1。

    例如：range（0， 5） 等价于 range(0, 5, 1)

  虽然被称为函数，但 range 实际上是一个不可变的序列类型

• repr(object)

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

  返回一个对象的 string 格式。

  >>>s = 'RUNOOB'
  >>> repr(s)
  "'RUNOOB'"
  >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
  >>> repr(dict)
  "{'google': 'google.com', 'runoob': 'runoob.com'}"
  

• reversed(seq)

  返回一个反向的 iterator。 seq 必须是一个具有 __reversed__() 方法的对象或者是支持该序列协议（具有从 0开始的整数类型参数的 __len__() 方法和 __getitem__() 方法）。

• round(number[, ndigits])

  返回 number 舍入到小数点后 ndigits 位精度的值。

• class set([iterable])

  返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。 set 是一个内置类型。

• setattr(object, name, value)

  此函数与 getattr() 两相对应。 其参数为一个对象、一个字符串和一个任意值。 字符串指定一个现有属性或者新增属性。 函数会将值赋给该属性，只要对象允许这种操作。

  例如，setattr(x, 'foobar', 123) 等价于 x.foobar = 123。

• class slice(stop)

  class slice(start, stop[, step])

  slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

  返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对象。 其中 start 和 step 参数默认为 None。 切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性 start, stop 和 step。 它们没有其他的显式功能；不过它们会被 NumPy 以及其他第三方扩展所使用。 切片对象也会在使用扩展索引语法时被生成。

  例如: a[start:stop:step] 或 a[start:stop, i]。

  >>>myslice = slice(5)    # 设置截取5个元素的切片
  >>> myslice
  slice(None, 5, None)
  >>> arr = range(10)
  >>> arr
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> arr[myslice]         # 截取 5 个元素
  [0, 1, 2, 3, 4]
  

• *sorted(iterable, , key=None, reverse=False)

  根据 iterable 中的项返回一个新的已排序列表。具有两个可选参数，它们都必须指定为关键字参数。key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

• @staticmethod

  将方法转换为静态方法。静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

  class C:
      @staticmethod
      def f(arg1, arg2, ...): ...
  

  静态方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。

• class str(object=’’)

  class str(object=b’’, encoding=‘utf-8’, errors=‘strict’)

  返回一个 str 版本的 object 。有关详细信息，请参阅 str() 。str 是内置字符串 class 。

• sum(iterable[, start])

  从 start 开始自左向右对 iterable 中的项求和并返回总计值。 start 默认为 0。 iterable 的项通常为数字，开始值则不允许为字符串。

• super([type[, object-or-type]])

  返回一个代理对象，它会将方法调用委托给 type 指定的父类或兄弟类。 这对于访问已在类中被重载的继承方法很有用。 搜索顺序与 getattr() 所使用的相同，只是 type 指定的类型本身会被跳过。

• tuple([iterable])

  返回一个元组

  虽然被称为函数，但 tuple 实际上是一个不可变的序列类型

• class type(object)

  class type(name, bases, dict)

  传入一个参数时，返回 object 的类型。 返回值是一个 type 对象，通常与 object.__class__ 所返回的对象相同。

  推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。传入三个参数时，返回一个新的 type 对象。

• vars([object])

  返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。

• *zip(iterables)

  zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，我们可以使用 list() 转换来输出列表。

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

  >>>a = [1,2,3]
  >>> b = [4,5,6]
  >>> c = [4,5,6,7,8]
  >>> zipped = zip(a,b)     # 返回一个对象
  >>> zipped
  <zip object at 0x103abc288>
  >>> list(zipped)  # list() 转换为列表
  [(1, 4), (2, 5), (3, 6)]
  >>> list(zip(a,c))              # 元素个数与最短的列表一致
  [(1, 4), (2, 5), (3, 6)]
   
  >>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
  >>> list(a1)
  [1, 2, 3]
  >>> list(a2)
  [4, 5, 6]
  

• __import__(name, globals=None, locals=None, fromlist=(), level=0)

  此函数会由 import 语句发起调用。 它可以被替换 (通过导入 builtins 模块并赋值给 builtins.__import__) 以便修改 import 语句的语义，但是 强烈 不建议这样做。

内置函数分类

作用域相关

基于字典的形式获取局部变量和全局变量

globals()——获取全局变量的字典

locals()——获取执行本方法所在命名空间内的局部变量的字典

迭代器/生成器相关

next(迭代器) 等于 迭代器.__next__()

迭代器 = iter(可迭代) 等于 迭代器 = 可迭代的.__iter__()

range()

其他

查看参数所属类型的所有内置方法

dir() 默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量

print(dir(list))  #查看列表的内置方法
print(dir(int))  #查看整数的内置方法

和调用相关

callable(o)，o是参数，看这个变量是不是可调用。

如果o是一个函数名，就会返回True

def func():pass
print(callable(func))  #参数是函数名，可调用，返回True
print(callable(123))   #参数是数字，不可调用，返回False

帮助方法

在控制台执行**help()**进入帮助模式。可以随意输入变量或者变量的类型。输入q退出

或者直接执行help(o)，o是参数，查看和变量o有关的操作。。。

模块操作相关

__import__导入一个模块

import time

os = __import__('os')
print(os.path.abspath('.'))

文件操作相关

open() 打开一个文件，返回一个文件操作符(文件句柄)

操作文件的模式有r,w,a,r+,w+,a+ 共6种，每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)

可以用encoding指定编码.

内存相关：

id(o) o是参数，返回一个变量的内存地址

hash(o) o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错。

t = (1,2,3)
l = [1,2,3]
print(hash(t))  #可hash
print(hash(l))  #会报错

'''
结果：
TypeError: unhashable type: 'list'
'''

hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。

*每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。

数据类型相关：

type(o) 返回变量o的数据类型

输入输出相关：

input() 输入

s = input("请输入内容 ： ")  #输入的内容赋值给s变量
print(s)  #输入什么打印什么。数据类型是str

print() 输出

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """
    

f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)

# 进度条打印
import time
for i in range(0,101,2):  
     time.sleep(0.1)
     char_num = i//2      #打印多少个'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)
#小越越  ： \r 可以把光标移动到行首但不换行

字符串类型代码的执行

eval() 将字符串类型的代码执行并返回结果

print(eval('1+2+3+4'))

>>> 10

exec()将自字符串类型的代码执行

print(exec("1+2+3+4"))
exec("print('hello,world')")

>>> None
>>> hello,world

code = '''
import os 
print(os.path.abspath('.'))
'''
code = '''
print(123)
a = 20
print(a)
'''
a = 10
exec(code,{'print':print},)
print(a)

>>> 123
>>> 20
>>> 10

compile 将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。

参数说明：

1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。
2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。
3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为’single’。

>>> #流程语句使用exec
>>> code1 = 'for i in range(0,10): print (i)'
>>> compile1 = compile(code1,'','exec')
>>> exec (compile1)
1
3
5
7
9


>>> #简单求值表达式用eval
>>> code2 = '1 + 2 + 3 + 4'
>>> compile2 = compile(code2,'','eval')
>>> eval(compile2)


>>> #交互语句用single
>>> code3 = 'name = input("please input your name:")'
>>> compile3 = compile(code3,'','single')
>>> name #执行前name变量不存在
Traceback (most recent call last):
  File "", line 1, in <module>
    name
NameError: name 'name' is not defined
>>> exec(compile3) #执行时显示交互命令，提示输入
please input your name:'pythoner'
>>> name #执行后name变量有值
"'pythoner'"

和数字相关

数字——数据类型相关：bool，int，float，complex

数字——进制转换相关：bin，oct，hex

数字——数学运算：abs，divmod，min，max，sum，round，pow

和数据结构相关

序列——列表和元组相关的：list和tuple

序列——字符串相关的：str，format，bytes，bytearry，memoryview，ord，chr，ascii，repr

序列：reversed，slice

数据集合——字典和集合：dict，set，frozenset

数据集合：len，sorted，enumerate，all，any，zip，filter，map

all() # 检查一个序列中是否含有空字符，只要有一个空字符就返回False
any() # 检查一个序列中是否含有空字符,只要有一个不是空字符就返回True

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
newlist = filter(is_sqr, range(1, 101))
print(newlist)