python3.7.1 内置函数

python3.7.1 内置函数列表

内置函数
abs() delattr() hash() memoryview() set()
all() dict() help() min() setattr()
any() dir() hex() next() slice()
ascii() divmod() id() object() sorted()
bin() enumrate() 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)：绝对值
  • complex([real[, imag]])：创建一个 'real + imag*j'的复数，或者转化一个字符串或者数字为复数
  • divmod(a,b)：求 a/b 的商和余数
  • int([x])、int(x, base=10)：整数
  • float([x])：浮点数
  • len(s)：求长度
  • pow(x, y[, z])： 只有 x、y参数，返回x的y次方的值（x**y）。三个参数都有返回x的y次方除以z取模 (x**y)%z
  • round(number[, ndigits])：返回 number 四舍五入后的值。如果 ndigits 为空或者None，则返回最接近number的整数。
  • sum(iterable[, start])：计算 iterable 中所有元素和 start 的总和

真假判断：

  • all(iterable)：是否全为真
  • any(iterable)：是否有一个为真
  • bool(x)：判断元素真假
  • callable(object)：判断对象是否可以调用
  • hasattr()：判断是否具有某属性值
  • isinstance(object,classinfo)：判断object是不是classinfo的直接、间接或者子类的实例
  • issubclass(class, classinfo)：判断 class 是否是 classinfo 直接、间接或者虚拟的子类

进制转换：

  • bin(x)：二进制。 '0b'
  • hex(x)：十六进制。 '0x'
  • oct(x)：八进制。 '0o'

编码字节：

  • bytearray([source[,encoding[,errors]]])：可变字节数组
  • bytes([source[, encoding[, errors]]])：不可变字节对象
  • chr(i)：把一个整数转换为Unicode编码表中对应的字符。
  • ord(c)：返回一个Unicode字符串的整数编号位置。
  • repr(object)：将 object 转换为可供解释器读取的字符串形式。

类相关：

  • @classmethod：把类中的一个方法转换为类方法，使得它可以在不实例化的情况下调用。
  • delattr(object,name)：删除object中名称为 name 属性
  • getattr(object, name[, default])：获取属性值
  • hasattr(object, name)：判断是否具有某属性值
  • setattr(object, name, value)：如果object允许，函数将会把value赋值给name。
  • isinstance(object,classinfo)：判断object是不是classinfo的直接、间接或者子类的实例
  • issubclass(class, classinfo)：判断 class 是否是 classinfo 直接、间接或者虚拟的子类
  • property(fget=None, fset=None, fdel=None, doc=None)：将类中的方法像类属性一样调用，规范化的访问类的属性和修改类属性的值的一种方法
  • @staticmethod：将类中的一个方法转换为静态方法。
  • super([type[, object-or-type]])：在子类内调用父类的方法
  • type(object)、type(name, bases, dict)：一个参数，返回对象的类型。三个参数，返回一个新的类型对象。
  • _import_(name, globals=None, locals=None, fromlist=(), level=0)：用于动态的加载类和函数

字符串的执行：

  • compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)：编译一段字符串/字节字符串/AST对象，通过exec或者eval或者single执行
  • eval(expression, globals=None, locals=None)：获取表达式 expression 的值
  • exec(object[, globals[, locals]])：执行 object 代码块

类型/对象：

  • dict(**kwarg)、dict(mapping, **kwarg)、dict(iterable, **kwarg)：创建一个字典。
  • frozenset([iterable])：生成一个冻结的集合。
  • list([iterable])：将元组或者字符串转换为列表。
  • set([iterable])：创建一个set对象。
  • str(object='')、str(object=b'', encoding='utf-8', errors='strict')：把一个对象转换为 str。
  • tuple([iterable])：把 iterable 转换为一个元组。
  • iter(object[, sentinel])：用于生成一个迭代器。
  • range(stop)，range(start,stop[,step])：返回一个可迭代对象。
  • memoryview(obj)：根据传入的对象创建一个内存查看对象。
  • open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：打开文件并返回响应的文件对象。
  • reversed(seq)：返回一个反向的迭代器

其他1：

  • filter(function, iterable)：通过指定函数过滤迭代器内的元素并返回一个新的迭代对象
  • map(function, iterable, ...)：把一个迭代器内的元素或多个迭代器内同一位置的元素，带入 function 内执行，返回一个结果的迭代器。（多个迭代器，以最短的为标准）
  • max(iterable, *[, key, default])、max(arg1, arg2, *args[, key])：返回 iterable 内或 arg1、arg2...中的最大项。iterable 为空返回 default。 key 不为空时，以key指定的函数为标准。根据ord()获取对应字符串在ASCII中的位置来比较大小
  • min(iterable, *[, key, default])、min(arg1, arg2, *args[, key])：返回 iterable 内或 arg1、arg2...中的最小项。iterable 为空返回 default。 key 不为空时，以key指定的函数为标准。根据ord()获取对应字符串在ASCII中的位置来比较大小
  • sorted(iterable, *, key=None, reverse=False)：对iterable进行排序操作。指定了key，把iterable内的元素逐个带入函数内，并根据返回的值的排序来对iterable进行排序

其他2：

  • locals()：当前环境的局部变量
  • globals()：获取当前环境的全局变量字典
  • vars([object])：返回带有__dict__属性的模块、类、实例或任何其他对象的__dict__属性。
  • dir([object])：获取 object 的方法、属性列表

其他3：

  • enumerate(iterable, start=0)：获取可迭代对象内元素以 start 开头的序列和元素值的元组。
  • format(value[,format_spec])：字符串格式化
  • hash(object)：获取某个对象的哈希值
  • help([object])：获取帮助信息
  • id(object)：获取对象的内存标识
  • input([prompt])：获取一个标准输入
  • ascii(object)：返回可打印对象的字符串表示形式
  • breakpoint(*args, **kws)：断点调试
  • object：所有类的基类，具有所有python类都通用的方法。
  • print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)：将对象打印到文本流文件中，以sep分隔，以end结尾。sep、end、file和flush如果存在，必须作为关键字参数给出。
  • slice(stop)、slice(start, stop[, step])：返回一个切片对象。
  • zip(*iterables)：将可迭代的对象作为参数，将各个对象中对应索引位置的元素打包成一个个元组，然后返回由这些元组组成的对象。如果给定的可迭代对象长度不等，则以最短的迭代对象为准。

abs(x)

描述

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

参数

  • x：整数、浮点数、复数

返回值

返回数字的绝对值

示例

>>> abs(22)      #整数
22
>>> abs(22.33)   #浮点数
22.33
>>> abs(1+1.0j)  #复数
1.4142135623730951

all(iterable)

描述

判断给定的可迭代对象内所有元素是否都为真。如果都为真，则返回True，反之则返回False。（当可迭代对象为空时，返回值为True）
函数等价于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

参数

  • iterable：可迭代对象，如：列表、元组

返回值

True或False

示例

