内置函数

内置函数

内置函数    1

1.    数学运算(7个)    4

1.1.    divmod：返回两个数值的商和余数    4

1.2.    max：返回可迭代对象中的元素中的最大值或者所有参数的最大值    5

1.3.    min：返回可迭代对象中的元素中的最小值或者所有参数的最小值    5

1.4.    sum：对元素类型是数值的可迭代对象中的每个元素求和    6

1.5.    abs：求数值的绝对值    7

1.6.    round：对浮点数进行四舍五入求值    7

1.7.    pow：返回两个数值的幂运算值或其与指定整数的模值    7

2.    类型转换(24个)    8

2.1.    bytes：根据传入的参数创建一个新的不可变字节数组    8

2.2.    range：根据传入的参数创建一个新的range对象    9

2.3.    bool：根据传入的参数的逻辑值创建一个新的布尔值    9

2.4.    int：根据传入的参数创建一个新的整数    10

2.5.    float：根据传入的参数创建一个新的浮点数    10

2.6.    complex：根据传入参数创建一个新的复数    11

2.7.    str：返回一个对象的字符串表现形式(给用户)    11

2.8.    bytearray：根据传入的参数创建一个新的字节数组    12

2.9.    memoryview：根据传入的参数创建一个新的内存查看对象    12

2.10.    ord：返回Unicode字符对应的整数    13

2.11.    chr：返回整数所对应的Unicode字符    13

2.12.    bin：将整数转换成2进制字符串    13

2.13.    oct：将整数转化成8进制数字符串    14

2.14.    hex：将整数转换成16进制字符串    14

2.15.    tuple：根据传入的参数创建一个新的元组    14

2.16.    list：根据传入的参数创建一个新的列表    15

2.17.    dict：根据传入的参数创建一个新的字典    15

2.18.    set：根据传入的参数创建一个新的集合    16

2.19.    frozenset：根据传入的参数创建一个新的不可变集合    16

2.20.    enumerate：根据可迭代对象创建枚举对象    17

2.21.    iter：根据传入的参数创建一个新的可迭代对象    17

2.22.    slice：根据传入的参数创建一个新的切片对象    18

2.23.    super：根据传入的参数创建一个新的子类和父类关系的代理对象    19

2.24.    object：创建一个新的object对象    20

3.    序列操作(8个)    20

3.1.    filter：使用指定方法过滤可迭代对象的元素    21

3.2.    map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象    21

3.3.    reversed：反转序列生成新的可迭代对象    22

3.4.    sorted：对可迭代对象进行排序，返回一个新的列表    22

3.5.    zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器    23

3.6.    all：判断可迭代对象的每个元素是否都为True值    23

3.7.    any：判断可迭代对象的元素是否有为True值的元素    24

3.8.    next：返回可迭代对象中的下一个元素值    24

4.    对象操作(9个)    25

4.1.    help：返回对象的帮助信息    25

4.2.    dir：返回对象或者当前作用域内的属性列表    26

4.3.    id：返回对象的唯一标识符    27

4.4.    hash：获取对象的哈希值    27

4.5.    type：返回对象的类型，或者根据传入的参数创建一个新的类型    28

4.6.    len：返回对象的长度    28

4.7.    ascii：返回对象的可打印表字符串表现方式    29

4.8.    format：格式化显示值    29

4.9.    vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表    32

5.    反射操作(8个)    33

5.1.    callable：检测对象是否可被调用    33

5.2.    __import__：动态导入模块    34

5.3.    isinstance：判断对象是否是类或者类型元组中任意类元素的实例    35

5.4.    issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类    35

5.5.    hasattr：检查对象是否含有属性    35

5.6.    getattr：获取对象的属性值    36

5.7.    setattr：设置对象的属性值    37

5.8.    delattr：删除对象的属性    38

6.    变量操作(2个)    39

6.1.    globals：返回当前作用域内的全局变量和其值组成的字典    39

6.2.    locals：返回当前作用域内的局部变量和其值组成的字典    40

7.    交互操作(2个)    41

