python解释器的内置函数可以直接使用吗

本文链接：https://blog.csdn.net/weixin_39561004/article/details/114462226

Python内置函数

Python有着丰富的内置函数，这些内置函数可以在程序中直接使用，因为在python解释器启动后会自动加载这些函数，我们这里讨论的是除去异常BIF的剩余的72个。基于python3.6，后面python版本可能有所删减。

1.abs(x)

返回参数x的绝对值,如果x是复数,就返回其模的大小

>>> abs(3)3

>>> abs(-3.5)3.5

>>> abs(3+4j)5.0

>>>

2.all(iterable)

如果对于iterable中的每一个元素x,bool(x)都为真,即iterable中所有元素都为真，就返回True，只要有一个为假就返回False

>>> all([1,'a',[1]])

True>>> all([True,False,1])

False>>>

3.any(iterable)

如果对于iterable中的每一个元素x,bool(x)只要有一个为True，就返回True，否则返回False

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

True>>> any(['',0,False])

False>>>

4.dir(object)

返回object的属性与方法

>>>dir(set)

['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute

__','__gt__','__hash__','__iand__','__init__','__init_subclass__','__ior__','__isub__','__iter__','__ixor__','__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub

__','__rxor__','__setattr__','__sizeof__','__str__','__sub__','__subclasshook__','__xor__','add','clear','copy','dif

ference','difference_update','discard','intersection','intersection_update','isdisjoint','issubset','issuperset','pop',

'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']>>>

5.id(object)

返回一个对象的内存地址

>>> str1 = 'Keys'

>>>id(str1)720667107880

>>> id(100)1772213008

>>>

6.len(object)

返回一个容器中的项目数量

>>> str1 = 'Keys'

>>> list1 = [1,2,3,4]>>>len(str1)4

>>>len(list1)4

>>>

7.list(iterable)

将一个iterable对象转换成一个列表或创建一个新列表

>>> a='Keys'

>>>list(a)

['K', 'e', 'y', 's']>>> b=(1,2,3,4)>>>list(b)

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

8.max(...)

如果只有一个可迭代参数，则返回其最大项，如果有两个或者更多参数，返回其最大的参数

>>> list1 = [2,8,9,7]>>>max(list1)9

>>> str1 = 'Keys'

>>>max(str1)'y'

>>> max(1,2,3)3

>>>

9.min(...)

如果只有一个可迭代参数，则返回其最小项，如果有两个或者更多参数，返回其最小的参数

>>> min(1,2,3)1

>>> str1 = 'Keys'

>>>min(str1)'K'

>>> list1 = [2,8,9,7]>>>min(list1)2

>>>

10.pow(x,y,z=None)

如果只有x，y两个参数，返回x**y,如果有x,y,z三个参数，返回x**y % z

>>> pow(2,3)8

>>> pow(2,3,7)1

>>>

11.int(object)

将object转换为整型(object为数字或者字符串型数字)

>>> int('1') # 字符串1转换成整型1，默认base=10，即按照10进制来转换为10进制整数

>>> int('11',base=2) # 按照2进制将11转换成10进制整数

>>> int('11',base=5) # 按照5进制将11转换成10进制整数

>>> int(1.11) # 当参数为小数时，会将小数部分直接截断而不是四舍五入

12.isinstance(object,classinfo)

如果一个参数(object)是第二个参数(classinfo)的实例对象，则返回True，否则返回False

#1.如果object是classinfo子类的一个实例，也符合条件

#2.如果第一个参数不是对象，则永远返回False

#3.classinfo可以是类对象组成的元组，只要class是其中任何一个候选项的子类，则返回True

#4.如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常

>>> name='Keys'

>>> isinstance(name,str)

True

>>> isinstance(name,int)

False

>>> isinstance(name,(str,int))

True

>>>

13.range(start,stop,step)

range函数接收三个参数，用于生成一个序列

start:开始

stop:结束(不包括)

step:步长

>>> for i in range(10):

... print(i,end=',')

...

0,1,2,3,4,5,6,7,8,9,

>>>

>>> for i in range(5,10):

... print(i,end=' ')