>>> all(['a','b','c'])         #列表，元素都不为空或0
True
>>> all(['a','b','c',''])      #列表，元素存在一个为空
False
>>> all([1,2,3,0])             #列表，元素存在一个为0
False
>>> all(('a','b','c'))         #元组，元素都不为空或0
True
>>> all(('a','b','c',''))      #元组，元素存在一个为空
False
>>> all((1,2,3,0))             #元组，元素存在一个为0
False
>>> all([])                    #空列表
True
>>> all(())                    #空元组
True

any(iterable)

描述

判定给定的可迭代对象内的元素是否有一个为真。如果有一个为真，则返回True,反之则返回False。（当可迭代对象为空时，返回值为False

函数等价于：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

参数

  • iterable：可迭代对象，如：列表、元组

返回值

True或False

示例

>>> any(['a','b','c'])         #列表，元素都为True
True
>>> any(['a','b','c',''])      #列表，元素存在一个为空
True
>>> any(['',0,None])           #列表，元素都为False
False
>>> any(('a','b','c'))         #元组，元素都为True
True
>>> any(('a','b','c',''))      #元组，元素存在一个为空
True
>>> any(('',0,None))           #元组，元素都为False
False 
>>> any([])                    #空列表
False
>>> any(())                    #空元组
False

ascii(object)

描述

返回一个可打印对象的字符串表示方式，如果是非ascii字符就输出\x,\u或\U等字符。

参数

  • object：可打印对象

返回值

字符串

示例

>>> ascii(1111)                      #数字
'1111'
>>> ascii('aaaaaa')                  #字符串
"'aaaaaa'" 
>>> ascii([1,2,3])                   #列表
'[1, 2, 3]' 
>>> ascii({'a':1,'b':2})             #字典
"{'a': 1, 'b': 2}"
>>> ascii('十万伏特')                 #非ascii字符
"'\\u5341\\u4e07\\u4f0f\\u7279'"

bin(x)

描述

把一个整数转换为以 0b 开头的二进制

参数

  • x：整数

返回值

二进制

示例

>>> bin(22)
'0b10110'
>>> bin(-33)
'-0b100001'

class bool([X])

描述

将给定的指定参数转换为布尔类型（True或者False)，可用来判定一个元素的真假。如果参数为空则返回False。bool是int的一个子类。

参数

  • x：需要进行转换的参数

返回值

True或False

示例

>>> bool(1)
True
>>> bool('aa')
True
>>> bool([1,2])
True
>>> bool((1,2))
True
>>> bool({'a':1})
True
>>> bool()
False
>>> bool('')
False
>>> bool(None)
False
>>> bool([])
False
>>> bool(())
False
>>> bool({})
False
>>> issubclass(bool,int)      #判读bool是否是int的子类
True

breakpoint(*args, **kws)

描述

在未设置 PYTHONBREAKPOINT 的情况下，breakpoint() 会中断当前程序并进入 pdb 调试器。用于断点调试。

示例

>\#!/usr/bin/env python3
>\# _*_ coding:utf-8 _*_
>\# Created by fjg on 2018/10/25
>def guess_num(num_guess: str) -> str:
>    user_guess: str = input("猜想的数字：")
>    breakpoint()
>    if user_guess == num_guess:
>        return "猜对了"
>    else:
>        return "猜错了"
>
>
>if __name__ == '__main__':
>    right_num: int = 555
>    print(guess_num(right_num))

执行结果

E:\dev\lye\venv\Scripts\python.exe E:/dev/lye/test/test_breakpoint.py
猜想的数字：111
> e:\dev\lye\test\test_breakpoint.py(7)guess_num()
-> if user_guess == num_guess:
(Pdb) locals()
{'num_guess': 555, 'user_guess': '111'}
(Pdb)

calss bytearray([source[,encoding[,errors]]])

描述

返回一个可变的字节数组。数组内每个元素的范围：0<=x<256

参数

  • x：
    • 整数：返回一个长度为source的初始化数组
    • 字符串：如果是字符串，必须给定一个编码方式（encoding参数）。bytearray将使用str.endcode()把字符串转换为字节。
    • 可迭代类型：可迭代的类型中的元素必须为[0,255]中的整数
    • 空：初始化一个有0个元素的数组
    • 如果source为与buffer接口一直的对象，则此对象可用于初始化bytearray
  • encoding：编码格式
  • errors：指定如何处理编码和解码错误

返回值

一个可变的字节数组

示例

>>> bytearray(10)  # 整数
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> bytearray("python",'utf-8')  # 字符串
bytearray(b'python')
>>> bytearray([1,2,3])  # 可迭代类型，元素为[0,255]中的整数
bytearray(b'\x01\x02\x03')
>>> bytearray(["1",2,3])  # 可迭代类型，元素中有个字符串，就报错了
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: an integer is required
>>> bytearray()  # 空
bytearray(b'')

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

描述

返回一个新的bytes对象，该对象是一个0<=x<256区间内的整数不可变数列。它是bytearray的不可变版本。

参数

参照bytearray()

返回值

返回一个新的bytes对象

示例

>>> bytes(10)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> bytes('python','utf-8')
b'python'
>>> bytes([1,2,3])
b'\x01\x02\x03'
>>> bytes(["1",2,3])
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
>>> bytes()
b''

callable(object)

描述

如果对象参数是可调用的返回True,反之则返回False。如果返回True,这个对象有可能还会调用失败，如果返回False，则一定不可能被调用成功。如果这个对象具有__call__()方法，它都会返回True.

参数

  • object：一个对象

返回值

True或False

示例

>>> callable(0)
False
>>> callable('python')
False
>>> def add(a,b):
...     return a+b
    ... 
>>> callable(add)
    True
>>> class A:
...     def add(self):
...         return 0
...
>>> callable(A)
True
>>> a = A()
>>> callable(a)
False
>>> class B:
...     def __call__(self):
...         return 0
...
>>> b = B()
>>> callable(B)
True
>>> callable(b)
True

chr(i)

描述

返回其Unicode编码位是整数i字符的字符串，i 的有效值范围为[0,1114112].超过这个范围则会抛出 ValueError

参数

  • i：[0,1114112]，可以是十进制也可以是十六进制

示例

>>> chr(0)
'\x00'
>>> chr(97)
'a'
>>> chr(48)   # 十进制
'0'
>>> chr(1114111)  # 可取的最大值
'\U0010ffff'
>>> chr(1114112)  # 超出取值范围
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)
>>> chr(0x00)
'\x00'
>>> chr(0x61)
'a'
>>> chr(0x30)   # 十六进制
'0'

@classmethod

描述

将一个方法转换为类方法的装饰器。可以在不实例化一个类的前提下，调用这个方法（可以在类上面调用，也可以在实例上面调用）。在类下面的该方法不需要self参数，但是第一个参数需要是表示自身类的cls参数，可以用来调用类的属性，方法，实例化对象等。

返回值

返回该函数的类方法。

示例

>>> class A(object):
...     aa = 1
...     def func1(self):
...         print('this is func1')
...     @classmethod
...     def func2(cls):
...         print('this is func2')
...         print(cls.aa)  # 调用类属性
...         cls().func1()  # 利用cls实例化A并调用func1方法
...
>>> A.func2()  # 在类上面调用
this is func2
1
this is func1
>>> A().func2()  # 在实例上调用
this is func2
1
this is func1

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

