Python3.5 内置函数大全

时间:2021-12-08 02:40:42

上次打算把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 ]):返回迭代器下一个数据项,生成器、迭代器、可迭代对象的解释戳这里

        这里有一篇文章,详细解释的生成器,迭代器,可迭代对象之间的关系 ,请猛戳上面的链接
    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):创建类 参考这里

    关于元类这里就不解释了
  • 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}
    如果需要保持相对位置不变,需要自己实现一个函数来完成相应功能