python 内置函数

python 内置函数

    Python内置(built-in)函数随着python解释器的运行而创建。在Python的程序中，你

可以随时调用这些函数，不需要定义。

 

abs()     # 求一个数的绝对值；abs(-1)=1

all()     # 接受一个序列，判断 如果所有的值都是真的 就返回真 否则返回假

any()     # 接受一个序列，判断 如果其中有一个值是真的 就返回真 没有任何真值返回假

             >>>li=['asd','','14']

             >>>all(li)       False

             >>>any(li)       True

ascii()   # 这个函数跟repr()函数一样，返回一个可打印的对象字符串方式表示。当遇到非ASCII码时，

              就会输出\x，\u或\U等字符来表示

            >>> print(ascii('ax\123'))      'axS'

            >>> print(ascii('0\123'))       '0S'

            >>> print(ascii('0123'))        '0123'

            >>> print(ascii('01\23'))       '01\x13'

bin()      # 返回一个字符串，表示数值的二进制数 例：>>> bin(21) '0b10101'

bool()     # 判断值的真假，真返回True 假返回False

bytearray()  # 返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

                如果source是一个字符串，那么必须给出endcoding是什么样编码的，以便转换为合适的字节保存；

                如果source是一个整数，那么这个数组将初始化为空字节；

                如果source是一个有缓冲区接口的对象，那么只读的接口初始到数组里；

                如果source是一个迭代对象，那么这个迭代对象的元素都必须符合0 <= x < 256，

                            以便可以初始化到数组里;

                如果没有输入任何参数，默认就是初始化数组为0个元素.例：                

                >>> bytearray('北京','utf-8')

                bytearray(b'\xe5\x8c\x97\xe4\xba\xac')

                >>> bytearray('abc123','utf-8')

                bytearray(b'abc123')

                >>> bytearray('123','utf-8')

                bytearray(b'123')

                >>> bytearray()

                bytearray(b'')

                >>> bytearray([1,2,3,4])

                bytearray(b'\x01\x02\x03\x04')      

bytes()     # bytes函数与bytearray函数主要区别是bytes函数产生的对象的元素不能修改，

              而bytearray函数产生的对象的元素可以修改。因此，除了可修改的对象函数

              跟bytearray函数不一样之外，其它使用方法全部是相同的。

callable()  # 判断程序是否可执行

chr()       # 将数值转换成字符 例：>>> chr(21)  '\x15'

classmethod() 

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

                        如果 x == y 返回 0, 如果 x > y 返回 1。

compile()   # 编译字符串称为code对象 例：

             >>> test1 = compile("print(123)",'test.py','exec')

             >>> exec(test1)       123

             >>> eval(test1)       123

complex()   # >>> complex(2,3)  (2+3j) 返回复数

dict()      # 定义一个字典数据结构>>>dict(a=1,b=2,c=[1,2]) {'c': [1, 2], 'a': 1, 'b': 2} 

dir()       # 返回一个类所具有的方法

divmod()    # 返回除法结果和余数

enumerate() # enumerate([]，执行数字起始值)

            li=[11,22,33,44,55,66]

            for k,v in enumerate(li,1):

                print k,v

eval()      # 解释字符串表达方式>>> eval("21+1") 22，参数也可以是compile()返回的code对象；

exec()      # 解释并执行字符串，>>> exec("print(123)")  123 .参数也可以是compile（）

                返回的code对象；

filter()    # 通过定义的函数和数值筛选符合条件的值 例：

            >>> def func(x):

            ...     if x>22:

            ...             return True

            ...     else: return False

            ... 

            >>> test = [11,22,33,44]

            >>> res = filter(func,test)

            >>> list(res)

            [33, 44]

float()     # 转换为浮点数float(5) 

format()    # 

frozenset() # 定义一个不可变集合            

            >>> test = frozenset('abc123')

            >>> test

            frozenset({'3', 'b', 'a', '1', '2', 'c'})

            >>> test1 = set('abc123')

            >>> test1

            {'3', 'b', 'a', '1', '2', 'c'}    

globals()   # 返回全局变量及值的全部信息

hasattr()   # 类实例化后可通过hasattr() 来检验是否继承类中方法，是返回True 否则False 例：

getattr()   # getattr(real_class,'func') 返回func的属性；

setattr()   # setattr(real_class,'func'，new_func) 将func的属性设置为new_func；

delattr()   # delattr(real_class,'func')  删除func的属性；

isinstance()# isinstance(real_class,test_class) 判断real_class对象是否为test_class                                                       生成的对象，返回bool值；

issubclass()# issubclass(test_class，object) 判断test_class 的类是否为object类的子类，

                                             返回bool值；

hash()      #

help()      # help(list) 返回类的帮助文档信息； 

hex()       # 返回一个字符串，表示21的十六进制数 例：>>> hex(21)  '0x15'

id()        # 返回值的内存地址信息；

input()     # 从终端输入信息，默认返回的均为字符串；

int()       # 返回初始定义的int整数数据类型；

iter()      # iter迭代一个对象并返回一个迭代器，迭代穷尽则返回stopiteration 例：

            >>> test = iter(('a','b','c',1,2))

            >>> print(next(test))      a

            >>> print(next(test))      b

            >>> print(next(test))      c

            >>> print(next(test))      1

            >>> print(next(test))      2

            >>> print(next(test))

            ...

            StopIteration

len()       # 返回一个对象的长度；

list()      # 初始定义列表数据类型；

locals()    # 返回局部变量及值的全部信息；

long()      # 转换为长整数数据类型 long('21')；

map()       # 对应值映射，统一经过一个程序后输出结果，例：

            >>> tu = (11,22,33,44)

            >>> new_value = map(lambda x:x+1,tu)

            >>> new_value

            

            >>> test = list(new_value)

            >>> test

            [12, 23, 34, 45]

max()       # 求最大值max（[1,2,3,4]）

memoryview()

min()       # 求最小值min([1,2,3,4])

next()      # 迭代器中使用选择下一元素 与iter（） 同用

object()

oct()       # 返回一个字符串，表示数值的八进制数，例：>>> oct(21)  '0o25'

open()      # 打开文件操作

ord()       # 将字符传换成相应的数值，与chr（）同用  例 ：>>> ord('\x15') 21

pow()       # 幂运算 pow(2**3)

print()     # 打印输出到终端

properity()

range()

reduce()

reload()    # 重新载入模块及文件操作

repr()      # 返回对象的属性并以字符串的形式展示，repr(real_class)

                

reversed()  # 按照给定的列表顺序倒叙排出 例：

            >>> reversed([1,6,3])

            

            >>> test = reversed([1,6,3])

            >>> test_list = list(test)

            >>> test_list

            [3, 6, 1]

round()     # 求一个数的四舍五入法

set()       # 初始一个集合类型

slice()

sorted()    # >>> sorted([1,6,3])  [1, 3, 6] 按数据从小到大排序

staticmethod()

str()       #  转换为字符串类型

super()     #  

sum()

    ----------------------

    在给sum函数中加入参数。sum（a，axis=0）或者是.sum(axis=1) 就有点不解了

    

    在我实验以后发现 我们平时用的sum应该是默认的axis=0 就是普通的相加 

    

    而当加入axis=1以后就是将一个矩阵的每一行向量相加

    

    例如：import numpy as np

    np.sum([[0,1,2],[2,1,3],axis=1)的结果就是：array（[3,6]）

    -----------------------

tuple()    # 初始一个元祖数据类型

type()     # 返回一个数据类型

vars()     # 返回属性值

zip()      

    --------------------------更新中 -----------------------------