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

            class test_class(object): 

              def func(self):

                  print('welcome')

               def test(self):

                    print('hello')

            real_class = test_class()

           print(hasattr(real_class,'func'))

--------      

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

            Traceback (most recent call last):

              File "<stdin>", line 1, in <module>

            StopIteration

    

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

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

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

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

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

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

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

            >>> new_value

            <map object at 0x7f53f6838a58>

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

                <excise.test_class object at 0x000000000162FCF8>

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

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

            <list_reverseiterator object at 0x7f53f6838a20>

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

__import__()

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