abs()

abs() 函数返回数字的绝对值。

all()

函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

元素除了是 0、空、None、False 外都算 True。空元组、空列表返回值为True，这里要特别注意。

例子：if all([user, news]):  

any()

 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。

例子：if all([user, news]):

bin()

返回一个整数 int 或者长整数 long int 的二进制表示。 

例子：>>>bin(10)   '0b1010'

bool()

函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。例子：bool(0)

chr()

用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符   注意：参数可以是10进制也可以是16进制的形式的数字。

例子：

>>>print chr(0x30), chr(0x31), chr(0x61) # 十六进制

0 1 a

>>> print chr(48), chr(49), chr(97) # 十进制

0 1 a

callable()

函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

classmethod()

修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

例子：

class People(object):
    country = 'china'

    #类方法，用classmethod来进行修饰
    @classmethod
    def get_country(cls):
        return cls.country

p = People()
print(p.get_country())    #可以用过实例对象引用
print(People.get_country())    #可以通过类对象引用

cmp()

函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

例子：print "cmp(80, 100) : ", cmp(80, 100)

注意：python3中替换python2中cmp函数

import operator
operator.lt(a,b)

lt(a,b) 相当于 a<b（less than） 从第一个数字或字母（ASCII）比大小

le(a,b)相当于a<=b (less than or equal)

eq(a,b)相当于a==b (equal) 字母完全一样，返回True,

ne(a,b)相当于a!=b (not equal)

gt(a,b)相当于a>b (greater than)

ge(a,b)相当于 a>=b (greater than or equal)

dict()

函数用于创建一个字典。

dict 语法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
参数说明：
**kwargs -- 关键字
mapping -- 元素的容器。
iterable -- 可迭代对象。

例子：

print(dict(a=1, b=2))
print(dict(zip(['a', 'b', 'c'], [1, 2, 3])))
print(dict([('a', 1), ('b', 2), ('c', 3)]))

dir()

函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

例子：

print(dir())

divmod()

函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组 。

例子：

print(divmod(8,4))
(2, 0)

 

enumerate()

函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

 

enumerate(sequence, [start=0])

sequence -- 一个序列、迭代器或其他支持迭代对象。

start -- 下标起始位置。

例子：

print([(x,y) for x,y in enumerate(['a','b','c'])])

eval（)

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

例子：

x=100
print(eval（'x+5'))
print(type(eval（'2+2')))

 

execfile()

函数可以用来执行一个文件。

例子：

# 假设文件 hello.py，内容如下：
print('runoob');
# execfile 调用该文件
print(execfile('hello.py'))

python3已经删除

exec()

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

Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了

注意：

exec 返回值永远为 None。

例子：

print(exec(open('./LX_faker.py', 'r').read()))

filter()

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

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

例子：

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)

float()

函数用于将整数和字符串转换成浮点数

 

format()

通过 {} 和 : 来代替以前的 % 。

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

例子：

name='xxx'
print('{}比黄花瘦'.format('人'))
print('{}你好'.format(name))

frozenset()

返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

参数：

  • iterable -- 可迭代的对象，比如列表、字典、元组等等。

例子：

print(frozenset(range(10)))

getattr()

函数用于返回一个对象属性值。

例子：

>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
3

globals()

函数会以字典类型返回当前位置的全部全局变量。

例子：

print(globals())

hasattr()

函数用于判断对象是否包含对应的属性

hasattr 语法：

hasattr(object, name)

例子：

class Coordinate:

x = 10

point1 = Coordinate()

print(hasattr(point1, 'x'))

print(hasattr(point1, 'no')) # 没有该属性

hash()

用于获取取一个对象（字符串或者数值等）的哈希值。

例子：

print(hash('dvf'))
print(hash(155))
print(hash(str({'a':1})))

help()

函数用于查看函数或模块用途的详细说明。

help('sys') # 查看 sys 模块的帮助

hex()

函数用于将一个指定数字转换为 16 进制数。

hex 语法：

hex(x)

id()

 函数返回对象的唯一标识符，标识符是一个整数。

CPython 中 id() 函数用于获取对象的内存地址。

》》》id(object)

input()

函数接受一个标准输入数据，返回为 string 类型。

int()

 函数用于将一个字符串或数字转换为整型

isinstance()

 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
print(isinstance('a', (str, int, list)))   # 是元组中的一个返回 True

issubclass()

方法用于判断参数 class 是否是类型参数 classinfo 的子类。

iter()

函数用来生成迭代器。

语法:

iter(object[, sentinel])

 

len()

方法返回对象（字符、列表、元组等）长度或项目个数。

list()

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

locals()

 函数会以字典类型返回当前位置的全部局部变量。

map()

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

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表

例子：

def A(a):
  return a+1
xx=list(map(A,[1,2,3]))
print(xx)

max()

方法返回给定参数的最大值，参数可以为序列

print(max(100,62,9455))

memoryview()

memoryview() 函数返回给定参数的内存查看对象(memory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

min()

min() 方法返回给定参数的最小值，参数可以为序列。

print(max(100,62,9455))

next()

next() 返回迭代器的下一个项目。

next() 函数要和生成迭代器的iter() 函数一起使用。

 

next 语法：

next(iterable[, default])

oct()

函数将一个整数转换成 8 进制字符串，8 进制以 0o 作为前缀表示

open()

Python open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

pow()

pow() 方法返回 xy（x的y次方） 的值。

以下是 math 模块 pow() 方法的语法:

import math
math.pow( x, y )

内置的 pow() 方法

pow(x, y[, z])

函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

 

property()

property() 函数的作用是在新式类中返回属性值。

range()

Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。

Python3 list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。

Python2 range() 函数返回的是列表。

repr()

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

 

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

reversed()

函数返回一个反转的迭代器。

round()

round() 方法返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入）。

精度要求高的，不建议使用该函数。

 

round() 方法的语法:

round( x [, n]  )
  • x -- 数字表达式。
  • n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。

set()

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

 

>>>x = set('runoob')

>>> y = set('google')

>>> x, y

(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重复的被删除

>>> x & y # 交集 set(['o'])

>>> x | y # 并集 set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])

>>> x - y # 差集 set(['r', 'b', 'u', 'n'])

>>>

setattr()

函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

slice()

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

slice 语法：

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

参数说明：

  • start -- 起始位置
  • stop -- 结束位置
  • step -- 间距
list1 = list(range(10))
print(list1)
x = slice(5)
print(list1[x])
print(list1[slice(10,4,-1)])

sorted()

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted 语法：

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

参数说明：

  • iterable -- 可迭代对象。
  • key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
list1 =list(range(1,11))
print(sorted(list1,reverse=True))

你也可以使用 list 的 list.sort() 方法。这个方法会修改原始的 list（返回值为None）。通常这个方法不如sorted()方便-如果你不需要原始的 list，list.sort()方法效率会稍微高一些。

 

staticmethod()

python staticmethod 返回函数的静态方法。

该方法不强制要求传递参数，如下声明一个静态方法：

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

以上实例声明了静态方法 f，从而可以实现实例化使用 C().f()，当然也可以不实例化调用该方法 C.f()。

str()

str() 函数将对象转化为适于人阅读的形式。

sum()

sum() 方法对系列进行求和计算。

以下是 sum() 方法的语法:

sum(iterable[, start])

参数：

  • iterable -- 可迭代对象，如：列表、元组、集合。
  • start -- 指定相加的参数，如果没有设置这个值，默认为0。

语法：

>>>sum([0,1,2])

3

>>> sum((2, 3, 4), 1) # 元组计算总和后再加 1

10

>>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2

12

super()

super() 函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

tuple()

tuple 函数将可迭代系列（如列表）转换为元组。

type()

type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。isinstance() 与 type()
 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用 isinstance()。以下是 type() 方法的语法:
type(object)
type(name, bases, dict)
参数
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典，类内定义的命名空间变量。

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

实例

以下展示了使用 type 函数的实例：

一个参数实例

>>> type(1)

<type 'int'>

>>> type('runoob')

<type 'str'>

>>> type([2])

<type 'list'>

>>> type({0:'zero'})

<type 'dict'>

>>> x = 1

>>> type( x ) == int # 判断类型是否相等

True

# 三个参数

>>> class X(object):

...

a = 1

...

>>>

X = type('X', (object,), dict(a=1)) # 产生一个新的类型

X >>>

X <class '__main__.X'>

type() 与 isinstance()区别：

class A:

pass

class B(A):

pass

isinstance(A(), A) # returns True

type(A()) == A # returns True

isinstance(B(), A) # returns True

type(B()) == A # returns False

vars()

vars() 函数返回对象object的属性和属性值的字典对象

zip()

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

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

 

实例

以下实例展示了 zip 的使用方法：

>>>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__()

__import__() 函数用于动态加载类和函数 。

如果一个模块经常变化就可以使用 __import__() 来动态载入。