Python自動化開發學習的第四周------函數進階

1.裝飾器

定義：本質就是函數
功能：用來裝飾其餘函數，（就是爲其餘函數添加附加功能）
原則：
1.不能修改被裝飾的函數的源代碼
2.不能修改被裝飾的函數的調用方式
實現裝飾器知識儲備：
1.函數即「變量」
2.高級函數

變量能夠指向函數，函數的參數能接收變量，那麼一個函數就能夠接收另外一個函數做爲參數，這種函數就稱之爲高階函數。

1 def bar():
2     print("in the bar")
3 
4 def foo(func):
5     res=func()
6     return res
7 foo(bar)

2.1把一個函數當成實參傳給另一個函數（在不修改被裝飾函數源代碼的狀況下添加功能）
2.2返回值中包含函數名（不修改函數的調用方式）
3.嵌套函數

1 def foo():
2     def bar():
3         print （「in the bar」）
4  
5     bar()
6  
7 foo()

 

高階函數+嵌套函數=》裝飾器

裝飾器：

1.函數參數固定

import time
def timer(func):
    def deco():
        start_time=time.time()
        func()
        stop_time=time.time()
        print("the func run time %s" %(stop_time-start_time))
    return  deco
@timer
def test1():
    time.sleep(1)
    print("in the test1")
@timer
def test2():
    time.sleep(1)
    print("in the test2")
test1()
test2()

打印結果：

in the test1
the func run time 1.000126838684082
in the test2
the func run time 1.0001270771026611

2.函數參數不固定

import time
def timer(func):
    def deco(*args,**kwargs):
        start_time=time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print("the func run time %s" %(stop_time-start_time))
    return  deco
@timer
def test1():
    time.sleep(1)
    print("in the test1")
@timer
def test2(name):
    time.sleep(1)
    print("test2:",name)
test1()
test2("蒼老師")

打印結果：

in the test1
the func run time 1.0001270771026611
test2: 蒼老師
the func run time 1.0001270771026611

3.函數有返回值

name="hh"
passwd="123"

def auth(func):
    def wapper(*args,**kwargs):
        username=input("input your username:").strip()
        password=input("input your password:").strip()
        if username==name and password==passwd:
            print("\033[32;1mWelcome %s\033[0m"%username)
            return func(*args,**kwargs)
        else:
            exit("\033[31;1mInvalid username or password\033[0m")
    return wapper


def index():
    print("welcome to index")
@auth
def home():
    print("welcome to home")
    return "form home"
@auth
def bbs():
    print("welcome to bbs")

index()
print(home())
bbs()

打印結果：

welcome to index
input your username:hh
input your password:123
Welcome hh
welcome to home
form home
input your username:hh
input your password:123
Welcome hh
welcome to bbs

4.裝飾器沒有參數

name="hh"
passwd="123"

def auth(func):
    def wapper(*args,**kwargs):
        username=input("input your username:").strip()
        password=input("input your password:").strip()
        if username==name and password==passwd:
            print("\033[32;1mWelcome %s\033[0m"%username)
            return func(*args,**kwargs)
        else:
            exit("\033[31;1mInvalid username or password\033[0m")
    return wapper


def index():
    print("welcome to index")
@auth
def home():
    print("welcome to home")
    return "form home"
@auth
def bbs():
    print("welcome to bbs")

index()
print(home())
bbs()

打印結果：

welcome to index
input your username:hh
input your password:123
.Welcome hh
welcome to home
form home
input your username:hh
input your password:456
Invalid username or password

5.裝飾器有參數

name="hh"
passwd="123"
def auth(auth_type):
    print("auth_type:",auth_type)
    def out_wapper(func):
        def wapper(*args,**kwargs):
            print("auth_type:",*args,**kwargs)
            if auth_type=="local":
                username=input("input your username:").strip()
                password=input("input your password:").strip()
                if username==name and password==passwd:
                    print("\033[32;1mWelcome %s\033[0m"%username)
                    return func(*args,**kwargs)

                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type=="ldap":
                print("啥都不會")
        return wapper
    return out_wapper


def index():
    print("welcome to index")

@auth(auth_type="local")
def home():
    print("welcome to home")
    return "form home"

@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs")

index()
print(home())
bbs()

 打印結果：

auth_type: local
auth_type: ldap
welcome to index
auth_type:
input your username:hh
input your password:123
Welcome hh
welcome to home
form home
auth_type:
啥都不會

2.列表生成式

列表生成式，是python中內置的一種極其強大的生成list的表達式。

若是要生成一個list [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9] 能夠用 range(1 , 10)：

>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

但是，若是要生成[1*1 , 2*2 , 3*3 , ... , 10*10] 怎麼作呢？可使用循環：

>>> a=[]
>>> for i in range(1,10):
...     a.append(i*i)
...
>>> a
[1, 4, 9, 16, 25, 36, 49, 64, 81]

而列表生成式，能夠用一句代替以上的繁瑣循環來完成上面的操做：

>>> print([i*i for i in range(1,10)])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

列表生成式的書寫格式：[x*x for x in range(1 , 11)]

第一：把要生成的元素 x*x 放到前面

第二：後面跟上for循環

這樣就能夠把list建立出來，代碼簡潔。

for循環後面還能夠加上if判斷，這樣能夠篩選出偶數的平方：

>>> [i*i for i in range(1,10) if i%2==0]
[4, 16, 36, 64]

固然，使用兩層循環，生成全排列：

>>> print( [m + n for m in 'ABCD' for n in 'XYZ'])
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ', 'DX', 'DY', 'DZ']

如今有 list 中包含字符串，和整數，把list中得大寫字符轉爲小寫，推到出另一個list

一、使用內建的isinstance函數能夠判斷一個變量是否是字符串

二、s.lower() 能夠將一個大寫字母轉爲小寫。

三、增長if語句保證列表生成式正確執行。

L = ["Java" ,"C" , "Swift" , "Python" , 123]
print(s.lower() if isinstance(s,str) else s for s in L)
print([s.lower() if isinstance(s,str) else s for s in L])

打印結果：

<generator object <genexpr> at 0x0000000000B63A40>
['java', 'c', 'swift', 'python', 123]

3.生成器

經過列表生成式，咱們能夠直接建立一個列表。可是，受到內存限制，列表容量確定是有限的。並且，建立一個包含100萬個元素的列表，不只佔用很大的存儲空間，若是咱們僅僅須要訪問前面幾個元素，那後面絕大多數元素佔用的空間都白白浪費了。

因此，若是列表元素能夠按照某種算法推算出來，那咱們是否能夠在循環的過程當中不斷推算出後續的元素呢？這樣就沒必要建立完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱爲生成器：generator。　　

要建立一個generator，有不少種方法。第一種方法很簡單，只要把一個列表生成式的[]改爲()，就建立了一個generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

建立L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。

咱們能夠直接打印出list的每個元素，但咱們怎麼打印出generator的每個元素呢？

若是要一個一個打印出來，能夠經過next()函數得到generator的下一個返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

咱們講過，generator保存的是算法，每次調用next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，拋出StopIteration的錯誤。

固然，上面這種不斷調用next(g)實在是太變態了，正確的方法是使用for循環，由於generator也是可迭代對象：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
...
0
1
4
9
16
25
36
49
64
81

因此，咱們建立了一個generator後，基本上永遠不會調用next()，而是經過for循環來迭代它，而且不須要關心StopIteration的錯誤。

generator很是強大。若是推算的算法比較複雜，用相似列表生成式的for循環沒法實現的時候，還能夠用函數來實現。