描述

将 source 编译为代码或者AST对象。代码可以通过exec()或者eval()执行。

参数

  • source: source 可以是普通的字符串、字节字符串或者AST对象。
  • filename: filename 参数应该是可以读取代码的文件位置。如果没有从文件中读取代码，则需要传递一些可识别的参数（通常是给 "" 空的字符串 ）
  • mode: mode 指定代码的编译种类。如果是一系列流程语句，可以使用 'exec'；如果是单个表达式，可以使用'eval';如果是一个交互式语句，则可以使用 'single'。
  • optimize：指定编译器的优化级别，默认值-1选择的解释器的优化级别为-O选项。具体级别有：0（无优化，__debug__为true），1（移除断言，__debug__为false）或2（移除文档字符串）。

示例

>>> str1='for i in range(5):print(i)'
>>> a1 = compile(str1,'','exec')  # 流程语句
>>> a1
<code object <module> at 0x041224F0, file "", line 1>
>>> exec(a1)
0
1
2
3
4
>>> str2 = "1*4+2*3"
>>> a2 = compile(str2,'','eval')  # 表达式
>>> a2
<code object <module> at 0x04162860, file "", line 1>
>>> exec(a2)
>>> eval(a2)
10
>>> str3="bb3 = input('输入')"
>>> a3 = compile(str3,'','single')  # 交互式语句
>>> a3
<code object <module> at 0x04122F40, file "", line 1>
>>> exec(a3)
输入>? python
>>> print(bb3)
python

class complex([real[, imag]])

描述

用于创建一个 real+imag*j 的复数或者转化一个字符串或者数字为复数。如果第一个参数为字符串，则不需要指定第二个参数。第二个参数绝对不可以是字符串。每个参数可以是任何数字类型（包括复数）。
注意： 当转化字符串时，在 + 或者 - 两侧不能有空格，否则会抛出 ValueError的异常。

参数

  • real: 整数、浮点数、字符串。
  • imag: 整数、浮点数

返回值

一个复数

示例

>>> complex()
0j
>>> complex(1,2)
(1+2j)
>>> complex(1.1,2.2)
(1.1+2.2j)
>>> complex("1")
(1+0j)
>>> complex("1+2j")
(1+2j)
>>> complex("1 + 2j")  # +  周围有空格 报错。
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: complex() arg is a malformed string

delattr(object, name)

描述

与 setattr() 相对。参数是一个对象和一个字符串。字符串必须是对象属性中的一个名字，如果对象允许，delattr将删除该名称的属性。

参数

  • object: 对象
  • name: 必须是对象属性的名称

示例

>>> class A(object):
...     a = 1
...     b = 2
...     c = 3
...     
>>> aa = A()
>>> aa.a
1
>>> aa.b
2
>>> aa.c
3
>>> delattr(A,"b")
>>> aa.a
1
>>> aa.b
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'A' object has no attribute 'b'
>>> aa.c
3

class dict(**kwarg)、class dict(mapping, **kwarg)、class dict(iterable, **kwarg)

描述

用于创建一个字典

参数

  • **kwarg: 关键字
  • mapping: 元素的容器
  • iterable: 可迭代对象

返回值

一个字典

示例

>>> dict()
{}
>>> dict(a=1,b=2,c=3)
{'a': 1, 'b': 2, 'c': 3}
>>> dict([('a',1),('b',2),('c',3)])
{'a': 1, 'b': 2, 'c': 3}
>>> dict(zip(['a','b','c'],[1,2,3]))
{'a': 1, 'b': 2, 'c': 3}

dir([object])

描述

如果不带参数，则返回当前范围内的变量、方法和定义的类型列表。带参数时，返回参数的有效属性列表（属性、方法）。如果对象带有 __dir__()方法,则该方法将会被调用，并且一定返回一个有效属性列表。对象允许通过__getattr__()或者__getattribute__()函数来自定义 dir() 的内容。
当对象不提供__dir__()方法时，并且定义了__dict__()属性，函数将试着通过对象的__dict__()及其类型对象中尽可能的获取信息。结果列表可能不完整，并且当对象拥有__getattr__()属性时，可能不准确。

参数

dir() 对不同的对象类型有不同的处理机制。 它试图展示最相关的信息而不是最完整的。

  • 如果对象是一个模块对象，则列表包含这个模块的名称。
  • 如果对象是一个类或者类对象，则列表包含其属性名称和它的基础属性。
  • 否则，列表包含对象的属性名、类的属性名以及类的基类的属性的递归名称。

返回值

一个列表

示例

>>> import struct
>>> dir()   
['__builtins__', '__name__', 'struct']
>>> dir(struct)
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
     '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

divmod(a,b)

描述

将两个(非复数)数字作为参数，并在使用整数除法时返回由它们的商和余数组成的一对数字。

参数

  • a,b：a和b可以为整数或者浮点数，不能为复数

返回值

一个商和余数的元组

示例

>>> divmod(1,2)   # 整数
(0, 1)
>>> divmod(0.3,0.2)  # 浮点数
(1.0, 0.09999999999999998)
>>> divmod(0.3,0.4)
(0.0, 0.3)
>>> divmod(1+2j,1+0.5j)  # 复数报错
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: can't take floor or mod of complex number.
>>> a = divmod(1,2)
>>> type(a)  # 返回的是一个元组
<class 'tuple'>

enumerate(iterable, start=0)

描述

enumerate()返回的迭代器的__next__()方法返回一个元组，该元组包含一个计数(从默认值为0的开始)和通过iterable进行迭代获得的值。
该函数等同于：

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

参数

  • iterable: 必须是序列、迭代器或者是其他可迭代的对象。
  • start: 计数器开始的数值。整数

返回值

返回一个enumerate对象

示例

>>> a = ['a','b','c','d']
>>> list(enumerate(a,start=0))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(a,start=1))
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

eval(expression, globals=None, locals=None)

描述

执行一段字符串表达式，并返回表达式的值，解析expression参数并作为一个python表达式进行计算。

参数

  • expression： 一个字符串表达式
  • globals: 全局命名空间，如果提供，则必须是一个字典对象。指定全局变量
  • locals: 局部命名空间，如果提供，可以是任何映射对象。指定局部变量

返回值

返回字符串表达式计算的结果

示例

请注意提供不同参数，变量调用的差异。

>>> a = 1
>>> eval('a+1')  # 不提供 globals和locals
2
>>> a = 1
>>> g={'a':11}
>>> eval('a+1',g)  # 提供 globals,不提供locals
12
>>> a = 1 
>>> g = {'a':11}
>>> l = {'a':111}
>>> eval('a+1',g,l) # 同时提供globals和locals
112

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

描述

用于python代码的动态执行

参数

  • object: 必须是字符串或者代码对象。如果是字符串，则字符串会被解析为一段python代码并执行，除非它出现语法错误。如果它是代码对象，则直接执行它。
  • globals: 可选参数。指定全局变量，必须是一个字典。
  • locals: 可选参数。指定局部变量，它可以是任何映射类型。

