python运维_third_chapter（2）

最新推荐文章于 2024-06-23 11:18:01 发布

三分之一给你

最新推荐文章于 2024-06-23 11:18:01 发布

阅读量868

点赞数

分类专栏： python运维课程文章标签： python 内置函数

python运维课程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

python内置函数

源码地址：

python内置函数

随便翻译了一下，练练手。

python解释器有些内置的函数它们随时都可以使用。

abs(x)

返回一个数的绝对值。其参数可以为整数或浮点数。如果参数是一个复数，它的magnitude就会被返回。

all(iterable)

如果可迭代对象中的所有元素都为真就返回真（或者可迭代对象为空时）

any(iterable)

如果可迭代对象中的任何一个元素为真就返回真。如果可迭代对象为空，就返回False

ascii(object)

像repr()函数一样，返回一个可打印的对象的呈现方式，但是若object为非ASCII码字符时就会返回通过repr()函数使用\x,\u或\u后的结果。这个函数产生的字符与python2中使用repr()函数返回的结果相似。

bin(x)

转换一个整数数字为一个前缀为’0b’的二进制字符。该返回的结果是有效的python表达式。如果x不是一个python 的int对象，他就要定一个 index()魔法方法返回一个整数。
如果你不想要前缀’0b’你可以使用format()函数。

format(x,'b')

类 bool([x])

返回一个布尔值，True 或 False其中之一。python会使用一个真实测试进程对x进行测试。如果x是False或者被省略的，它就会返回False；否则它会返回True。类bool是int类的子类（详细内容请看数字类型-整数，浮点数，复数).不能进一步地继承为另一个子类。它只能变成False或者True的实例。（详细请查看布尔值）。

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

返回一个新的字节数列。类bytearray对象是一个在范围0到256的整数生成的可变序列，更多描述在章节’可变序列类型‘中查看。

可选参数source可以在不同的情况下被使用来初始化数组：

若参数为字符串，那么就一定要给出编码方式参数encoding（和可选参数错误处理方式errors）；然后就可以使用str.encode()转换字符串为字节。
若参数为整数，那么数列就会是大小为该整数初始化为空字节的数列。
若参数为与缓冲器接口一致的对象，一个对象的只读缓冲器就会被用来初始化自己数列。
若参数为可迭代对象，它一定要为一个范围在0到256的整数的可迭代对象，然后会将其初始化为数列的内容。

若没有任何参数，一个大小为0的数列就会被创建。

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

返回一个新的字节对象，其为范围在0到256之间的不可变序列。bytes算是bytearray的不可变版本-它也有一样的不可变方法和同样的索引、切片操作。

相同地，结构器参数的使用方法与bytearray相一致。

callable（object）

如果参数object是可调用的那么就放回True，反之则False。就算返回的是true，该对象也有可能调用失败，但是如果返回的是false，调用改对象就永远不会成功。注意这些类是可以调用的（调用类会返回一个新的实例）；若实例的类中有call()方法那么该实例就是可调用的。

chr（i）

返回字符串，其呈现的字符为在Unicode中整数i指向的字符。例如，chr（97）就是返回字符‘a’，chr（8364）就是返回字符‘€’。该操作可以认为与ord（）相反。

函数有效的参数范围一0到11141111（在16进制中为0x10FFFF）。如果i超出这个返回就会出现ValueError。

classmethod（function）

返回一个函数的类方法。

一个类方法隐式地接收一个类作为第一个参数，就像一个实例方法接收一个实例。声明一个类方法，可以使用下面的代码块：

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

@classmethod形式是函数装饰器-在章节‘Function definitions’中查看更多关于函数定义的细节描述。

它可以通过类（例如C.f()）或者实例（例如C().f()）来调用。除了它的类实例是可以被忽略的。如果类方法是从一个起源类中调用的，那么这个起源类就要被隐式地传入第一个参数。

类方法不同与C++或者Java的静态方法。如果你想要了解的更多，可以查看章节‘staticmenthod()’。

compile（source，filename，mode，flags=0，dont_inherit=False,optimze=-1)