...

5 6 7 8 9

>>> for i in range(1,10,3):

... print(i,end=' ')

...

1 4 7

>>>

14.type(object)

返回对象的类型

>>> name = 'Keys'

>>> type(name)

>>> age = 27

>>> type(age)

>>>

15.tuple(iterable)

python工厂函数，用于创建元组

>>> tuple('Keys')

('K', 'e', 'y', 's')

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

>>> tuple(list1)

(1, 2, 3, 4)

>>>

16.str(object)

用于将其他对象转换成字符串对象

>>> age=27

>>> type(age)

>>> str(age)

'27'

>>> age=str(age)

>>> type(age)

>>>

17.sum(iterable)

当iterable对象是可加时，返回iterable对象的和

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

>>> sum(list1)

18.set()

python工厂函数，用于创建集合

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

>>> set(list1)

{1, 2, 3}

>>> str1='happy'

>>> set(str1)

{'h', 'y', 'a', 'p'}

>>>

19.float()

将一个对象转换为浮点型，与int()类似

>>> a=1

>>> float(a)

1.0

>>> a='1'

>>> float(a)

1.0

>>>

20.help(object)

打印出object的帮助信息

>>>help(str)

Help on class str in module builtins:

class str(object)

| str(object='') -> str

| str(bytes_or_buffer[, encoding[, errors]]) -> str

| Create a new string object from the given object. If encoding or

| errors is specified, then the object must expose a data buffer

| that will be decoded using the given encoding and error handler.

-- More --

21.ascii(object)

ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。生成字符串类似 Python2 版本中 repr() 函数的返回值。

>>> ascii('Keys')

"'Keys'"

>>>

22.bin(x) x -- int 或者 long int 数字

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

>>> bin(100)

'0b1100100'

>>> bin(10)

'0b1010'

>>>

23.bool([x])

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

bool 是 int 的子类

>>>bool()

False

>>> bool(0)

False

>>> bool(1)

True

>>> bool(2)

True

>>> issubclass(bool, int) # bool 是 int 子类

True

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

bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256

如果 source 为整数，则返回一个长度为 source 的初始化数组；

如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；

如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray

如果没有输入任何参数，默认就是初始化数组为0个元素

>>> bytearray()

bytearray(b'')

>>> bytearray([1,2])

bytearray(b'\x01\x02')

>>> bytearray('keys','utf-8')

bytearray(b'keys')

>>>

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

bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本

如果 source 为整数，则返回一个长度为 source 的初始化数组；

如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；

如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。

如果没有输入任何参数，默认就是初始化数组为0个元素。

>>>a = bytes([1,2,3,4])

>>> a

b'\x01\x02\x03\x04'

>>> type(a)

>>>

>>> a = bytes('hello','ascii')

>>>

>>> a

b'hello'

>>> type(a)

>>>

26.callable(object)

callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True

View Code

27.chr(x) x -- 可以是10进制也可以是16进制的形式的数字

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

>>>print chr(0x30), chr(0x31), chr(0x61) # 十六进制

0 1 a

>>> print chr(48), chr(49), chr(97) # 十进制

0 1 a

28.classmethod

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class A(object):

bar = 1

def func1(self):

print ('foo')

@classmethod

def func2(cls):

print ('func2')

print (cls.bar)

cls().func1() # 调用 foo 方法

A.func2() # 不需要实例化

29.compile(source, filename, mode[, flags[, dont_inherit]])

compile() 函数将一个字符串编译为字节代码。

source -- 字符串或者AST(Abstract Syntax Trees)对象。。

filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。

mode -- 指定编译代码的种类。可以指定为 exec, eval, single。

flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。

flags和dont_inherit是用来控制编译源码时的标志

View Code

30.complex([real[, imag]])

real -- int, long, float或字符串；

imag -- int, long, float；

complex() 函数用于创建一个值为 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)

31.copyright

交互式提示对象打印许可文本，一个列表

32.credits

object -- 对象

name -- 必须是对象的属性

View Code

运行结果：

('x = ', 10)

('y = ', -5)

('z = ', 0)