返回值

永远为None。

示例

>>> a = 1
>>> exec("a=11")
>>> a
11
>>> a = 1
>>> b = 2
>>> g = {'a':11,'b':22}
>>> exec("global a;print(a,b)",g)
11 22
>>> a = 1
>>> b = 2
>>> c = 3
>>> g = {'a':11,'b':22}
>>> l = {'b':222,'c':33}
>>> exec("global a;print(a,b,c)",g,l)
11 222 33

filter(function, iterable)

描述

把 iterable 中的元素逐个传入 function 内，将所有返回值为True的元素重新构建一个迭代器对象。可以通过list()把返回的迭代器对象转换为列表

参数

  • function： 判断函数
  • iterable：序列、支持迭代的容器或者迭代器

返回值

返回一个迭代器对象

示例

>>> def get_odd(x):
...     return x % 2 == 1
... 
>>> odd_list = filter(get_odd,[1,2,3,4,5,6,7,8,9,10])
>>> type(odd_list)
    <class 'filter'>
>>> print(odd_list)
<filter object at 0x045D94B0>
>>> list(odd_list)
[1, 3, 5, 7, 9]

class float([x])

描述

返回由字符串或者数字 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])

描述

字符串格式化
参考博客：字符串

class frozenset([iterable])

描述

使用iterable内的元素生成一个冻结的集合，该集合不能添加和删除元素。

参数

  • iterabel：可迭代的对象。如列表、元组、字典等

返回值

一个新的frozenset对象。

示例

>>> a = frozenset(range(10))
>>> type(a)
<class 'frozenset'>
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> b = frozenset('hello world')
>>> b
frozenset({'l', 'o', 'h', 'e', 'w', 'r', 'd', ' '})

getattr(object, name[, default])

描述

返回 object 对象 name 属性的值。

参数

  • object：对象
  • name: name必须是一个字符串，如果字符串是对象属性名称之一，则返回该对象的值。如果指定的对象不存在则返回 default 的值。否则引发 AttributeError 报错。
  • default: 默认返回值，如果不提供。在没有对应属性值时，会触发AttributeError.

返回值

返回对象的属性值

示例

>>> class A(object):
...     a = 1
...     
>>> aa = A()
>>> getattr(aa,'a')
    1
>>> getattr(aa,'b')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'A' object has no attribute 'b'
>>> getattr(aa,'b',2)
2

globals()

描述

返回当前环境的全局变量的字典。

返回值

所有全局变量的字典

示例

>>> globals()
{'__builtins__': {'__name__': 'builtins', '__package__': '', '__loader__': <class   '_frozen_importlib.BuiltinImporter'>, '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>), '__build_class__': <built-in function __build_class__>, '__import__': <bound method ImportHookManager.do_import of <module '_pydev_bundle.pydev_import_hook.import_hook'>>, 'abs': <built-in function abs>, 'all': <built-in function all>, 'any': <built-in function any>, 
......省略......
'bin': <built-in function bin>, 'breakpoint': <built-in function breakpoint>, 'callable': <built-in function callable>, 'chr': <built-in function chr>, 'compile': <built-in function compile>, 'delattr': <built-in function delattr>, 'dir': <built-in function dir>, 'divmod': <built-in function divmod>, 'eval': <built-in function eval>, 'exec': <built-in function exec>,}, 'sys': <module 'sys' (built-in)>}

hasattr(object, name)

描述

判断 name 是不是 object 属性之一，如果是则返回True,否则返回False

参数

  • object: 对象
  • name: 要判断的属性名，字符串

返回值

True或False

示例

>>> class A(object):
...     a = 1
...     b = 2
...     def c(self):
...         return 0
...     
>>> hasattr(A,'a')
True
>>> hasattr(A,'b')
True
>>> hasattr(A,'c')
True
>>> hasattr(A,'d')
False

hash(object)

描述

用于获取一个对象的哈希值（如果有的话），如果是数字的话，等值的数字的哈希值是一致的。如：1.0和1 尽管它们属于不同的类型。

参数

  • object：对象

返回值

对象的哈希值

示例

>>> hash(1)
1
>>> hash('python')
1817897009
>>> hash([1,2,3])
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash(str([1,2,3]))
-970184530
>>> hash(str({'a':1,'b':2}))
1261408225

help([object])

描述

调用内置的帮助系统。

参数

对象。如果参数是字符串，那么将查找该字符串作为模块、函数、类、方法、关键字或文档主题的名称，并在控制台打印帮助页面。如果参数是任何其他类型的对象，就会生成对象上的帮助页面。如果没有参数，将启动一个帮助控制台。

返回值

返回对象的帮助信息，或者进入帮助控制台

示例

>>> help()

Welcome to Python 3.7's help utility!

...省略...
help> q
>>> help('sys')
Help on built-in module sys:

NAME
    sys

MODULE REFERENCE
    https://docs.python.org/3.7/library/sys
...省略...
>>> a = [1,2,3]
>>> help(a.append)
Help on built-in function append:

append(object, /) method of builtins.list instance
    Append object to the end of the list.

hex(x)

描述

把一个整数转换为以'0x'开头的小写十六进制字符串。如果 x 不是一个整数对象，它必须定义一个返回整数的 index() 方法。

参数

十进制整数

返回值

十六进制字符串

示例

>>> hex(233)
'0xe9'
>>> hex(-233)
'-0xe9'
>>> type(hex(28))
<class 'str'>

id(object)

描述

返回对象的内存标识，也就是所谓的内存地址。

参数

对象

返回值

对象的内存地址

示例

>>> a = 1
>>> id(a)
257017984
>>> b = a
>>> id(b)
257017984
>>> class A(object):
...     a = 11
...     b = 22
...     
>>> c = A()
>>> id(c)
72534064

input([prompt])

描述

接收一个标准数据输入，返回值为字符串。如果存在 prompt ，则会获取一个标准输入，并去掉行位的换行符。

参数

提示信息

返回值

字符串

示例

>>> a = input('num:')
num:>? 111
>>> type(a)
<class 'str'>

class int([x])、class int(x, base=10)

描述

返回由数字或字符串x构造的整数对象，如果没有给出参数，则返回0。如果 x 定义了 int()，则 int(x) 返回 x.int() . 如果 x 定义了 trunc(), 则返回 x.trunc()。对于浮点数，将直接忽略小数点后面的数字。
如果x不是一个数字或者给了base参数，则x必须是一个字符串、bytes或bytearray实例。

参数

  • x：字符串或者数字
  • base：进制数，默认是十进制。如果带有base参数，则x必须是字符串。

返回值

返回一个整型数据

示例

>>> int()
0
>>> int(3)
3
>>> int(1.9)
1
>>> int('12',16)
18
>>> int(12,16)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: int() can't convert non-string with explicit base

isinstance(object, classinfo)

描述

如果 object 是 classinfo 参数的实例，或者其直接、间接或虚拟子类的实例，则返回true。如果对象不是给定类型的对象，则返回false。如果classinfo是类型对象的元组(或者递归地，其他的元组)，如果object是其中任何一个类型的实例，返回true。如果classinfo不是类型或类型的元组，那么就会 TypeError 错误异常。

