Python内置函数.md

Python3 内置函数

abs(x)

返回一个数的绝对值。参数可以是一个整数或者一个浮点数。如果参数是一个复数，那么将返回它的模。

>>> abs(-123456)
123456
>>> abs(123456)
123456

all(iterable)

当 iterable 中所有元素都为 True 时（或者 iterable 为空），返回 True 。相当于：

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

举例:

>>> all([0,1,""])
False
>>> all([None,2,3])
False
>>> all([0,3])
False
>>> all([1,3])
True
>>> all([])
True

假的参数有：False、0、None、""、[]、()、{}等，查看一个元素是否为假可以使用bool进行查看。

any(iterable)

当 iterable 中有元素为 True 时，则返回 True 。如果当 iterable 为空时，返回 False 。相当于：

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

举例：

>>> any([0,1,3])
True
>>> any([{},(),0])
False

ascii(object)

就像函数 repr() ， 返回一个输入对象的可打印的字符串，但是在返回字符串中去掉非 ASCII 编码的字符，而这些字符在 repr() 生成的字符串中利用编码加 \x ， \u 或 \U 前缀来表示。这个函数所生成的字符串与 Python2 中的 repr() 函数类似。

bin(x)

将一个整数转化为一个二进制字符串。结果是一个可用的 Python 表达式。

举例

返回一个整数的二进制：

>>> bin(100)
‘0b1100100‘

如果 x 不是 Python 中的 int 类型，那么需要定义 __index__() 方法使之返回一个整数。

 >>> class myType:
 ...   def __index__(self):
 ...       return 35
 ...
 >>> myvar = myType()
 >>> bin(myvar)
‘0b100011‘

bool([x])

将一个值转换为布尔类型，使用标准的真值判断过程。如果 x 为假或者不存在，将返回 False ；否则则返回 True 。 bool 同样是一个类，是 int 的子类， bool 类不能作为其他子类。它仅有的实例是 False 和 True 。

>>> bool([])
False
>>> bool({})
False
>>> bool(0)
False
>>> bool(2)
True

bytearry([source[,encoding[,errors]]])

bytearray([source [, encoding [, errors]]])返回一个byte数组。Bytearray类型是一个可变的序列，并且序列中的元素的取值范围为 [0 ,255]。

source参数：

  • 如果source为整数，则返回一个长度为source的初始化数组；
  • 如果source为字符串，则按照指定的encoding将字符串转换为字节序列；
  • 如果source为可迭代类型，则元素必须为[0 ,255]中的整数；
  • 如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray。

bytes([source[,encoding[,errors]]])

返回一个bytes类型。

callable(object)

返回一个对象是否可以被执行：

>>> def func():
...  return 123
...
>>> callable(func)
True
>>> func = 123
>>> callable(func)
False

chr(i)

返回一个数字在ASCII编码中对应的字符，取值范围256个。

>>> chr(66)
‘B‘
>>> chr(5)
‘\x05‘
>>> chr(55)
‘7‘
>>> chr(255)
‘\xff‘
>>> chr(25)
‘\x19‘
>>> chr(65)
‘A‘

compile(source,filenname,mode,flags=0,dont_inherit=False,optimize=-1)

把字符串编译成python可执行的代码。

>>> str = "for i in range(0,6): print(i)"
>>> c = compile(str, ‘‘, ‘exec‘)
>>> exec(c)
0
1
2
3
4
5

complex([real[,imag]])

创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

>>> complex(1, 2)
(1+2j)
# 数字
>>> complex(1)
(1+0j)
# 当做字符串处理
>>> complex("1")
(1+0j)
# 注意：这个地方在“+”号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1+2j)

delattr(object,name)

删除一个对象的属性，相当于del object.name。

dict(**kwarg)

创建一个数据类型为字典。

>>> dic = dict({"k1":"123","k2":"456"})
>>> dic
{‘k1‘: ‘123‘, ‘k2‘: ‘456‘}

dir([object])

返回一个类中的所有方法。

>>> a = [1,2,3]
>>> dir(a)
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]

divmod(a,b)

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

>>> divmod(10,3)
(3, 1)

enumerate(iterable,start=0)

遍历可迭代的数据类型，并为元素生成下标。

a = [1,2]
for k,v in enumerate(a):
    print(k,v)
print("---------")
b = {‘a‘:1,‘b‘:2}
for i,j in enumerate(b):
    print(i,j)

0 1
1 2
---------
0 a
1 b

eval(expression,globals=None,locals=None)

把一个字符串当作一个表达式去执行。

>>> string = "1 + 3"
>>> string
‘1 + 3‘
>>> eval(string)
4

exec(object[,globals[,locals]])

把字符串当作python代码执行。

>>> exec("for n in range(5): print(n)")
0
1
2
3
4

filter(function,iterable)

筛选过滤，循环可迭代的对象，把迭代的对象当作函数的参数，如果符合条件就返回True，否则就返回False。

def func(x):
    if x == 11 or x ==22:
        return True

ret = filter(func,[11,22,33,44])
for i in ret:
    print(i)

11
22

float([x])

将整数和字符串转换成浮点数。

