Python3.5 内置函数大全

喜欢ヅ旅行 2022-06-15 06:19 287阅读 0赞

**上次打算把Python 内置函数全部写出来分享给大家，但是写了一半就没管了，这次我把Python3.5的内置函数全部写出来，不写完不睡觉！**

*  在解释函数时，函数的命名格式中出现的中括号 \[\] 表示 其中的参数是可选的，例如`vars([object ])` ,但这不是我们定义函数时的格式
    
    --------------------
 *  1 **abs(x)** : 求x绝对值,x可以是正数或者浮点数，最简单的函数
    
        abs(-10) ----> 10
 *  2 **dict()**：用以生成字典对象,有三个版本，确切来说dict 是个类，字典是映射类型的对象，以键值对形式存在，键必须唯一
    
        class dict(**kwarg)
        class dict(mapping, **kwarg) ，第一个参数可以使映射类型
        class dict(iterable, **kwarg)，
        例1 dic=dict(a='1',b='2')  dic={'a': '1', 'b': '2'}
        例2 a=[(1,2),(3,4),(5,6),(7,8)] dict(a)---->{1: 2, 3: 4, 5: 6, 7: 8},遵循鸭子类型原则，长得像字典，就可以转化为字典
        例3 遍历 for key, value in dic.items(),这点初学者可能经常忘记
 *  3 **help(obj)**：帮助手册
    
        当对某个函数，对象的某个方法不懂的时候扔给help函数，会返回一些有用的信息
        help(int)
 *  4 **min(iterable, \*\[, key, default \])**
 *  4 **min(arg1, arg2, \*args\[, key \])**：求最小值，类似的有求最大值 max函数
    
    Return the smallest item in an iterable or the smallest of two or more arguments.  
    翻译过来就是：获取序列中的最小值项，或者参数列表中的最小值项  
    例1：a =\[3,2,4,5\] min(a)—->2  
    例2 min(2,3,4,1) —>1
 *  5 **setattr(object, name, value)**：设置属性
    
        set(x,'foo',123)  等同于 x.foo = 123
 *  6 **all(iterable)**：序列的数据项全为真返回真，否则返回假
    
        a = [1,2,3,4] all(a)---->True
        a = [1,2,0,3,4] all(a)---->False 有一个数据项为假即返回假
 *  7 **dir(\[object\])**：返回名称列表
    
        这个函数在交互环境下很有用，可以查看一个对象有多少可用属性，可用方法
        dir(obj)
        不带参数时，交互环境下回列出当前环境里所有名称列表
        对于对象来说，不显示其私有属性
        如果还想获取名称对应的对象，使用不带参数的vars()函数，
        会返回一个name-object 字典
 *  8 **hex(x)**：整数x转十六进制
    
        hex(100) ---> '0x64'
        需要注意的是返回的是字符串，参数需要时整数
 *  9 **next(iterator\[, default \])**：返回迭代器下一个数据项，生成器、迭代器、可迭代对象的解释[戳这里][Link 1]
    
        这里有一篇文章，详细解释的生成器，迭代器，可迭代对象之间的关系 ,请猛戳上面的链接
            1 对于生成器a来说 next(a) 相当于 a.send(None),获取生成器下一个值
 *  10 **slice(stop)**：生成切片对象
 *  10 **slice(start,stop\[,step\])**：生成切片对象, step是可选参数，默认1
    
        a = [1,2,3,4,5,6,7,8,9]
        s = slice(3)
        a[s] --> [1,2,3] 相当于 a[:3] 绕了个圈圈
 *  11 **any(iterable)**：序列的数据项全为假返回假，否则返回真
    
        any([1,2,3,4,0])----> True
        any([0,{},'']) ----> False
 *  12 **divmod(x,y)**：求余求整,可以有两个参数，也可以有三个参数
    
        divmod(10,3) ---> (3,1) 返回一个元组，首元素是整数部分，第二个是余数部分，相当于 a=10,b=3,（a//b, a%b）
        divmod(12.4,3.2) --->(3.0, 2.8) 浮点数也是可以的
        注意：Python2.7 的版本这个函数可以有三个参数
 *  13 **id(object)**：获取一个对象的身份证号，哈哈，可用以判断对象是否相同
    
        a = 10
        id(a) ---> 4297555168
        这个是常用函数，判断对象是否相同，也可以使用 is 运算符判断对象是否相同
        a is b ---> True/False
 *  14 **object()** 无参数，获取object类的一个实例
    
        a = object()
 *  15 **sorted(iterable\[, key\]\[, reverse\])**：对可迭代对象进行排序,返回列表对象
    
        a = [2,3,1,4,5]
        sorted(a) ---> [1, 2, 3, 4, 5]
        默认升序，从小到大
        key 排序的标准，可以是函数
        reverse :是否逆序，默认False
        
        a = [-9,1,-5,3,2,7,12]
        sorted(a,key=abs,reverse=True)：使用绝对值排序，降序
        [12, -9, 7, -5, 3, 2, 1]
 *  16 **ascii(obj)**：类似于repr()函数，返回对象的字符串表示，对于非ascii 字符，会进行转义，没感觉有啥用~~
 *  17 **enumerate(iterable,start=0)**：序列枚举，返回的对象需要转换
    
        默认从首项元素开始
         seasons = ['Spring', 'Summer', 'Fall', 'Winter']
         list(enumerate(seasons))
         [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] 
         list(enumerate(seasons, start=1))
         [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
        
         如果使用for 语句对序列进行遍历，又想获取每个元素下标，可以这么干
             a = [-9,1,-5,3,2,7,12]
            for k,v in enumerate(a):
                     print(k,v)
                0 -9
                1 1
                2 -5
                3 3
                4 2
                5 7
                6 12
 *  18 **input(\[prompt\])**：获取输入函数
    
        num_str = input('请输入一个数字：')
            注意：获取整行输入，按enter键结束输入，返回字符串对象，根据需要进行转换
 *  19 **oct(x)**：转八进制，类似转十六进制，返回字符串
    
        oct(100)----> '0o144'
 *  20 **staticmethod()**：装饰器函数，用以构造静态方法,编写类的时候用的到
 *  21 **bin(x)**：整数生成二进制字符串
    
        bin(100) -----> '0b1100100'
 *  22 **eval(expression, globals=None, locals=None)**：将字符串str当成有效的表达式来求值并返回计算结果。
    
        expression：一个Python表达式字符串
        globals：可选。必须是dictionary
        locals：可选，任意map对象
        栗子：
        eval( 'print("hello")' ) ---- > hello ，注意参数是字符串表达式
        eval('3**2') --->9
 *  23 **int(x,base=10)**:将字符串x转为数值，默认转为十进制,
    
        int( "1000") --> 1000
        int('100', base=8) -->64
        int( '100', base = 2) -->4
        
        oct hex bin ---> 字符串
        int -------> 数值
 *  24 **open()**：打开一个文件
    
        f=open('test.txt','r')
        for line in f:
            print(line)
 *  25 **class str(obj=”)**：将对象转为字符串对象,有时候需要编码字符集
 *  25 **class str(object=b”, encoding=’utf-8’, errors=’strict’)**
    
        str(100)---> '100'
 *  26 **bool(obj)**：测试对象是否为真
    
        bool(1)----> True
        bool({})----> False
 *  27 **exec(object\[, globals\[, locals \] \])**：用来执行Python code 对象，比eval 函数更强大
    
        简单的例子：
        exec('print("hello world")') --->hello world
 *  28 **isinstance(obj,classinfo)**:判断对象是否属与某类型
    
        obj:待检测的对象
        classinfo: 类型，可以是类型组成的元组
        isinstance({},dict) --> True
        
        1判断对象是否可迭代
        from collections.abc import Iterable
        a = [1,2,3,4]
        isinstance(a, Iterable) -->True：可迭代
        isinstance(a,Iterator) --> False :判断迭代器
        结论：可迭代对象不一定是迭代器对象
        b = iter(a)---> 将可迭代对象转化为迭代器对象
        isinstance(b,(Iterable,Iterator))--->True
        
        2 判断对象是否是数值
        from numbers import Number
        a = 10,
        b = 12.3
        isinstance(a,Number) ---> True
        isinstance(b,Number) ---> True
 *  29 **ord(c)**：返回字符的unicode编码
    
        ord('中')-----> 20013
        ord('a')---> 97
        在mac/linux 终端下命令
        $ man ascii 可以调出ascii 码表
 *  30 **sum(iterable\[, start \])**：序列求和，默认从首项开始
    
        a = [1,3,4,5,6]
        sum(a)--->19
        sum(a,10) --->29
 *  31 **class bytearray(\[source\[, encoding\[, errors\]\]\])**：生成可变字节序列
    
        与之相对的有个bytes类，生成不可变字节序列
        str()函数生成 unicode 序列
        
        字节序列中 每个字节值的范围 0 <= x < 256
        
         a = b'hello' 带前缀b 的字符串就是不可变字节序列，注意字符串编码值不能超出 255，即不能出现中文
         type(a) ---> <class 'bytes'>
 *  32 **filter(function, iterable)**：序列过滤器函数
    
        用function函数对iterable序列中每一个数据项进行检查过滤
        例子：求1-10之间的奇数
        a = filter(lambda x: x%2, range(1,11))
        list(a)
        [1, 3, 5, 7, 9]
        
        函数可以在外部定义，也可以使用lambda表达式
 *  33 **issubclass(class, classinfo)**：判断类classA 是否是类classB的后代类
    
        class A(B):
            pass
        class C(A):
            pass
        issubclass(A,B) ---> True
        issubclass(C,B) --->True
 *  34 **pow(x, y\[, z \])**：求幂函数
    
        pow(x,y) 等同于 x ** y
        pow(2,10) ---> 1024
        pow(x,y,x) 等同于( x ** y) % z
        pow(2,10,3) -->1
 *  35 **super(\[type\[, object-or-type \] \])**：调用父类方法时使用的函数
    
        class C(B):
            def method(self, arg):
                    super().method(arg)   #  super(C, self).method(arg)
 *  36 **class bytes(\[source\[, encoding\[, errors\]\]\])**：不可变字节序列，参考可变字节序列
 *  38 **float(\[x\])**：对象x转为浮点数,x可以是数值也可以是字符串
    
        float(10) ---> 10.0
        float('10') ---> 10.0
 *  39 **iter(object\[, sentinel \])**：生成迭代器对象 参考next 函数
 *  40 **print(\*objects, sep=”,end=’\\n’, file=sys.stdout, flush=False)**：输出函数
    
        print(a, b, c) ---> 一次性输出多个值
         print(*obj,sep='-----') 输出多个值中间使用的区分字符串
         print(2,1,3,sep='----') ---> 2----1----3
         print(2,1,3,sep='----',end = '') 不换行，默认换行
         给file 参数指定一个文件对象参数，可将内容写入文件
         f = open('abc.txt', 'w')
         print('hello world',file=f)
 *  41 **tuple(\[iterable \])**：生成元组对象
    
        使用可迭代序列生成元组
        不带参数生成空元组 ()
        tuple([1,2,3,4]) ---> (1,2,3,4)
 *  42 **callable(object)**：判断对象是否可调用
    
        如果定义类的时候实现了 __call__ 函数，可以向调用函数一样调用对象，则callable(obj) ---->True
        
        def __call__(self, *args, **kwargs):
                print('****')
        a = A()
        a() ----> '****'
 *  43 **format(value\[, format\_spec \])** 将值value 转换为format\_spec格式，还没仔细研究过
 *  44 **len(s)**：检测序列s的长度（元素个数）
    
        len('hello美女') ------> 7
 *  45 **property(fget=None, fset=None, fdel=None, doc=None)**：属性
    
        上例子：
        class C:
            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.")
         c = C()
         c.x =10 触发setx方法
         c.x 触发getx方法
         del c.x 触发delx 方法
         另一种写法，使用装饰器写法：
        
        class C:
            def __init__(self):
            self._x = None 
        
            @property
            def x(self):
            """I'm the 'x' property.""" 
                return self._x
        
            @x.setter
            def x(self, value):
                self._x = value
        
            @x.deleter 
            def x(self):
                del self._x
 *  46 **class type(object)**检测对象类型
    
        type(10) ---> <class 'int'>
 *  46 **class type(name, bases, dict)**：创建类 [参考这里][Link 2]
    
        关于元类这里就不解释了
 *  47 chr(i)：根据字符编码值 返回字符
    
        ord('中') ---> 20013
        chr(20013) ---> '中'
 *  48 **frozenset(\[iterable \])**：生成不可变集合
    
        不可变集合拥有集合的很多特点，如：元素不会重复等
 *  49 **list(\[iterable \])**：生成列表对象，这个不解释
 *  50 **range(stop)** ：生成范围对象
 *  50 **range(start, stop\[, step \])**
    
        在2.7 版本中
            range(10) ---> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
            在3.5 版本中
            range(10) ---> range(0, 10) 
            注意：生成的不再是列表
            start :起点
            stop:上限终点 不会超过
            step :步长
            倒序
            list(range(10,0,-1)) --->[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
 *  51 **vars(\[object \])**：返回模块 类 实例对象 或者其他对象的`__dict__` 属性
    
        class A:
            def __init__(self):
                self.name = 'wzz'
        
            def sayHello(self):
                print("滚")
        
        a = A()
        print(vars(a)) ----> {'name': 'wzz'}
        
        在交互环境下，使用
        vars() ，不带参数，可获取当前环境所有 name - object 组成的字典
 *  52 **classmethod(function)**：装饰器函数，生成类方法
    
        class C: 
            @classmethod
            def f(cls, arg1, arg2, ...): ...
        类方法 实例和类都可调用，真是蛋疼，其他语言不是这样的，会的Objectie-C 同学注意了！
 *  53 **getattr(object, name\[, default \])**：获取对象的某个属性
    
        name 必须是字符串
        假设对象 a.age = 10
        getattr(a,'age' )---> 10
        假设对象a 没有 gender 属性
        getattr(a, 'gender', 'man') --> man
 *  54 **locals()**：返回局部name-object字典
    
        在交互环境下试试就知道啦~
 *  55 **repr(obj)**：返回机器友好字符串
    
        repr(a) ---> '<__main__.A object at 0x102a68d68>'
        可以通过重写 __repr__ 函数 改变返回值
 *  56 **zip(\*iterables)**：序列压缩重组函数
    
        序列长度不同
        zip('ABCD', 'xy') --> Ax By
        x = [1,2,3]
        y = [3,4,5]
        z = [5,6,7]
        rs = zip(x,y,z) 
        list(rs) ---> [(1,3,5),(2,4,6),(3,5,7)]
        for i,j,k in rs:
            print(i,j,k)
        
        1 3 5
        2 4 6
        3 5 7
 *  57 **compile(source, filename, mode, flags=0, dont\_inherit=False, optimize=-1)**：
    
        这个函数。。。太厉害，不想研究它
 *  58 **globals()**：返回全局name-object字典
    
        在终端敲一下就懂啦~
 *  59 **map(function,iterable,…)**：映射函数，这个函数使用广泛
    
        a = map(lambda x:x**2, range(100))
        <map object at 0x102268cf8> 返回的是map 对象
        第一个参数可以是个函数，也可以是lambda 表达式，函数或者lambda表达式的参数个数，取决于有多少个可迭代对象
 *  60 **reversed(seq)**：翻转函数,将序列倒序
    
        a = [2,3,4,1,4,5] 
        reversed(a)-----> list_reverseiterator object at 0x102268cc0>
        list(reversed(a))---->[5,4,1,4,3,2]
        返回的并不是原来的序列，会生成新的对象，根据需要转换
 *  61`__import__()` 基本用不到
    
        当我们使用import 导入模块时，会触发该函数
 *  62 **complex(\[real\[,imag\]\])**：生成复数对象
    
        complex(2,3) ----> 2+3j
 *  63 **hasattr(obj,name)**：判断对象是否有某个属性
    
        x.foo = 123
        hasattr(x,foo)  --> True
 *  64 **max()**：获取序列中最大值元素，请参考min的用法
 *  65 **round(number\[, ndigits \])**：对浮点数number进行近似取值，保留ndigits位小数
    
        规则：如果距离两边一样远，会保留到偶数的一边。比如round(0.5)和round(-0.5)都会保留到0，而round(1.5)会保留到2
        round(1.3) ---> 1
        round(1000.2545,3)----->1000.255
 *  66 delattr()：删除对象的属性
    
        delattr(obj, attrname)
        obj :对象
        attrname: 对象属性名称
        删除之后再去访问，会报错
 *  67 hash():生成对象的哈希值，对象必须不可变
    
        a = (1,2,3)
        hash(a) --->2528502973977326415
 *  68 **memoryview(obj)**： 返回一个对象的memory view 对象
    
        相当于内存快照
 *  69 set(iterable) :将可迭代对象生成集合对象
    
        a = set() 生成空集合的方法
        a = {}   a 是空字典 需要注意的地方
        集合特点：集合中不会有相同的数据项，因此常用来去重，但要注意，去重后元素的相对位置可能发生变化
        a = [1,2,3,1,2,4,5,7,9,0]
        b = set(a) b---> {0, 1, 2, 3, 4, 5, 7, 9}
        如果需要保持相对位置不变，需要自己实现一个函数来完成相应功能

[Link 1]: http://www.open-open.com/lib/view/open1463668934647.html
[Link 2]: http://blog.jobbole.com/21351/