注：一般標榜著 “ XX天學會XX”丁寄、“ XX 分鐘了解XX”的文章都不會是讓你增長功力的文章,如本文伊磺。

隨著互聯(lián)網(wǎng)發(fā)展删咱，全球在快速數(shù)字化痰滋，編程這件事也從數(shù)十年前只有科研人研在實驗室才能做的事變得越來越讓人們所熟悉。但是作為平時甚少接觸編程的小伙伴徊哑，是不是也會對計算機世界擁有一點點好奇心呢（比如電影《黑客帝國》聪富、《源代碼》）墩蔓？

Q1: "怎么進入編程世界?"

首先，你要學會一門編程語言昏名！
而我要推薦的計算機語言阵面，答案已在標題中被出賣：Python!
Python是一門十分容易上手样刷，但是又被IT業(yè)界廣泛使用的編程語言（Scratch這種圖形化編程雖然簡單，但基本只能用于教學）镇饮。2016年5月份Python在全球最受歡迎編程語言中排第五箕母。

Q2: “Python如何學？”

如果你是一位從未接觸過編程語言的新手钙勃，請移步 這里肺缕。 此書作者是一位程序員大叔授帕，大叔說了：“學編程跛十，首先，得會打字Ｖ拮稹奈偏！不會打字您就別學了哈”惊来。大叔的在書提出的觀點個人覺得也是值得學習的，無論用于編程還是其他事情矢渊，如：
As you study this book, and continue with programming, remember that anything worth doing is difficult at first. Maybe you are the kind of person who is afraid of failure so you give up at the first sign of difficulty. Maybe you never learned self-discipline so you can't do anything that's "boring." Maybe you were told that you are "gifted" so you never attempt anything that might make you seem stupid or not a prodigy. Maybe you are competitive and unfairly compare yourself to someone like me who's been programming for more than 20 years.
Whatever your reason for wanting to quit, keep at it. Force yourself. If you run into a Study Drill you can't do, or a lesson you just do not understand, then skip it and come back to it later. Just keep going because with programming there's this very odd thing that happens. At first, you will not understand anything. It'll be weird, just like with learning any human language. You will struggle with words, and not know what symbols are what, and it'll all be very confusing. Then one day BANG your brain will snap and you will suddenly "get it." If you keep doing the exercises and keep trying to understand them, you will get it. You might not be a master coder, but you will at least understand how programming works.”
萬事開頭難矮男，但自己選擇的路室谚，即使跪著也要走完秒赤。也許你是那種一碰到困難就想到放棄的人；也許你從未掌握“自律”這件事導致你無法做任何“枯燥”的事情撑螺；也許你一直被認為是“天才”甘晤，所以你不會傻到嘗試去做那些有可能讓你看起來是一個笨蛋或者至少不是“神童”的事情；也許你覺得和我這種已經編程超過20年的人比較編程這件事是一件逗逼的事情遏弱。
無論是什么原因使你想要退出塞弊，不要管它!要管住自己（譯者注：論“自虐”能力的重要性游沿。）！ 如果某一個練習你不會做袋坑，或者有一課你聽不明白眯勾，那就跳過它吃环，然后再回來重新學習（譯者注：子曰：溫故而知新）。編程這事說起來是件奇怪的事情歇拆，當你沒有領悟真諦的時候你只需要堅持范咨。像學習任何一門自然語言一樣渠啊，剛開始時可能總會感覺怪怪的。那些奇怪的單詞贯溅，那些你不知道的符號躲查，也許會讓你感到十分困惑镣煮。但只要你堅持不懈，堅持做本書中的那些練習并且嘗試著去理解它們镊折。會有一天恨胚，你的腦子會突然閃出“哇哈~！原來是這樣寒波！” 的頓悟時刻升熊。也許你不會成為一個高級碼農僚碎，但是至少你將會知道編程到底是什么鬼阴幌。
言歸正傳矛双，本文面向對象為具有一丁點編程經驗的小伙伴，旨在快速了解Python的基本語法和部分特性懒闷。