参数

  • object：实例对象。
  • classinfo：可以是直接或间接类名、基本类型或者由他们组成的元组。常见的classinfo：int、float、bool、complex、str、list、dict、set、tuple

返回值

True或者False

示例

>>> a = 1
>>> isinstance(a,str)
False
>>> isinstance(a,int)
True
>>> isinstance(a,(int,str))
True
>>> class A(object):
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(),A)
True
>>> isinstance(B(),A)
True

issubclass(class, classinfo)

描述

如果class是classinfo直接、间接或者虚拟的子类，则返回True，反之则返回False。class被认为是class自己的子类。classinfo可以是一个元组，如果class是元组其中之一的子类则返回True，反之则为False。

参数

  • class：类
  • classinfo：类或者类的元组

返回值

True或False

示例

>>> class A(object):
...     pass
... 
>>> class B(A):  # B继承A
...     pass
... 
>>> class C(B):  # C继承B
...     pass
... 
>>> class D(object):
...     pass
... 
>>> class E(object):
...     pass
...
>>> issubclass(A,A)  # A是自己的子类
True
>>> issubclass(B,A)  # B是A的子类
True
>>> issubclass(C,A)  # C也是A的子类
True
>>> issubclass(C,D)  # C不是D的子类
False
>>> issubclass(C,(A,B))  # C是A和B的子类
True
>>> issubclass(C,(A,B,D))  
True
>>> issubclass(C,(D,E))  # C不是D和E的子类
False

iter(object[, sentinel])

描述

用来生成迭代器

参数

  • object：应是一个容器，支持迭代协议(即定义有__iter__()函数)，或者支持序列访问协议（即定义有__getitem__()函数），否则会返回TypeError异常。
  • sentinel：当第二个参数sentinel出现时，参数callable应是一个可调用对象(实例)，即定义了__call__()方法，当枚举到的值等于哨兵时，就会抛出异常StopIteration。

返回值

返回一个迭代器对象。

示例

无第二参数：

>>> a = [1, 2, 3, 4, 5]
>>> for i in iter(a):
...     print(i)
...     
1
2
3
4
5

有第二参数

class TestIter(object):

    def __init__(self):
        self.l = [1, 2, 4, 5, 'a', 6, 7, 8]
        self.i = iter(self.l)

    def __call__(self):  # 定义了__call__方法的类的实例是可调用的
        item = next(self.i)
        print("__call__ is called,which would return", item)
        return item

    def __iter__(self):  # 支持迭代协议(即定义有__iter__()函数)
        print("__iter__ is called!!")
        return iter(self.l)


t = TestIter()  # t是可调用的
t1 = iter(t, 'a')  # t必须是callable的，否则无法返回callable_iterator
print(callable(t))
for i in t1:
    print(i)

输出结果

True
__call__ is called,which would return 1
1
__call__ is called,which would return 2
2
__call__ is called,which would return 4
4
__call__ is called,which would return 5
5
__call__ is called,which would return a

Process finished with exit code 0

len(s)

描述

返回对象的长度(项的数量)

参数

参数可以是序列(例如字符串、字节、元组、列表或范围)或集合(例如字典、集合或冻结集合)。

返回值

对象的长度

示例

>>> len('python')
6
>>> len([1,2,3,4,5])
5

class list([iterable])

描述

用于将元组或字符串转换为列表

参数

元组或字符串

返回值

一个列表

示例

>>> a = 'python'
>>> list(a)
['p', 'y', 't', 'h', 'o', 'n']
>>> b = (1,2,3,4,5)
>>> list(b)
[1, 2, 3, 4, 5]

locals()

描述

以字典的方式返回当前所在位置的全部局部变量，

参数

无

返回值

局部变量的字典

示例

>>> def A(b):
...     a = 1
...     print(locals())
...     
>>> A(2)
{'b': 2, 'a': 1}

map(function, iterable, ...)

描述

把 iterable 内的元素逐个带入到 function 内，然后把得到的结果放入一个迭代器内返回。如果传入了多个 iterable 则会按照序列把每个 iterable 内的相同位置的元素同时传入 function 内执行。直到最短的那个 iterable 执行完成。

参数

  • function：函数
  • iterable：一个或多个迭代器

返回值

迭代器

示例

>>> def A(x):
...     return x ** 2
... 
>>> a = map(A,[1,2,3,4])  # 单个迭代器
>>> type(a)
<class 'map'>
>>> a
<map object at 0x03C88470>
>>> list(a)
[1, 4, 9, 16]
>>> b = map(lambda x: x ** 2,[1,2,3,4])   # 使用匿名函数
>>> list(b)
[1, 4, 9, 16]
>>> c = map(lambda x ,y: x + y,[1,2,3,4],[1,2,3,4,5,6,7])  # 同时传入两个迭代器，最短的取完元素就结束了。
>>> list(c)
[2, 4, 6, 8]

max(iterable, *[, key, default])、max(arg1, arg2, *args[, key])

描述

返回可迭代对象 iterable 或者两个或多个参数arg1,arg2... 中最大的项。如果只有一个参数，那么它必须是可迭代的对象，并返回其中最大的项。如果提供了两个或多个参数，则返回这些参数中最大的参数。如果 iterable 为空，默认参数指定要返回的对象。如果 iterable 为空且没有提供默认值，则会引发 ValueError 。根据ord()获取对应字符串在ASCII中的位置来比较大小。

参数

  • iterable：可迭代对象。
  • key：当key不为空时，以key的函数对象作为比较的标准

返回值

返回给定参数的最大值

示例

>>> a = range(10)
>>> max(a)
9
>>> b = 'python'
>>> max(b)
'y'
>>> max(a, key=lambda x: x > 3)
4
>>> max(1, 4, 5, 7, 8, 0, 5, 54, 65, 7)
65
>>> max('an', 'bg', key=lambda x: x[1])
'an'
>>> c = range(0, 10, 2)
>>> max(a, c, key=lambda x: x[1])
range(0, 10, 2)
>>> def A(x):
...     return x[2]
... 
>>> max('an1','bg9',key=A)
'bg9'

memoryview(obj)

描述

根据传入的对象创建一个内存查看对象。所谓的内存查看对象，是指对支持缓冲区协议的数据进行包装，使它在不需要复制对象的基础上允许python代码访问。

参数

obj必须支持缓存协议。支持缓存协议的内置对象包括 bytes 和 bytearray

返回值

memoryview对象

示例

>> a = b'python'
>>> b = bytearray('python','utf-8')
>>> aa = memoryview(a)
>>> bb = memoryview(b)
>>> aa[1]
121
>>> bb[1]
121
>>> aa[:3]
<memory at 0x046B7B90>
>>> bb[:3]
<memory at 0x046B7AC0>
>>> aa.readonly
True
>>> bb.readonly
False
>>> aa[:3].tobytes()
b'pyt'
>>> bb[:3].tobytes()
b'pyt'

