python内置函数详解_breakpointhook

内置函数

---

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

• abs(x)

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

• all(iterable)

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

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

  # 等价于
  def all(iterable):
      for element in iterable:
          if not element:
              return False
      return True
  1
  2
  3
  4
  5
  6

• any(iterable)

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

  # 等价于
  
  def any(iterable):
      for element in iterable:
          if element:
              return True
      return False
  1
  2
  3
  4
  5
  6
  7

• 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, ...): ...
  1
  2
  3
  4

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

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

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

  • source 可以是常规的字符串、字节字符串，或者 AST 对象。
  • filename 实参需要是代码读取的文件名；如果代码不需要从文件中读取，可以传入一些可辨识的值（经常会使用 '<string>'）。
  • 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']
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• 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
  1
  2
  3
  4
  5
  6

  例子：

  >>> 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')]
  1
  2
  3
  4
  5

• 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
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

• 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
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

• 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]
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20

• 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
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

• 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'
  1
  2
  3
  4
  5
  6
  7
  8
  9

  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" 是必须的
  
  # 三个输出都是 学校名：工大，地址：杭州
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

• 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'
  1
  2
  3
  4

  如果要将整数转换为大写或小写的十六进制字符串，并可选择有无“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')
  1
  2
  3
  4
  5
  6

• 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]
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

• 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.")
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

  如果 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'}"
  1
  2
  3
  4
  5
  6

• 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]
  1
  2
  3
  4
  5
  6
  7
  8

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

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

• @staticmethod

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

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

  静态方法的调用可以在类上进行 (例如 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]
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

• __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))  #查看整数的内置方法
1
2

和调用相关

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

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

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

帮助方法

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

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

模块操作相关

__import__导入一个模块

import time

os = __import__('os')
print(os.path.abspath('.'))
1
2
3
4

文件操作相关

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'
'''
1
2
3
4
5
6
7
8
9

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

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

数据类型相关：

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

输入输出相关：

input() 输入

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

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 可以把光标移动到行首但不换行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

字符串类型代码的执行

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

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

>>> 10
1
2
3

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

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

>>> None
>>> hello,world
1
2
3
4
5

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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 "<pyshell#29>", line 1, in <module>
    name
NameError: name 'name' is not defined
>>> exec(compile3) #执行时显示交互命令，提示输入
please input your name:'pythoner'
>>> name #执行后name变量有值
"'pythoner'"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

和数字相关

数字——数据类型相关：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
1
2

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