--删除 z 属性后--

('x = ', 10)

('y = ', -5)

Traceback (most recent call last):

File "test.py", line 22, in

print('z = ',point1.z)

AttributeError: Coordinate instance has no attribute 'z'

34.dict()

python工厂函数，用于创建一个字典

>>>dict() # 创建空字典

{}

>>> dict(a='a', b='b', t='t') # 传入关键字

{'a': 'a', 'b': 'b', 't': 't'}

>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典

{'three': 3, 'two': 2, 'one': 1}

>>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典

{'three': 3, 'two': 2, 'one': 1}

>>>

35.divmod(a,b)

a,b都是数字

python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)

>>>divmod(7, 2)

(3, 1)

>>> divmod(8, 2)

(4, 0)

>>> divmod(1+2j,1+0.5j)

((1+0j), 1.5j)

36.enumerate(sequence,[start=0])

sequence -- 一个序列、迭代器或其他支持迭代对象

start -- 下标起始位置

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

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']

>>>list(enumerate(seasons))

[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

>>>list(enumerate(seasons, start=1)) # 小标从 1 开始

[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

用于for循环中

>>>seq = ['one', 'two', 'three']

>>>for i, element in enumerate(seq):

... print(i, seq[i])

...

0 one

1 two

2 three

>>>

37.eval(expression[,globals[,locals]])

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

expression -- 表达式。

globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

>>>x = 7

>>> eval( '3 * x' )

>>> eval('pow(2,2)')

>>> eval('2 + 2')

>>> n=81

>>> eval("n + 4")

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

object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行(除非发生语法错误)。如果object是一个code对象，那么它只是被简单的执行。

globals：可选参数，表示全局命名空间(存放全局变量)，如果被提供，则必须是一个字典对象。

locals：可选参数，表示当前局部命名空间(存放局部变量)，如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值

exec 返回值永远为 None

>>>exec('print("Hello Keys")')

Hello Keys

# 单行语句字符串

# 多行语句字符串

>>> exec ("""for i in range(5):

... print ("iter time: %d" % i)

... """)

iter time: 0

iter time: 1

iter time: 2

iter time: 3

iter time: 4

x = 10

expr = """

z = 30

sum = x + y + z

print(sum)

"""

def func():

y = 20

exec(expr)

exec(expr, {'x': 1, 'y': 2})

exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})

func()

输出结果：

39.filter(unction,iterable)

function -- 判断函数

iterable -- 可迭代对象

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中

#!/usr/bin/python3

import math

def is_sqr(x):

return math.sqrt(x) % 1 == 0

tmplist = filter(is_sqr, range(1, 101))

newlist = list(tmplist)

print(newlist)

运行结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

40.exit(n)

退出程序，默认返回0代表程序运行成功，非0表示异常，也可以自己定义程序退出时的返回值

41.format

参考前面字符串方法中的format

42.frozenset([iterable])iterable -- 可迭代的对象，比如列表、字典、元组等等

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

返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合

>>>a = frozenset(range(10)) # 生成一个新的不可变集合

>>> a

frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> b = frozenset('runoob')

>>> b

frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合

>>>

43.getattr(object, name[, default])

object -- 对象。

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

default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError

>>>class A(object):

... bar = 1

...

>>> a = A()

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

>>> getattr(a, 'bar2') # 属性 bar2 不存在，触发异常

Traceback (most recent call last):

File "", line 1, in

AttributeError: 'A' object has no attribute 'bar2'

>>> getattr(a, 'bar2', 3) # 属性 bar2 不存在，但设置了默认值

>>>

44.globals()

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

45.hasattr(object, name)

object -- 对象。

name -- 字符串，属性名

如果对象有该属性返回 True，否则返回 False

class Coordinate:

x = 10

y = -5

z = 0

point1 = Coordinate()

print(hasattr(point1, 'x'))

print(hasattr(point1, 'y'))

print(hasattr(point1, 'z'))

print(hasattr(point1, 'no')) # 没有该属性

输出结果

True

False

46.hash(object)

用于获取取一个对象(字符串或者数值等)的哈希值