将参数source编码为code或者AST对象。Code对象可以使用exec（）或者evaluate（）执行一些操作。参数source可以为普通的字符串，字节串或者AST对象。可以从‘ast组件文档’中查看光宇操作AST对象的资料。

参数filename应当是代码读取的文件名；若代码不是从文件中读取的就闯入一些可识别的值（’string‘就是常用的值）

参数mode指定被编码的代码类型；如果source由语句序列组成他就可以为’exec‘，如果source为单个表达式组成他就可以为’eval‘，如果source为单个相互作用的语句它就可以为’single‘（在最后一种情况下，表达式语句计算一些东西而不是None就会被输出）。

可选参数flags和dont_inherit 控制未来的声明将会影响source的编码。如果两个参数都没有指定，那么未来声明语句将会影响被complie（）调用的代码。如果flags参数给出了并且dont-inherit参数没有给出，那么未来声明语句就会通过被使用的flags参数来指定。最后一种情况，未来声明在编码的时候会被忽略。

未来声明是通过bits来指定的。bitfield需要指定一个可以在 _ future _ 组件中的_Feature 实例中compiler_flag属性中

参数optimize是用来指定编译器的优化等级；默认值为-1。可选值为0，1，2. the default value of -1 selects the optimization level of the interpreter as given by -O options. Explicit levels are 0 (no optimization; debug is true), 1 (asserts are removed, debug is false) or 2 (docstrings are removed too).

This function raises SyntaxError if the compiled source is invalid, and ValueError if the source contains null bytes.

类 complex([real[,imag]])
返回一个带有real + image*j值的复数或者转化为一个字符串。若第一个参数为字符串，它就会被翻译为一个辅助的数值而且在调用函数时不能带有第二个参数。第二个参数永远不能为字符串。两个参数可以为任何数值型（包括复数）。如果image被省略，它就默认为0并且构造器的作用就想是把数值转化为int或者folat类型。若两个参数都省略了，就返回0.

注意：当转换字符串时，字符串不能在+或者-号周围包含空白格。For example, complex(‘1+2j’) is fine, but complex(‘1 + 2j’) raises ValueError.

delattr（object，name）
这个函数与setattr相关。参数分别为一个对象和一个字符串。字符串必须为对象的一个属性名。该函数会删除这个属性。For example, delattr(x, ‘foobar’) is equivalent to del x.foobar.

dir（[object]）

没有参数，返回当前局部范围的names列表。当有一个参数时，就会返回对应object的有效属性列表。

若object有名为dir()的方法，这个方法就可以被调用而且一定会返回属性的列表。它允许object执行自定义的函数 getattr()或getattribute()来自定义dir（）呈现的属性。

若object没有提供dir()魔法方法，该函数就会尽量地从object的dict 属性中去获取收集信息，若有定义，就会从object的类型中获取。生产的结果列表不是必须完全完整的，而且当object有自定义魔法方法getattr() 时返回的结果也不一定是准确。

默认的dir()机制会随着对象类型的不同而有着不同的表现，它会以生成最相关的结果为目的而不是生成完整的信息：

若对象是一个组件对象，那么生产的列表就会包含组件的属性名。
若对象是typr或者class对象，生成的列表就会包含它的属性以及它递归的基础属性。
其他的情况，生成的列表就会包含对象的属性名，该对象的类属性名和它的类的基类属性。

生成的列表会按字母排序。例如：

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

注意：由于dir()主要是在使用者使用交互提示符时提供便利的函数，所以它会提供值得注意的名字集合而不是提供严格的或者完全已定义的名字集合，并且在释放内存时它的细节表现也许会被改变。例如metaclass（元类）属性是不会被提供的当传入的参数是一个类时。

divmod(a,b)