>>> float("124")
124.0
>>> float("123.45")
123.45
>>> float("-123.34")
-123.34

format(value[,format_spec])

字符串格式化。

>>> a = "My name is {0}, age is {1}".format(‘lucky‘, 18)
>>> print(a)
My name is lucky, age is 18

frozenset([iterable])

frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法。

getattr(object,name)

获得对象的name属性，当该属性不存在的时候可以使用一个默认值作为返回值。

globals()

获取当前scripts文件内的所有全局变量。

>>> a = 3
>>> bsd = "54asd"
>>> globals()
{‘__doc__‘: None, ‘bsd‘: ‘54asd‘, ‘__package__‘: None, ‘a‘: 3, ‘__spec__‘: None, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>}

hasattr(object,name)

参数是一个对象和一个字符串，如果字符串是对象的某个属性的名称，则结果为True，否则为False。

hash(object)

返回一个对象的hash值。

>>> a = "asdadasdwqeq234sdfdf"
>>> hash(a)
5390438057823015497

help([object])

查看一个类的所有详细方法。

hex(x)

获取一个数的十六进制。

>>> hex(15)
‘0xf‘

id(object)

返回一个对象的内存地址。

>>> a = 123
>>> id(a)
1835400816

input([prompt])

交互式输入。

int(x,base=10)

获取一个数的十进制。

>>> int("31")
31

isinstance(object,classinfo)

判断对象是否是这个类创建的。

>>> li = [11,22,33]
>>> isinstance(li,list)
True

issubclass(class,classinfo)

查看一个对象是否为子类。

iter(object[,sentinel])

创建一个可迭代的对象。

>>> obj = iter([11,22,33,44])
>>> obj
<list_iterator object at 0x000002477DB25198>
>>> for n in obj:
 ...  print(n)
 ...
11
22
33
44

len(s)

查看一个对象的长度。

>>> name = ‘lucky‘
>>> len(name)
5

list([iterable])

创建一个数据类型为列表。

>>> li = list([11,22,33,44])
>>> li
[11, 22, 33, 44]

locals()

返回当前scripts的局部变量,返回结果为字典格式。

>>> def func():
...     name="lucky"
...     print(locals())
...
>>> func()
{‘name‘: ‘lucky‘}

map(function,iterable,...)

把可迭代的对象作为函数的值。

>>> ret = map(lambda x: x + 100, [1, 2, 3, 4, 5])
>>> for n in ret:
 ...  print(n)
 ...
101
102
103
104
105

max(iterable,*[,key,default]) max(arg1,arg2,*args[,key])

获取一个对象中的最大值。

>>> li = [1, 3, 5, 9 ,3]
>>> max(li)
9

memoryview(object)

返回对象object的内存查看对象。

min(iterable,*[,key,default]) min(arg1,arg2,*args[,key])

获取一个对象中的最小值

>>> >>> li = list([11,22,33,44])
>>> li = [11,22,33,44]
>>> min(li)
11

next(iterable[,default])

每次只拿取可迭代对象的一个元素。

>>> obj = iter([11,22,33,44])
>>> next(obj)
11
>>> next(obj)
22
>>> next(obj)
33
>>> next(obj)
44
>>> next(obj)
 # 如果没有可迭代的元素了就会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

object

返回一个新的无特征对象。

oct(x)

获取一个字符串的八进制。

>>> oct(13)
‘0o15‘

open(file,mode=‘r‘,buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)

文件操作的函数，用来做文件操作的。

ord(c)

把一个字母转换为ASCII对对应表中的数字。

>>> ord("a")
97
>>> ord("t")
116

pow(x,y[,z])

返回一个数的N次方。

>>> pow(2, 10)
1024
 >>> pow(2, 20)
1048576

print(*objects,sep=‘ ‘,end=‘\n‘,file=sys.stdout,flush=False)

打印输出。

property(fget=None,fset=None,doc=None)

函数 property() 的作用就是把类中的方法当作属性来访问。

range(sart,stop[,step])

生成一个可迭代序列。

>>> range(10)
range(0, 10)
>>> for n in range(5):
 ...  print(n)
 ...
0
1
2
3
4

repr(object)

返回一个包含对象的可打印表示的字符串。

reversed(seq)

对一个对象的元素进行反转。

>>> li = [1, 2, 3, 4]
 >>> reversed(li)
<list_reverseiterator object at 0x000002CF0EF6A940>
 >>> for n in reversed(li):
 ...  print(n)
 ...
4
3
2
1

round(number[,ndigits])

四舍五入。

>>> round(3.3)
3
>>> round(3.7)
4

set([iterable])

创建一个数据类型为集合。

>>> varss = set([11,222,333])
>>> type(varss)
<class ‘set‘>

setattr(object,name,value)

为一个对象的name属性设置一个value值。

slice(start,stop[,step])

元素的切片操作都是调用的这个方法。

sorted(iterable[,key[,reverse]])

为一个对象的元素进行排序。

>>> li = [ 2, 3, 4, 9, 1, 100]
>>> sorted(li)
[1, 2, 3, 4, 9, 100]

staticmethod(function)

返回一个静态的方法。

str([object[,encoding[,errors]]])

