python下劃線的函數

㈠ python3.4學習筆記 3.x和2.x的區別，持續更新

python3.4學習筆記(四) 3.x和2.x的區別

在2.x中:print html，3.x中必須改成:print(html)

import urllib2
ImportError: No mole named 'urllib2'
在python3.x裡面，用urllib.request代替urllib2

import thread
ImportError: No mole named 'thread'
在python3.x裡面，用_thread(在前面加一個下劃線)代替thread

在2.x中except Exception,e : 3.x中改為except (Exception):

=================================
print函數
雖然print語法是Python 3中一個很小的改動，且應該已經廣為人知，但依然值得提一下：Python 2中的print語句被Python 3中的print()函數取代，這意味著在Python 3中必須用括弧將需要輸出的對象括起來。
在Python 2中使用額外的括弧也是可以的。但反過來在Python 3中想以Python2的形式不帶括弧調用print函數時，會觸發SyntaxError。
Python 2.7.6

print 'Python', python_version()
print 'Hello, World!'
print('Hello, World!')
print "text", ; print 'print more text on the same line'
輸出：
Hello, World!
Hello, World!
text print more text on the same line
---------------------------

Python 3.4.1
print('Python', python_version())
print('Hello, World!')

print("some text,", end="")
print(' print more text on the same line')
輸出：
Hello, World!
some text, print more text on the same line
print 'Hello, World!'
File "<ipython-input-3-139a7c5835bd>", line 1
print 'Hello, World!'
^
SyntaxError: invalid syntax

注意：在Python中，帶不帶括弧輸出」Hello World」都很正常。
但如果在圓括弧中同時輸出多個對象時，就會創建一個元組，這是因為在Python 2中，print是一個語句，而不是函數調用。

print 'Python', python_version()
print('a', 'b')
print 'a', 'b'
Python 2.7.7
('a', 'b')
a b

---------------------------------
整數除法
由於人們常常會忽視Python 3在整數除法上的改動（寫錯了也不會觸發Syntax Error），所以在移植代碼或在Python 2中執行Python 3的代碼時，需要特別注意這個改動。

所以，我還是會在Python 3的腳本中嘗試用float(3)/2或 3/2.0代替3/2，以此來避免代碼在Python
2環境下可能導致的錯誤（或與之相反，在Python 2腳本中用from __future__ import division來使用Python
3的除法）。

Python 2.7.6
3 / 2 = 1
3 // 2 = 1
3 / 2.0 = 1.5
3 // 2.0 = 1.0

Python 3.4.1
3 / 2 = 1.5
3 // 2 = 1
3 / 2.0 = 1.5
3 // 2.0 = 1.0
---------------------------------
Unicode
Python 2有基於ASCII的str()類型，其可通過單獨的unicode()函數轉成unicode類型，但沒有byte類型。
而在Python 3中，終於有了Unicode（utf-8）字元串，以及兩個位元組類：bytes和bytearrays。

Python 2.7.6
print type(unicode('this is like a python3 str type'))
<type 'unicode'>
print type(b'byte type does not exist')
<type 'str'>
print 'they are really' + b' the same'
they are really the same
print type(bytearray(b'bytearray oddly does exist though'))
<type 'bytearray'>

Python 3.4.1 has <class 'bytes'>
print('and Python', python_version(), end="")
print(' also has', type(bytearray(b'bytearrays')))
and Python 3.4.1 also has <class 'bytearray'>
1
'note that we cannot add a string' + b'bytes for data'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-13-d3e8942ccf81> in <mole>()
----> 1 'note that we cannot add a string' + b'bytes for data'

TypeError: Can't convert 'bytes' object to str implicitly

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

python 2.4 與 python 3.0 的比較
一、 print 從語句變為函數
原: print 1,2+3
改為: print ( 1,2+3 )

二、range 與 xrange
原 : range( 0, 4 ) 結果 是 列表 [0,1,2,3 ]
改為：list( range(0,4) )
原 : xrange( 0, 4 ) 適用於 for 循環的變數控制
改為：range(0,4)

三、字元串
原: 字元串以 8-bit 字元串存儲
改為: 字元串以 16-bit Unicode 字元串存儲