前言

# Python中單行注釋請用‘#’
""" Python中多行注釋
    請用""",我寫不了那么
    多字栈幸，隨便湊個樣板速址。
"""

1. 基本類型和運算符

   定義了一個數(shù)字 3

   3 # => 3

   基本計算

   1 + 1 # => 2
   8 - 1 # => 7
   10 * 2 # => 20
   35 / 5 # => 7

   當除數(shù)和被除數(shù)都為整型時，除 這個操作只求整數(shù)

   ( python2.x語法昔园。經測試默刚，Python3.x 已經全部當做浮點數(shù)處理,還會計算小數(shù))

   5 / 2 # => 2
   10/-3 #python3的結果為-3.3333333333333335 python2 結果為-4
   10/3 #python3的結果為3.3333333333333335 python2 結果為3

   由上面兩個結果也可以看出逃魄，在Python2中，如結果有小數(shù)店展，則會取最近最小整數(shù)

# 如果我們除數(shù)和被除數(shù)為浮點型秃流，則Python會自動把結果保存為浮點數(shù)
2.0  # 這是浮點數(shù)
11.0 / 4.0  # 這個時候結果就是2.75啦舶胀！是不是很神奇？ 

# 當用‘//’進行計算時糖赔，python3不會全部單做浮點數(shù)處理.
5 // 3   # => 1
5.0 // 3.0 # => 1.0 
-5 // 3  # => -2
-5.0 // 3.0 # => -2.0


from __future__ import division # 注可以在通過 __future__  關鍵字
                                # 在python2中引入python3 特性
11/4    # => 2.75  ... 標準除法
11//4   # => 2 ... 除后取整

# 求余數(shù)操作
7 % 3 # => 1

# 冪操作 2的4次方
2**4 # => 16

# 先乘除放典，后加減基茵，口號優(yōu)先
(1 + 3) * 2  # => 8

# 布爾值操作
# 注：or 和 and 兩個關鍵字是大小寫敏感的
True and False #=> 返回False
False or True #=> 返回True

# 布爾值和整形的關系拱层，除了0外，其他都為真
0 and 2 #=> 0
-5 or 0 #=> -5
0 == False #=> True
2 == True #=> False
1 == True #=> True

#  not 操作
not True  # => False
not False  # => True

#等值比較 “==”径缅，相等返回值為True 纳猪，不相等返回False
1 == 1  # => True
2 == 1  # => False

# 非等比較“桃笙！=”怎栽，如果兩個數(shù)不相等返回True熏瞄，相等返回Flase
1 != 1  # => False
2 != 1  # => True

# 大于/小于 和等于的組合比較
1 < 10  # => True
1 > 10  # => False
2 <= 2  # => True
2 >= 2  # => True

# Python可以支持多數(shù)值進行組合比較，
       #但只要一個等值為False由桌，則結果為False
1 < 2 < 3  # => True
2 < 3 < 2  # => False

# 可以通過 " 或者 '來創(chuàng)建字符串
"This is a string."
'This is also a string.'

# 字符串間可以通過 + 號進行相加行您，是不是簡單到爆？
"Hello " + "world!"  # => "Hello world!"
# 甚至不使用'+'號炕檩，也可以把字符串進行連接
"Hello " "world!"  # => "Hello world!"

 #可以通過 * 號笛质，對字符串進行復制捞蚂，比如 姓迅；
         importantNote = "重要的事情說三遍\n" * 3 
         print （importantNote）
        """ 結果為：
         重要的事情說三遍
         重要的事情說三遍
         重要的事情說三遍
        """

"Hello" * 3  # => "HelloHelloHello"

# 字符串可以在任意位置被打斷
"This is a string"[0]  # => 'T'

#字符串可以用 %連接，并且可以打印出變量值
       #（和C/C++ 一樣%d 表示整數(shù)肩杈，%s表示字符串锋恬，
       #但python可以自己進行判斷编丘，我們無需太擔心這個問題）
x = 'apple'
y = 'lemon'
z = "The items in the basket are %s and %s" % (x,y)

# 一個新的更好的字符串連接方式是通過.format()函數(shù)嘉抓，推薦使用該方式
"{} is a {}".format("This", "placeholder")
"{0} can be {1}".format("strings", "formatted")
# You can use keywords if you don't want to count.
"{name} wants to eat {food}".format(name="Bob", food="lasagna")

# None是一個對象,None就是None抑片，它是一個特殊的變量
None  # => None

# 在和None進行比較時杨赤，不要用“==”操作符疾牲，用 “is”
"etc" is None  # => False
None is None  # => True


#“is"操作符用于對象之間的比較，
        #對于底層類型進行比較時
#不建議用“is”焰枢，但對于對象之間的比較济锄，用“is”是最合適的
# bool可以用于對任何對象進行判斷
# 以下這些值是非真的
#   - None
#   - 各類數(shù)值型的0 (e.g., 0, 0L, 0.0, 0j)
#   - 空元組、空列表 (e.g., '', (), [])
#   - 空字典一汽、空集合 (e.g., {}, set())
#   - 其他值請參考：
#     https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
#
# All other values are truthy (using the bool() function on them returns True).
bool(0)  # => False
bool("")  # => False

2. 變量和集合

   打印 print()

   print ("I'm Python. Nice to meet you!") # => I'm Python. Nice to meet you!

   從控制臺中獲取輸入

   input_string_var = raw_input("Enter some data: ") # 返回字符串類型
   input_var = input("Enter some data: ") # python會判斷類型如果是字符串 則輸入時要加“”or''

   注意：在 python 3中, input() 由 raw_input() 代替

   在Python中不需要設定變量類型角虫，python會自動根據(jù)值進行判斷

   some_var = 5
   some_var # => 5

# if 可以作為表達時被使用,下句可以這樣理解 “輸出‘yahool’如果3大于2的話戳鹅，不然輸出2“
"yahoo!" if 3 > 2 else 2  # => "yahoo!"

列表

# python中的列表定義
li = []
# 也可以通過初始化時內置列表的值
other_li = [4, 5, 6]

# append函數(shù)可以在列表中插入值
li.append(1)    # li is now [1]
li.append(2)    # li is now [1, 2]
li.append(4)    # li is now [1, 2, 4]
li.append(3)    # li is now [1, 2, 4, 3]
# pop函數(shù)從列表末移除值
li.pop()        # => 3 and li is now [1, 2, 4]
# 移除后通過append接回
li.append(3)    # li is now [1, 2, 4, 3] again.

# 通過[]的方式可以提取任何列表中的任意值
       #（前提枫虏，index不大于列表總數(shù)）
li[0]  # => 1
# 也可以通過[]下標的方式直接給列表賦值
li[0] = 42
li[0]  # => 42
# 如果[]小標的值為負數(shù)爬虱，則表示以逆序獲取列表中的值
li[-1]  # => 3

# 查詢的值不可以超出列表個數(shù)跑筝，否則報錯。
# 但是利用insert()插入時可以赞警，超出范圍的值會直接被插入到列表最末
li[4]  # Raises an IndexError

# 可以通過[:],獲取列表中指定范圍的值
# (It's a closed/open range for you mathy types.)
# 這是半開取值法愧旦，比如li[1:3],取的是列表中index為1定罢、2的兩個值祖凫，
# 該法則適用于以下所有通過[]取值的方式
li[1:3]  # => [2, 4]
# 如果一邊不去值惠况，則表示取所有該邊的值。
li[2:]  # => [4, 3]
li[:3]  # => [1, 2, 4]

# [::2]表示選擇從[0]開始罚拟，步長為2上的值
li[::2]   # =>[1, 4]
# [::-1]表示反向選擇赐俗，-可以理解為 反向選擇，而1表示步長粱快，步長1則包含了列表中的所有元素
li[::-1]   # => [3, 4, 2, 1]
# []規(guī)則完整版表示方法[開始：結束：步長]
# li[start:end:step]

#  "del"關鍵字可以直接刪除列表中的值
del li[2]   # li is now [1, 2, 3]

# 可以通過“+”操作符對列表進行操作,注：列表只有 + 操作事哭，而集合（set）有+ 和 -
li + other_li   # => [1, 2, 3, 4, 5, 6]


# 也可以 "extend()"方法對列表進行擴展
li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]

# Remove 方法和 del 類似瓜富，但remove的直接是數(shù)值与柑，而不是index
li.remove(2)  # li is now [1, 3, 4, 5, 6]
li.remove(2)  # 如果remove的值不存在列表中，則會報錯

# 在指定位置插入數(shù)值丑念，上面已經提過脯倚，如果index值超過的話嵌屎，會直接插到列表末
li.insert(1, 2)  # li is now [1, 2, 3, 4, 5, 6] again

# 獲取某個值的index
li.index(2)  # => 1
li.index(7)  # 如果

# "in"可以直接查看某個值是否存在于列表中
1 in li   # => True

# "len()"函數(shù)可以檢測隊列的數(shù)量
len(li)   # => 6

元組

# Tuples(元組）是一個類似數(shù)列的數(shù)據(jù)結構编整，但是元組是不可修改的
tup = (1, 2, 3)
tup[0]   # => 1
tup[0] = 3  # 一修改就會報錯

#數(shù)列中的方法在元組也可以使用（除了 修改）
len(tup)   # => 3
tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
tup[:2]   # => (1, 2)
2 in tup   # => True

# 可以一次性賦值幾個變量
a, b, c = (1, 2, 3)  # a 為1掌测，b為2产园，c為3
d, e, f = 4, 5, 6      # 元組賦值也可以不用括號
# 同樣元組不用括號也同樣可以創(chuàng)建
g = 4, 5, 6          # => (4, 5, 6)
# Python中的數(shù)據(jù)交換十分簡單：只要在賦值時互調位置即可
e, d = d, e  # d is now 5 and e is now 4

字典

# Python中的字典定義
empty_dict = {}
# 也可以通過定義時賦值給字典
filled_dict = {"one": 1, "two": 2, "three": 3}

# 可以通過[]的key方式查詢字典中的值
filled_dict["one"]   # => 1

# 可以通過"keys()"方法獲取字典中的所有key值
filled_dict.keys()   # => ["three", "two", "one"]
# Note - 返回的keys并不一定按照順序排列的.
# 所以測試結果可能和上述結果不一致

# 通過 "values()"的方式可以獲取字典中所有值粘勒，
 #同樣他們返回的結果也不一定按照順序排列
filled_dict.values()   # => [3, 2, 1]


# 可以通過 "in"方式獲取查詢某個鍵值是否存在字典中屎即，但是數(shù)值不可以
"one" in filled_dict   # => True
1 in filled_dict   # => False

# 查找不存在的key值時，Python會報錯
filled_dict["four"]   # KeyError

#用 "get()" 方法可以避免鍵值錯誤的產生
filled_dict.get("one")   # => 1
filled_dict.get("four")   # => None
# 當鍵值不存在的時候统台，get方法可以通過返回默認值啡邑，
# 但是并沒有對值字典進行賦值
filled_dict.get("one", 4)   # => 1
filled_dict.get("four", 4)   # => 4


# 字典中設置值的方式和列表類似谤逼，通過[]方式可以設置
filled_dict["four"] = 4  # now, filled_dict["four"] => 4

# "setdefault()" 可以設置字典中的值
# 但是注意：只有當該鍵值之前未存在的時候流部，setdefault（）函數(shù)才生效
filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5

集合

empty_set = set()
# 初始化set的方式可以通過 set()來實現(xiàn)
some_set = set([1, 2, 2, 3, 4])   # some_set is now set([1, 2, 3, 4])

# 集合的排列是無序的枝冀！集合的排列是無序的！集合的排列是無序的瓷马！
another_set = set([4, 3, 2, 2, 1])  # another_set is now set([1, 2, 3, 4])

# Python2.7以后欧聘，{}可以用于被定義集合
filled_set = {1, 2, 2, 3, 4}   # => {1, 2, 3, 4}

# Add方法可用于增加集合成員
filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}

#集合可通過 &操作符取交集
other_set = {3, 4, 5, 6}
filled_set & other_set   # => {3, 4, 5}

# 通過|操作符取并集
filled_set | other_set   # => {1, 2, 3, 4, 5, 6}

# 通過 - 操作符取差集
{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}

# 通過 ^ 操作符取非集
{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}

# 通過 >= 判斷左邊集合是否是右邊集合的超集
{1, 2} >= {1, 2, 3} # => False

# 通過 <= 判斷左邊集合是否右邊集合的子集
{1, 2} <= {1, 2, 3} # => True

# 通過 in 可以判斷元素是否在集合中
2 in filled_set   # => True
10 in filled_set   # => False

Python數(shù)據(jù)集合類型總結
列表 定義方式 li = [1,2,3,4怀骤，“Hello World”] （列表可以包含任意基本類型）
元組 定義方式 tup = (1,2,3,4) （和列表類似蒋伦，但 元組不可更改）
字典 定義方式 dic = {“one”：2焚鹊，“tow”：3末患，“three”：0}（字典璧针，就是字典嘛。以 key:value 方式存在）
集合 定義方式 set=set（1申屹，2哗讥，3，4）or set = {1车酣，2湖员，3娘摔，4} （集合里的元素是唯一的唤反，集合支持 & | ^ + -操作）

3. Python 邏輯運算符

   創(chuàng)建一個變量

   some_var = 5

   通過if進行邏輯判斷

   if some_var > 10:
   print "some_var is totally bigger than 10."
   elif some_var < 10: # This elif clause is optional.
   print "some_var is smaller than 10."
   else: # This is optional too.
   print "some_var is indeed 10."

"""
    通過for...in...進行循環(huán)打油獭：
    dog is a mammal
    cat is a mammal
    mouse is a mammal