min(iterable, *[, key, default])、min(arg1, arg2, *args[, key])

与max是相对的。

next(iterator[, default])

描述

通过调用 iterable 的__next__()方法从迭代器中检索下一个项目。如果给定 default ，那么当迭代器耗尽时，返回该值，否则将引发 StopIteration 错误。

参数

  • iterable：可迭代对象
  • default：当迭代器耗尽时的默认值

返回值

迭代器中的元素

示例

>>> a = iter([1,2,3,4,5])
>>> while True:
...     try:
...         b = next(a)
...         print(b)
...     except StopIteration:
...         break
...         
1
2
3
4
5

class object

描述

object是所有类的基类，它具有所有python类都通用的方法。这个函数不接受任何参数。

oct(x)

描述

将整数转换为以“0o”开头的八进制字符串。如果 x 不会一个int对象，那它必须定义有一个返回整数的 index() 方法。

参数

整数

返回值

以"0o"开头的八进制字符串

示例

>>> oct(10)
'0o12'
>>> oct(111)
'0o157'
>>> class A(object):
...     def __index__(self):
...         return 10
...     
>>> aa = A()
>>> oct(aa)
'0o12'

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

描述

打开文件并返回响应的文件对象。如果文件无法打开，则返回一个 OSError 错误。

参数

  • file：文件的位置。文件的绝对路径或者相对于当前工作目录的相对路径。
  • mode：文件的打开模式。
    • r：只读模式，文件指针会在放在文件的开头。
    • t：文本模式（默认）
    • x：写模式，新加你一个文件，如果文件存在则会报错。
    • b：二进制模式
    • +：更新一个文件（可读，可写）
    • U：通用换行模式
    • rb：以二进制格式、只读方式打开文件件。文件指针在文件开头。一般用于非文本文件如图片等。
    • r+：打开一个文件用于读写。文件指针在开头。
    • rb+：以二进制格式、只读方式打开一个文件用于读写。一般用于非文本文件如图片等。
    • w：打开一个文件用于写入。如果文件已经存在，则会清空原有文件内容，从头开始编辑写入。如果文件不存在，则创建新文件。
    • wb：以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
    • w+：打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
    • wb+：以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
    • a：打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
    • ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
    • a+：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
    • ab+：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
  • buffering：设置缓冲策略。当没有指定buffering时：二进制文件以固定大小的块进行缓冲。通过启发式方法尝试获取底层设备的块大小，并返回到 io.DEFAULT_BUFFER_SIZE 。在大多数系统中，缓冲区大小通常为4096或者8192字节；“交互式”文本文件(isatty()返回True的文件)使用行缓冲。其他文本文件对二进制文件使用上述策略。
    • 0：关闭缓冲。只能在二进制模式下使用。
    • 1：行缓冲。只能在文本模式下使用。
    • >1：大于1的整数。指定缓冲区块的字节大小。
  • encoding：指定编码或解码方式。这个只能用在文本模式中。默认的编码方式取决于所用平台（locale.getpreferredencoding()的返回值）。
  • errors：可选的字符串，指定如何处理编码和解码错误（不能在二进制模式中使用）。
  • newline：控制通用换行模式的工作方式(它只适用于文本模式)。它可以是：None、''、'\n'、'\r'、'\n\r'。
  • closefd：如果closefd为False，并且提供了文件描述符(而不是文件名)，那么在关闭文件时，底层文件描述符将保持打开状态。如果给定文件名closefd必须为真(默认)，否则将引发错误。
  • opener：

ord(c)

描述

给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode编码点的整数编号。

参数

一个字符串

返回值

Unicode编码表内的整数编号

示例

>>> ord('1')
49
>>> ord('a')
97
>>> ord('A')
65
>>> ord('中')
20013
>>> ord('国')
22269

pow(x, y[, z])

描述

返回x**y的值，如果给定了 z 参数，则返回 x**y%z的值

参数

x,y,z：必须具有数字类型。对于混合操作数类型，应用二进制算术运算符的强制规则。对于int操作数，结果具有与操作数相同的类型(强制后)，除非第二个参数为负;在这种情况下，所有参数都转换为float，并交付float结果。如果第二个参数为负数，则必须省略第三个参数。如果z存在，x和y必须是整数类型，y必须是非负的。

返回值

x的y次方、x的y次方除以Z取模

示例

>>> pow(2,4)
16
>>> pow(2,4,3)
1
>>> pow(2.1, 2)
4.41
>>> pow(2.1, 2, 2)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: pow() 3rd argument not allowed unless all arguments are integers

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

描述

将对象打印到文本流文件中，以sep分隔，以end结尾。sep、end、file和flush如果存在，必须作为关键字参数给出。sep 和 end 必须是字符串。也可以是 None，这就代表使用默认值。如果没有给定 objects 则将只会输出 end .

参数

  • objects：复数，可以一次输出多个对象。输出多个对象时，以 ',' 分隔。
  • sep：当输出多个对象时，用来分隔对象。默认值是空格
  • end：用来设定以什么结尾。默认值时换行符。
  • file：必须是具有 write(string) 方法的对象。如果未指定或设置为 None，将使用 sys.stdout。由于打印参数被转换为文本字符串，所以print()不能用于二进制模式文件对象。对于这些，使用file.write(…)代替。
  • flush：是否强制刷新缓存。

示例

>>> print('a')
a
>>> print('a','b')
a b
>>> print('a','b',sep='...')
a...b
>>> print('a','b',sep='...',end='+++')
a...b+++

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

描述

将类中的方法像类属性一样调用，规范化的访问类的属性和修改类属性的值的一种方法

参数

  • fget：获取属性值的函数
  • fset：设置属性值的函数
  • fdel：深处属性值的函数
  • doc：返回属性说明的函数

返回值

返回一个property类

示例

第一种

>>> class A(object):
...     def __init__(self, a, b):
...         self.a = a
...         self.b = b
... 
...     def getValue(self):
...         return self.a, self.b
... 
...     def setValue(self, size):
...         self.a, self.b = size
... 
...     def delValue(self):
...         del self.a
... 
...     size = property(fget=getValue, fset=setValue, fdel=delValue, doc="十万伏特")
... 
>>> test = A(22, 33)
>>> print(test.a, test.b)
22 33
>>> print(test.size)
(22, 33)
>>> test.size = 2222, 3333
>>> print(test.size)
(2222, 3333)
>>> del test.b
>>> print(test.size)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "<input>", line 7, in getValue
AttributeError: 'A' object has no attribute 'b'
>>> A.size.__doc__
'十万伏特'

第二种

>>> class B(object):
...     def __init__(self, a, b):
...         self.a = a
...         self.b = b
... 
...     @property
...     def Values(self):
...         """十万伏特"""
...         return self.a, self.b
... 
...     @Values.setter
...     def Values(self, size):
...         self.a, self.b = size
... 
...     @Values.deleter
...     def Values(self):
...         del self.b
...         del self.a
...         
>>> bb = B(44, 55)
>>> bb.a
44
>>> bb.b
55
>>> bb.Values
(44, 55)
>>> bb.Values = 4444, 5555
>>> bb.Values
(4444, 5555)
>>> bb.a
4444
>>> bb.b
5555
>>> del bb.a
>>> bb.b
5555
>>> bb.a
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'B' object has no attribute 'a'