四、try except 語句的變化
在2.x中except Exception,e : 3.x中改為except (Exception):

五、打開文件
原： file( ..... )
或 open(.....)
改為：
只能用 open(.....)
六、從鍵盤錄入一個字元串
原: raw_input( "提示信息" )
改為: input( "提示信息" )

七、bytes 數據類型
A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0 <= x < 256.
bytes 可以看成是「位元組數組」對象，每個元素是 8-bit 的位元組，取值范圍 0~255。
由於在 python 3.0中字元串以 unicode 編碼存儲，當寫入二進制文件時，字元串無法直接寫入（或讀取），必須以某種方式的編碼為位元組序列後，方可寫入。

（一）字元串編碼(encode) 為 bytes
例: s = "張三abc12"
b = s.encode( 編碼方式)
# b 就是 bytes 類型的數據
# 常用的編碼方式為 ： "uft-16" , "utf-8", "gbk", "gb2312", "ascii" , "latin1" 等
# 注 ： 當字元串不能編碼為指定的「編碼方式」時，會引發異常
(二) bytes 解碼(decode)為字元串
s = "張三abc12"
b = s.encode( "gbk") # 字元串 s 編碼為 gbk 格式的位元組序列
s1 = b.decode("gbk") # 將位元組序列 b以gbk格式 解碼為字元串
# 說明，當位元組序列不能以指定的編碼格式解碼時會引發異常
(三）使用方法舉例
#coding=gbk
f = open("c:\\1234.txt", "wb")
s = "張三李四abcd1234"
# -------------------------------
# 在 python2.4 中我們可以這樣寫：
# f.write( s )
# 但在 python 3.0中會引發異常
# -------------------------------
b = s.encode("gbk")
f.write( b )
f.close()
input("?")
讀取該文件的例子:
#coding=gbk
f = open("c:\\1234.txt", "rb")
f.seek(0,2) #定位至文件尾
n = f.tell() #讀取文件的位元組數
f.seek(0,0) #重新定位至文件開始處
b = f.read( n )
# ------------------------------
# 在 python 2.4 中 b 是字元串類型
# 要 python 3.0 中 b 是 bytes 類型
# 因此需要按指定的編碼方式確碼
# ------------------------------
s = b.decode("gbk")
print ( s )
# ------------------------------
# 在 python 2.4 中 可以寫作 print s 或 print ( s )
# 要 python 3.0 中 必須寫作 print ( s )
# ------------------------------
f.close()
input("?")
運行後應顯示:
張三李四abcd1234

(四) bytes序列，一但形成，其內容是不可變的，例：
s="ABCD"
b=s.encode("gbk")
print b[0] # 顯示 65
b[0] = 66
# 執行該句，出現異常: 'bytes' object does not support item assignment

八、 chr( K ) 與 ord( c )
python 2.4.2以前
chr( K ) 將編碼K 轉為字元，K的范圍是 0 ~ 255
ord( c ) 取單個字元的編碼, 返回值的范圍: 0 ~ 255
python 3.0
chr( K ) 將編碼K 轉為字元，K的范圍是 0 ~ 65535
ord( c ) 取單個字元的編碼, 返回值的范圍: 0 ~ 65535

九、 除法運算符
python 2.4.2以前
10/3 結果為 3
python 3.0
10 / 3 結果為 3.3333333333333335
10 // 3 結果為 3
十、位元組數組對象 --- 新增
(一） 初始化
a = bytearray( 10 )
# a 是一個由十個位元組組成的數組，其每個元素是一個位元組，類型借用 int
# 此時，每個元素初始值為 0
（二） 位元組數組 是可變的
a = bytearray( 10 )
a[0] = 25
# 可以用賦值語句更改其元素，但所賦的值必須在 0 ~ 255 之間
(三) 位元組數組的切片仍是位元組數組
(四) 字元串轉化為位元組數組
#coding=gbk
s ="你好"
b = s.encode( "gbk") # 先將字元串按某種「GBK」編碼方式轉化為 bytes
c = bytearray( b ) #再將 bytes 轉化為 位元組數組
也可以寫作
c = bytearray( "你好", "gbk")

(五) 位元組數組轉化為字元串
c = bytearray( 4 )
c[0] = 65 ; c[1]=66; c[2]= 67; c[3]= 68
s = c.decode( "gbk" )
print ( s )
# 應顯示： ABCD

(六) 位元組數組可用於寫入文本文件
#coding=gbk
f = open("c:\\1234.txt", "wb")
s = "張三李四abcd1234"
# -------------------------------
# 在 python2.4 中我們可以這樣寫：
# f.write( s )
# 但在 python 3.0中會引發異常
# -------------------------------
b = s.encode("gbk")
f.write( b )
c=bytearray( "王五","gbk")
f.write( c )
f.close()
input("?")

㈡ python中下劃線命名的含義

python中有五種下劃線命名；
(1)單前導下劃線： var
以單個下劃線開頭的變數或方法僅供內部使用，但是不強制執行。通過類名.變數名依然可以引用，但是在使用通配符導入模塊（from 模塊 import *）時，不能調用使用下劃線定義的函數，而常規導入（import 模塊）是可以調用的。
(2)單末尾下劃線：var
當最符合當前函數的變數名被佔用，則可以使用_來解決命名沖突。單個末尾下劃線（後綴）是一個約定，用來避免與Python關鍵字產生命名沖突。
(3)雙前導下劃線：_ var
雙下劃線前綴會導致Python解釋器重寫屬性名稱，以避免子類中的命名沖突。
這也叫做名稱修飾（name mangling） - 解釋器更改變數的名稱，以便在類被擴展的時候不容易產生沖突。
(4)雙前導和末尾下劃線： var
Python保留了有雙前導和雙末尾下劃線的名稱，用於特殊用途。 這樣的例子有， init 對象構造函數，或 call --- 它使得一個對象可以被調用。最好避免在自己的程序中使用以雙下劃線（「nders」）開頭和結尾的名稱，以避免與將來Python語言的變化產生沖突。
(5)單下劃線：
有時候單個獨立下劃線是用作一個名字，來表示某個變數是臨時的或無關緊要的。單個下劃線僅僅是一個有效的變數名稱，會有這個用途而已。
總結：

參考： Python中下劃線的5種含義

㈢ python 變數下劃線命名規則

單下劃線和雙下劃線在Python變數、類、模塊命名中都有不懂的含義，名稱中都各有其含義。有一些是程序員之間約定俗成的，Python解釋器不用強制其執行，但有些Python解釋器會強制執行。

本文從以下幾種不同使用方式，對下劃線的用途和含義進行說明：

1）變數
通常用於類內部變數的命名，表明該變數是該類私用變數，外部不要去訪問它，但也是可以訪問到的。這只是程序員之間的一個約定俗成的做法，Python解釋器本身不會對它進行限制。
我們創建一個類：

實例化A，並訪問它的變數，aa._bar 也是可以訪問的，但既然人家這么命名了，外部最好不要去訪問了

2）函數和模塊
和變數一樣，這是一個私有函數，不建議外部程序調用該函數。
我們創建一個腳本aa.py, 裡面有2個函數 _aa，bb：

導入aa，分別調用函數 _aa和bb，bb 可以調用，但顯示無 _aa

3）類
同變數和函數一樣，都是私有變數，外部最好不要調用

用來避免和Python內置函數命名產生沖突，PEP8解釋了這個約定。
如class或def不能用作Python中的變數名稱，如果之間用，會提示錯誤。如果你非要用它，可以 使用 class_或 def_。
還有一些函數名，如chr，chr()是Python內置函數，用來表示ascii碼對應的字元他的輸入時數字，可以用十進制，也可以用十六進制。如果你非要它來表示染色體，可以用chr_來代替。當然如果你直接使用它作為變數名，它也不會報錯，但最好不要這樣使用。

在python中定義私有變數只需要在變數名或函數名前加上 "__" (兩個下劃線)，那麼這個函數或變數就會成為私有的了。

在內部，python使用一種 name mangling 技術，將__var 替換成 _classname__var，因此在外部調用__var會找不到，代替它的是_classname_var。這種處理方式叫做名稱修飾（name mangling）:解釋器更改變數的名稱，以便在類被擴展的時候不容易產生沖突。

由雙下劃線前綴和後綴包圍的變數，不會應用名稱修飾，因此不會被Python解釋器修改：
我們創建一個類B，dir() 查看類的所有屬性，發現 存在 __aa__

但是，Python保留了有雙前導和雙末尾下劃線的名稱，用於特殊用途。 如，__init__對象構造函數，或 __call__ 它使得一個對象可以被調用。所有我們盡量不要使用這種方式命名變數，以免和Python解釋器內置的函數發生沖突。

_ 不加任何其他字元，單獨作為一個名字，用來表示某個臨時的或者無關緊要的變數。

舉例1： 表示一個臨時變數 。在下面的循環中，我們不需要獲取循環的索引，只是print n 行 'Hello World'，可以用 "_" 來表示它只是一個臨時值：

舉例2： 表示一個不關心的變數 ，僅僅是個佔位符變數，用來佔位。mlist 列表中，我只想獲得1，2，4 位的變數，那 3 和 5 可以 用 _ 來佔位

舉例3 ： 表示由解釋器評估的最近一個表達式的結果 ，方便進行查看。

㈣ python中的_doc_是什麼意思

您好，首先您描述有誤，應該是__doc__，雙下劃線。

每個對象都會有一個__doc__屬性，用於描述該對象的作用。在一個模塊被import時，其文件中的某些特殊的字元串會被python解釋器保存在相應對象的__doc__屬性中。比如，一個模塊有模塊的__doc__，一個class或function也有其對應的__doc__屬性。在python中，一個模塊其實就是一個.py文件。在文件中特殊的地方書寫的字元串就是所謂的docstrings，就是將被放到__doc__的內容。這個「特殊的地方」包括：

1.一個文件任何一條可執行的代碼之前 #模塊的__doc__

2.一個類，在類定義語句後，任何可執行代碼前#類的__doc__

3.一個函數，在函數定義語句後，任何可執行代碼前#函數的__doc__

舉個例子：

#use__doc__屬性
classMyClass:
'string.'
defprintSay():
'printsaywelcometoyou.'
print'saywelcometoyou.'
printMyClass.__doc__
printMyClass.printSay.__doc__

#輸出結果
string.
printsaywelcometoyou.

㈤ Python魔法函數（特殊函數）

Python中如何實現運算符的重載，即實現例如a+b這樣的運算符操作呢？

在C++中可以使用 operator 關鍵字實現運算符的重載。但是在Python中沒有類似這樣的關鍵字，所以要實現運算符的重載，就要用到Python的魔法函數。Python魔法函數是以雙下劃線開頭，雙下劃線結尾的一組函數。我們在類定義中最常用到的 __init__ 函數就是這樣一個魔法函數，它在創建類對象時被自動調用。

下面我們來看個簡單的例子。

上述代碼示例了幾個魔法函數的用法。 __add__ 函數對應了二元運算符+，當執行a+b語句時，python就會自動調用a. add (b)。 對於上述例子中的v1+v2+v3，則相當於調用了(v1. add(v2)). add(v3)。

代碼中還有一個在Python類定義經常使用的 __str__ 函數，當使用 str() 時會被調用。print函數對傳入的參數都調用了str()將其轉換成易讀的字元串形式，便於列印輸出，因而會調用類定義的__str__函數打出自定義的字元串。

代碼中還有一個特殊的 __call__ 函數，該函數在將對象採用函數調用方式使用時被調用, 例如v1()相當於v1. call ()。

以上就是魔法函數的基本使用方法。常見的魔法函數我們可以使用 dir() 函數來查看。

輸出結果為：

上述結果中形式為『__函數名__』的函數為魔法函數，注意有些對象也是這種形式，例如__class__, __mole__等, 這些不是魔法函數。具體的魔法函數說明可以參考Python官方說明文檔。

以上代碼在Python3.6運行通過.

㈥ 為什麼python變數或者文件命名經常帶__

前後各有兩個下劃線的方法是特殊方法。
特殊方法又被成為魔法方法(magic method)，定義了許多Python語法和表達方式。當對象中定義了特殊方法的時候，Python也會對它們有「特殊優待」。比如定義了__init__()方法的類，會在創建對象的時候自動執行__init__()方法中的操作。
有時如果變數名或者函數名是Python的關鍵字，會在變數名的最後加一個下劃線，比如lambda_。