传入两个数值作为参数，返回由这两个参数做整数除法时的商和余数组成的数字对。在使用混合数学操作类型时，规则遵从应用二进制算法操作的规则。For integers, the result is the same as (a // b, a % b). For floating point numbers the result is (q, a % b), where q is usually math.floor(a / b) but may be 1 less than that. In any case q * b + a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b) < abs(b).

enumerate(iterable,start = 0)

返回一个枚举对象，参数iterable一定要为一个序列，一个迭代器，或者其他支持迭代的对象。next()方法会在被返回包含计数值和可迭代对象中取迭代的值的二元元组后被调用。

>>> 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')]

相当于：

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

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

该函数的参数为一个字符串和可选参数globals与locals。若可选参数有给出，参数globals一定要为一个字典，参数locals一定要为一个可映射对象。

参数expression会作为使用在局部或全局命名空间参数globals和locas的python表达式来被解析与计算。若参数golbals字典有给出并且缺少’buitins‘，那么在表达式被解析之前，当前的局部空间就会复制到参数globals中。这就意味着参数expression它通常是都可以访问标准的’builtins’组件并且受限的环境会被复制。若参数local被省略了，它就会默认为参数globals。若两个都被省略了，那么表达式就会在eval（）被调用的环境中执行。返回的值是表达式计算的结果。在其他情况下会出现语法错误的情况。

>>> x = 1
>>> eval('x+1')
2

该参数也可以用来对arbitrary代码对象（像通过compile()创建的对象）执行操作。在这种情况下code对象就代替字符串。如果code对象被’exec’用对模块参数进行编译，那么eval（）返回的结果就为None。

Hints: dynamic execution of statements is supported by the exec() function. The globals() and locals() functions returns the current global and local dictionary, respectively, which may be useful to pass around for use by eval() or exec().

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

这个函数提供了python代码的动态执行。object必须为字符串或者代码对象。若是字符串，该字符串就会被当成一组python语句一样被解析（除非语句错误发送）。若是代码对象，就会被简单地执行。在所有情况下，被执行的代码像文件输入一样被期望是有效的。需要注意的是在传入exec（）函数的代码中包含了函数定义的return和yield语句也许不会在外部进行使用。返回值为None。

在所有情况下，若可选部分被省略，代码就只会在当前范围内执行。若有提供globals参数，他一定要为字典，该字典用来作全局和局部变量。若参数globals和locals都有提供，那么它们就会被各自用作全局和局部变量。参数locals可以为任何可映射的对象。若exec（）有两个分割开的对象作为参数globals和locals，只要代码是在类定义中就可以被执行。

若参数globals字典不包含key__builtins__ 的值，一个在内置组件builtins中提到的字典就会在这个key的下面被插入。这样你就可以在将其传入exec()前插入你的builtins 字典到参数globals，执行代码时控制什么builtins是有效的。

注：内置函数globals()和locals()会各自返回当前全局和局部字典，它们可以作为函数exec（）的第二个或第三个参数。

filter（function，iterable）

对在函数function中返回true的可迭代对象iterable的元素构建为一个迭代器。可迭代对象iterable可以为数列，支持迭代的容器或者迭代器。若参数function为None，识别函数就假定为，对于迭代对象iterable中所有的元素为false的就被移除。

注意函数filter(function,iterable)与生成器表达式(item for item in iterable if function(item))相同。

类 float([x])

把数字或者字符x转换为浮点数结构。

若参数为字符，它可以包含小数，可选的前置正负符号和可选的内嵌空格。可选的符号可以为’+’或者’-‘;一个’+’号对于生成的值来说没有什么影响。参数也可以为一个代表NaN的字符，或者无穷大、无穷小。更确切地说，输入语法要遵循如下语法开头和结尾的空格字符都被移除：

sign ::= “+” | “-“
infinity ::= “Infinity” | “inf”
nan ::= “nan”
numeric_value ::= floatnumber | infinity | nan
numeric_string ::= [sign] numeric_value

这里的浮点数是一种python浮点文字设计，在章节’Floating point literals’中有详细讲解。大小写是不重要的，所以，你可以这样拼写无穷大‘inf’,’Inf’,’INFINITY’和’iNfINity’，这些都是可以接受的。

若参数是整数或者一个浮点数，就会返回一个相同值的浮点数对象。若参数超出python浮点对象的范围，那么OverflowError就会出现

对于python的对象x来说，float(x)就代表x.float()。

若没有参数传入，0.0就会被返回。

例子：

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

format(value[,format_spec])

把参数value转移到一个设计好的语句中，就像被参数format_spec控制一样。对参数format_spec的解释取决于参数value的类型，可是在许多的built-in类型中有许多被使用的标准设计语句：’Format Specification Mini-Language‘。

默认的format_spec值是像调用str(value)一样给出相同影响的空字符。

调用format(value, format_spec)时，python会将其转化为type(value).__format__(value, format_spec),当搜索值的__format__()方法时就传入实例字典。当该方法搜索一个对象并且参数format_spec不为空、不为字符或者返回值不为字符时就会报错。

类 frozenset（[iterable])

