python partition函数_Python内置方法/函数

abs()

返回数字的绝对值。

abs(x)

all()

用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

元素除了是 0、空、None、False 外都算 True。

all(iterable) #iterable -- 元组或列表

>>> all([1,2,0])

False

>>> all([1,2,1])

True

any()

用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。

>>> any([1,2,0])

True

>>> any([0,0])

False

ascii()

中文转ASC码。

>>> ascii([1,2,"测试"])

"[1, 2, '\\u6d4b\\u8bd5']"

bin()

十进制转二进制。

bin(x)

bool()

判断真假。

>>> bool(1)

True

>>> bool(0)

False

bytes()

返回一个新的“bytes”对象， 是一个不可变序列。

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

>>> bytes('abcd',encoding="utf-8")

b'abcd'

bytearray()

返回一个新的 bytes 数组。 bytearray 类是一个可变序列。改二进制字符。

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

>>> a = bytearray('abcd',encoding="utf-8")

>>> a[0]

97

>>> a[0] = 99

>>> a

bytearray(b'cbcd')

callable()

如果参数 object 是可调用的就返回 True，否则返回 False。

>>> callable(int)

True

chr()

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

>>> chr(100)

'd'

ord()

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。

>>> ord('a')

97

@classmethod

把一个方法封装成类方法。

class C:

@classmethod

def f(cls, arg1, arg2, ...): ...

compile()

compile() 函数将一个字符串编译为字节代码，用于底层编译的。

语法：

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

将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。source 可以是常规的字符串、字节字符串，或者 AST 对象。

filename 实参需要是代码读取的文件名

mode 实参指定了编译代码必须用的模式。如果 source 是语句序列，可以是 'exec'；如果是单一表达式，可以是 'eval'；如果是单个交互式语句，可以是 'single'。

>>> code = "for i in range(10):print(i)"

>>> c = compile(code,'','exec')

>>> c

at 0x000001A23F969300, file "", line 1>

>>> exec(c)

0

1

2

3

4

5

6

7

8

9

也可以是表达式。

>>> code = "1+2+3/2"

>>> c = compile(code,'','eval')

>>> eval(c)

4.5

exec()

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

这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。 如果是代码对象，它将被直接执行。在任何情况下，被执行的代码都需要和文件输入一样是有效的

complex()

返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。

>>> complex(1,2)

(1+2j)

delattr()

delattr(object, name)

实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。

例如 delattr(x, 'foobar') 等价于 del x.foobar 。

dir()

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

>>> dir(code)

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

divmod()

它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。

>>> divmod(10,2)

(5, 0)

enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>> a=['a','b','b','d','e']

>>> for i,e in enumerate(a):

... print(i,e)

...

0 a

1 b

2 b

3 d

4 e

eval()

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

可以把字符串变成字典。

>>> a="{'a':'b'}"

>>> type(a)

>>> b = eval(a)

>>> type(b)

filter()

filter(function, iterable)

用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。iterable 可以是一个序列，一个支持迭代的容器，或一个迭代器。

>>> f = filter(lambda n:n>5,range(10))

>>> f

>>> for i in f:

... print(i)

...

6

7

8

9

map()

返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。

map(function, iterable)

>>> m = map(lambda n:n*n,range(10))

>>> for i in m:

... print(i)

...

0

1

4

9

16

25

36

49

64

81

float()

返回从数字或字符串 x 生成的浮点数。

>>> float(2)

2.0

format()

将 value 转换为 format_spec 控制的“格式化”表示。

>>> "{}".format("hello")

'hello'

frozenset()

frozenset([iterable])

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

>>> l = [1,2,3,4]

>>> dir(l)

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__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']

>>> frozenset(l)

frozenset({1, 2, 3, 4})

>>> x = frozenset(l)

>>> dir(x)

['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']

getattr()

getattr(object, name[, default])

返回对象命名属性的值。name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。例如， getattr(x, 'foobar') 等同于 x.foobar。

globals()

以键值对的方式返回当前程序的所有变量。

>>> print(globals())

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': "{'a':'b'}", 'code': '1+2+3/2', 'c': at 0x000001A23F9699C0, file "", line 1>, 'i': 81, 'e': 'e', 'b': {'a': 'b'}, 'f': , 'm': , 'l': [1, 2, 3, 4], 'x': frozenset({1, 2, 3, 4})}

hash()

返回该对象的哈希值（如果它有的话）。哈希值是整数。

>>> hash('abcs')

-5430407018906191666

help()

查看函数或模块用途的详细说明。

>>> help(chr)

Help on built-in function chr in module builtins:

chr(i, /)

Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.

hex()

将一个指定数字转换为 16 进制数。

>>> hex(15)

'0xf'

id()

获取对象的内存地址。

>>> a="hello"

>>> id(a)

2047968913928

int()

将一个字符串或数字转换为整型。

>>> int("111")

111

input()

接受一个标准输入数据，返回为 string 类型。

>>> str = input("Input value")

Input value hello

>>> str

' hello'

isinstance()

判断一个对象是否是一个已知的类型。

>>>a = 2

>>> isinstance (a,int)

True

>>> isinstance (a,str)

False

issubclass()

判断参数 class 是否是类型参数 classinfo 的子类。

class A:

pass

class B(A):

pass

