不斷的提高自己，你今天的無奈，如果你不去面對和改善，明天你講面對的就是尷尬！
Python 2.x和3.x的區別
如果可能，儘量使用3.x版本
##print語句取消
print ("使用函數print");
##Unicode
#Python3.X 源碼文件默認使用utf-8編碼，這就使得以下代碼是合法的：
中國="hhhhhhh";
print (中國);
##除法運算
print (1/2);
###對於//除法，這種除法叫做floor除法
###會對除法的結果自動進行一個floor操作，在python 2.x和python 3.x中是一致的。
print (1//2);
import math;
print (math.trunc(1 / 2));
##異常
'''
在 Python 3 中處理異常也輕微的改變了，在 Python 3 中我們現在使用 as 作爲關鍵詞。
捕獲異常的語法由 except exc, var 改爲 except exc as var。
使用語法except (exc1, exc2) as var可以同時捕獲多種類別的異常。
Python 2.6已經支持這兩種語法。
1. 在2.x時代，所有類型的對象都是可以被直接拋出的，在3.x時代，只有繼承自BaseException的對象纔可以被拋出。
2. 2.x raise語句使用逗號將拋出對象類型和參數分開，3.x取消了這種奇葩的寫法，直接調用構造函數拋出對象即可。
在2.x時代，異常在代碼中除了表示程序錯誤，還經常做一些普通控制結構應該做的事情，
在3.x中可以看出，設計者讓異常變的更加專一，只有在錯誤發生的情況才能去用異常捕獲語句來處理。
'''
class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
try:
raise Networkerror("Bad hostname")
except Networkerror as e:
print (e.args);
try:
print ("Test");
raise Exception("TTTTTTTTTTT");
except Exception as e:
print (e.args)
else:
print ("OK Test");
finally:
print ("finally process!");
##xrange
'''
在 Python 3 中，range() 是像 xrange() 那樣實現以至於一個專門的 xrange() 函數都不再存在
（在 Python 3 中 xrange() 會拋出命名異常）。
'''
import timeit
def test_range(n):
for i in range(n):
print (i)
#pass
'''
##xrange是python2中使用
在python3中推薦使用range
def test_xrange(n):
for i in xrange(n):
print (i)
#pass
'''
print (test_range(100));
##不等運算符
###Python 2.x中不等於有兩種寫法 != 和 <>
###Python 3.x中去掉了<>, 只有!=一種寫法，還好，我從來沒有使用<>的習慣
##去掉了repr表達式``
'''
Python 2.x 中反引號``相當於repr函數的作用
Python 3.x 中去掉了``這種寫法，只允許使用repr函數，這樣做的目的是爲了使代碼看上去更清晰麼？不過我感覺用repr的機會很少，一般只在debug的時候才用，多數時候還是用str函數來用字符串描述對象。
'''
##數據類型
'''
1）Py3.X去除了long類型，現在只有一種整型——int，但它的行爲就像2.X版本的long
2）新增了bytes類型，對應於2.X版本的八位串，定義一個bytes字面量的方法如下：
>>> b = b'china'
>>> type(b)
<type 'bytes'>
str對象和bytes對象可以使用.encode() (str -> bytes) or .decode() (bytes -> str)方法相互轉化。
>>> s = b.decode()
>>> s
'china'
>>> b1 = s.encode()
>>> b1
b'china'
3）dict的.keys()、.items 和.values()方法返回迭代器，而之前的iterkeys()等函數都被廢棄。同時去掉的還有 dict.has_key()，用 in替代它吧 。
'''
b = b'china';
print (type(b));
s = b.decode() ;
print (s);
print (b);
bb=s.encode();
print (bb);
##八進制字面量表示
####八進制數必須寫成0o777，原來的形式0777不能用了；二進制必須寫成0b111。
print (0o1000);
###print (01000);
print (bin(0o1000));#新增了一個bin()函數用於將一個整數轉換成二進制字串
##模塊變動
'''
1）移除了cPickle模塊，可以使用pickle模塊代替。最終我們將會有一個透明高效的模塊。
2）移除了imageop模塊
3）移除了 audiodev, Bastion, bsddb185, exceptions, linuxaudiodev, md5, MimeWriter, mimify, popen2,
rexec, sets, sha, stringold, strop, sunaudiodev, timing和xmllib模塊
4）移除了bsddb模塊(單獨發佈，可以從http://www.jcea.es/programacion/pybsddb.htm獲取)
5）移除了new模塊
6）os.tmpnam()和os.tmpfile()函數被移動到tmpfile模塊下
7）tokenize模塊現在使用bytes工作。主要的入口點不再是generate_tokens，而是 tokenize.tokenize()
'''
print (type(b));
Python IDE
Sublime Text 的主要功能包括：拼寫檢查，書籤，完整的 Python API ， Goto 功能，即時項目切換，多選擇，多窗口等等。
Sublime Text 是一個跨平臺的編輯器，同時支持Windows、Linux、Mac OS X等操作系統。
Python面向對象
##面向對象python
'''
面向對象技術簡介
類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。
類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作爲實例變量使用。
數據成員：類變量或者實例變量用於處理類及其實例對象的相關的數據。
方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱爲方法的重寫。
實例變量：定義在方法中的變量，只作用於當前實例的類。
繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作爲一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關係（例圖，Dog是一個Animal）。
實例化：創建一個類的實例，類的具體對象。
方法：類中定義的函數。
對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。
'''
##創建類
class baseObject(object):
""" 人員信息的基類"""
tCount = 0;#類變量
'''構造函數 第一種方法__init__()方法是一種特殊的方法，被稱爲類的構造函數或初始化方法，當創建了這個類的實例時就會調用該方法'''
def __init__(self, name,age):
super(baseObject, self).__init__();
self.name=name;
self.age=age;
baseObject.tCount+=1;
def displayCount(self):
print ("The total is %d" % baseObject.tCount);
def displayInfo(self):
print ("Name : ",self.name, ",age: ", self.age)
##創建實例對象
ob1 = baseObject("zhangsan",4);
ob2 = baseObject("lisi",44);
##對象方法調用
ob1.displayCount();
ob1.displayInfo();
print (hasattr(ob1,'age'));#屬性存在
print (getattr(ob1,'age'));#屬性值獲取
setattr(ob1,'age',90);#屬性值修改
###delattr(empl, 'age');# 刪除屬性 'age'
print (hasattr(ob1,'age'));
print (getattr(ob1,'age'));
###python內置類屬性
'''
__dict__ : 類的屬性（包含一個字典，由類的數據屬性組成）
__doc__ :類的文檔字符串
__name__: 類名
__module__: 類定義所在的模塊（類的全名是'__main__.className'，如果類位於一個導入模塊mymod中，那麼className.__module__ 等於 mymod）
__bases__ : 類的所有父類構成元素（包含了以個由所有父類組成的元組）
'''
print ("baseObject.__doc__",baseObject.__doc__);
print ("baseObject.__name__",baseObject.__name__);
print ("baseObject.__dict__",baseObject.__dict__);
print ("baseObject.__module__",baseObject.__module__);
print ("baseObject.__bases__",baseObject.__bases__);
##python對象銷燬(垃圾回收)
'''
同Java語言一樣，Python使用了引用計數這一簡單技術來追蹤內存中的對象。
在Python內部記錄着所有使用中的對象各有多少引用。
一個內部跟蹤變量，稱爲一個引用計數器。
當對象被創建時， 就創建了一個引用計數， 當這個對象不再需要時， 也就是說，
這個對象的引用計數變爲0 時， 它被垃圾回收。但是回收不是"立即"的，
由解釋器在適當的時機，將垃圾對象佔用的內存空間回收。
垃圾回收機制不僅針對引用計數爲0的對象，同樣也可以處理循環引用的情況
循環引用指的是，兩個對象相互引用，但是沒有其他變量引用他們。
這種情況下，僅使用引用計數是不夠的。Python 的垃圾收集器實際上是一個
引用計數器和一個循環垃圾收集器。作爲引用計數的補充， 垃圾收集器也會
留心被分配的總量很大（及未通過引用計數銷燬的那些）的對象。
在這種情況下， 解釋器會暫停下來， 試圖清理所有未引用的循環。
'''
a=40; # 創建對象 <40>
print (a);
b=a;
print (a);# 增加引用， <40> 的計數
c=[b];
print (a);# 增加引用， <40> 的計數
del a; # 減少引用 <40> 的計數
print (b);
b=100; # 減少引用 <40> 的計數
print (b);
c[0]=-1; # 減少引用 <40> 的計數
print (c);
##析構函數 __del__ ，__del__在對象銷燬的時候被調用，當對象不再被使用時，__del__方法運行
class Point:
def __init__( self, x=0, y=0):
self.x = x
self.y = y
def __del__(self):
class_name = self.__class__.__name__
print (class_name, "銷燬")
pt1=Point();
pt2=pt1;
pt3=pt2;
print (id(pt1),id(pt2),id(pt3));
del pt1;
del pt2;
del pt3;
#注意：通常你需要在單獨的文件中定義一個類
##類的繼承
'''
面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是通過繼承機制。繼承完全可以理解成類之間的類型和子類型關係。
需要注意的地方：繼承語法 class 派生類名（基類名）：
//... 基類名寫作括號裏，基本類是在類定義的時候，在元組之中指明的。
在python中繼承中的一些特點：
1：在繼承中基類的構造（__init__()方法）不會被自動調用，它需要在其派生類的構造中親自專門調用。
2：在調用基類的方法時，需要加上基類的類名前綴，且需要帶上self參數變量。區別於在類中調用普通函數時並不需要帶上self參數
3：Python總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它纔開始到基類中逐個查找。（先在本類中查找調用的方法，找不到纔去基類中找）。
如果在繼承元組中列了一個以上的類，那麼它就被稱作"多重繼承" 。
語法：
派生類的聲明，與他們的父類類似，繼承的基類列表跟在類名之後，如下所示：
'''
class Parent: # 定義父類
parentAttr = 100
def __init__(self):
print ("調用父類構造函數");
def myMethod(self):
print ('調用父類方法');
def parentMethod(self):
print ('調用父類方法');
def setAttr(self, attr):
Parent.parentAttr = attr;
def getAttr(self):
print ("父類屬性 :", Parent.parentAttr)
class Child(Parent): # 定義子類
def __init__(self):
print ("調用子類構造方法");
#方法重寫
def myMethod(self):
print ('調用zi類方法');
def childMethod(self):
print ('調用子類方法 child method');
def childTestMethod(self):
Parent.parentMethod(self);##使用父類名稱調用父類方法
c = Child();
c.childMethod();
c.parentMethod();
c.setAttr(200);
c.getAttr();
c.childTestMethod();
c.myMethod();
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
##求和 運算符重載
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b);
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
##類的屬性和方法
'''
類屬性與方法
類的私有屬性
__private_attrs：兩個下劃線開頭，聲明該屬性爲私有，不能在類地外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs。
類的方法
在類地內部，使用def關鍵字可以爲類定義一個方法，與一般函數定義不同，類方法必須包含參數self,且爲第一個參數
類的私有方法
__private_method：兩個下劃線開頭，聲明該方法爲私有方法，不能在類地外部調用。在類的內部調用 self.__private_methods
'''
class JustCounter:
__secretCount = 0 # 私有變量
publicCount = 0 # 公開變量
def count(self):
self.__secretCount += 1;
self.publicCount =self.__secretCount;
print (self.__secretCount);
counter = JustCounter();
counter.count();
counter.count();
print (counter.publicCount);
#print (counter.__secretCount); # 報錯，實例不能訪問私有變量
print (counter._JustCounter__secretCount);
#Python不允許實例化的類訪問私有數據，但你可以使用 object._className__attrName 訪問屬性