返回一个新的frozenset对象，从iterable.frozenset中获取的元素为内置类。

getattr(object,name[,default])

返回object的属性名。参数name必须为字符串。若字符串为object中的一个属性的属性名，返回的结果就是属性的值。例如，getattr(x,’foobar’)与x.foobar相等。若属性不存在，在提供default参数的情况下default会被返回，否则会报错。

globals()

返回陈述当前全局象征表的一个字典。它总是当前组件的字典。

hasattr（object，name）

参数为一个对象和一个字符串。若字符串为对象其中之一的属性名返回True，否则反之。

hash（object）

返回一个hash对象值。hash值为整数。他们是用来在进行字典查询时进行快速比对字典键值。

help([object])

调用内置的帮助系统。若没有给参数，那么交互帮助系统就会在翻译器的控制台开始。若参数为字符串，那么字符串就会被当作模块名、函数、类、方法、键值或文档标题来进行查找，然后会将帮助页面打印在控制台。若参数为对象，那么帮助页面就会在对象中进行生成。

hex(x)

把整数转化为小写形式带有’0x’的十六进制字符。若参数x不为python的int对象，那它必须要定义一个用来返回整数的__index()__方法。例子：

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

如果你想要把整数转换为大写或小写，带有前缀或不带有的形式，你可以使用下面的方法：

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

id(object)

返回对象的’identity’。

input([prompt])

若参数prompt有给出，那么它就会不带有结尾符号的标准输出行。函数会读取该行的输入，转换为字符串，并且返回它。当EOF被读取，EOFError就会出现。例子：

>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

类int(x=0)
类int(x,base=10)

返回一个通过数字或者字符X构建的整数对象，若无参数就返回0.若x是数字，返回x.__int__()。对于浮点数，它会合并0.

若x不为数字或参数base有给出，那么x就一定要为字符串，字节或者bytearray实例呈现在基数base内的整数文字。该文字可以在前面放置符号+或者-（不按插空格）和被空格围绕。一个基数为n的文字由数值0到n-1组成，对于a到z，代表值10到35.默认的基数为10，它允许值为0和2到36.基数为2，8和16文字就可以被选择性地在前面放置0b/0B, 0o/0O, 或 0x/0X，作为在代码中的整数文字。基数0意味着确切地翻译为代码文字，实际情况是基数只有2，8，10或16，所以int(‘010’,0)是非法的，不过int(‘010’)与int(‘010’, 8)相同。

isinstance(object,classinfo)

若参数object是参数classinfo的实例或子类就返回true。若参数object不是给出的lclassinfo对象，那么函数总是返回false。若classinfo是对象类型的元组，那么object只要是其中之一就返回true。若classinfo都不是以上几种情况，那么就会报错TypeError。

issubclass(class,classinfo)

若参数class是classinfo的子类就返回true。类本身可以被当作自己的子类。参数classinfo可以为类对象的元组，在这种情况下class只要为该元组中的元素之一的子类就返回true。在其他情况下，会报错TypeError。

iter（object[,sentinel])

返回要给迭代器对象。第一个参数对应不同的第二个参数会有不同的解释。在没有第二个参数的情况下，参数object一定要为支持迭代器协议（__iter__()方法），或者支持数列协议（可以从0开始带有整数参数的__getitem__()方法）。若是不支持以上两者，TypeError就会出现。若有给出第二个参数sentinel，那么参数object一定要为一个可调用对象。在这种情况下就会不带参数地调用对象只是通过每次调用它的__next__()方法来生成迭代器；若返回的值与参数sentinel相同，StopIteration就会出现，否则值会被返回。