"""
for animal in ["dog", "cat", "mouse"]:
    # You can use {0} to interpolate formatted strings. (See above.)
    print "{0} is a mammal".format(animal)

"""
通過"range()" 方式盏阶，控制for的循環(huán)次數(shù)
prints:
    0
    1
    2
    3
"""
for i in range(4):
    print i

"""
"range(lower, upper)" 返回 lower 到 upper的值,
 注意：range左邊必須小于右邊參數(shù)
prints:
    4
    5
    6
    7
"""
for i in range(4, 8):
    print i

"""
while 循環(huán)
prints:
    0
    1
    2
    3
"""
x = 0
while x < 4:
    print x
    x += 1  # Shorthand for x = x + 1

# Python支持 try/except 語法

# Python2.6以上的版本名斟，支持try...except...:
try:
    # raise顯示地引發(fā)異常。一旦執(zhí)行了raise語句闷袒，raise后面的語句將不能執(zhí)行囊骤。
    raise IndexError("This is an index error")
except IndexError as e:
    pass    # pass 空語句淘捡，跳過處理
except (TypeError, NameError):
    pass    # python 支持同時檢測多個錯誤
else:   # Python必須要處理所有情況池摧，這里是其他未定義的情況
    print "All good!"   
finally: #  finally無論有沒有異常都會執(zhí)行
    print "We can clean up resources here"

#通過with函數(shù)，可以替代try....except...函數(shù)  [with詳解](http://www.ibm.com/developerworks/cn/opensource/os-cn-pythonwith/)
with open("myfile.txt") as f:
    for line in f:
        print line

4. Functions

   def 關鍵字定義函數(shù)

   def add(x, y):
   print "x is {0} and y is {1}".format(x, y)
   return x + y #可以直接return結果

   函數(shù)調用參數(shù)

   add(5, 6) # => prints out "x is 5 and y is 6" and returns 11

   Python支持參數(shù)互換激况，只需要在調用函數(shù)時加上形參

   add(y=6, x=5) # Keyword arguments can arrive in any order.

# Python函數(shù)支持可變參數(shù)
#  在定義函數(shù)時通過*號表示可變長參數(shù)
def varargs(*args):
    return args

varargs(1, 2, 3)   # => (1, 2, 3)

# 可以通過**的方式定義Key可變長參數(shù)查找字典中的關鍵詞

def keyword_args(**kwargs):
    return kwargs

# 當函數(shù)參數(shù)是**類型的時候作彤，Python可以通過該函數(shù)定義字典
keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}


#同時支持函數(shù)和字典類型參數(shù)膘魄，具體事例如下：
def all_the_args(*args, **kwargs):
    print args
    print kwargs
"""
all_the_args(1, 2, a=3, b=4) prints:
    (1, 2)
    {"a": 3, "b": 4}