range(stop)，range(start,stop[,step])

描述

返回一个可迭代对象，而不是列表类型

参数

  • start：计数从start开始
  • stop：计数到stop结束，但不包括stop。
  • step：步长，默认值为1.

返回值

一个可迭代对象

示例

>>> a = range(5)
>>> type(a)
<class 'range'>
>>> a
range(0, 5)
>>> from collections import Iterable
>>> isinstance(a,Iterable)
True
>>> for i in a:
...     print(i)
...     
0
1
2
3
4
>>> b = range(2, 6, 2)
>>> type(b)
<class 'range'>
>>> b
range(2, 6, 2)
>>> isinstance(b,Iterable)
True
>>> for i in b:
...     print(i)
...     
2
4

repr(object)

描述

将 object 转换为可供解释器杜旭的字符串形式。通常情况下，object = eval(repr(object))，否则，返回一个用尖括号括起来的字符串，其中包含object的名称以及附加信息(通常包括对象的名称和地址)。

参数

  • repr：对象

返回值

字符串

示例

>>> a = [1, 2, 3, 4]
>>> repr(a)
'[1, 2, 3, 4]'
>>> aa = eval(repr(a))
>>> aa
[1, 2, 3, 4]
>>> a
[1, 2, 3, 4]
class B(object):
    def A(self):
        return 111
b = B()
repr(b)
'<B object at 0x039E6350>'
b
<B object at 0x039E6350>

reversed(seq)

描述

返回一个反向的迭代器。

参数

seq必须是一个具有__reversed__()方法或支持序列协议(len()方法和__getitem__()方法的对象，整数参数从0开始)。

返回值

反向迭代器

示例

>>> "".join(list(reversed('python')))
'nohtyp'
>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]
>>> tuple(reversed((1,2,3,4,5)))
(5, 4, 3, 2, 1)

round(number[, ndigits])

描述

返回 number 四舍五入后的值。如果 ndigits 为空或者None，则返回最接近number的整数。

参数

  • number：数字表达式
  • ndigits：小数点位数，默认为0

返回值

返回number的四舍五入值

示例

>>> round(2.345)
2
>>> round(2.345,1)
2.3
>>> round(2.345,2)
2.35
>>> round(2.345,3)
2.345
>>> round(2.345,4)
2.345
>>> round(2.00000567,3)
2.0
>>> round(-2.00000567,3)
-2.0
>>> round(-2.00000567,5)
-2.00001
# 需要注意的几个
>>> round(0.5)  #取整到偶数部分
0
>>> round(-0.5)
0
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(10.5)
10
>>> round(11.5)
12
>>> round(2.675,2)  # 并不是bug，有些浮点数在计算机中并不能像整数那样被精准的表达，它可能是一个近似值。
2.67

class set([iterable])

描述

创建一个set对象。或者使用iterable中的元素生成一个set对象。

参数

  • iterable：可迭代对象

返回值

新的集合对象

示例

>>> a = set()
>>> a
set()
>>> set('python')
{'p', 'o', 'y', 'h', 't', 'n'}
>>> set('hello world')
{' ', 'e', 'w', 'd', 'o', 'l', 'h', 'r'}

setattr(object, name, value)

描述

和 getattr 相似，如果 object 允许，函数将会把 value 赋值给 name。

参数

  • object：对象
  • name：字符串，对象属性名。可以是现有属性或是新属性。
  • value：属性值

示例

>>> class A(object):
...     a = 1
...     
>>> aa = A()
>>> aa.a
1
>>> getattr(aa,'a')
1
>>> setattr(aa,'a', 2)  # 设置现有属性
>>> getattr(aa,'a')
2
>>> setattr(aa,'b', 2)  # 设置新属性
>>> aa.b
2
>>> getattr(aa,'b')
2

class slice(stop)、class slice(start, stop[, step])

描述

返回一个切片对象，该对象是一组由rang(start,stop,step)指定的索引集合。start、step 参数的默认值为None。 slice 对象具有只读数据属性 start、stop 和 step，他们将返回设定的参数值或者默认值。

参数

  • start：起始位置
  • stop：结束位置
  • step：间距

返回值

一个切片对象

示例

>>> a = slice(5)
>>> a.start,a.stop,a.step
(None, 5, None)
>>> a
slice(None, 5, None)
>>> aa = range(10)
>>> list(aa)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aa[a]
range(0, 5)
>>> list(aa[a])
[0, 1, 2, 3, 4]
>>> b = slice(2, 8, 2)
>>> b.start,b.stop,b.step
(2, 8, 2)
>>> aa[b]
range(2, 8, 2)
>>> list(aa[b])
[2, 4, 6]

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

描述

对 iterable 进行排序操作，并返回一个新的list

参数

  • iterable：可迭代对象
  • key：指定一个函数，并把 iterable 中的每一个元素带入函数中，并根据返回的值的排序来对iterable进行排序。默认值是None
  • reverse：是否反转。False 升序，True 降序。

返回值

重新排列后的iterable

示例

>>> sorted([5,2,5,7,1,6])
[1, 2, 5, 5, 6, 7]
>>> sorted(('a', 'b', '1', '4', '7', '5', '3', 'A'))
['1', '3', '4', '5', '7', 'A', 'a', 'b']
>>> a = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
>>> def By_name(x):
...     return x[0][0].lower()
... 
>>> sorted(a,key=By_name)
[('Adam', 92), ('Bob', 75), ('Bart', 66), ('Lisa', 88)]
>>> def By_num(x):
...     return x[1]
... 
>>> sorted(a,key=By_num)
[('Bart', 66), ('Bob', 75), ('Lisa', 88), ('Adam', 92)]
>>> sorted(a, key=By_num, reverse=True)
[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]

@staticmethod

描述

将一个方法转换为静态方法。在类中，静态方法不会隐式的接收第一个参数。

示例

>>> class A(object):
...     @staticmethod
...     def B():
...         print('刀剑神域')
...         
>>> A.B()  # 静态方法可以在不实例化类的情况下调用
刀剑神域
>>> a = A()
>>> a.B()
刀剑神域

class str(object='')、class str(object=b'', encoding='utf-8', errors='strict')

描述

返回对象的 str 版本

参数

  • object=''：需要转换成字符串的对象，默认是空字符串。
  • object=b''：需要转换成字符串的对象，参数必须是一个类字节对象（如：bytes、bytearray），默认是空字节对象
  • encoding：转换成字符串时使用的编码，默认编码是 utf-8
  • errors：转换字符串时，设置报告错误的级别。参数必须是系统中定义的错误级别，默认为strict.

返回值

返回转换后的字符串

示例

>>> str('关于我转生变成史莱姆这档事')
'关于我转生变成史莱姆这档事'
>>> str([1,2,3,4,5])
'[1, 2, 3, 4, 5]'
>>> str(b'Angels of Death','utf-8')
'Angels of Death'