第二种情况有用的场景之一就是读一个文件的行直道某一确定的行出现。下面的例子就是读取文件知道readline（）方法返回一个空的字符串：

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

len(s)

返回s的长度（项目的个数）。参数可以为数列（例如字符串，字节，元组，列表或者range），也可以为收集器（例如字典，集合或者frozen集合）。

类list([iterable])

与其说是为函数，list可以更确切地认为是一个易变的序列类型。

locals（）

返回一个呈现当前局部符号表的字典。当函数locals（）在函数模块中被调用，而不是在类模块中被调用时返回的内容是会变的。

map(function,iterable,…)

应用函数function对可迭代对象中的每一个元素进行操作生成对应的结果然后返回这些结果组成的迭代器。若附加的可迭代对象参数有给出，那么函数function就要取出所有参数并且并行地对所有的可迭代对象iterable中的元素进行操作生成对应结果。对于多元可迭代对象的情况，当最短的可迭代对象被取完时迭代器就会停止生成。

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

返回可迭代对象中最大的元素或者两个或多个参数中最大的哪一个。

若就给出了一个参数，他一定要为可迭代对象。可迭代对象中的最大元素要被返回。若给出了两个至多个参数，那么这些参数中值最大的参数就会被返回。

这个有两个唯可选的一关键字参数。参数key指定一个实参排序函数就像使用list.sort()一样。参数default指定一个对象进行返回当提供的可迭代对象为空时。若可迭代对象为空并且默认的default参数没有提供，那么ValueError就会出现。

若有多个元素为最大值，那么函数就会返回第一个出现的值。

memoryview(obj)

返回一个从给出的参数中创造的’memory view’对象。

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

与上面的max函数使用方法相似。

next（iterable[,default])

通过调用迭代器的__next()__魔法方法从迭代器中取回其下一个元素。若参数default有给出，在迭代器被取完的情况下该参数就会被返回，否则StopIteration就会出现。

类 object

返回一个新的无特征的对象。object是所有类的基础。它有的方法对于python中所有的类的实例来说都是拥有的。这个函数不接受任何参数。

注：object不存在__dict__魔法反法，所以你不能分配任意属性到object类的实例中去。

oct(x)

把整数转化为一个带有前缀’0o’八进制字符串。生成的结果为有效python表达式。若x不是python int 对象，那它就一定要定义一个返回整数__index__()魔法方法。例如：

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

如果你想不带有前缀’0o’地把整数转化为八进制字符，你可以使用一下方法。

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

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

打开file并且返回相一致的file对象。若file不能被打开，OSError就会出现。

参数file是一个相似路径对象给出被打开文件的路径名（当前工作绝对或者相对路径）或者被封装的文件的整数文件描述符。（若文件描述符有给出，当返回I/O口的对象被关闭时，文件就会被关闭，除非参数closefd被设置False）

可选参数为一个字符串用来指定被打开文件的模式。它默认为’r’意味为了读文本内容而打开的模式。其他常用值为’w’写操作（若文件已存在就会截断它），‘x’为单独生成操作和’a’为添加操作（在一些Unix系统中，意味所有的写操作都添加在文件结尾处不管当前文件seek的位置）。在文本模式下，编码要指定为平台的编码方式：locale.getpreferendencoding(False)可以用来读取当前平台的编码方式。

'r' open for reading (default)
'w' open for writing, truncating the file first
'x' open for exclusive creation, failing if the file already exists
'a' open for writing, appending to the end of the file if it exists
'b' binary mode
't' text mode (default)
'+' open a disk file for updating (reading and writing)
'U' universal newlines mode (deprecated)