"""

# 在調用函數(shù)時，可以同時賦值竭讳，文字難以表達创葡，例子如下：
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, a=3, b=4)

# 在函數(shù)中也可以通過單獨處理* 或者 **的方式，增加函數(shù)的健壯性
def pass_all_the_args(*args, **kwargs):
    all_the_args(*args, **kwargs)
    print varargs(*args)
    print keyword_args(**kwargs)

# 全局變量 X
x = 5

def set_x(num):
    # 當在函數(shù)里面改變變量時绢慢，如果沒有加gloabl關鍵字，則改變的是局部變量
    x = num # => 43
    print x # => 43

def set_global_x(num):
    global x
    print x # => 5
    x = num # 加了global關鍵字后胰舆，即可在函數(shù)內操作全局變量
    print x # => 6

set_x(43)
set_global_x(6)

# 返回函數(shù)指針方式定義函數(shù)/*換個說法骚露，匿名函數(shù)*/
def create_adder(x):
    def adder(y):
        return x + y
    return adder

add_10 = create_adder(10)
add_10(3)   # => 13

# Lambda 關鍵字定義的匿名函數(shù)
(lambda x: x > 2)(3)   # => True 
(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5

# map方式也可以調用函數(shù)并傳入?yún)?shù)
map(add_10, [1, 2, 3])   # => [11, 12, 13]
map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]

filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]

# 可以通過這兩種方式結合調用，下面的函數(shù)解析：
#add_10(i) 是映射了for...in...函數(shù)的返回值缚窿，返回值作為參數(shù)傳進棘幸。
[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]

5. Python中的類

   下面代碼是定義了一個Human類，繼承自object類

   Python類可以繼承自多個類倦零，如class Human(object,orangOutang)

   class Human(object):

    # 類變量
    species = "H. sapiens"類接口
                __species = "Other.sapiens" #內部結構误续，無法被外部直接訪問
   
    # __init__(),初始化函數(shù)，python中在對類進行處理時扫茅，會先處理以下函數(shù)蹋嵌，
    #其實就是系統(tǒng)默認定義了接口，而這個接口是開放給用戶去實現(xiàn)的葫隙，具體如下：   
    #__init__  構造函數(shù)欣尼，在生成對象時調用
    # __del__   析構函數(shù)，釋放對象時使用
    #__repr__ 打印停蕉，轉換
    #__setitem__按照索引賦值
    #__getitem__按照索引獲取值
    #__len__獲得長度
    #__cmp__比較運算
    #__call__函數(shù)調用
    #__add__加運算
    #__sub__減運算
    #__mul__乘運算
    #__div__除運算
    #__mod__求余運算
    #__pow__稱方
   
    def __init__(self, name):
        #聲明類中的屬性愕鼓，并初始化，在初始化的時候同時
        #就是定義了變量類型
        self.name = name
        self.age = 0
   
    # 在類中所有函數(shù)都必須把self作為第一個參數(shù)
    #（下面定義的類方法和靜態(tài)方法除外）
    def say(self, msg):
        return "{0}: {1}".format(self.name, msg)
   
    # 類方法
    @classmethod
    def get_species(cls):
        return cls.species
   
    # 靜態(tài)方法慧起，
    @staticmethod
    def grunt():
        return "*grunt*"
   
    # A property is just like a getter.
    # It turns the method age() into an read-only attribute
    # of the same name.
    #property屬性菇晃，相當于getter
    @property
    def age(self):
        return self._age
   
    # This allows the property to be set
    @age.setter
    def age(self, age):
        self._age = age
   
    # This allows the property to be deleted
    @age.deleter
    def age(self):
        del self._age
   

   類實例化

   i = Human(name="Ian")
   print i.say("hi") # prints out "Ian: hi"

   j = Human("Joel")
   print j.say("hello") # prints out "Joel: hello"

   調用實例方法用"."

   i.get_species() # => "H. sapiens"

   改變類變量

   Human.species = "H. neanderthalensis"
   i.get_species() # => "H. neanderthalensis"
   j.get_species() # => "H. neanderthalensis"

   調用靜態(tài)方法

   Human.grunt() # => "grunt"

   給age賦值

   i.age = 42

   獲取age值

   i.age # => 42

   刪除age

   del i.age
   i.age # => raises an AttributeError

6. Python的模塊（庫）

   Python中的一個*.py文件就是一個模塊

   import math
   print math.sqrt(16) # => 4

   可以只引入模塊中的某些類/方法

   from math import ceil, floor
   print ceil(3.7) # => 4.0
   print floor(3.7) # => 3.0

   也可以通過*引入全部方法

   Warning: this is not recommended

   from math import *

   math庫的縮寫可以為m

   math.sqrt(16) == m.sqrt(16) # => True

   可以直接引入sqrt庫

   from math import sqrt
   math.sqrt == m.sqrt == sqrt # => True

#python的庫就只是文件
import math
dir(math)

# If you have a Python script named math.py in the same
# folder as your current script, the file math.py will 
# be loaded instead of the built-in Python module. 
# This happens because the local folder has priority
# over Python's built-in libraries. 

#如果你在當前目錄下有一個Python腳本的名字也叫math.py
#當前目錄下的math.py會替換掉內置的Python模塊
#因為在Python中當前目錄的優(yōu)先級會高于內置模塊的優(yōu)先級

7. Python中的高級特性（生成器、裝飾器:wraps）

   Generators 蚓挤，生成器函數(shù)在Python中與迭代器協(xié)議的概念聯(lián)系在一起磺送。

   簡而言之，包含yield語句的函數(shù)會被特地編譯成生成器灿意。

   當函數(shù)被調用時估灿，他們返回一個生成器對象，這個對象支持迭代器接口缤剧。函數(shù)

   也許會有個return語句馅袁，但它的作用是用來yield產生值的。

   for i in iterable:
   yield i + i

   xrange_ = xrange(1, 900000000)

   for i in double_numbers(xrange_):
   print i
   if i >= 30:
   break

# 裝飾器wraps荒辕，wraps可以包裝
# Beg will call say. If say_please is True then it will change the returned
# message
from functools import wraps

def beg(target_function):
    @wraps(target_function)
    def wrapper(*args, **kwargs):
        msg, say_please = target_function(*args, **kwargs)
        if say_please:
            return "{} {}".format(msg, "Please! I am poor :(")
        return msg

    return wrapper

@beg

def say(say_please=False):
msg = "Can you buy me a beer?"
return msg, say_please

print say() # Can you buy me a beer?
print say(say_please=True) # Can you buy me a beer? Please! I am poor :

[1]learnxinyminutes,本文代碼大部分取于該網(wǎng)站汗销，在此對該網(wǎng)站作者表示感謝犹褒！