Python内置函数介绍

Python/C API：https://docs.python.org/2/

内置函数：

abs(number)  #返回值是一个数字的绝对值，如果是复数，返回值是复数的模

abs(-1.2) #返回 1.2
abs(1.2) #返回 1.2
abs(-1-1j) #返回 1.41421356237

　　

all(iterable)  #所有的值为真时才为真，只要有一个是假就是假

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

　　

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

any(iterable)  #只要有一个为真就是真

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

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

apply(p_object, args=None, kwargs=None)  

# 用于当函数参数已经存在于一个元组或字典中时，间接地调用函数。args是一个包含将要提供给函数的按位置传递的参数的元组。如果省略了args，任何参数都不会被传递，kwargs是一个包含关键字参数的字典。

# 没有带参数
def say():
    print 'say in'
apply(say)
# 只带元组的参数  
def say(a, b):
    print a, b
apply(say,("hello", "张三python"))  # function(object， *args)
# 带关键字参数
def say(a=1,b=2):
    print a,b
def haha(**kw):
    apply(say,(),kw)   # function(object, (), **keywords)
print haha(a='a',b='b')

# apply()的返回值就是func()的返回值，apply()的元素参数是有序的，元素的顺序必须和func()形式参数的顺序一致

bin(number)  #将整数x转换为二进制字符串，如果x不为Python中int类型，x必须包含方法__index__()并且返回值为integer

#整数的情况， 前面多了0b，这是表示二进制的意思。
bin(521)
'0b1000001001'
#非整型的情况，必须包含__index__()方法切返回值为integer的类型
class Type:
    def __index__(self):
        return 8
testbin = Type()
print bin(testbin)
'0b1000'

callable(p_object)  #检查对象object是否可调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

>>> class A:
    def add(a, b):
        return a + b
>>> callable(A)
True
>>> a = A()
>>> callable(a)
False
>>> class B:
    def __call__(self):
        return 0
>>> callable(B)
True
>>> b = B()
>>> callable(b)  #类是可调用的，而类的实例实现了__call__()方法才可调用
True

chr(i)  # 返回整数i对应的ASCII字符，i取值范围[0, 255]之间的正数

>>> chr(27)
'\x1b'
>>> chr(97)
'a'
>>> chr(98)
'b'

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

>>> cmp(80, 100)
-1
>>> cmp(180, 100)
1
>>> cmp(-80, 100)
-1
>>> cmp(80, -100)
1
>>> cmp(80, 80)
0

coerce(x, y)  # 如果有一个操作数是复数， 另一个操作数被转换为复数；否则，如果有一个操作数是浮点数， 另一个操作数被转换为浮点数；否则, 如果有一个操作数是长整数，则另一个操作数被转换为长整数；否则，两者必然都是普通整数，无须类型转换

