1. <pre id="rjcw3"><strong id="rjcw3"><xmp id="rjcw3"></xmp></strong></pre>

    2. <object id="rjcw3"><strong id="rjcw3"></strong></object>

        <track id="rjcw3"></track>

        <acronym id="rjcw3"><strong id="rjcw3"><address id="rjcw3"></address></strong></acronym>
        <track id="rjcw3"><strike id="rjcw3"></strike></track>
      1. IT系統集成商

        系統集成 | 虛擬化應用 | 群暉網絡存儲 | 視頻會議 | 數據防泄密 | 技術運維

        手機: 130-1534-6247   電話: 0351-2396570

        Python筆記1-變量與對象

        關注億維訊達
        關注億維訊達

        一、Python 中,一切皆對象。每個對象由:標識(identity)、類型(type)、value(值)組成。
        1. 標識用于唯一標識對象。使用內置函數 id(obj)可返回對象 obj 的標識。
        2. 類型用于表示對象存儲的“數據”的類型?梢允褂 type(obj)獲得對象的所屬類型。
        3. 值表示對象所存儲的數據的信息。使用 print(obj)可以直接打印出值。
        4. Python 是動態類型語言,變量不需要顯式聲明類型。根據變量引用的對象,Python 解釋器自動確定數據類型。
        5. Python 是強類型語言,每個對象都有數據類型,只支持該類型支持的操作。
         
        二、賦值
         
        在 Python 中,變量也稱為對象的引用。變量引用“對象”。
        變量位于棧內存。對象位于堆內存。
         
        python 賦值
        變量盒子

        Python 賦值語句實際上與“變量盒子”模型略有不同。在 Python 中,值可能最終放在內存中的任何位置,而變量用于引用它們。對變量賦值就像把一個黃色小粘貼便簽放在值上,并說“這是 x”。
        python 賦值
        賦值就象貼標簽
         
        上圖是一個更準確的 Python 賦值的效果。箭頭用于顯示變量引用的值。舊值不會被新值擦除,變量只需重新綁定新值。效果就像將粘貼便簽從一個對象移動到另一個對象一樣(重新綁定)。

        你也不必擔心計算機內存中充滿“被丟棄”的值。如果一個值不再被任何變量引用,它就不再有用。 Python將自動從內存中清除這些值,以便空間可以用于存放新值。這個自動內存管理的過程確實被稱為“垃圾收集”。

        變量在使用前必須先進行初始化,也就是將變量綁定在一個對象上,格式如:變量名 = 表達式。執行過程中,解釋器先運行右邊的表達式,在堆內存中創建一個對象,然后將對象的內存地址賦給左邊的變量。

        <section style="margin: 0px; padding: 0px; color: rgb(51, 51, 51); font-family: mp-quote, -apple-system-font, BlinkMacSystemFont, " helvetica="" neue",="" "pingfang="" sc",="" "hiragino="" sans="" gb",="" "microsoft="" yahei="" ui",="" yahei",="" arial,="" sans-serif;="" font-size:="" 17px;="" text-align:="" justify;="" text-indent:="" 2em;"=""> 為了簡化內存管理,Python通過引用計數機制實現自動垃圾回收功能,Python中的每個對象都有一個引用計數,用來計數該對象在不同場所分別被引用了多少次。每當引用一次Python對象,相應的引用計數就增1,每當消毀一次Python對象,則相應的引用就減1,只有當引用計數為零時,才真正從內存中刪除Python對象。

         

        不要將is用于數和字符串等不可變的基本值。鑒于Python在內部處理這些對象時可能會采用“small integer cache”的方式,將一些小整數、字符串等不可變對象只保留一份拷貝,這樣做的結果是不可預測的。
         
        三、 可變對象與不可變對象
         
        Python在heap中分配的對象分成2類:
          1. 不可變對象(immutable object):Number(int、float、bool、complex)、String、Tuple. 采用等效于“傳引用”的方式。
          2. 可變對象(mutable object):List、dictionary.采用等效于“傳值”的方式。
         
        四、關于參數傳遞
         
        在編程語言設計中,有兩種常見的范例將參數傳遞給函數:
            傳遞值:參數的副本傳遞給函數。
            傳遞引用:對參數的引用將傳遞給函數。
         
        Python中的參數是按值傳遞還是按引用傳遞?答案是,兩者都不是。
         
        回想一下,在Python中,每條數據都是一個對象。引用指向一個對象,而不是一個特定的內存位置。
        在Python中,類似的賦值語句如下:
         
        x = 5
        x = 10
        這些賦值語句具有以下含義:
         
        第一條語句導致x指向一個值為的對象5。
        下x一條語句重新分配為值為的另一個對象的新引用10。換句話說,第二個賦值重新綁定x到具有value的另一個對象10。
        在Python中,當您將參數傳遞給函數時,會發生類似的重新綁定?紤]以下示例:
         
        def f(fx):
            fx = 10
         
        x = 5
        f(x)
        ---------------------
        >>>x
        >>>5
        在主程序中,第x = 5的語句創建一個名為x的引用,該引用x綁定到一個值為的對象5。然后x作為參數調用f()。當f()第一次啟動時,一個叫做fx新的引用被創建,它最初指向對象x(也就是5)
         
        python參數傳遞
         
        函數調用圖
         
        但是,在執行fx = 10的語句時,將fx重新綁定 到值為10的新對象。x和fx這兩個引用相互分離。沒有影響主程序中的x,并且在f()終止x時仍會指向該對象5,就像在函數調用之前一樣:
        python參數傳遞
         
        Python函數調用
         
        可以使用id()確認。顯示了所涉及對象的數字標識符:
         
        >>> def f(fx):
         2 ...     print('fx =', fx, '/ id(fx) = ', id(fx))
         3 ...     fx = 10
         4 ...     print('fx =', fx, '/ id(fx) = ', id(fx))
         5 ...
         6 
         7 >>> x = 5
         8 >>> print('x =', x, '/ id(x) = ', id(x))
         9 x = 5 / id(x) =  1357924048
        10 
        11 >>> f(x)
        12 fx = 5 / id(fx) =  1357924048
        13 fx = 10 / id(fx) =  1357924128
        14 
        15 >>> print('x =', x, '/ id(x) = ', id(x))
        16 x = 5 / id(x) =  1357924048
        當f()第一次啟動,fx與x都指向同一個對象,它id()是1357924048。f()執行語句fx = 10后,fx指向不同的對象,它id()是1357924128。調用環境中與原始對象的連接丟失。
         
        Python中的參數傳遞在某種程度上是按值傳遞和按引用傳遞之間的混合。傳遞給函數的是對對象的引用,但該引用是按值傳遞的。
         
        注意: Python的參數傳遞機制稱為pass-by-assignment。這是因為參數名稱綁定到Python中函數輸入上的對象,并且賦值也是將名稱綁定到對象的過程。您可能還會看到術語“按對象傳遞”,“按對象傳遞引用”或“按共享傳遞”。
         
        這里的關鍵要點是,Python函數無法通過將相應的參數重新分配給其他東西來更改參數的值。下面的示例演示了這一點:
        >>> def f(x):
        ...     x = 'foo'
        ...
        >>> for i in (40,dict(foo=1, bar=2),{1, 2, 3},'bar',['foo', 'bar', 'baz']):
        ...     f(i)
        ...     print(i)
        ...
        40
        {'foo': 1, 'bar': 2}
        {1, 2, 3}
        bar
        ['foo', 'bar', 'baz']
        在這里,類型的對象int,dict,set,str,,list傳遞給f()作為參數。但是正如您所看到的,一旦回到調用環境中,它們都保持不變。一旦f()執行任務x = 'foo',將被重新綁定,原始對象的連接丟失。
         
        這是否意味著Python函數根本無法修改其參數?其實不,不是這樣!注意這里發生的情況:
         
        >>> def f(x):
        ...     x[0] = '---'
        ...
        
        >>> my_list = ['foo', 'bar', 'baz', 'qux']
        
        >>> f(my_list)
        >>> my_list
        ['---', 'bar', 'baz', 'qux']
        在這種情況下,f()參數是list。當f()被調用時,一個引用my_list被傳遞。您已經看到f()無法重新分配my_list。但是,f()可以在內部使用引用進行修改my_list。在這里,f()已經修改了第一個元素。您可以看到,函數一旦返回,my_list實際上在調用環境中已被更改。相同的概念適用于字典:
         
        >>> def f(x):
        ...     x['bar'] = 22
        ...
        
        >>> my_dict = {'foo': 1, 'bar': 2, 'baz': 3}
        
        >>> f(my_dict)
        >>> my_dict
        {'foo': 1, 'bar': 22, 'baz': 3}
        在這里,f()修改了my_dict。該更改反映在f()返回后的調用環境中。
         
        參數傳遞摘要
         
        Python中傳遞的參數可以總結如下。傳遞一個不可變的對象,像int,str,tuple,或frozenset,傳遞給Python函數的行為類似于按值傳遞。該函數無法在調用環境中修改對象。傳遞一個可變的對象,比如list、dict或set,可以起到類似于引用傳遞的作用,但不完全是這樣。該函數不能完全重新分配對象,但它可以在對象中適當地更改項,這些更改將反映在調用環境中。
        關注億維訊達
        關注億維訊達