7.1.    print：向标准输出对象打印输出    41

7.2.    input：读取用户输入值    42

8.    文件操作(1个)    42

8.1.    open：使用指定的模式和编码打开文件，返回文件读写对象    42

9.    编译执行(4个)    43

9.1.    eval：执行动态表达式求值    43

9.2.    exec：执行动态语句块    43

9.3.    repr：返回一个对象的字符串表现形式(给解释器)    44

9.4.    compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值    44

10.    装饰器(3个)    45

10.1.    property：标示属性的装饰器    46

10.2.    classmethod：标示方法为类方法的装饰器    47

10.3.    staticmethod：标示方法为静态方法的装饰器    48

 

1. 数学运算(7个)

   

   1. divmod：返回两个数值的商和余数

       

   

   

   1. max：返回可迭代对象中的元素中的最大值或者所有参数的最大值

      

   

   

   1. min：返回可迭代对象中的元素中的最小值或者所有参数的最小值

      

   

   

   1. sum：对元素类型是数值的可迭代对象中的每个元素求和

      

   

   

   1. abs：求数值的绝对值

      

   

   

   1. round：对浮点数进行四舍五入求值

      

   

   

   1. pow：返回两个数值的幂运算值或其与指定整数的模值

      

   

   

2. 类型转换(24个)

   

   1. bytes：根据传入的参数创建一个新的不可变字节数组

      

   

   

   1. range：根据传入的参数创建一个新的range对象

      

   

   

   1. bool：根据传入的参数的逻辑值创建一个新的布尔值

   

   

   1. int：根据传入的参数创建一个新的整数

   

   

   1. float：根据传入的参数创建一个新的浮点数

   

   

   1. complex：根据传入参数创建一个新的复数

   

   

   1. str：返回一个对象的字符串表现形式(给用户)

   

   

   1. bytearray：根据传入的参数创建一个新的字节数组

   

   

   1. memoryview：根据传入的参数创建一个新的内存查看对象

   

   

   1. ord：返回Unicode字符对应的整数

   

   

   1. chr：返回整数所对应的Unicode字符

   

   

   1. bin：将整数转换成2进制字符串

   

   

   1. oct：将整数转化成8进制数字符串

   

   

   1. hex：将整数转换成16进制字符串

   

   

   1. tuple：根据传入的参数创建一个新的元组

   

   

   1. list：根据传入的参数创建一个新的列表

   

   

   1. dict：根据传入的参数创建一个新的字典

   

   

   1. set：根据传入的参数创建一个新的集合

   

   

   1. frozenset：根据传入的参数创建一个新的不可变集合

   

   

   1. enumerate：根据可迭代对象创建枚举对象

   

   

   1. iter：根据传入的参数创建一个新的可迭代对象

   

   

   1. slice：根据传入的参数创建一个新的切片对象

   

   

   1. super：根据传入的参数创建一个新的子类和父类关系的代理对象

   

   

   1. object：创建一个新的object对象

   

   

3. 序列操作(8个)

   

   1. filter：使用指定方法过滤可迭代对象的元素

      

   

   

   1. map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

      

   

   

   1. reversed：反转序列生成新的可迭代对象

      

   

   

   1. sorted：对可迭代对象进行排序，返回一个新的列表

      

   

   

   1. zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

      

   

   

   1. all：判断可迭代对象的每个元素是否都为True值

      

   

   

   1. any：判断可迭代对象的元素是否有为True值的元素

      

   

   

   1. next：返回可迭代对象中的下一个元素值

   

   