好比，著名的斐波那契數列（Fibonacci），除第一個和第二個數外，任意一個數均可由前兩個數相加獲得：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波那契數列用列表生成式寫不出來，可是，用函數把它打印出來卻很容易：

def fib(max):
    n,a,b = 0,0,1
    while n<max:
        print(b)
        a,b = b,a+b
        n+=1
    return "----done----"

fib(10)

結果：
1
1
2
3
5
8
13
21
34
55

仔細觀察，能夠看出，fib函數其實是定義了斐波那契數列的推算規則，能夠從第一個元素開始，推算出後續任意的元素，這種邏輯其實很是相似generator。

也就是說，上面的函數和generator僅一步之遙。要把fib函數變成generator，只須要把print(b)改成yield b就能夠了：

def fib(max):
    n,a,b = 0,0,1
    while n<max:
        #print(b)
        yield b
        a,b = b,a+b
        n+=1
    return "----done----"

f=fib(10)
print(f)

結果：
<generator object fib at 0x0000000000A13B48>

這就是定義generator的另外一種方法。若是一個函數定義中包含yield關鍵字，那麼這個函數就再也不是一個普通函數，而是一個generator：

這裏，最難理解的就是generator和函數的執行流程不同。函數是順序執行，遇到return語句或者最後一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

def fib(max):
    n,a,b = 0,0,1
    while n<max:
        #print(b)
        yield b
        a,b = b,a+b
        n+=1
    return "----done----"

f=fib(10)
print(f)
print(f.__next__())
print(f.__next__())
print("我是插進來的")
print(f.__next__())
print(f.__next__())
print(f.__next__())

結果：
<generator object fib at 0x0000000000473BA0>
1
1
我是插進來的
2
3
5

在上面fib的例子，咱們在循環過程當中不斷調用yield，就會不斷中斷。固然要給循環設置一個條件來退出循環，否則就會產生一個無限數列出來。

一樣的，把函數改爲generator後，咱們基本上歷來不會用next()來獲取下一個返回值，而是直接使用for循環來迭代：

def fib(max):
    n,a,b = 0,0,1
    while n<max:
        #print(b)
        yield b
        a,b = b,a+b
        n+=1
    return "----done----"

f=fib(10)
print(f)
print(f.__next__())
print(f.__next__())
print("我是插進來的")
print(f.__next__())
print(f.__next__())
print(f.__next__())
for i in f:
    print(i)

結果：
<generator object fib at 0x00000000005F3BA0>
1
1
我是插進來的
2
3
5
8
13
21
34
55

可是用for循環調用generator時，發現拿不到generator的return語句的返回值。若是想要拿到返回值，必須捕獲StopIteration錯誤，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

經過yield實如今單線程的狀況下實現併發運算的效果

import time
def consumer(name):
    print("%s 準備吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]來了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子開始準備作包子啦!")
    for i in range(10):
        time.sleep(1)
        print("作了2個包子!")
        c.send(i)
        c2.send(i)

producer("alex")

生成器總結：

1.生成器不會把結果保存在一個系列中，而是保存生成器的狀態，在每次進行迭代時返回一個值，直到遇到StopIteration異常結束，只有在調用時纔會生成相應的數據。

2.生成器表達式： 通列表解析語法，只不過把列表解析的[]換成()，生成器表達式能作的事情列表解析基本都能處理，只不過在須要處理的序列比較大時，列表解析比較費內存。

3.在函數中若是出現了yield關鍵字，那麼該函數就再也不是普通函數，而是生成器函數。

yield 的做用就是把一個函數變成一個 generator，帶有 yield 的函數再也不是一個普通函數，Python 解釋器會將其視爲一個 generator。

 4.yield 與 return

在一個生成器中，若是沒有return，則默認執行到函數完畢時返回StopIteration；

若是遇到return,若是在執行過程當中 return，則直接拋出 StopIteration 終止迭代。

若是在return後返回一個值，那麼這個值爲StopIteration異常的說明，不是程序的返回值。

生成器沒有辦法使用return來返回值。

 5.生成器支持的方法 

close()

手動關閉生成器函數，後面的調用會直接返回StopIteration異常。

send()

生成器函數最大的特色是能夠接受外部傳入的一個變量，並根據變量內容計算結果後返回。
這是生成器函數最難理解的地方，也是最重要的地方，實現後面的協程就全靠它了。

 throw()

用來向生成器函數送入一個異常，能夠結束系統定義的異常，或者自定義的異常。
throw()後直接跑出異常並結束程序，或者消耗掉一個yield，或者在沒有下一個yield的時候直接進行到程序的結尾。

4.迭代器

咱們已經知道，能夠直接做用於for循環的數據類型有如下幾種：

一類是集合數據類型，如list、tuple、dict、set、str等；

一類是generator，包括生成器和帶yield的generator function。

這些能夠直接做用於for循環的對象統稱爲可迭代對象：Iterable。

可使用isinstance()判斷一個對象是不是Iterable對象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但能夠做用於for循環，還能夠被next()函數不斷調用並返回下一個值，直到最後拋出StopIteration錯誤表示沒法繼續返回下一個值了。

*能夠被next()函數調用並不斷返回下一個值的對象稱爲迭代器：Iterator。

可使用isinstance()判斷一個對象是不是Iterator對象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)

生成器都是Iterator對象，但list、dict、str雖然是Iterable，卻不是Iterator。

把list、dict、str等Iterable變成Iterator可使用iter()函數：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能會問，爲何list、dict、str等數據類型不是Iterator？

這是由於Python的Iterator對象表示的是一個數據流，Iterator對象能夠被next()函數調用並不斷返回下一個數據，直到沒有數據時拋出StopIteration錯誤。能夠把這個數據流看作是一個有序序列，但咱們卻不能提早知道序列的長度，只能不斷經過next()函數實現按需計算下一個數據，因此Iterator的計算是惰性的，只有在須要返回下一個數據時它纔會計算。

Iterator甚至能夠表示一個無限大的數據流，例如全體天然數。而使用list是永遠不可能存儲全體天然數的。

 

小結

凡是可做用於for循環的對象都是Iterable類型；

凡是可做用於next()函數的對象都是Iterator類型，它們表示一個惰性計算的序列；

集合數據類型如list、dict、str等是Iterable但不是Iterator，不過能夠經過iter()函數得到一個Iterator對象。

Python的for循環本質上就是經過不斷調用next()函數實現的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

實際上徹底等價於：

# 首先得到Iterator對象:
it = iter([1, 2, 3, 4, 5])
# 循環:
while True:
    try:
        # 得到下一個值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循環
        break

5.內置函數

abs (x)

返回一個數的絕對值。參數多是整數或浮點數。若是參數是一個複數,返回它的大小。

>>> abs(-1)
1
>>> abs(2)
2
>>> abs(-123)
123

all (iterable)

返回 True若是全部的元素iterable真(或者若是iterable爲空)。等價於:

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

any (iterable)

返回 True若是任何元素的iterable是正確的。若是iterable爲空,返回 False。等價於:

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

ascii (對象)

做爲 repr()返回一個字符串,包含一個可打印的表示一個對象,可是逃避返回的字符串中的非ascii字符 repr()使用 \x, \u或 \U逃跑了。這生成一個字符串返回的類似 repr()在Python中2。

>>> [ascii([1,2,"abc"])]
["[1, 2, 'abc']"]

bin (x)

將一個整數轉換成一個二進制字符串。結果是一個有效的Python表達式。若是x是Python int對象,它必須定義一個 __index__()方法返回一個整數。

>>> bin(2)
'0b10'
>>> bin(4)
'0b100'
>>> bin(8)
'0b1000'
>>> bin(9)
'0b1001'

類  bool ([x])