>>> coerce(1, 2) 
(1, 2) 
>>> 
>>> coerce(1.3, 134L) 
(1.3, 134.0) 
>>> 
>>> coerce(1, 134L) 
(1L, 134L) 
>>> 
>>> coerce(1j, 134L) 
(1j, (134+0j)) 
>>> 
>>> coerce(1.23-41j, 134
((1.23-41j), (134+0j))

compile(source, filename, mode, flags=None, dont_inherit=None)  # 将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()或者single进行求值。

>>> code = "for i in range(0, 10): print i"
>>> cmpcode = compile(code, '', 'exec')
>>> exec cmpcode

>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17

copyright(*args, **kwargs)  # 用于打印许可文本的交互式提示对象，投稿人及版权声明

>>> copyright()  

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

>>> class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

        
>>> p = Person("canon", 25)
>>> dir(p)
['__doc__', '__init__', '__module__', 'age', 'name']
>>> delattr(p, "age")
>>> dir(p)
['__doc__', '__init__', '__module__', 'name']

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

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['Struct', '__builtins__', '__doc__', '__file__', '__name__',
 '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape(object):
        def __dir__(self):
            return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

divmod(x, y)  #  返回的是a//b（除法取整）以及a对b的余数，返回结果类型为tuple

>>> divmod(9,2)
(4, 1)
>>> divmod(11,3)
(3, 2)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

 eval(source, globals=None, locals=None)  #将字符串str当成有效的表达式来求值并返回计算结果

>>> a = '1*2+3'
>>> b =eval(a)
>>> print b
5
>>> a = "{1: 'a', 2: 'b'}"
>>> b = eval(a)
>>> b = eval(a)
>>> print b
{1: 'a', 2: 'b'}

execfile(filename, globals=None, locals=None) #  用来执行一个文件

>>> execfile('test1.py')

exit(*args, **kwargs)  # builtin.exit 是一个 Quitter 对象，这个对象的 call 方法会抛出一个 SystemExit 异常

>>> exit(0) #无错误退出 
>>> exit(1) #有错误退出
>>> exit()   #退出代码是告诉解释器的（或操作系统）

filter(function_or_none, sequence)  #该函数根据function参数返回的结果是否为真来过滤list参数中的项，最后返回一个新列表

>>>a=[1,2,3,4,5,6,7]
>>>b=filter(lambda x:x>5, a)
>>>print b
[6,7]
>>>a=[0,1,2,3,4,5,6,7]  #filter参数值为None，就使用identity（）函数，list参数中所有为假的元素都将被删除
>>>b=filter(None, a)
>>>print b
[1,2,3,4,5,6,7]

format(value, format_spec=None)  #格式化字符串

>>>　'{:,}'.format(1234567890)　＃千位分割
1,234,567,890
>>>　'{:b}'.format(17)　＃b、d、o、x分别是二进制、十进制、八进制、十六进制, 2f是百分位的小数 
'10001'
>>>　class Person:  
            def __init__(self,name,age):  
                self.name,self.age = name,age  
            def __str__(self):  
                return 'This guy is {self.name},is {self.age}　old'.format(self=self) 
>>>　str(Person('cjn',18)) 
'This guy is kzc,is 18 old'  

getattr(object, name, default=None)  # 获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址，如果需要运行这个方法，可以在后面添加一对括号

>>> func = getattr(obj, "method") # 与result = obj.method(args)相同
>>> result = func(args)
>>> result = getattr(obj, "method")(args)

>>> class test():
            name="cjn"
            def run(self):
                return "HelloWord"
>>> t=test()
>>> getattr(t, "name") #获取name属性，存在就打印出来。
'cjn'
>>> getattr(t, "run") #获取run方法，存在就打印出方法的内存地址。
<bound method test.run of <__main__.test instance at 0x0269C878>>
>>> getattr(t, "run")() #获取run方法，后面加括号可以将这个方法运行。
'HelloWord'
>>> getattr(t, "age") #获取一个不存在的属性。
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: test instance has no attribute 'age'
>>> getattr(t, "age","18") #若属性不存在，返回一个默认值。
'18'    

globals()  #在当前作用域下，查看全局变量；返回基于字典的访问全局变量的方式

>>> b = 'cjn'
>>> print globals()
{'b': 'cjn', '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:/PyCharm/PycharmProjects/test/test.py', '__package__': None, '__name__': '__main__', 'foo': <function foo at 0x0000000002EF6CF8>, '__doc__': None}

hasattr(p_object, name)  #判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False

>>> class test():
            name="cjn"
             def run(self):
                   return "HelloWord"
 >>> t=test()
 >>> hasattr(t, "name") #判断对象有name属性
 True
 >>> hasattr(t, "run")  #判断对象有run方法
 True    

hash(p_object)  # 返回的哈希值是使用一个整数表示，通常使用在字典里，以便实现快速查询键值,参数为数字类型

>>> print(hash('abc'))
-1600925533
>>> print(hash(2.0))
2
>>> print(hash(2))
2

help(with_a_twist)  #查看函数或模块用途的详细说明

>>> help(len)
Help on built-in function len in module __builtin__:

len(...)
    len(object) -> integer
    
    Return the number of items of a sequence or collection.

hex(number)  # 整数转换为十六进制的字符串

>>> hex(10)
'0xa'
>>> hex(100)
'0x64'

id(p_object)  # 获得对象的内存地址，如果两个对象的内存地址是一样的，那么这两个对象肯定是一个对象

>>> class test:
    def test():
        print test    
>>> a = test()
>>> id(a)
52681032L

input(prompt=None)  # 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用双引号将它括起来，否则它会引发一个 SyntaxError

>>> input_A = input("Input: ")
>>> Input: "abc"   # 输入abc时，需要加上括号

intern(string)  # 值相同的字符串对象只会保存一份，是共用的

>>> a = intern('abc')
>>> b = intern('abc')
>>> print id(a)
38508424
>>> print id(b)
38508424

isinstance(p_object, class_or_type_or_tuple)  # 判断一个对象是否是一个已知的类型；若object为对象，判断实例是否是这个类或者对象，若object为变量，判断变量是否是这个类型

>>> class objA:   
    pass
>>> A = objA()
>>> B = 'a','v'
>>> C = 'a string'
>>> lst = [1,2,3,4]
>>> print isinstance(A, objA)
True
>>> print isinstance(B, tuple)
True
>>> print isinstance(C, basestring)
True
>>> isinstance(lst, list)
True
>>> isinstance(lst, (int, str, list) )
True

issubclass(C, B)  # 判断类参数C是否是类型参数B的子类

>>> class Line:  
            pass  
>>> class RedLine(Line):  
            pass    
>>> class Rect:  
            pass      
>>> print(issubclass(RedLine, Line))  
True
>>> print(issubclass(Rect, Line))  
False

iter(source, sentinel=None)  # 迭代器为类序列对象提供了一个类序列的接口, 而且它还允许程序员迭代非序列类型，包括用户定义的对象、字典的键、一个文件的行等

i = iter('abcd')
for k in i:
    print k

s = {'one':1,'two':2,'three':3}
m = iter(s)
for k in m:
    print k

len(p_object)  # 返回字符串长度

>>> s = {'one':1,'two':2,'three':3}
>>> print len(s)
3
>>> a = '12345789'
>>> print len(a)
8

license(*args, **kwargs)  

>>> license()

locals()  # 返回基于字典的访问局部变量的方式

>>> def foo(arg, a):  
            x = 1  
            y = 'xxxxxx'  
            for i in range(10):  
                j = 1  
                k = i  
                print locals()  
>>> foo(1,2)  
{'a': 2, 'i': 9, 'k': 9, 'j': 1, 'arg': 1, 'y': 'xxxxxx', 'x': 1}                  

map(function, sequence, *sequence_1)  # 第一个参数接收一个函数名，第二个参数接收一个可迭代对象；接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回

ls = [1,2,3]
rs = map(str, ls)
print rs      #打印结果 ['1', '2', '3']

lt = [1, 2, 3, 4, 5, 6]
def add(num):
    return num + 1
rs = map(add, lt)
print rs     #打印结果 [2,3,4,5,6,7]

max(*args, **kwargs)  # 返回给定参数的最大值，参数可以为序列

print "max(80, 100, 1000) : ", max(80, 100, 1000)
print "max(-20, 100, 400) : ", max(-20, 100, 400)
print "max(-80, -20, -10) : ", max(-80, -20, -10)
print "max(0, 100, -400) : ", max(0, 100, -400)

min(*args, **kwargs)  # 返回给定参数的最小值，参数可以为序列

print "min(80, 100, 1000) : ", min(80, 100, 1000)
print "min(-20, 100, 400) : ", min(-20, 100, 400)
print "min(-80, -20, -10) : ", min(-80, -20, -10)
print "min(0, 100, -400) : ", min(0, 100, -400)

next(iterator, default=None)  # 用在一个循环中，当一个文件被作为一个迭代器通常使用的next（）方法被调用多次.此方法返回下一个输入行，或引发StopIteration异常的EOF被击中时

fo = open("foo.txt", "r")
print "Name of the file: ", fo.name

for index in range(5):
   line = fo.next()  
   print "Line No %d - %s" % (index, line)  

fo.close()

oct(number)  # 一个整数转换成8进制字符串。如果传入浮点数或者字符串均会报错

>>> a = oct(10)
>>> a
'0o12'

# 如果传入参数不是整数，则其必须是一个定义了__index__并返回整数函数的类的实例对象
# 定义了__index__函数，而且返回值是int类型，能转换
>>> class Student:
  def __init__(self,name,age):
    self.name = name
    self.age = age
  def __index__(self):
    return self.age

>>> a = Student('Kim',10)
>>> oct(a)
'0o12'

open(name, mode=None, buffering=None)   # 打开文件

#open(路径+文件名,读写模式)
f=open('/tmp/hello.txt','w')

#读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式
如:'rb','wb','r+b'等等

读写模式的类型有：
rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w     以写方式打开，
a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+     以读写模式打开
w+     以读写模式打开 (参见 w )
a+     以读写模式打开 (参见 a )
rb     以二进制读模式打开
wb     以二进制写模式打开 (参见 w )
ab     以二进制追加模式打开 (参见 a )
rb+    以二进制读写模式打开 (参见 r+ )
wb+    以二进制读写模式打开 (参见 w+ )
ab+    以二进制读写模式打开 (参见 a+ )

ord(c)  # 以一个字符（长度为1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的Unicode字符超出了你的Python定义范围，则会引发一个TypeError的异常

>>> ord('a')
97
>>> ord(u'\ufffff')
Traceback (most recent call last):
   File "<stdin>", line 1, in ?
     ord(u'\ufffff')
TypeError: ord() expected a character, but string of length 2 found
>>> ord(u'\u2345')
9029

pow(x, y, z=None)  # 返回 x^y（x的y次方） 的值。

>>> pow(100, 2)
10000

print(*args, **kwargs)  # 打印相应的信息

>>> a = '123456'
>>> print a
123456

quit(*args, **kwargs)  # 退出程序

a = input("input quit to quit:")
    if a.upper() == 'QUIT':
       quit()
    else:
       print 'continue'
       pass

range(start=None, stop=None, step=None)  # 输出一个顺序的list

>>> range(1,5) #代表从1到5(不包含5)
[1, 2, 3, 4]
>>> range(1,5,2) #代表从1到5，间隔2(不包含5)
[1, 3]
>>> range(5) #代表从0到5(不包含5)
[0, 1, 2, 3, 4]

raw_input(prompt=None)  # 能接收 字符串 ，raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）

>>> raw_input_A = raw_input("raw_input: ")
>>> raw_input: abc

reduce(function, sequence, initial=None)  # reduce内建函数是一个二元操作函数，他用来将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 func()（必须是一个二元操作函数）先对集合中的第1，2个数据进行操作，得到的结果再与第三个数据用func()函数运算，最后得到一个结果

# 第一种方式：
def myadd(x,y):  
        return x+y  
sum=reduce(myadd,(1,2,3,4,5,6,7))  
print sum  
# 第二种方式
sum=reduce(lambda x,y:x+y,(1,2,3,4,5,6,7))  
print sum

reload(module)  # 对已经加载的模块进行重新加载，一般用于原模块有变化等特殊情况，reload前该模块必须已经import过

import os
reload(os)
# reload会重新加载已加载的模块，但原来已经使用的实例还是会使用旧的模块，而新生产的实例会使用新的模块；reload后还是用原来的内存地址；不能支持from。。import。。格式的模块进行重新加载。

repr(p_object)  # 将任意值转为字符串；转化为供解释器读取的形式

>>> obj='I love Python'
>>> obj==eval(repr(obj))
True

round(number, ndigits=None)  # 返回浮点数x的四舍五入值

print round(80.23456, 2)
print round(100.000056, 3)
print round(-100.000056, 3)

setattr(p_object, name, value)  # 给对象的属性赋值，若属性不存在，先创建再赋值

>>> class test():
            name="cjn"
            def run(self):
                  return "HelloWord"
>>> t=test()
>>> hasattr(t, "age")   #判断属性是否存在
False
>>> setattr(t, "age", "18")   #为属相赋值，并没有返回值
>>> hasattr(t, "age")    #属性存在了
True

sorted(iterable, cmp=None, key=None, reverse=False)  # 对List、Dict进行排序；reverse=False默认是逆序，True为正序

cmp参数

cmp接受一个函数，拿整形举例，形式为：

def f(a,b):

　　 return a-b

如果排序的元素是其他类型的，如果a逻辑小于b，函数返回负数；a逻辑等于b，函数返回0；a逻辑大于b，函数返回正数

# 对数组进行排序
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),] 
>>> sorted(students, key=lambda student : student[2])   
#按年龄进行排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]  