print(issubclass(B,A)) # 返回 True

iter()

用来生成迭代器。

iter(object[, sentinel])

object -- 支持迭代的集合对象。

sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

>>>lst = [1, 2, 3]

>>> for i in iter(lst):

... print(i)

...

1

2

3

len()

返回对象（字符、列表、元组等）长度或项目个数。

>>> len('avc')

3

locals()

以字典类型返回当前位置的全部局部变量。

>>> def a():

... x='aaa'

... print(locals())

...

>>> a()

{'x': 'aaa'}

list()

用于将元组或字符串转换为列表。

>>> a = '[1,2,3,4]'

>>> x = list(a)

>>> x

['[', '1', ',', '2', ',', '3', ',', '4', ']']

max()

返回给定参数的最大值，参数可以为序列。

>>> max(100,1000,10)

1000

min()

返回给定参数的最小值，参数可以为序列。

>>> min('a','b','c')

'a'

memoryview()

返回给定参数的内存查看对象(Momory view)。

>>>v = memoryview(bytearray("abcefg", 'utf-8'))

>>> print(v[1])

98

>>> print(v[-1])

103

>>> print(v[1:4])

>>> print(v[1:4].tobytes())

b'bce'

>>>

next()

返回迭代器的下一个项目，相当于__next__()。

it = iter([1, 2, 3, 4, 5])

while True:

try:

x = next(it)

print(x)

except StopIteration:

break

object()

面向对象中的对象。

oct()

将一个整数转换成8进制字符串

>>> oct(1)

'0o1'

open()

用于打开一个文件，并返回文件对象。

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

file: 必需，文件路径（相对或者绝对路径）。

mode: 可选，文件打开模式

buffering: 设置缓冲

encoding: 一般使用utf8

errors: 报错级别

newline: 区分换行符

closefd: 传入的file参数类型

opener:

pow()

返回x的y次方的值。

>>> import math

>>> math.pow(2,3)

8.0

print()

用于打印输出。

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

objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。

sep -- 用来间隔多个对象，默认值是一个空格。

end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。

file -- 要写入的文件对象。

flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

property()

新式类中返回属性值。

class property([fget[, fset[, fdel[, doc]]]])

参数

fget -- 获取属性值的函数

fset -- 设置属性值的函数

fdel -- 删除属性值函数

doc -- 属性描述信息

class C(object):

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

range()

返回的是一个可迭代对象（类型是对象）。

>>>range(5)

range(0, 5)

repr()

将对象转化为供解释器读取的形式。

>>> a

'[1,2,3,4]'

>>> repr(a)

"'[1,2,3,4]'"

reversed()

返回一个反转的迭代器。

>>> a="admin"

>>>reversed(a)

>>>print(a)

admin

round()

返回浮点数 x 的四舍五入值。

round( x [, n] )

>>> round(1.335,2)

1.33

set()

创建一个无序不重复元素集。

>>> x=set('test')

>>> x

{'t', 'e', 's'}

slice()

实现切片对象，主要用在切片操作函数里的参数传递。

setattr(object,name,value)

object -- 对象。

name -- 字符串，对象属性。

value -- 属性值。

>>> a = range(0,20)

>>> a[slice(5,10)]

range(5, 10)

setattr()

对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

setattr(object, name, value)

object -- 对象。

name -- 字符串，对象属性。

value -- 属性值。

>>>class A(object):

... bar = 1

...

>>> a = A()

>>> getattr(a, 'bar') # 获取属性 bar 值

1

>>> setattr(a, 'bar', 5) # 设置属性 bar 值

>>> a.bar

5

sorted()

对所有可迭代的对象进行排序操作。

>>> a = [1,3,5,97,12,55,33]

>>> x = sorted(a)

>>> x

[1, 3, 5, 12, 33, 55, 97]

staticmethod()

返回函数的静态方法。

class C(object):

@staticmethod

def f():

print('runoob');

C.f(); # 静态方法无需实例化

cobj=C()

cobj.f() # 也可以实例化后调用

##输出

runoob

runoob

str()

将对象转化为文本的形式。

sum()

对系列进行求和计算。

sum(iterable[,start])

iterable -- 可迭代对象，如：列表、元组、集合。

start -- 指定相加的参数，如果没有设置这个值，默认为0。

>>> a = [1,2,3]

>>> sum(a)

6

super()

用于调用父类(超类)的一个方法。用于面向对象继承。

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

type -- 类。

object-or-type -- 类，一般是 self

tuple()

将可迭代系列（如列表）转换为元组。

tuple( iterable )

iterable -- 要转换为元组的可迭代序列。

type()

只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

type(object)

type(name, bases, dict)

name -- 类的名称。

bases -- 基类的元组。

dict -- 字典，类内定义的命名空间变量。

vars()

返回对象object的属性和属性值的字典对象。

>>> class Test:

... a = 1

...

>>> print(vars(Test))

{'a': 1, '__module__': '__main__', '__doc__': None}

zip()

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

>>> a

[1, 2, 3]

>>> b=['a','b','c']

>>> print(zip(a,b))

>>> for i in zip(a,b):

... print(i)

...

(1, 'a')

(2, 'b')

(3, 'c')

__import__()

用于动态加载类和函数 。

__import__('a') # 导入 a.py 模块