返回一個布爾值,即之一 True或 False。x是使用標準的轉換 真理的檢驗程序。若是x是虛假或省略,這個回報 False;不然它返回 True。的 bool類的一個子類 int(見 數值類型,int、浮點數、複雜)。它不能再進一步。它惟一的實例 False和 True(見 布爾值).

>>> bool(1)
True
>>> bool(0)
False

類  bytearray ([源[,編碼[,錯誤]]])

返回一個新的數組的字節數。的 bytearray類是一個可變的序列的整數範圍0 < = x < 256。它具備可變序列的最多見的方法,描述了 可變序列類型,以及大多數的方法 bytes類型,看 字節和中Bytearray操做.

可選的源參數能夠用來初始化數組在幾個不一樣的方式:

• 若是它是一個字符串,你還必須給編碼(和可選地,錯誤)參數; bytearray()而後將字符串轉換成字節使用 str.encode().
• 若是它是一個整數,該數組將與空字節大小和將被初始化。
• 若是它是一個對象符合緩衝界面,一個只讀緩衝區將被用來初始化對象的字節數組。
• 若是它是一個iterable,它必須是一個整數的iterable範圍 0 <= x < 256,這是做爲數組的初始內容。

沒有一個論點,建立了一個數組大小爲0。

另請參閱 二進制序列類型——字節中bytearray,memoryview和 中Bytearray對象.

類  bytes ([源[,編碼[,錯誤]]])

返回一個新的「字節」對象,這是一個不可變的序列的整數範圍 0 <= x < 256. bytes不可變的版本嗎 bytearray接觸非變異——它有相同的刺突的方法和相同的索引和切片的行爲。

所以,構造函數參數解釋爲 bytearray().

字節對象也能夠建立文字,明白了 文本字符串和字節.

另請參閱 二進制序列類型——字節中bytearray,memoryview, 字節, 字節和中Bytearray操做.

>>> a= bytes("abcde",encoding="utf-8")
>>> b= bytearray("abcde",encoding="utf-8")
>>> print(a[0])
97
>>> print(a[1])
98
>>> print(b[0])
97
>>> print(b[1])
98
>>> a[0]=100
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment
>>> b[0]=100
>>> print(b)
bytearray(b'dbcde')

callable (對象)

返回 True若是對象參數出現可調用的, False若是不是。若是返回true,它仍然是有可能的,調用失敗,可是若是它是假的,調用對象永遠不會成功。注意,類是可調用(調用一個類返回一個新實例);若是他們的類有一個可調用的實例__call__()方法。

在新的3.2版本:這個函數首先移除在Python 3.0,而後帶回在Python 3.2。

>>> def hello():pass
...

>>> print(callable(hello))
True
>>> print(callable([]))
False

chr (我)

返回的字符串表明一個字符的Unicode代碼點整我。例如, chr(97)返回的字符串 'a',而 chr(8364)返回的字符串 '€'。這是的倒數 ord().

參數的有效範圍從0到1114111年(0 x10ffff基地16)。 ValueError若是我不在這個範圍將提升。

>>> chr(98)
'b'
>>> chr(8523)
'\u214b'
>>> chr(87)
'W'

classmethod (函數)

函數返回一個類方法。

一個類方法接收類隱式的第一個參數,就像一個實例方法接收實例。聲明一個類方法,使用這個成語:

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

的 @classmethod表單是一個函數 裝飾——看到函數定義的描述 函數定義獲取詳細信息。

它能夠被稱爲類(如 C.f()(好比)或在一個實例 C().f())。除了它的類實例被忽略。若是一個類派生類的方法被調用時,派生類對象做爲隱含第一個參數傳遞。

類方法是不一樣的比c++或Java靜態方法。若是你想要這些,明白了 staticmethod()在這一節中。

關於類方法的更多信息,請參考文檔標準類型層次結構 標準的類型層次結構.

compile (源、文件名模式,旗幟= 0,dont_inherit = False,優化= 1)

編譯成一個源代碼或AST對象。對象能夠執行的代碼 exec()或 eval()。來源能夠是一個普通的字符串,一個字節的字符串,或一個AST對象。指的是 ast模塊的文檔信息如何使用AST對象。

文件名參數應該給文件的代碼閱讀,經過一些可識別的值若是不是從文件讀('<string>'是經常使用的)。

模式參數指定什麼樣的代碼必須被編譯,就能夠 'exec'若是源由一系列的語句, 'eval'若是它包含一個表達式,或 'single'若是它包括一個交互式的聲明(在後一種狀況下,表達式語句,評估之外的東西 None將打印)。

將來的可選參數標誌和dont_inherit控制語句(見PEP 236)影響源的編譯。若是不存在(或爲零)的代碼編譯與將來的語句中實際上調用的代碼 compile()。若是旗幟參數是dont_inherit並非(或爲零),那麼將來語句指定的標誌使用參數除了那些將使用。若是dont_inherit是一個非零的整數,那麼旗幟的論點是,將來在調用編譯語句實際上被忽略。

將來語句指定比特可按位或共同指定多個語句。所需的設置指定給定的特性能夠發現 compiler_flag屬性 _Feature實例的 __future__模塊。

參數優化指定編譯器的優化級別;默認值的 -1選擇的翻譯的優化級別 -O選項。明確的水平 0(沒有優化; __debug__是正確的), 1(斷言移除, __debug__是假的)或 2(刪除文檔字符串)。

這個函數了 SyntaxError若是編譯源無效 ValueError若是源包含空字節。

若是你想Python代碼解析成AST表示,看到的 ast.parse().

請注意

當編譯一個字符串與多行代碼 'single'或 'eval'模式下,輸入必須終止由至少一個換行符。這是爲了方便檢測不完整的和完整的語句 code模塊。

3.2版本的變化:容許使用Windows和Mac換行。也投入 'exec'模式沒有以換行符結束了。增長了優化參數。

3.5版本的變化:在此以前, TypeError長大當空字節中遇到的來源。

類  complex ([真正的[,圖像放大]])

返回一個與真實值+複數圖像放大* 1 j或字符串或數字轉換爲複數。若是第一個參數是一個字符串,它將被視爲複數和函數必須調用第二個參數。第二個參數不能是一個字符串。每一個參數能夠是任何數字類型(包括複雜)。若是省略圖像放大,它默認爲零和構造函數做爲一個數字轉換 int和 float。若是兩個參數省略,回報 0j.

請注意

當轉換從一個字符串,字符串必須不包含空格在中央 +或 -操做符。例如, complex('1+2j')是能夠的,但 complex('1 + 2j')提出了 ValueError.

描述的複雜類型 數值類型,int、浮點數、複雜.

3.6版本的變化:分組代碼中位數與下劃線文字是被容許的。

delattr (對象,的名字)

這是一個相對的 setattr()。的參數是一個對象和一個字符串。字符串必須是一個對象的屬性的名稱。該函數刪除指定的屬性,提供了對象容許它。例如, delattr(x, 'foobar')至關於 del x.foobar.

類  dict (* * kwarg)

類  dict (映射,* * kwarg)

類  dict (iterable,* * kwarg)

建立一個新字典。的 dict對象字典類。看到 dict和 映射類型——dict類型關於這個類的文檔。

對於其餘容器內置 list, set, tuple類,以及 collections模塊。

dir ([對象])

沒有參數,返回當前局部範圍的名單。與論證,試圖返回有效的屬性的對象的列表。

若是對象有一個名爲的方法 __dir__(),這個方法將被稱爲,必須返回屬性的列表。這樣就能夠實現一個自定義的對象 __getattr__()或 __getattribute__()功能定製 dir()報告它們的屬性。