# 对字典进行排序
>>> from operator import itemgetter, attrgetter 
>>> d = {'data1':3, 'data2':1, 'data3':2, 'data4':4}  
>>> sorted(d.iteritems(), key=itemgetter(1), reverse=True)  
[('data4', 4), ('data1', 3), ('data3', 2), ('data2', 1)]  

sum(sequence, start=None)  # 求和函数

>>> sum([1,2,3])
6
>>> sum(range(1,11))
55
>>> a = range(1,11)
>>> b = range(1,10)
>>> c =  sum([item for item in a if item in b])
>>> print c
45

unichr(i)  # 用一个范围的整数作参数，返回一个对应的Unicode字符；如果是配置为USC2的Unicode，那么它的允许范围就是range（65536）或0x0000-0xFFFF；如果配置为UCS4，那么这个值应该是range（1114112）或0x000000-0x110000。如果提供的参数不在允许的范围内，则会报一个ValueError的异常

>>> unichr(20013)
u'\u4e2d'
>>> print unichr(20013)
中

vars(p_object=None)  # 实现返回对象object的属性和属性值的字典对象

>>> print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Foo:  
    a = 1    
>>> print(vars(Foo))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> foo = Foo()
>>> print(vars(foo))
{}

zip(seq1, seq2, *more_seqs)  # 接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = zip(x, y, z)
print xyz
# 运行的结果是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
# zip(*xyz) 等价于 zip(x, y, z)

x = [1, 2, 3]
r = zip(* [x] * 3)
print r
# 运行的结果是：[(1, 1, 1), (2, 2, 2), (3, 3, 3)]

__import__(name, globals={}, locals={}, fromlist=[], level=-1)  # 只接收字符串作为参数；import语句就是调用这个函数进行导入工作的，import sys <==>sys = __import__('sys')

# 通过字符串来动态导入模块
__import__('os',globals(),locals(),['path','pip']) # 等价于from os import path, pip

'''
通过字符串动态重新加载模块；试试reload('os')直接报错，虽然不能直接reload但是可以先unimport一个模块，然后再__import__来重新加载模块。
在Python解释里可以通过globals(),locals(),vars(),dir()等函数查看到当前环境下加载的模块及其位置，但是这些都只能看不能删除，所以无法unimport；
不过除此之外还有一个地方是专门存放模块的，这就是sys.modules，通过sys.modules可以查看所有的已加载并且成功的模块，而且比globals要多，说明默认会加载一些额外的模块
'''
import sys  
__import__('a')      #第一次导入会打印消息  
del sys.modules['a']   #unimport  
__import__('a')    #再次导入还是会打印消息，因为已经unimport一次了  
__import__('a')    #这次就不会打印消息了