默认的模式为’r’(为了读取文本而打开，与’rt’同义）。对于二进制数的读写操作，用’w+b’模式打开并且会把文档截断为0字节。’r+b’模式打开不会对文件截断。

在章节’Overview‘中有提示到，python对二进制和文本有着严格的区分。文档通过二进制模式打开就会返回没有任何解码的字节内容。在文本模式下，返回的文档内容会是字符串，字节会首先通过平台设置的编码方式或者使用指定的encoding若有给出的话。

可选参数buffering为整数用来设置缓冲策略。传入0为选择关闭缓冲（只能运行二进制模式），1为选择行缓冲（只能在文本模式中使用），当传入的整数大于1时显示已设定大小的缓冲器中字节的长度内容。当参数buffering有给出，默认的缓冲策略工作模式如下：

二进制文档在已设定长度的缓冲器区域中被缓冲；被选择的缓冲器的尺寸通过探索性地尝试去决定下层设备的’区域大小‘然后放回到io.DEFAULT_BUFFER_SIZE中。在许多系统中，缓冲器会为经典的4096或者8192字节长度。
’交互式的‘文本文档使用行缓冲机制。其他的文本文档使用的策略为上面二进制文档的策略。

参数encoding为用来解码或者编码文档的方式名称。这个参数只能用在文本模式中。默认的编码方式为平台设置好的方式。

可选参数errors为字符串其作用为指定在编码或解码错误的情况下会如何处理错误——它不能用在二进制模式中。标准错误处理器的种类都是有效的，寄存在codecs.register_error()中的任何错误处理方式也都是被确认有效的。标准的错误处理名包括：

'strict' to raise a ValueError exception if there is an encoding error. The default value of None has the same effect.

'ignore' ignores errors. Note that ignoring encoding errors can lead to data loss.

'replace' causes a replacement marker (such as '?') to be inserted where there is malformed data.

'surrogateescape' will represent any incorrect bytes as code points in the Unicode Private Use Area ranging from U+DC80 to U+DCFF. These private code points will then be turned back into the same bytes when the surrogateescape error handler is used when writing data. This is useful for processing files in an unknown encoding.

'xmlcharrefreplace' is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference &#nnn;.

'backslashreplace' replaces malformed data by Python’s backslashed escape sequences.

'namereplace' (also only supported when writing) replaces unsupported characters with \N{...} escape sequences.

参数newline控制通用的新行工作模式（它只能用在文本模式中）。它可以为None, ”, ‘\n’, ‘\r’, 和 ‘\r\n’。它如下工作：

When reading input from the stream, if newline is None, universal newlines mode is enabled. Lines in the input can end in '\n', '\r', or '\r\n', and these are translated into '\n' before being returned to the caller. If it is '', universal newlines mode is enabled, but line endings are returned to the caller untranslated. If it has any of the other legal values, input lines are only terminated by the given string, and the line ending is returned to the caller untranslated.

When writing output to the stream, if newline is None, any '\n' characters written are translated to the system default line separator, os.linesep. If newline is '' or '\n', no translation takes place. If newline is any of the other legal values, any '\n' characters written are translated to the given string.

若参数clasefd为False并且文档描述符有给出并非文档名，当文件关闭时底层文件描述符会继续保持打开。若文件名有给出那么参数clasefd就一定要为True否则会报错。

下面这段翻译不来…

A custom opener can be used by passing a callable as opener. The underlying file descriptor for the file object is then obtained by calling opener with (file, flags). opener must return an open file descriptor (passing os.open as opener results in functionality similar to passing None).

The newly created file is non-inheritable.

The following example uses the dir_fd parameter of the os.open() function to open a file relative to a given directory:

>>>
>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor
The type of file object returned by the open() function depends on the mode. When open() is used to open a file in a text mode ('w', 'r', 'wt', 'rt', etc.), it returns a subclass of io.TextIOBase (specifically io.TextIOWrapper). When used to open a file in a binary mode with buffering, the returned class is a subclass of io.BufferedIOBase. The exact class varies: in read binary mode, it returns an io.BufferedReader; in write binary and append binary modes, it returns an io.BufferedWriter, and in read/write mode, it returns an io.BufferedRandom. When buffering is disabled, the raw stream, a subclass of io.RawIOBase, io.FileIO, is returned.

See also the file handling modules, such as, fileinput, io (where open() is declared), os, os.path, tempfile, and shutil.

ord(c)

给出代表一个Unicode字符的字符串，返回一个代表该字符的Unicode位置的整数。例如，ord(a)就返回97，ord(a)就返回8364.它的反操作为chr（）。

pow(x,y[,z])

返回x的y次方；若z有给出，就返回x的y次方再对z取模（计算效率比pow(x, y) % z高）。pow（x ，y ）相当于使用乘幂操作：x**y。

参数一定要为数值类型。在有混合操作数类型的情况下，就会强制应用二进制算数操作规则。对于int操作数，返回一样的int操作数类型除非第二个参数为负数；在这种情况下，所以的参数都会被转化为浮点数然后返回的结果就生成了浮点数。例如，10**2为100，不过10**-2就为0.01.若第二参数为负，那么第三个参数就要被省略。若z有给出，那么x和y就必须为整数类型，并且y要为非负数的。

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

把object打印为文本流文件，用参数sep进行分割并且当要给出参数end,sep,end,file和flush时，一定要以关键字的形式给出。

所有非关键字参数都会被转化为字符串就像使用过str()函数一样然后写到文本流中，被参数sep分割并在结尾带有end参数。参数sep和end都要为字符串；它们可以为None，就意味使用默认值。若参数objects没有给出，print()就只会写出参数end的内容。

参数file一定为带有write（string）方法的对象；若它没有给出或者为None，sys.stdout就会被拿来使用。自从打印参数被转化为文本字符串，函数print()就不能用来处理二进制数。可以通过使用file.write(… )来代替。

类property（fget=None, fset=None,fdel=None,doc=None)
返回一个特征属性。