字符串。

sum(iterable[,start])

求和。

>>> sum([11,22,33])
66

super([type[,object-or-type]])

super() 常用于继承中调用父类的方法。

tuple([iterable])

创建一个对象，数据类型为元组。

type(object)

查看一个对象的数据类型。

>>> a = 1
>>> type(a)
<class ‘int‘>
>>> a = "str"
>>> type(a)
<class ‘str‘>

vars([object])

查看一个对象里面有多少个变量。

zip(*iterable)

联合迭代。

>>> li1 = ["k1","k2","k3"]
>>> li2 = ["a","b","c"]
>>> zip(li1,li2)
<zip object at 0x0000026BF1803288>
>>> dic = zip(li1,li2)
>>> for n in dic:
 ...  print(n)
 ...
(‘k1‘, ‘a‘)
(‘k2‘, ‘b‘)
(‘k3‘, ‘c‘)

__import__(name,globals=None,locals=None,fromlist=(),level=0)

导入模块，把导入的模块作为一个别名。

参考及扩展：

http://docspy3zh.readthedocs.io/en/latest/library/functions.html

http://openskill.cn/article/432

http://blog.csdn.net/lisonglisonglisong/article/details/38960341

https://juejin.im/post/58952b87b123db16a393ffdc

时间： 2024-12-09 05:16:41

Python内置函数.md的相关文章

Python内置函数_数学运算类

本文和大家分享的主要是python内置函数数据运算类相关内容,一起来看看吧,希望对大家学习python 有所帮助. abs abs(x) 求绝对值 · X可以是整型,也可以是复数 · 若X是复数,则返回复数的模 >>> abs(-1)1>>> abs(-3+4j)5.0>>> bin bin(x) 将整数x转换为二进制字符串 >>> bin(2)'0b10'>>> bin(3)'0b11' bool bool([x]

Python内置函数进制转换的用法

使用Python内置函数:bin().oct().int().hex()可实现进制转换. 先看Python官方文档中对这几个内置函数的描述: bin(x)Convert an integer number to a binary string. The result is a valid Python expression. If x is not a Python int object, it has to define an __index__() method that returns a

Python补充--Python内置函数清单

Python内置函数 Python内置(built-in)函数随着python解释器的运行而创建.在Python的程序中,你可以随时调用这些函数,不需要定义.最常见的内置函数是: print("Hello World!") 在Python教程中,我们已经提到下面一些内置函数:基本数据类型 type()反过头来看看 dir()   help()    len()词典 len()文本文件的输入输出 open()循环设计 range()   enumerate()    zip()循环对象

python基础9 -----python内置函数

python内置函数1 一.python内所有的内置函数: 二.python内常用的内置函数: 三.python内内置函数详解: 1.数学运算函数: 2.集合类函数: 3.逻辑类函数: 4.映射类函数: 5.IO操作:

Python 内置函数sorted()有哪些高级用法？

本文和大家分享的主要是python内置函数sorted()的相关内容,一起来看看吧,希望对大家学习python http://www.maiziedu.com/land/python/有所帮助. 1.对于 Python 内置函数 sorted() ,先拿来跟list(列表)中的成员函数 list.sort() 进行下对比.在本质上,list的排序和内建函数sorted的排序是差不多的,连参数都基本上是一样的. 2.主要的区别在于, list.sort() 是对已经存在的列表进行操作,进而可以改变

[python基础知识]python内置函数map/reduce/filter

python内置函数map/reduce/filter 这三个函数用的顺手了,很cool. filter()函数:filter函数相当于过滤,调用一个bool_func(只返回bool类型数据的方法)来迭代遍历每个序列中的元素. 返回bool_func结果为true的元素的序列(注意弄清楚序列是什么意思)http://blog.csdn.net/bolike/article/details/19997465序列参考</a> 如果filter参数值为None,list参数中所有为假的元 素都将被

lambda 表达式+python内置函数

#函数 def f1(a,b): retrun  a+b #lambda方式,形参(a,b):返回值(a+b) f2=lambda a,b : a+b 在一些比较简单的过程计算就可以用lambda python内置函数 abc 获取绝对值 all 循环对象,都为真就返回真否则为假 >>> li[1, 2, 3]>>> all(li)True #0为假 >>> li=[0,1,2,3]>>> all(li)False bool 真假判断

python内置函数（三）

python内置函数目前需要知道的如下: 代码: #!/usr/bin/env python# -*- coding:utf-8 -*-# author by lh #map(函数,可迭代的对象)def f1(x): return x+100ret=map(f1,[1,2,3,4,5])for i in ret: print iprint '---------------------------------------'#hash转换成哈希值,节约内存dic={ 'dvfhsuicbfhascj

python学习系列--python内置函数（一）

先列出所有的python内置函数,可以看到还是挺多的. abs()        求给定数的绝对值. all()          传入一个列表,只有当列表中所有元素都是真时,该函数返回真. any()        传入一个列表,只要列表中有一个元素为真,该函数即返回真. ascii()       执行对象中的__repr__方法.该函数在python2.7中已弃用. bin()         将给定的值转换成二进制. bool()       判断真假. bytearray()