python之内建函数

一、数学运算类

1.abs(x)求绝对值，参数可以是整型，也可以是复数，若参数是复数，则返回复数的模

>>> abs(-10)
10
>>> abs(-10.1)
10.1

2.complex()创建一个复数

>>> complex(10,10)
(10+10j)

3.divmod(a,b)分别取商和余数，整型和浮点型都可以,返回一个包含商和余数的元组(a // b, a % b)

>>> divmod(3,2)
(1, 1)
>>> divmod(111,222)
(0, 111)

4.float(x)将整数或字符串转换为浮点型，参数为空，则返回0.0

>>> float(10)
10.0
>>> float('10')
10.0

5.int(x,base)将一个字符串或浮点型转换为整型，base表示进制

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

6.pow(x,y)返回x的y次幂

>>> pow(2,3)
8

7.range(start,stop,step)返回一个序列，默认从0开始，步长为1

>>> for i in range(1,10,2):
...     print('{0}'.format(i))
... 
1
3
5
7
9

8.round(x,n)四舍五入

>>> round(4.4)
4
>>> round(4.5)
4
>>> round(4.6)
5

9.sum(iterable,start)求和

>>> sum([1,2,3])#参数为可迭代对象
6

10.bin(x)将一个整数转换为二进制

扫描二维码关注公众号，回复： 3272960 查看本文章

>>> bin(1)
'0b1'
>>> bin(2)
'0b10'

11.oct(x)将一个数字转换为八进制

>>> oct(1)
'0o1'
>>> oct(2)
'0o2'

12.hex()将一个数字转换为十六进制

>>> hex(1)
'0x1'
>>> hex(2)
'0x2'

13.chr(i)将int类型转换为对应的ASCII字符

>>> chr(97)
'a'

14.ord(i)将字符串转换为对应的ASCII 码

>>> ord('a')
97

15.bool(x)将x转换为boolean类型

>>> bool(1)
True
>>> bool(0)
False
>>> bool(-1)
True
>>> bool('akldhasl')
True

二、集合类操作

1.format(value,format_spec)格式化输出字符串，格式化参数的参数从0开始，如"i am {0},you are {1}".format()

>>> a=[1,2,3,4]
>>> print('a is {0}'.format(a))
a is [1, 2, 3, 4]

2.enumerate(squence,start=0)返回一个可枚举的对象

>>> seq=[1,2,3,4]
>>> enumerate(seq)
<enumerate object at 0x7f57635421b0>
>>> for i in seq:
...     print(i)
... 
1
2
3
4
>>> for i in enumerate(seq):
...     print(i)
... 
(0, 1)
(1, 2)
(2, 3)
(3, 4)

3.iter(obj,sentinel)生成一个对象的迭代器，sentinel表示分隔符

>>> a=iter([1,2,3])
>>> next(a)
1
>>> next(a)
2
>>> next(a)
3
>>> next(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

4.max()最大值

>>> max(1,2,3)
3
>>> max((1,2,3))
3

5.min()最小值

>>> min(1,2,3)
1
>>> min([1,2,3])
1

6.dict()创建一个空字典

>>> d=dict()
>>> print(d)
{}

7.list(iterable)创建/转换为列表

>>> a=list()
>>> print(a)
[]
>>> b=list((1,2,3))
>>> print(b)
[1, 2, 3]

8.set()将set对象实例化

>>> a=set()
>>> print(a)
set()
>>> b=set([1,2,3])
>>> print(b)
{1, 2, 3}

9.frozenset(iterable)创建一个不可变集合(冻结集合)，参数为一个可迭代对象

>>> a=frozenset()
>>> print(a)
frozenset()
>>> b=frozenset([1,2,3,4])
>>> print(b)
frozenset({1, 2, 3, 4})

10.tuple(iterable)创建一个元组

>>> a=tuple()
>>> print(a)
()
>>> b=tuple('abcd')
>>> print(b)
('a', 'b', 'c', 'd')

11.str()转换为str类型

>>> a=str()
>>> print(a)

>>> a=str(123)
>>> print(a)
123

12.sorted(iterable,cmp,key,reverse)序列排序

L = [('b',2),('a',1),('c',3),('d',4)]
        sorted(L, key=lambda x: x[1]), reverse=True)      # 使用Key参数和reverse参数
        sorted(L, key=lambda x: (x[0], x[1]))             # 使用key参数进行多条件排序，即如果x[0]相同，则比较x[1]
>>> a=[('a',1),('f',3),('b',2)]
>>> sorted(a,key=lambda x:x[0],reverse=False)
[('a', 1), ('b', 2), ('f', 3)]

三、逻辑判断类

1.all(iterable)集合中的元素都为真时，返回True，若空串也返回True

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

2.any(iterable)集合中的元素都为真时，返回True，若空串返回False

>>>any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True
>>> any(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
True
>>> any([0, '', False])        # 列表list,元素全为0,'',false
False

 

四、I/0操作类

五、其他

callable(object)检查对象是否可调用

>>>callable(0)
False
>>> callable("runoob")
False
 
>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True

classmethod(func)检查参数否是个类方法

#classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。 
class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

staticmethod(fun)检查这个方法是个静态方法

#python staticmethod 返回函数的静态方法。
#该方法不强制要求传递参数，如下声明一个静态方法：
#class C(object):
#    @staticmethod
#    def f(arg1, arg2, ...):
#        ...
#以上实例声明了静态方法 f，类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 #C().f()。
class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用

dir(object)不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

>>> import sys
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'd', 'i', 'seq', 'sys']

help(object)返回boject的帮助信息

eval(expression)计算表达式expression的值，并返回

>>> eval('1+2')
3

exec(str)将str作为python语句执行

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

execfile(filename)用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。

fiter(func，iterable)构造一个序类，等价于[item for item in iterable if function(item)],function为返回值是True或False的函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法
filter(function, iterable)
参数
    function -- 判断函数。
    iterable -- 可迭代对象。
返回值
返回一个迭代器对象
实例1
list(filter(bool, range(-3, 4)))# 返回[-3, -2, -1, 1, 2, 3], 没有0
实例2
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)