参数是一个要获取属性的函数。参数fset是一个设置属性值的函数。参数fdel是一个删除属性值的函数。参数doc把属性创建为文档字符串。

一个典型的管理属性x的定义如下：

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就会调取getter，c.x=value就会调取setter，del c.x会调取deleter。

若doc有给出，其就会成为特征属性的文档。否则，特征就会复制fgei的文档（若存在的话）。这样的话生成一个能够轻松地使用property（）函数作为装饰器的只读特征就是有可能的：

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

装饰器@property把voltage（）方法转到带有同名的只读属性的getter方法中，并且它为voltage设置了解释文档’Get the current voltage.’

一个property对象有getter，setter和deleter方法，它们能生成property的副本然后可以装饰函数使函数获得相对应的功能。下面的例子就能做最好的解释：

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

这段代码的与第一段完全相同。要确认有给出附加的函数名作为原始特征。（在此例中x就是原始特征）

返回的property对象与构建的参数一样有相同的fget，fset
和fdel属性。

range（stop）
range（start，stop[,step])

与其说是函数，range可以确切地说是稳定的数列类型。

repr(object)

返回一个包含可打印的代表对象的字符串。对于许多类型对象而言，这个函数的作用就是生成一个可以在传入eval()中会产生相同值的字符串，否则呈现的就是在尖括号中的字符串，该字符串内容为聚集了经常包含对象的名字和地址等附加信息的对象类型名。一个类可以通过定义__repr__()魔法方法来控制这个函数放回的实例。

reversed（seq）

返回一个相反的迭代器。seq一定要为有__reversed__()魔法方法或者支持数列协议的对象（the __len__()魔法方法和带有从0开始的整数参数的__getitem__()魔法方法）

round(number[,ndigits])

返回一个取整ndigits精度小数点的数值。若ndigits被省略或者为None，它就会返回四舍五入的结果。

对于内置支持round的类型而言，值对于负数的ndigits会被取值到最接近的10的倍数；若两个倍数相同，就会取整相同的值（例如，round（0.5）和round（-0.5）的结果都为0，round（1.5）为2）。任何整数值对于ndigits来说都是有效的（positive，zero或negative）。若只有一个参数返回的值就为整数，否则就是number类型的数。

Note The behavior of round() for floats can be surprising: for example, round(2.675, 2) gives 2.67 instead of the expected 2.68. This is not a bug: it’s a result of the fact that most decimal fractions can’t be represented exactly as a float. See Floating Point Arithmetic: Issues and Limitations for more information.

类 set([iterable])

返回一个从可迭代对象iterable中获取元素生成的set对象。set是内置的类。

setattr（object，name，value）