若是對象沒有提供 __dir__(),功能儘可能從對象的收集信息 __dict__屬性,若是定義,並從其類型對象。結果不必定是完整的列表,和對象有一個自定義時可能不許確 __getattr__().

默認的 dir()機制不一樣的行爲與不一樣類型的對象,由於它試圖產生最相關的,而不是完整的信息:

• 若是對象是一個模塊對象,列表包含模塊的屬性的名稱。
• 若是對象是一個類型或類對象,列表包含它的屬性的名稱和屬性的遞歸的基地。
• 不然,該列表包含該對象的屬性的名稱、類的屬性的名稱和屬性的遞歸的類的基類。

生成的列表按字母順序排序。例如:

>>> a={}
>>> dir(a)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__forma
t__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__
le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setat
tr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get
', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>>

請注意

由於 dir()主要是提供方便使用交互式提示符,它試圖提供一組有趣的名字超過它試圖提供一個嚴格或定義一致的組名稱,並在發佈其詳細的行爲可能會改變。例如,元類屬性不是在結果列表參數是一個類。

divmod (一個,b)

取兩個(非複雜)的數字做爲參數並返回一個數字組成的商和餘數當使用整數的除法。與混合操做數類型,二進制算術運算符的規則適用。爲整數,結果是同樣的 (a // b, a % b)。浮點數結果 (q, a % b)一般,問 math.floor(a /b)但可能小於1。在任何狀況下 q * b + a % b很是接近,若是 a % b非零和b同樣的標誌,而後呢 0 <= abs(a % b) < abs(b).

enumerate (iterable,= 0開始)

返回一個枚舉對象。iterable必須是一個序列,一個 迭代器或其餘對象支持迭代。的 __next__()返回的迭代器的方法 enumerate()返回一個元組,其中包含一個計數(從開始默認爲0),並得到的值遍歷iterable。

>>>

>> 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 (表達式,全局變量=沒有當地人=沒有)【字符串轉成字典】

參數是一個字符串,可選的全局和當地人。若是提供,全局變量必須是一個字典。若是提供,當地人能夠是任何對象的映射。

解析表達式參數和評估做爲一個Python表達式(技術上來講,一個條件列表)使用全局和本地詞典做爲全球和本地名稱空間。若是存在全局字典,缺少「__builtins__」,當前全局變量複製到全局解析表達式。這意味着表達式一般有徹底訪問的標準 builtins模塊和限制環境傳播。若是省略當地人字典它默認爲全局字典。若是字典都省略了,表達式是在環境中執行 eval()被稱爲。返回值是計算表達式的結果。語法錯誤報告爲例外。例子:

>>>

>>> x=1

>>> eval('x+1')

2

這個函數也能夠用來執行任意代碼(好比由對象 compile())。在這種狀況下,傳遞一個代碼對象,而不是一個字符串。若是代碼對象編譯了 'exec'做爲模式的參數, eval()的返回值 None.

提示:支持動態執行語句 exec()函數。的 globals()和 locals()函數返回當前全球和本地詞典,分別,這多是有用的在使用的 eval()或 exec().

看到 ast.literal_eval()爲一個函數,能夠安全評估與表達式只包含字符串字面值。

exec (對象[,全局變量[,當地人]])

這個函數支持Python代碼的動態執行。對象必須是一個字符串或對象代碼。若是它是一個字符串,字符串解析爲一套而後執行Python語句(除非出現語法錯誤)。[1]若是它是一個代碼的��象,它只是執行。在全部狀況下,預計將是有效執行的代碼文件輸入(見參考手冊中的部分「輸入文件」)。請注意, return和 yield語句以外不得使用函數定義的上下文中甚至代碼傳遞到 exec()函數。返回值是 None.

在全部狀況下,若是省略可選的部分,執行代碼在當前的範圍。若是全局變量,它必須是一個字典,將用於全球和本地變量。若是全局變量和當地人,他們用於全球和本地變量,分別。若是提供,當地人能夠是任何對象的映射。記住,在模塊級別,全局和當地人是相同的字典。若是執行兩個獨立的對象做爲全局變量和當地居民,將執行的代碼,就好像它是嵌入在一個類的定義。

若是全局字典不包含一個值的關鍵 __builtins__,內置的詞典模塊 builtins插入鑰匙。這樣你能夠控制內置命令能夠執行代碼插入本身的 __builtins__字典到全局變量傳遞以前 exec().

請注意

內置的功能 globals()和 locals()返回當前全球和本地詞典,分別,這多是有用的在第二和第三個參數使用 exec().

請注意

默認的當地人做爲函數的描述 locals()下圖:修改默認當地人字典不該該嘗試。經過顯式的當地人字典若是你須要看後的代碼對當地人的影響函數 exec()的回報。

filter (函數,iterable)【一組數據中，過濾出你須要的】

從這些元素的iterable構造迭代器函數返回true。iterable能夠是一個���列,一個容器支持迭代,迭代器。若是函數是 None,恆等函數假設,即全部元素的iterable假被刪除。

請注意, filter(function, iterable)至關於生成器表達式 (item for item in iterable if function(item))若是函數不 None和 (item for item in iterable if item)若是函數是 None.

看到 itertools.filterfalse()iterable互補函數,它返回元素的函數返回false。

res=filter(lambda n:n>5,range(10))
for i in res:
    print(i)

6
7
8
9

類  float ([x])

返回一個浮點數由一個數字或字符串x。

若是參數是一個字符串,它應該包含一個十進制數,選擇以前簽署,有選擇地嵌入空格。可選的跡象 '+'或 '-'; '+'對產生的價值沒有影響。參數也能夠是一個字符串表明南(不是一個數字),或積極或消極的無窮。更準確地說,輸入後必須符合如下語法前導和尾隨空白字符刪除:

簽名::= " + " |「-」
無窮::=「∞」|「正」
南::= "南"
numeric_value::= |  | 
numeric_string::=(] floatnumberinfinitynansignnumeric_value

在這裏 floatnumberPython浮點文字的形式,描述在嗎 浮點文字。狀況並不明顯,因此,例如,「正」、「正」、「∞」和「∞」都是可接受的拼寫爲正無窮。

不然,若是參數是一個整數或浮點數,浮點數和相同的值(在Python的浮點精度)返回。若是參數是一個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

浮子式中描述 數值類型,int、浮點數、複雜.

3.6版本的變化:分組代碼中位數與下劃線文字是被容許的。

format (價值[,format_spec])

將一個值轉換爲一個表示「格式化」,由format_spec控制。解釋format_spec取決於值的類型參數,然而有一個標準格式使用語法,最內置類型: 格式規範迷你語言.

默認format_spec是一個空字符串一般給調用相同的效果 str(value).

調用 format(value, format_spec)是翻譯 type(value).__format__(value, format_spec)它繞過了實例的字典當尋找價值的 __format__()方法。一個 TypeError若是搜索的方法達到異常 objectformat_spec非空,或者若是format_spec或返回值不是字符串。

3.4版本的變化: object().__format__(format_spec)提出了 TypeError若是format_spec不是一個空字符串。

類  frozenset ([iterable])【不可變集合】

返回一個新的 frozenset對象,可選元素取自iterable。 frozenset是一個內置的類。看到 frozenset和 類型——集合,frozenset關於這個類的文檔。

對於其餘容器內置 set, list, tuple, dict類,以及 collections模塊。

getattr (對象,的名字[,默認的])

返回指定屬性的值的對象。名稱必須是一個字符串。若是字符串是對象的一個屬性的名字,結果是,屬性的值。例如, getattr(x, 'foobar')至關於 x.foobar。若是指定的屬性不存在,返回默認若是提供,不然 AttributeError是提升。

globals ()【返回整個程序裏面的變量和變量值的字典形式，變量：keys  變量值：vlaues】

返回一個表明當前全局符號表字典。這老是當前模塊的字典(在一個函數或方法,這是定義的模塊,不叫作的模塊)。

>>> globals()
{'Iterable': <class 'collections.abc.Iterable'>, 'Iterator': <class 'collections.abc.Iterator'>, 'he
llo': <function hello at 0x0000000000D71B70>, '__builtins__': <module 'builtins' (built-in)>, '__pac
kage__': None, 'b': bytearray(b'dbcde'), '__doc__': None, 'res': <filter object at 0x0000000000D7886
0>, '__name__': '__main__', '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporte
r'>, 'a': 'abcd'}
>>>

hasattr (對象,的名字)

的參數是一個對象和一個字符串。結果是 True若是字符串是對象的一個屬性的名字, False若是不是。(這是經過調用實現的 getattr(object, name)看到它是否提出了一個 AttributeError不信)。

hash (對象)

返回對象的散列值(若是它有一個)。散列值是整數。他們是用來快速比較在字典查找字典鍵。數值比較平等有相同的散列值(即便他們是不一樣類型的,1和1.0)同樣。

請注意

與自定義對象 __hash__()方法,注意, hash()返回值截斷基於主機的位寬。看到 __hash__()獲取詳細信息。

help ([對象])

調用內置的幫助系統。(這個函數是用於交互式使用。)若是沒有參數,翻譯上的互動幫助系統啓動控制檯。若是參數是一個字符串,字符串查找模塊的名稱,函數,類,方法,關鍵字,或文檔的主題,一個幫助頁面打印在控制檯上。若是參數是任何其餘類型的對象,生成一個對象上的幫助頁面。

這個函數添加到內置的名稱空間 site模塊。

3.4版本的變化:更改 pydoc和 inspect意味着報道簽名可調用如今更全面和一致的。

hex (x)

把一個整數轉換成小寫的十六進制字符串前綴「0 x」,例如:

>>> hex(1)
'0x1'
>>> hex(16)
'0x10'
>>> hex(32)
'0x20'
>>> hex(255)
'0xff'

若是x是Python int對象,它必須定義一個__index__()方法,它返回一個整數。

另請參閱 int()將十六進制字符串轉換爲一個整數使用16的基地。

請注意

得到一個浮動的十六進制字符串表示,使用 float.hex()方法。

id (對象)

返回一個對象的「身份」。這是一個整數保證獨特和常數這個對象在它的生命週期。兩個對象重疊壽命可能有相同的 id()價值。

CPython的實現細節:這是在內存中對象的地址。

input ([提示])

若是提示存在爭論,末尾寫到標準輸出沒有換行符。從輸入函數而後讀取一行,將其轉換爲一個字符串(剝離後換行),並返回。當EOF閱讀, EOFError是提升。例子:

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

若是 readline模塊被加載 input()將使用它來提供詳盡的行編輯和歷史特徵。

類  int (x = 0)

類  int (x,基礎= 10)

返回一個整數對象由一個數字或字符串x,或者退貨 0若是沒有參數。若是x是一個數字,回報 x.__int__()。對於浮點數,這對截斷零。

若是x不是不少或者基地,那麼x必須是一個字符串, bytes,或 bytearray實例表明一個 整數字面在基數基礎。可選地,能夠以前的文字 +或 -(沒有之間的空間)和周圍的空白。base-n文字由數字0到n - 1, a來 z(或 A來 Z10 - 35)值。默認的基礎是10。容許的值是0,轉動。以2爲底,8,-16文字能夠選擇前綴 0b/0B, 0o/0O,或 0x/0X在代碼中,與整數文字。基地0意味着代碼字面解釋同樣,因此實際的基礎是2,8,10或16,因此 int('010', 0)是不合法的,int('010')是,以及 int('010', 8).

描述的整數類型 數值類型,int、浮點數、複雜.

3.4版本的變化:若是基礎不是的一個實例 int和基礎對象 base.__index__方法,調用方法得到一個整數的基地。使用之前的版本 base.__int__而不是 base.__index__.

3.6版本的變化:分組代碼中位數與下劃線文字是被容許的。

isinstance (對象,classinfo)

返回true,若是參數是對象的一個實例classinfo論點,或(直接、間接或 虛擬)子類。若是對象不是一個給定類型的對象,函數始終返回false。若是classinfo tuple類型的對象(或遞歸,其餘元組),返回true,若是對象是任何類型的一個實例。若是classinfo不是一個類型或元組的類型和元組等 TypeError例外。

issubclass (類,classinfo)

返回true,若是類(直接、間接或一個子類 虛擬classinfo)。一個類被認爲是自身的一個子類。classinfo多是一個類對象的元組,在這種狀況下,每個進入classinfo將檢查。在任何其餘狀況下, TypeError例外。

iter (對象[,哨兵])

返回一個 迭代器對象。第一個參數是解釋不一樣的根據第二個參數的存在。沒有第二個參數,對象必須是一組對象支持迭代協議( __iter__()方法),或它必須支持序列協議( __getitem__()方法用整數參數開始 0)。若是它不支持的協議, TypeError是提升。哨兵,若是第二個參數,那麼對象必須是一個可調用對象。在這種狀況下,建立的迭代器將爲每一個調用不帶參數調用對象 __next__()方法;若是返回的值等於哨兵, StopIteration將提升,不然將返回值。

另請參閱 迭代器類型.

第二種的一個有用的應用程序 iter()是讀取行一個文件直到到達必定行。下面的例子將讀取一個文件,直到 readline()方法返回一個空字符串:

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

len (年代)

返回對象的長度(項目)的數量。參數能夠是一個序列(如一個字符串,字節,tuple,列表,或範圍)或一組(如字典、集,或冷凍集)。

類  list ([iterable])

而不是一個函數, list其實是一個可變的序列類型,記錄在嗎 列表和 序列類型——列表、元組、範圍.

locals ()【返回局部變量裏面的數據】

字典更新並返回一個表示當前本地符號表。自由變量返回 locals()當它被稱爲功能塊,但不是在課堂上。

請注意

這本字典的內容不該被修改;變化可能不會影響當地和自由變量的值所使用的翻譯。

map (函數,iterable, ...)

返回一個迭代器函數適用於每件iterable,產生結果。若是額外iterable參數傳遞,函數必須採起許多參數和應用於項目並行iterable。與多個iterable,迭代器中止當最短的iterable耗盡。狀況下,函數已經安排輸入參數元組,明白了itertools.starmap().

max (iterable, *[的關鍵,默認的])

max (__arg一、最長,* args[,關鍵])

返回iterable或最大的項目中最大的兩個或兩個以上的參數。

若是提供了一個位置參數,它應該是一個 iterable。最大的項目返回iterable。若是提供兩個或兩個以上的位置參數,返��最大的位置參數。

有兩個可選keyword-only參數。關鍵參數指定一個參數排序函數用於 list.sort()。默認參數指定一個對象返回,若是提供iterable是空的。若是iterable爲空,默認不提供, ValueError是提升。

若是多個項目最大,函數返回第一個。這是符合其餘sort-stability保留等工具 sorted(iterable, key=keyfunc, reverse=True)[0]和 heapq.nlargest(1, iterable, key=keyfunc).

在新的3.4版本:默認keyword-only論點。

res=map(lambda n:n>5,range(10))
for i in res:
   print(i)

False
False
False
False
False
False
True
True
True
True

memoryview (obj)

返回一個「內存視圖對象建立從給定的參數。看到 內存視圖爲更多的信息。

min (iterable, *[的關鍵,默認的])

min (__arg一、最長,* args[,關鍵])

返回最小項iterable或最小的兩個或兩個以上的參數。

若是提供了一個位置參數,它應該是一個 iterable。最小的項目返回iterable。若是提供兩個或兩個以上的位置參數,返回最小的位置參數。

有兩個可選keyword-only參數。關鍵參數指定一個參數排序函數用於 list.sort()。默認參數指定一個對象返回,若是提供iterable是空的。若是iterable爲空,默認不提供, ValueError是提升。

若是多個項目是最小的,函數返回第一個。這是符合其餘sort-stability保留等工具 sorted(iterable, key=keyfunc)[0]和 heapq.nsmallest(1, iterable, key=keyfunc).

在新的3.4版本:默認keyword-only論點。

next (迭代器[,默認的])

檢索從迭代器經過調用它的下一個項目 __next__()方法。若是違約,它返回迭代器是否耗盡,不然 StopIteration是提升。

類  object

返回一個新的無特點的對象。 object是全部類的一個基地。它的方法是常見的Python類的全部實例。這個函數不接受任何參數。

請注意

object沒有一個 __dict__,因此你不能指定任意屬性的一個實例 object類。

oct (x)

整數轉換爲八進制數的字符串。結果是一個有效的Python表達式。若是x是Python int對象,它必須定義一個 __index__()方法返回一個整數。

open (文件,模式= ' r ',緩衝= 1,編碼=沒有錯誤=沒有換行符= None,closefd = True,刀=沒有)

打開文件並返回一個對應的 文件對象。若是文件不能打開,一個 OSError是提升。

文件是一個 就對象給路徑名(絕對或相對於當前工做目錄)的文件打開或整數包裝文件的文件描述符。(若是一個文件描述符,它關閉時返回的I / O對象是關閉,除非closefd將 False.)

模式是一個可選的字符串,指定了模式的文件打開。它默認爲 'r'這意味着在文本模式打開閱讀。其餘常見的值 'w'寫做(刪除文件若是它已經存在), 'x'爲獨家建立和 'a'爲附加(在某些Unix系統,意味着全部寫附加到文件的末尾無論當前尋求位置)。在文本模式下,若是沒有指定編碼的編碼使用平臺的依賴: locale.getpreferredencoding(False)被稱爲當前語言環境編碼。(閱讀和寫做的原始字節使用二進制模式和編碼未指明的離開。)可用的模式是:

字符	意義
'r'	開放閱讀(默認)
'w'	開放的寫做,首先刪除文件
'x'	開放獨家創造,失敗若是文件已經存在
'a'	開放的寫做,附加的文件若是它存在
'b'	二進制模式
't'	文本模式(默認)
'+'	打開磁盤文件更新(閱讀和寫做)
'U'	廣泛的換行模式(棄用)

默認的模式是 'r'(打開閱讀文本,同義詞 'rt')。對於二進制讀寫訪問模式 'w+b'打開,這樣就爲0字節的文件。 'r+b'打開文件沒有截斷。

正如前面提到的, 概述,Python區分二進制和文本I / O。打開的文件(包括以二進制模式 'b'模式參數)返回的內容 bytes對象沒有任何解碼。在文本模式(默認,或者當 't'包含在模式參數),返回文件的內容是 str,字節被首先使用平臺相關的編碼或解碼編碼若是使用指定的。

請注意

Python不依賴於底層操做系統概念的文本文件,全部的處理是經過Python自己,所以獨立於平臺的。

緩衝是一個可選的整型用於設置緩衝政策。經過0關閉緩衝(只容許在二進制模式),1選擇行緩衝(僅在文本模式下可用),和一個整數> 1代表固定大小的塊的大小的字節緩衝區。當沒有緩衝參數,默認緩衝策略工做以下:

• 二進制文件緩存在固定大小的塊,緩衝區的大小是選擇使用啓發式試圖肯定底層設備的塊大小和回落 io.DEFAULT_BUFFER_SIZE。在許多系統中,緩衝區一般是4096或8192字節。
• 「互動」的文本文件(文件 isatty()返回 True)使用行緩衝。其餘文本文件爲二進制文件使用上述政策。

編碼所使用的編碼解碼的名稱或編碼文件。這應該只用於文本模式。默認的編碼是依賴於平臺(無論 locale.getpreferredencoding()返回),但任何 文本編碼可使用Python支持。看到 codecs模塊支持的編碼列表。

錯誤是一個可選的字符串指定編碼和解碼錯誤是如何處理這種不能用於二進制模式。各類標準的錯誤處理程序(如下列出 錯誤處理程序),儘管任何錯誤處理名稱已被註冊 codecs.register_error()也是有效的。標準的名稱包括:

• 'strict'提升一個 ValueError若是有一個編碼錯誤異常。的默認值 None有一樣的效果。
• 'ignore'忽略錯誤。注意,忽略編碼錯誤可能致使數據丟失。
• 'replace'致使替換標記(如 '?')插入哪裏有畸形的數據。
• 'surrogateescape'將表明任何錯誤的字節在Unicode代碼點私人使用面積從U + U + DCFF DC80。這些私人代碼點就會轉回時相同的字節 surrogateescape錯誤處理程序寫入數據時使用。這是有用的在一個未知的編碼處理文件。
• 'xmlcharrefreplace'只有當寫入一個文件的支持。不支持的字符編碼替換爲適當的XML字符引用 &#nnn;.
• 'backslashreplace'經過Python的斜轉義序列替換畸形數據。
• 'namereplace'(也寫做時僅支持)取代了不支持的字符 \N{...}轉義序列。

換行符控制 廣泛的換行工做模式(它只適用於文本模式)。它能夠 None, '', '\n', '\r', '\r\n'。它的工做原理以下:

• 閱讀時的輸入流,若是換行符 None,環球換行模式啓用。行輸入能夠結束 '\n', '\r',或 '\r\n',這些都是翻譯成 '\n'以前返回給調用者。若是它是 ''通用換行模式啓用,但結局都是返回給調用者翻譯。若是有任何其餘的法律價值觀,輸入行只是被給定字符串終止,和行結束返回給調用者未翻譯。
• 當編寫輸出流,若是換行符 None,任何 '\n'寫字符轉換到系統默認行分隔符, os.linesep。若是換行符 ''或 '\n',沒有翻譯。若是任何其餘法律價值換行, '\n'字符是給定字符串翻譯寫的。

若是closefd False和一個文件描述符,而不是一個文件名,底層文件描述符將保持關閉打開的文件。若是一個文件名closefd必須給出 True(默認),不然,它會拋出一個錯誤。

可使用一個定製刀經過一個可調用的。底層文件描述符的文件對象而後經過調用刀(文件、旗幟)。開瓶器必須返回一個打開的文件描述符(傳遞 os.open比賽結果在功能上相似於傳遞 None).

新建立的文件 non-inheritable.

下面的例子使用了 dir_fd參數的 os.open()函數打開一個文件相對於給定目錄:

>>> 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　

的類型 文件對象返回的 open()函數依賴於模式。當 open()用來打開一個文件在一個文本模式('w', 'r', 'wt', 'rt'等),它返回的一個子類 io.TextIOBase(特別是 io.TextIOWrapper)。當用於與緩衝以二進制方式打開一個文件,返回的類的一個子類 io.BufferedIOBase。確切的階級���同:在讀取二進制模式下,它返回一個 io.BufferedReader;在寫二進制和附加二進制模式,它返回一個 io.BufferedWriter以讀/寫模式,它返回一個 io.BufferedRandom。禁用緩衝時,原始流的一個子類 io.RawIOBase, io.FileIO,返回。

參見文件處理模塊,如 fileinput, io( open()聲明), os, os.path, tempfile, shutil.

3.3版本的變化:

• 刀參數了。
• 的 'x'模式是補充道。
• IOError用於提升,如今的別名 OSError.
• FileExistsError如今在獨家建立模式(若是文件打開'x')已經存在。

3.4版本的變化:

• 文件如今non-inheritable。

棄用自3.4版本,4.0版本將被刪除:的 'U'模式。

3.5版本的變化:

• 若是系統調用中斷和信號處理器不引起一個異常,該函數如今重試的系統調用,而不是一個 InterruptedError異常(見PEP 475基本原理)。
• 的 'namereplace'添加錯誤處理程序。

3.6版本的變化:

• 支持添加到接受對象實現 os.PathLike.
• 在Windows上,打開一個控制檯緩衝可能返回的一個子類 io.RawIOBase除了 io.FileIO.

ord (c)

給定一個字符串表明一個Unicode字符,返回一個整數表明字符的Unicode代碼點。例如, ord('a')返回整數 97和 ord('€')(歐元)的回報 8364。這是的倒數 chr().

pow (x,y[,z])

返回x到y;若是z,返回x y,z模(更有效率比計算 pow(x, y) % z)。雙參數形式 pow(x, y)至關於使用權力操做符: x**y.

必定數值類型的參數。混合操做數類型,強迫二進制算術運算符規則適用。爲 int操做數,結果有相同的類型做爲操做數(脅迫)除非第二個參數是消極的;在這種狀況下,全部參數轉換爲浮動,浮動的結果。例如, 10**2返回 100,但10**-2返回 0.01。若是第二個參數是負的,第三個參數必須省略。若是z,x和y必須是整數類型,和y必須是非負數。

>>> pow(2,2)
4
>>> pow(2,3)
8
>>> pow(2,4)
16

print (*對象,9 = ' ' = ' \ n '結束,文件= sys.stdout,沖洗= False)

打印文本流文件對象,由9月,緊隨其後的是結束。9月結束,文件和沖洗,若是存在,必須做爲關鍵字參數。

像全部non-keyword參數轉換爲字符串 str()和寫入到流,由9月,緊隨其後的是結束。9月和結束都必須是字符串;他們也能夠 None,這意味着使用默認值。若是沒有對象, print()只會寫。

文件的參數必須是一個對象 write(string)方法,若是它不存在或 None, sys.stdout就會被使用。由於印刷參數轉換爲文本字符串, print()不能用於二進制模式文件對象。對於這些,使用 file.write(...)代替。

是否輸出緩衝一般是由文件,可是若是沖洗關鍵字參數是正確的,流強制刷新。

3.3版本的變化:添加刷新關鍵字參數。

類  property (fget = None,fset = None,fdel =沒有醫生=沒有)

返回一個財產屬性。

fget函數獲取一個屬性的值。fset設置一個屬性值是一個函數。fdel刪除一個屬性值是一個函數。和醫生建立文檔字符串屬性。

一個典型的用途是定義一個屬性管理 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刪除人。

若是,醫生將因此的財產屬性。不然,房地產將複製fget docstring(若是它存在的話)。這使得它能夠建立只讀屬性很容易使用 property()做爲一個 裝飾:

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

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

的 @property修飾符將 voltage()方法爲「getter」爲一個只讀屬性相同的名稱,它爲電壓設置有「獲取當前電壓」。

屬性對象 getter, setter, deleter方法使用修飾符建立一份財產與相應的訪問器功能設置爲裝飾功能。這是用一個例子作了最好的解釋:

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在這種狀況下)。

返回的屬性對象也有屬性 fget, fset, fdel相應的構造函數參數。

3.5版本的變化:如今可寫屬性的文檔字符串對象。

range (中止)

range (開始,中止[,一步])

而不是一個函數, range其實是一個不可變的序列類型,記錄在嗎 範圍和 序列類型——列表、元組、範圍.

repr (對象)

返回一個字符串包含一個可打印的表明一個對象。對於許多類型,這個函數使試圖返回一個字符串,將產生一個對象傳遞給時相同的值 eval(),不然表示是用尖括號括起來的字符串,它包含的類型對象的名稱加上額外的信息一般包括對象的名稱和地址。一個類能夠控制經過定義這個函數返回的實例 __repr__()方法。

reversed (seq)

返回一個反向 迭代器。seq必須有一個對象 __reversed__()方法或支持的協議序列( __len__()方法和 __getitem__()方法用整數參數開始 0).

round (數量[,ndigits])

返回數字的小數點後ndigits精度。若是省略ndigits或 None,它返回最近的整數輸入。

內置類型支持 round()、價值觀四捨五入爲最接近的倍數10次方- ndigits;若是兩個一樣倍數接近,甚至舍入完成向的選擇(例如,兩個 round(0.5)和 round(-0.5)是 0, round(1.5)是 2)。任何整數的值是有效ndigits(正、零或負)。返回值是一個整數,若是調用了一個參數,不然相同類型的數量。

對於通常的Python對象 number, round(number, ndigits)表明 number.__round__(ndigits).

請注意

的行爲 round()花車能夠使人驚訝:例如, round(2.675, 2)給了 2.67而不是預期的 2.68。這不是一個錯誤:這是一個事實,大多數的結果小數分數不能徹底表示爲一個浮點數。看到 浮點運算:問題和侷限性爲更多的信息。

>>> round(1.3654)
1
>>> round(1.3654,2)
1.37
>>> round(1.3654,3)
1.365

類  set ([iterable])

返回一個新的 set對象,可選元素取自iterable。 set是一個內置的類。看到 set和 類型——集合,frozenset關於這個類的文檔。

對於其餘容器內置 frozenset, list, tuple, dict類,以及 collections模塊。

setattr (對象,名字,價值)

這是相對應的 getattr()。參數是一個對象,一個字符串和一個任意值。字符串可能現有的屬性或一個新屬性名稱。函數分配價值屬性,提供了對象容許它。例如, setattr(x, 'foobar', 123)至關於 x.foobar = 123.

類  slice (中止)

類  slice (開始,中止[,一步])

返回一個 片對象表明指定的一系列指標 range(start, stop, step)。參數默認的啓動和步驟 None。片有隻讀數據屬性的對象 start, stop和 step這僅僅是返回的參數值(或違約)���他們沒有其餘明確的功能,可是它們使用Numerical Python和其餘第三方擴展。部分對象也使用時生成擴展索引的語法。例如: a[start:stop:step]或 a[start:stop, i]。看到 itertools.islice()返回一個迭代器的另外一個版本。

sorted (iterable[,][,反向))

返回一個新的iterable項目的有序列表。

有兩個可選參數必須指定爲關鍵字參數。

鍵指定一個參數的函數,用於提取比較主要從每一個列表元素: key=str.lower。默認值是 None(比較直接的元素)。

相反的是一個布爾值。若是設置爲 True,那麼列表元素排序好像每一個比較逆轉。

使用 functools.cmp_to_key()一個老式的cmp函數轉換爲一個關鍵功能。

內置的 sorted()功能是保證穩定。排序是穩定的,若是保證不改變元素的相對順序比較平等——這有助於排序在多個傳遞(例如,由部門,而後由工資等級)。

用於排序的例子和一個簡短的排序教程,看看 排序如何.

a={1:2,3:5,9:7,98:-12,76:23}
print(sorted(a.items()))
print(sorted(a.items(),key=lambda x:x[1] ))
print(a)

[(1, 2), (3, 5), (9, 7), (76, 23), (98, -12)]
[(98, -12), (1, 2), (3, 5), (9, 7), (76, 23)]
{1: 2, 98: -12, 3: 5, 76: 23, 9: 7}

staticmethod (函數)

函數返回一個靜態方法。

靜態方法不能獲得一個隱式的第一個參數。要聲明一個靜態方法,使用這個成語:

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

的 @staticmethod表單是一個函數 裝飾——看到函數定義的描述 函數定義獲取詳細信息。

它能夠被稱爲類(如 C.f()(好比)或在一個實例 C().f())。除了它的類實例被忽略。

靜態方法在Python中發現相似Java或c++。也看到 classmethod()爲建立有用的變體替代類構造函數。

有關靜態方法的更多信息,請參考文檔標準類型層次結構 標準的類型層次結構.

類  str (對象= ")

類  str (對象= b」,編碼=「utf - 8」,錯誤=「嚴格的」)

返回一個 str版本的對象。看到 str()獲取詳細信息。

str是內置的字符串 類。對於通常信息字符串,明白了 文本序列類型- str.

sum (iterable[,開始])

資金開始和iterable從左到右的物品並返回。開始違約 0。iterable的項目一般是數字,開始值不能是一個字符串。

對於一些用例,有很好的替代品 sum()。的首選,快速鏈接字符串序列的方法是經過調用 ''.join(sequence)。添加和擴展精度浮點值,明白了 math.fsum()。鏈接一系列iterable,考慮使用 itertools.chain().

super ([類型[,對象或者類型]])

方法調用返回一個代理對象,表明父母或兄弟姐妹的類型。這是很是有用的用於訪問被覆蓋在一個類繼承的方法。使用的搜索順序是同樣的 getattr()除了類型自己是跳過。

的 __mro__屬性的類型列表使用的方法解析搜索順序 getattr()和 super()。屬性是動態的,能夠改變,不管什麼時候更新繼承層次結構。

若是省略第二個參數,返回超級對象是不受約束的。若是第二個參數是一個對象, isinstance(obj, type)必須是真實的。若是第二個參數是一個類型, issubclass(type2, type)必須是真實的(這是有用的類方法)。

有兩個超級的典型用例。與單繼承一個類層次結構,可使用超級引用父類沒有明確命名它們,從而使代碼更易於維護。這個用密切的類似之處在其餘編程語言中使用的。

第二個用例是支持合做動態執行環境中多重繼承。這個用例是獨一無二的,沒有找到Python和靜態編譯語言或語言只支持單繼承的。這使得它能夠實現「鑽石圖」,多個基類實現相同的方法。好的設計要求,該方法具備相同的調用簽名在任何狀況下(由於在運行時調用的順序決定,由於爲了適應類層次結構的變化,由於這個順序能夠包括兄弟姐妹類運行時)以前是未知的。

對於這兩個用例,一個典型的超類是這樣的:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

請注意, super()被實現爲綁定過程的一部分等明確的虛線屬性查找 super().__getitem__(name)。它經過實現本身 __getattribute__()搜索類的方法預測訂單,支持合做多重繼承。所以, super()是隱式定義查找使用語句或運營商如 super()[name].

還要注意,除了零參數形式, super()並不侷限於使用內部的方法。這兩個論點形式指定參數準確,使適當的引用。零參數形式只能在類的內部定義,編譯器填寫必要的細節正確檢索被定義的類,以及訪問當前實例的普通方法。

實際的建議關於如何設計合做類使用 super(),請參閱指南使用super().

tuple ([iterable])

而不是一個函數, tuple其實是一個不可變的序列類型,記錄在嗎 元組和 序列類型——列表、元組、範圍.

類  type (對象)

類  type (名稱、基地dict)

一個參數,返回一個對象的類型。返回值是一個對象類型和一般返回的對象同樣 object.__class__.

的 isinstance()內置函數建議測試一個對象的類型,由於它考慮了子類。

有三個參數,返回一個新的類型對象。這本質上是一個動態的形式 class聲明。這個名字是類名,成爲字符串 __name__元組屬性;基地列舉了基類,變成了 __bases__屬性;關鍵字詞典是包含類定義的名稱空間的身體和複製到成爲一個標準的字典 __dict__屬性。例如,如下兩個語句建立相同的 type對象:

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

另請參閱 類型的對象.

3.6版本的變化:的子類 type不覆蓋 type.__new__可能再也不使用一個參數形式來得到一個對象的類型。

vars ([對象])

返回 __dict__屬性模塊、類實例,或任何其餘對象 __dict__屬性。

對象模塊和實例等可更新 __dict__屬性;可是,其餘對象可能會限制他們的寫 __dict__屬性(例如,使用一個類 types.MappingProxyType爲了防止直接字典更新)。

沒有一個論點, vars()就像 locals()。注意,當地人字典只用於讀取以來更新當地人字典被忽略。

zip (* iterable)

作一個集合元素的迭代器從每一個iterable。

返回一個迭代器的元組,其中的第i個tuple包含每一個參數序列的第i個元素或iterable。輸入迭代器中止時最短iterable耗盡。用一個iterable論點,它返回一個迭代器1-tuples。不帶參數,它將返回一個空的迭代器。等價於:

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)

的評價從左到右順序iterable保證。這使可能的成語集羣數據系列分爲n-length組使用 zip(*[iter(s)]*n)。這種重複相同的迭代器 n次,這樣每一個輸出元組的結果 n調用迭代器。這樣作的效果是將輸入分紅n-length塊。

zip()只能使用不平等的長度輸入當你不關心的,無與倫比的值再也不iterable。若是這些值很重要,使用 itertools.zip_longest()代替。

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

__import__ (名稱、全局變量=沒有當地人= None,fromlist =(),水平= 0)

請注意

這是一個先進的功能,不須要在天天的Python編程,不像 importlib.import_module().

這個函數被調用的 import聲明。它能夠(經過進口替代 builtins模塊和分配 builtins.__import__爲了改變語義的 import聲明,但不提倡這樣作,由於它一般是更簡單的使用進口掛鉤(見PEP 302)實現相同的目標,不會致使問題的代碼假定默認實現使用的進口。直接使用 __import__()也不同意嗎 importlib.import_module().

導入功能模塊名稱,可能使用給定的全局和當地人來決定如何解釋這個名字在包上下文。fromlist給的名字應該進口的對象或子模塊的名字。標準實現不使用它的當地人蔘數,並使用它的全局惟一肯定的包上下文 import聲明。

指定是否使用絕對或相對進口水平。 0(默認)意味着只有執行絕對進口。積極的水平值顯示的數量相對於目錄的父目錄搜索模塊調用 __import__()(見PEP 328的詳細信息)。

當表單的變量的名稱 package.module,正常狀況下,頂層包(這個名字到第一個點)返回,而不是模塊的名字命名。然而,當一個非空fromlist參數,返回模塊命名的名字。

例如,語句 import spam結果在字節碼相似下面的代碼:

spam = __import__('spam', globals(), locals(), [], 0)

該聲明 import spam.ham這個調用的結果:

spam = __import__('spam.ham', globals(), locals(), [], 0)

請注意 __import__()返回頂層的模塊,由於這是由對象綁定到一個名稱 import聲明。

另外一方面,這一聲明 from spam.ham import eggs, sausage as saus結果

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

在這裏, spam.ham模塊是回來 __import__()。從這個對象中,導入名稱檢索並分配給各自的名字。

若是你只是想要導入一個模塊(可能在一個包)的名字,使用 importlib.import_module().

3.3版本的變化:負值爲水平再也不支持(也改變默認值爲0)。

 

軟件目錄結構規範

http://www.cnblogs.com/alex3714/articles/5765046.html