>>>hash('test') # 字符串

2314058222102390712

>>> hash(1) # 数字

>>> hash(str([1,2,3])) # 集合

1335416675971793195

>>> hash(str(sorted({'1':1}))) # 字典

7666464346782421378

>>>

47.hex(x)

用于将10进制整数转换成16进制，以字符串形式表示

>>> hex(10)

'0xa'

>>> hex(255)

'0xff'

>>>

48.input(prompt)prompt: 提示信息

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。

Python2.x 中 input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。

raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型( int, float )

49.issubclass(class,classinfo)

如果第一个参数是第二个参数的一个子类，则返回Truth，否则返回False

#1.一个类被认为是其自身的子类

#2.classinfo可以是类对象组成的元组，只要class是其中任何一个候选项的子类，则返回True

#3.在其他情况下抛出一个TypeError异常

50.iter(object[, sentinel])

用来生成迭代器

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

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

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

>>> for i in iter(lst):

... print(i)

...

51.license()

输出当前python 的license信息

A. HISTORY OF THE SOFTWARE

==========================

Python was created in the early 1990s by Guido van Rossum at Stichting

Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands

as a successor of a language called ABC. Guido remains Python's

principal author, although it includes many contributions from others.

In 1995, Guido continued his work on Python at the Corporation for

National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)

in Reston, Virginia where he released several versions of the

software.

In May 2000, Guido and the Python core development team moved to

BeOpen.com to form the BeOpen PythonLabs team. In October of the same

year, the PythonLabs team moved to Digital Creations (now Zope

Corporation, see http://www.zope.com). In 2001, the Python Software

Foundation (PSF, see http://www.python.org/psf/) was formed, a

non-profit organization created specifically to own Python-related

Intellectual Property. Zope Corporation is a sponsoring member of

the PSF.

All Python releases are Open Source (see http://www.opensource.org for

Hit Return for more, or q (and Return) to quit: q

52.locals()

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

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True

>>>def runoob(arg): # 两个局部变量：arg、z

... z = 1

... print (locals())

...

>>> runoob(4)

{'z': 1, 'arg': 4} # 返回一个名字/值对的字典

>>>

53.map(function, iterable, ...)

function -- 函数，有两个参数

iterable -- 一个或多个序列

Python 2.x 返回列表。

Python 3.x 返回迭代器

>>>def square(x) : # 计算平方数

... return x ** 2

...

>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方

[1, 4, 9, 16, 25]

>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数

[1, 4, 9, 16, 25]

# 提供了两个列表，对相同位置的列表数据进行相加

>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

[3, 7, 11, 15, 19]

54.memoryview(obj)

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

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问

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

>>> print(v[1])

>>> print(v[-1])

103

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

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

b'bce'

>>>

55.next()

返回迭代器的下一个项目

iterator[, default]

iterator -- 可迭代对象

default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常

# 首先获得Iterator对象:

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

# 循环:

while True:

try:

# 获得下一个值:

x = next(it)

print(x)

except StopIteration:

# 遇到StopIteration就退出循环

break

输出结果为：

56.object

Python3中最基本的类型

57.oct(x)

x -- 整数

返回8进制字符串

>>>oct(10)

'012'

>>> oct(20)

'024'

>>> oct(15)

'017'

>>>

58.open(name[, mode[, buffering]])

用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写

name : 一个包含了你要访问的文件名称的字符串值。

mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认

不同模式打开文件的完全列表：

file 对象方法

file.read([size]) size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)

file.readline() 返回一行

file.readlines([size]) 返回包含size行的列表,size 未指定则返回全部行

for line in f: print line #通过迭代器访问

f.write("hello\n") #如果要写入字符串以外的数据,先将他转换为字符串.

f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).

f.seek(偏移量,[起始位置]) 用来移动文件指针.

偏移量:单位:比特,可正可负

起始位置:0-文件头,默认值;1-当前位置;2-文件尾

f.close() 关闭文件

59.ord(c)c -- 字符

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

返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常

>>>ord('a')

>>> ord('b')

>>> ord('c')

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

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

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

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

file -- 要写入的文件对象

>>> quit()

C:\Users\wyj\Desktop\tmp\ABC>

63.repr(object)

将对象转化为供解释器读取的形式,返回一个对象的 string 格式

64.reversed(seq)

seq -- 要转换的序列，可以是 tuple, string, list 或 range

返回一个反转的迭代器

65.round(x [, n])

x -- 数字表达式。

n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0

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

print ("round(70.23456) : ", round(70.23456))

print ("round(56.659,1) : ", round(56.659,1))

print ("round(80.264, 2) : ", round(80.264, 2))

print ("round(100.000056, 3) : ", round(100.000056, 3))

print ("round(-100.000056, 3) : ", round(-100.000056, 3))

输出结果

round(70.23456) : 70

round(56.659,1) : 56.7

round(80.264, 2) : 80.26

round(100.000056, 3) : 100.0

round(-100.000056, 3) : -100.0

66.setattr(object, name, value)

setattr 函数对应函数 getatt()，用于设置属性值，该属性必须存在

object -- 对象。

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

value -- 属性值

>>>class A(object):

... bar = 1

...

>>> a = A()

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

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

>>> a.bar

67.slice(start, stop[, step])

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

start -- 起始位置

stop -- 结束位置

step -- 间距

>>>myslice = slice(5) # 设置截取5个元素的切片

>>> myslice

slice(None, 5, None)

>>> arr = range(10)

>>> arr

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> arr[myslice] # 截取 5 个元素

[0, 1, 2, 3, 4]

>>>

68.sorted(iterable, key=None, reverse=False)

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

iterable -- 可迭代对象。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序， reverse = False 升序(默认)

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

以下实例展示了 sorted 的最简单的使用方法：

>>>sorted([5, 2, 3, 1, 4])

[1, 2, 3, 4, 5] # 默认为升序

你也可以使用 list 的 list.sort() 方法。这个方法会修改原始的 list(返回值为None)。通常这个方法不如sorted()方便-如果你不需要原始的 list，list.sort()方法效率会稍微高一些。

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

>>> a.sort()

>>> a

[1,2,3,4,5]

另一个区别在于list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable

>>>sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})