这是getattr（）的补充。参数为一个对象，一个字符串和随意的值。字符串可以为存在的属性名或者新属性。函数会分配知道这个属性中，让提供的object支持该操作。例如：setattr(x, 'foobar', 123) 与 x.foobar = 123相等.

类slice（stop）
类slice（start，stop[,step])

返回一个显示由range(start,stop,step)指定指数的集合的slice对象。参数start和step默认为None。Slice对象拥有只读数据属性start，stop和step它们只能返回参数值（或是它们的默认值）。他没有其他显示的功能；但是它经常用在Numerical Python和其他第三方插件中。当扩展索引语句被使用时Slice对象就会出现。例如：a[start:stop:step] 或 a[start:stop, i]。

sorted(iterable,*,key=None,reverse=False)

返回一个把可迭代对象iterable中的值重新排序的列表。

两个可选参数一定要指定为关键字参数。

key参数指定一个一元函数用来提取每个列表元素中用来对比的键：key=str.lower。默认值为None（直接地对比每个元素）

参数reverse为布尔值。若为True，那么排序就会颠倒。

staticmethod（function）

返回一个函数的静态方法。

一个静态方法不能接受隐式的参数。用下面的代码块可以来声明一个静态方法：

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

class str(object=”)
class str(object=b”, encoding=’utf-8’, errors=’strict’)

返回一个str对象。

sum(iterable[, start])

求和函数，start的值不允许为字符串。

在一些场景下，你可以选择''.join(sequence)''.join(sequence) 来合并字符串。

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

返回一个代表方法从type的父类或同类中调用的代理对象。它对于获取在类中被覆盖的继承方法这个操作来说是很有用的。搜索的序列是与使用getattr（）方法相一致除了参数type本身被跳过了。

type的属性__mro__会列出使用getattr（）和super（）的解析搜索的序列。这个属性是动态的而且会随继承等级更新而改变。

若第二个参数被省略，那么super返回的对象就没有限定。若为对象，那么isinstance(obj, type)就要为真。若为type，那么issubclass(type2, type)就要为真（这对类方法来说是有用的）

tuple（[iterable])
返回元组。

class type(object)
class type(name, bases, dict)

当有一个参数，就返回object的类型。返回的值是类型对象并且通常使用object.__class__返回的对象是相同。

内置函数isinstance（）被推荐拿去测试object的类型，因为它把子类也放入到报告中。

当传入三个参数，返回一个新的类型对象。这个一个基础的动态类声明形式。参数name字符串就是类的名字并且也会成为属性__name__;参数bases元组列出基类并且成为属性__bases__；参数dict字典为一个命名空间包含函数体的声明并且会被拷贝成一个标准字典成为属性__dict__。例如，下面两个声明都是创造相同的类对象：

>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

vars([object])

返回带有属性__dict__的组件，类，实例或者其他对象的__dict__属性。

像组件和实例的兑现有可更新的__dict__属性；不过，其他对象的属性__dict__就会限制重写（例如，类使用types.MappingProxyType来阻止直接对字典更新）

在没有参数的情况下，vars（）与locals（）的作用相似。注意，在局部字典被忽略后局部字典就只能用来读了。

zip(*iterables)

通过把每个可迭代对象iterable中的元素聚合在一起生成一个迭代器。

返回一个元组迭代器，第i个元组包含每一个参数序列或可迭代对象的第i个元素。当最短的可迭代对象被取尽后迭代器就停止生成了。若只有一个参数，它就会返回一维元组迭代器。在没有参数的情况下它就返回空的迭代器。该函数等于：

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

zip（）加上*操作符可以用来对zip过的对象进行反向操作：

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

三分之一给你

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python运维_third_chapter（2）

python内置函数源码地址： python内置函数随便翻译了一下，练练手。python解释器有些内置的函数它们随时都可以使用。abs(x)返回一个数的绝对值。其参数可以为整数或浮点数。如果参数是一个复数，它的magnitude就会被返回。all(iterable)如果可迭代对象中的所有元素都为真就返回真（或者可迭代对象为空时）any(iterable)如果可迭代对象中的任何一个元素为真就返回
复制链接

扫一扫

专栏目录