hasattr(object,name)判断对象是否包含名为name的特性

hasattr() 函数用于判断对象是否包含对应的属性。
语法
hasattr(object, name)
参数
    object -- 对象。
    name -- 字符串，属性名。
返回值
如果对象有该属性返回 True，否则返回 False。
实例
以下实例展示了 hasattr 的使用方法：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性

getattr(object, name [, defalut])   # 获取一个类的属性

语法
getattr(object, name[, default])
参数
    object -- 对象。
    name -- 字符串，对象属性。
    default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

>>>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

setattr(object, name, value)        # 设置属性值

语法
setattr(object, name, value)
参数
    object -- 对象。
    name -- 字符串，对象属性。
    value -- 属性值。
返回值
无。
实例
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')          # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5)       # 设置属性 bar 值
>>> a.bar
5

delattr(object, name)               # 删除object对象名为name的属性

语法
delattr(object, name)
参数
    object -- 对象。
    name -- 必须是对象的属性。
class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print('z = ',point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
 
# 触发错误
print('z = ',point1.z)

globals()           # 返回一个描述当前全局符号表的字典

>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}

hash(object)返回对象的hash值

>>> hash('\a')
1091542968102354243

id(object)返回对象的唯一标识，一串数字

>>> a='123'
>>> b='123'
>>> id(a)
140013305352856
>>> id(b)
140013305352856

isinstance(object,classinfo)判断object是否是class的实例

>>> isinstance('a',str)
True
isinstance(1,int)判断1是否是int类型
isinstance(1,(int,float))isinstance第二个参数接受元组类型

issubclass(class,classinfo)判断class是否是classinfo的子类

以下是 issubclass() 方法的语法:
issubclass(class, classinfo)
参数
    class -- 类。
    classinfo -- 类。
class A:
    pass
class B(A):
    pass
print(issubclass(B,A))    # 返回 True

locals()返回当前的变量字典

>>> locals()
{'__doc__': None, 'sys': <module 'sys' (built-in)>, 'seq': [1, 2, 3, 4], 'b': '123', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'd': {}, '__spec__': None, '__name__': '__main__', '__package__': None, 'i': (3, 4), 'a': '123', '__builtins__': <module 'builtins' (built-in)>}

map(function,iterable)遍历每个元素，执行function操作

map(function, iterable, ...)
参数
    function -- 函数
    iterable -- 一个或多个序列
Python 3.x 返回迭代器。
实例
以下实例展示了 map() 的使用方法：
>>>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]

next(iterator,default)类似与iterator.next()

>>> iter([1,2,3])
<list_iterator object at 0x7f5760c82cf8>
>>> a=iter([1,2,3])
>>> next(a)
1
>>> next(a)
2
>>> next(a)
3

property(fget,fset,fdel,doc)属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter

以下是 property() 方法的语法:
class property([fget[, fset[, fdel[, doc]]]])
参数

    fget -- 获取属性值的函数
    fset -- 设置属性值的函数
    fdel -- 删除属性值函数
    doc -- 属性描述信息
返回值
返回新式类属性。
实例
定义一个可控属性值 x
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.")

reduce(function,iterable,initializar)合并操作，从第一个开始是前两个参数，然后是前两个参数的结果和第三个合并进行处理，以此类推

def add(x,y):return x+y

reduce(add,range(1,11))返回55(1+2+3....+10)

reduce(add,range(1,11),20)返回75

reload(module)重新加载模块

import sys
reload(sys)

repr(object)将一个对象变换为可打印的格式,对象转化为供解释器读取的形式。

以下是 repr() 方法的语法:
repr(object)
参数
    object -- 对象。
返回值
返回一个对象的 string 格式。
实例
以下展示了使用 repr() 方法的实例：
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

slice(start,stop,step)产生一个分片对象

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
slice 语法：
class slice(stop)
class slice(start, stop[, step])
参数说明：
    start -- 起始位置
    stop -- 结束位置
    step -- 间距
返回值
返回一个切片对象。
实例
以下实例展示了 slice 的使用方法：
>>>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]

type(object)返回对象的类型

>>> type(1)
<class 'int'>

vars(object)返回对象的变量名、变量值的字典

a=Class();  #class为一个空类

a.name='qi'，a.age=9

vars(a)     #返回{'name':'qi','age':9}

zip(iterable，....)返回对应数组

        list(zip([1, 2, 3], [4, 5, 6])) # [(1, 4), (2, 5), (3, 6)]
        a = [1, 2, 3],  b = ["a", "b", "c"]
        z = zip(a, b)                   # 压缩：[(1, "a"), (2, "b"), (3, "c")]
        zip(*z)                         # 解压缩：[(1, 2, 3), ("a", "b", "c")]

unicode(string,encoding,errors)将字符串string转换为unicode形式，string为encoded string