sum(iterable[, start])

描述

计算 iterabel 中所有元素和 start 的总和。iterable中的元素通常为数字，start 不可以为字符串。在有些实例中，sum()不是最优选择。如：连接字符串优先使用 ''.join(sequence)；对比较精准的浮点数进行计算优先使用math.fsum()；连接迭代器优先使用itertools.chain()

参数

  • iterable：可迭代对象
  • start：指定相加的参数，默认值为0

返回值

返回计算结果

示例

>>> sum([1,2,3])
6
>>> sum([1,2,3],4)
10

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

描述

用于子类调取父类的方法。

参数

  • type：类
  • object-or-type：类，一般为self

示例

>>> class Base(object):
...     def __init__(self):
...         print("in base")
...         print('out base')
...         
>>> class A(Base):
...     def __init__(self):
...         print("in A")
...         super().__init__()
...         print("out A")
...         
>>> class B(Base):
...     def __init__(self):
...         print("in B")
...         super(B, self).__init__()
...         print("out B")
... 
>>> class C(A, B):
...     def __init__(self):
...         print("in C")
...         super().__init__()
...         print("out C")
>>> cc = C()
in C
in A
in B
in base
out base
out B
out A
out C

tuple([iterable])

描述

不是一个函数，而是一个不可变的序列类型。

参数

  • 要转换成元组的可迭代对象

返回值

元组

示例

>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple('python')
('p', 'y', 't', 'h', 'o', 'n')
>>> tuple(['a,','b','c','d'])
('a,', 'b', 'c', 'd')

class type(object)、class type(name, bases, dict)

描述

对于一个参数，返回对象的类型。返回值是一个类型对象，通常与object.__class__返回的对象相同。推荐使用isinstance()内置函数来测试对象的类型，因为它考虑了子类。对于三个参数返回新的类型对象。

参数

  • object：需要进行判断的对象
  • name：字符串形式的类名
  • bases：元组形式的基类序列
  • dict：类内定义的命名空间变量。（类属性、类方法等组成的字典）

返回值

一个参数返回对象的类型。三个参数，返回新的类型对象。

示例

# 一个参数
>>> type('python')
<class 'str'>
>>> type(1)
<class 'int'>
>>> type(range(5))
<class 'range'>
# 三个参数 B等价于A
>>> def bb(self):
...     print(self.b)
...     
>>> B = type('B',(object,),dict(b = 1, bb = bb))
>>> B
<class 'B'>
>>> bb = B()
>>> bb.b
1
>>> bb.bb()
1
>>> class A(object):
...     def __init__(self):
...         self.a = 1
...     def aa(self):
...         print(self.a)
...         
>>> A
<class 'A'>
>>> aa = A()
>>> aa.a
1
>>> aa.aa()
1

vars([object])

描述

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

参数

对象

返回值

一个字典，对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。

示例

>>> class A(object):
...     a = 1
...     b = 2
...     def __init__(self):
...         self.c = 3
...         self.d = 4
...         
>>> vars(A)
mappingproxy({'__module__': 'builtins', 'a': 1, 'b': 2, '__init__': <function A.__init__ at 0x0456C108>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None})
>>> A.__dict__
mappingproxy({'__module__': 'builtins', 'a': 1, 'b': 2, '__init__': <function A.__init__ at 0x0456C108>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None})
>>> vars()
{'__builtins__': {'__name__': 'builtins', '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.", '__package__': '', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>), '__build_class__': <built-in function __build_class__>, '__import__': <bound method ImportHookManager.do_import of <module '_pydev_bundle.pydev_import_hook.import_hook'>>, 'abs': <built-in function abs>, 'all': <built-in function all>,
........省略............... 
'license': See http://www.python.org/3.7/license.html, 'help': Type help() for interactive help, or help(object) for help about object., 'execfile': <function execfile at 0x044C5228>, 'runfile': <function runfile at 0x04520C00>, '_': None}, 'sys': <module 'sys' (built-in)>, 'A': <class 'A'>}
>>> locals()
{'__builtins__': {'__name__': 'builtins', '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.", '__package__': '', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>), '__build_class__': <built-in function __build_class__>, '__import__': <bound method ImportHookManager.do_import of <module '_pydev_bundle.pydev_import_hook.import_hook'>>, 'abs': <built-in function abs>, 'all': <built-in function all>, 
.................省略.................
'license': See http://www.python.org/3.7/license.html, 'help': Type help() for interactive help, or help(object) for help about object., 'execfile': <function execfile at 0x044C5228>, 'runfile': <function runfile at 0x04520C00>, '_': None}, 'sys': <module 'sys' (built-in)>, 'A': <class 'A'>}

zip(*iterables)

描述

将可迭代的对象作为参数，将各个对象中对应索引位置的元素打包成一个个元组，然后返回由这些元组组成的对象。如果给定的可迭代对象长度不等，则以最短的迭代对象为准。

参数

一个或多个迭代器

返回值

返回一个zip对象

示例

>>> a = [1,2,3,4]
>>> b = (5,6,7,8)
>>> zip(a,b)
<zip object at 0x037A4760>
>>> list(zip(a,b))
[(1, 5), (2, 6), (3, 7), (4, 8)]
>>> c = [9,10,11,12,13,14]
>>> list(zip(a,c))
[(1, 9), (2, 10), (3, 11), (4, 12)]
>>> ab = zip(a,b)
>>> aa,bb = zip(*ab)
>>> aa,bb
((1, 2, 3, 4), (5, 6, 7, 8))

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

描述

用于动态的加载类和函数，只接收字符串作为参数，比如希望加载某个文件夹下的所有模块，但是其下面的模块又是会经常变化，这里就可以使用这个函数动态的加载所有模块了，常见的场景是插件功能的支持。import语句就是调用这个函数进行导入工作的，import os 等于 sys = import('sys')。

拓展

使用字符串动态的重载模块。
实现方法是先取消导入的模块然后在重新导入。利用 sys.modules 查看所有已经加载并成功的模块。然后利用 del sys.modules['模块名']。
a.py

#!/usr/bin/env python3
# * coding:utf-8 *
# Created by fjg on 2018/11/9

import os
print("this is a.",id(os))

b.py

#!/usr/bin/env python3
# * coding:utf-8 *
# Created by fjg on 2018/11/9

import sys
__import__('a')
print(sys.modules)
del sys.modules['a']
__import__('a')

执行结果

this is a. 52125440
{'sys': <module 'sys' (built-in)>, 
.........省略..............
'a': <module 'a' from 'E:\\dev\\lye\\test\\a.py'>}
this is a. 52125440

参数

  • name：字符串。模块名称
  • globals：指定全局变量
  • locals：指定局部变量
  • fromlist：指定要导入的子模块或者对象的名称。
  • level：指定时相对导入还是绝对导入。默认值为0
    • 0：绝对导入
    • > 0 ：大于0 的整数值，表示相对于 import() 当前目录向上搜索的父目录的数量。
posted @ 2018-11-12 16:16  付建功  阅读(269)  评论(0)  编辑  收藏  举报