4. 对象操作(9个)

   

   1. help：返回对象的帮助信息

   

   

   1. dir：返回对象或者当前作用域内的属性列表

   

   

   1. id：返回对象的唯一标识符

   

   

   1. hash：获取对象的哈希值

   

   

   1. type：返回对象的类型，或者根据传入的参数创建一个新的类型

   

   

   1. len：返回对象的长度

   

   

   1. ascii：返回对象的可打印表字符串表现方式

   

   

   1. format：格式化显示值

   

    

   #字符串可以提供的参数 's' None

   >>> format('some string','s')

   'some string'

   >>> format('some string')

   'some string'

    

   #整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None

   >>> format(3,'b') #转换成二进制

   '11'

   >>> format(97,'c') #转换unicode成字符

   'a'

   >>> format(11,'d') #转换成10进制

   '11'

   >>> format(11,'o') #转换成8进制

   '13'

   >>> format(11,'x') #转换成16进制 小写字母表示

   'b'

   >>> format(11,'X') #转换成16进制 大写字母表示

   'B'

   >>> format(11,'n') #和d一样

   '11'

   >>> format(11) #默认和d一样

   '11'

    

   #浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None

   >>> format(314159267,'e') #科学计数法，默认保留6位小数

   '3.141593e+08'

   >>> format(314159267,'0.2e') #科学计数法，指定保留2位小数

   '3.14e+08'

   >>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示

   '3.14E+08'

   >>> format(314159267,'f') #小数点计数法，默认保留6位小数

   '314159267.000000'

   >>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数

   '3.141593'

   >>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数

   '3.14159267'

   >>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数

   '3.1415926700'

   >>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母

   'INF'

    

   #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数

   >>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点

   '3e-05'

   >>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点

   '3.1e-05'

   >>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点

   '3.14e-05'

   >>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写

   '3.14E-05'

   >>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点

   '3'

   >>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点

   '3.1'

   >>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点

   '3.14'

   >>> format(0.00003141566,'.1n') #和g相同

   '3e-05'

   >>> format(0.00003141566,'.3n') #和g相同

   '3.14e-05'

   >>> format(0.00003141566) #和g相同

   '3.141566e-05'

   

   1. vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

   

   

5. 反射操作(8个)

   

   1. callable：检测对象是否可被调用

      

   

   

   1. __import__：动态导入模块

   

   

   1. isinstance：判断对象是否是类或者类型元组中任意类元素的实例

   

   

   1. issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类

   

   

   1. hasattr：检查对象是否含有属性

   

   

   1. getattr：获取对象的属性值

   

   

   1. setattr：设置对象的属性值

   

   

   1. delattr：删除对象的属性

   

   

6. 变量操作(2个)

   

   1. globals：返回当前作用域内的全局变量和其值组成的字典

      

   

   

   1. locals：返回当前作用域内的局部变量和其值组成的字典

      

   

   

7. 交互操作(2个)

   

   1. print：向标准输出对象打印输出

   

   

   1. input：读取用户输入值

   

   

8. 文件操作(1个)

   

   1. open：使用指定的模式和编码打开文件，返回文件读写对象

      

   

   

9. 编译执行(4个)

   

   1. eval：执行动态表达式求值

      

   

   

   1. exec：执行动态语句块

      

   

   

   1. repr：返回一个对象的字符串表现形式(给解释器)

      

   

   

   1. compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值

   

   

10. 装饰器(3个)

    

    1. property：标示属性的装饰器

        

       >>> class C:

       def __init__(self):

       self._name = ''

       @property

       def name(self):

       """i'm the 'name' property."""

       return self._name

       @name.setter

       def name(self,value):

       if value is None:

       raise RuntimeError('name can not be None')

       else:

       self._name = value

        

        

       >>> c = C()

        

       >>> c.name # 访问属性

       ''

       >>> c.name = None # 设置属性时进行验证

       Traceback (most recent call last):

       File "<pyshell#84>", line 1, in <module>

       c.name = None

       File "<pyshell#81>", line 11, in name

       raise RuntimeError('name can not be None')

       RuntimeError: name can not be None

        

       >>> c.name = 'Kim' # 设置属性

       >>> c.name # 访问属性

       'Kim'

        

       >>> del c.name # 删除属性，不提供deleter则不能删除

       Traceback (most recent call last):

       File "<pyshell#87>", line 1, in <module>

       del c.name

       AttributeError: can't delete attribute

       >>> c.name

       'Kim'

    2. classmethod：标示方法为类方法的装饰器

    

    

    1. staticmethod：标示方法为静态方法的装饰器