[1, 2, 3, 4, 5]

利用key进行倒序排序

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]

>>> result_list = sorted(example_list, key=lambda x: x*-1)

>>> print(result_list)

[7, 6, 5, 4, 3, 2, 1, 0]

>>>

要进行反向排序，也通过传入第三个参数 reverse=True：

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]

>>> sorted(example_list, reverse=True)

[7, 6, 5, 4, 3, 2, 1, 0]

sorted 的应用，也可以通过 key 的值来进行数组/字典的排序，比如：

array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]

array = sorted(array,key=lambda x:x["age"])

print(array)

输出结果：

[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

69.staticmethod(function)

返回函数的静态方法

该方法不强制要求传递参数，如下声明一个静态方法:

class C(object):

@staticmethod

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

...

以上实例声明了静态方法 f，类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()

class C(object):

@staticmethod

def f():

print('runoob');

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

cobj = C()

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

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

super() 函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

type -- 类。

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

Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :

Python3.x 实例：

class A:

pass

class B(A):

def add(self, x):

super().add(x)

class A(object): # Python2.x 记得继承 object

pass

class B(A):

def add(self, x):

super(B, self).add(x)

运行结果

Parent

Child

HelloWorld from Parent

Child bar fuction

I'm the parent.

71.vars([object])

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

返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值类似 locals()

72.zip([iterable, ...])

iterabl -- 一个或多个迭代器

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

>>> b = [4,5,6]

>>> c = [4,5,6,7,8]

>>> zipped = zip(a,b) # 返回一个对象

>>> zipped

>>> list(zipped) # list() 转换为列表

[(1, 4), (2, 5), (3, 6)]

>>> list(zip(a,c)) # 元素个数与最短的列表一致

[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b)) # 与 zip 相反，*zip 可理解为解压，返回二维矩阵式

>>> list(a1)

[1, 2, 3]

>>> list(a2)

[4, 5, 6]

>>>

python解释器的内置函数可以直接使用吗_python内置函数