驗證 交互 quest 選擇 temp named ret 難解 scrip

第一部分 基礎知識

第 1 章 運行第一個程序 打印消息 “Hello world!” 。
第 2 章 變量中存儲信息以及如何使用文本和數字。
第 3 4 章 列表 使用列表能夠在一個變量中存儲任意數量的信息，從而高效地處理數據：只需幾行代碼，你就能夠處理數百、數千乃至數百萬個值。
第 5 章 if 條件判斷
第 6 章 使用 Python 字典，將不同的信息關聯起來。與列表一樣，你也可以根據需要在字典中存儲任意數量的信息。
第 7 章 交互式程序 while 循環
第 8 章 函數。函數是執行特定任務的被命名的代碼塊
第 9 章 類，它讓你能夠模擬實物，如小狗、小貓、人、汽車、火箭等，讓你的代碼能夠表示任何真實或抽象的東西。

第 10 章 如何使用文件，以及如何處理錯誤以免程序意外地崩潰。你需要在程序關閉前保存數據，並在程序再次運行時讀取它們。你將學習 Python 異常，它們讓你能夠未雨綢繆，從而讓程序妥善地處理錯誤。
第 11 章為代碼編寫測試，以核實程序是否像你期望的那樣工作。這樣，擴展程序時，你就不用擔心引入新的 bug要想脫離初級程序員的陣容，躋身於中級程序員的行列，測試代碼是你必須掌握的基本技能之一。

第一章 第一個python程序

[root@localhost ~/python]# python #進入python2.7交互式界面 相關版本以及提示信息
Python 2.7.5 (default, Aug 4 2017, 00:39:18)

[GCC 4.8.5 20150623 (Red Hat 4.8.5-16)] on linux2
Type "help", "copyright", "credits" or "license" for more information.

>> print("Hello Python World") #也可將代碼保存在文件中中使用python命令運行 .py文件
Hello Python World

第二章 變量以及簡單數據類型：字符串 數字

2.1變量命名規範

• 1.變量名只能包含字母、數字和下劃線。變量名可以字母或下劃線打頭，但不能以數字打頭，
  
  例如，可將變量命名為 message_1 ，但不能將其命名為 1_message 。
• 2.變量名不能包含空格，但可使用下劃線來分隔其中的單詞。例如，變量名 greeting_message 可行，但變量名 greeting message 會引發錯誤。
• 3.不要將 Python 關鍵字和函數名用作變量名，即不要使用 Python 保留用於特殊用途的單詞，如 print （請參見附錄 A.4 ）。
• 4.變量名應既簡短又具有描述性。例如， name 比 n 好， student_name 比 s_n 好， name_length 比 length_of_persons_name 好。

• 慎用小寫字母 l 和大寫字母 O ，因為它們可能被人錯看成數字 1 和 0 。

      # vim hello_world.py
      message = "hello world"   #定義一個變量
      print(message)
      message = "hello python world"
      print(message)
  
      輸出信息：
      hello world
      hello python world
      python將記錄變量最新值

2.2字符串

• pyhon 中，用引號括起的都是字符串，其中的引號可以是單引號，也可以是雙引號。例如：
  print(‘I told my friend, "Python is my favorite language!"‘)
  print("The language ‘Python‘ is named after Monty Python, not the snake.")
  print("One of Python‘s strengths is its diverse and supportive community.")

• 調用一些簡單的方法進行處理 格式: 實例名.方法名

      >>> name = "test_name"
      >>> print(name.title())
      Test_Name
      >>> print(name.upper())
      TEST_NAME
      >>> print(name.lower())
      test_name
      其他方法:
      rstrip()  刪除字符串右側空白
      lstrip()  刪除左側空白
      strip()   刪除兩端空白

• 字符串 合並或拼接 用+號

       制表符:"\t"   
       換行符:"\n"
      first_name = "ada"
      last_name = "lovelace"
      full_name = first_name + " " + last_name
      print("Hello, " + full_name.title() + "!")
      print("Languages:\nJavaScript\n\t Python")

  註意:在 Python 2 中，無需將要打印的內容放在括號內。
  從技術上說， Python 3 中的 print 是一個函數，因此括號必不可少。有些 Python 2 print 語句也包含括號，但其行為與 Python 3 中
  稍有不同。簡單地說，在 Python 2 代碼中，有些 print 語句包含括號，有些不包含。

• 函數的使用方式 #函數名(參數名)
  使用str()函數
  age = 23
  message = "Happy " + str(age) + "rd Birthday!"
  print(message)

2.3數字

• 整數 :+ - x / 取余:% 乘方:*
  實例:(2 + 3) 4
• 浮點數 Python 將帶小數點的數字都稱為 浮點數
  從很大程度上說，使用浮點數時都無需考慮其行為。你只需輸入要使用的數字， Python 通常都會按你期望的方式處理它們

2.4添加 註釋

註釋用井號（ # ）標識。井號後面的內容都會被 Python 解釋器忽略，如下所示：
#向大家問好
print("Hello Python people!")

2.5python 之禪 .指導原則

編程語言 Perl 曾在互聯網領域長期占據著統治地位，早期的大多數交互式網站使用的都是 Perl 腳本。彼時， “ 解決問題的辦法有多個 ” 被 Perl 社區奉為座右銘。這種理念一度深受大家的喜愛，因為這種語言固有的靈活性使得大多數問題都有很多不同的解決之道。在開發項目期間，這種靈活性是可以接受的，但大家最終認識到，過於強調靈活性會導致大型項目難以維護：要通過研究代碼搞清楚當時解決復雜問題的人是怎麽想的，既困難又麻煩，還會耗費大量的時間

        import this 

    The Zen of Python, by Tim Peters
    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren‘t special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess.
    There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you‘re Dutch.
    Now is better than never.
    Although never is often better than *right* now.
    If the implementation is hard to explain, it‘s a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea -- let‘s do more of those!
    蒂姆彼得斯的Python的禪宗
    美麗勝於醜陋。
    顯式比隱式更好。
    簡單勝於復雜。
    復雜比復雜更好。
    Flat比嵌套更好。
    稀疏比密集好。
    可讀性計數。
    特殊情況不足以打破規則。
    雖然實用性勝過純凈。
    錯誤不應該默默通過。
    除非明確沈默。
    面對歧義，拒絕猜測的誘惑。
    應該有一個 - 而且最好只有一個 - 明顯的做法。
    盡管這種方式一開始可能並不明顯，除非你是荷蘭人。
    現在比永遠好。
    雖然現在永遠不會比*正確*更好。
    如果實現很難解釋，這是一個壞主意。
    如果實現很容易解釋，這可能是一個好主意。
    命名空間是一個好主意 - 讓我們做更多的這些！

第三章 列表( 索引 元素的值 組織列表)

3.1列表 （索引 元素增刪改查）

一系列按特定序列排列的元素組成。給列表啟一個表示復數的名稱是個不錯的選擇。在 用方括號[ ] 來表示列表，並用逗號來分隔其中的元素。
下面是一個簡單的列表示例，這個列表包含幾種自行車：
bicycles = [‘trek‘, ‘cannondale‘, ‘redline‘, ‘specialized‘]
print(bicycles)

• 訪問列表元素 需要指定元素的位置或索引
  print(bicycles[0])
• 索引 從0開始不是1
  print(bicycles[3]) ##要訪問第四個列表元素，可使用索引 3
  print(bicycles[-1].title()) ##對最後一個元素使用title()方法
• 元素的增刪改

      增：
          列表末尾添加元素 方法 append() 將元素 添加到了列表末尾，而不影響列表中的其他所有元素：
          motorcycles = []  ##定義空列表
          motorcycles.append(‘honda‘)  
          motorcycles.append(‘yamaha‘)
          motorcycles.append(‘suzuki‘)
          print(motorcycles)
      插入：
          使用方法insert()可以在列表的任意位置添加元素，但是需要指定索引以及值。
          motorcycles.insert(0, ‘ducati‘)  #指定索引以及值
          motorcycles = [‘honda‘, ‘yamaha‘, ‘suzuki‘]
          print(motorcycles)
          motorcycles[0] = ‘ducati‘
          print(motorcycles)
      刪：根據位置或值來刪除列表中的元素。
  * del 語句  條件是知道其索引，刪除後，你就無法再訪問它     
            del motorcycles[1]
  * pop() 方法：彈出列表末尾的元素 列表就像一個棧，而刪除列表末尾的元素相當於彈出棧頂元素。將元素從列表中刪除，並接著使用它的值將其保存在變量中
              popped_motorcycle = motorcycles.pop() 
              first_owned = motorcycles.pop(0) ##指定索引刪除特定的值
  * remove()方法：   知道要刪除的元素的值，可使用方法 remove() 
              motorcycles = [‘honda‘, ‘yamaha‘, ‘suzuki‘, ‘ducati‘]
              print(motorcycles)
              tooexpensive = ‘ducati‘
              motorcycles.remove(tooexpensive)
              print(motorcycles)
              print("\nA " + tooexpensive.title() + " is too expensive for me.")  #變量中保存刪除的元素
              回顯信息：
              [‘honda‘, ‘yamaha‘, ‘suzuki‘, ‘ducati‘]
              [‘honda‘, ‘yamaha‘, ‘suzuki‘]
              A Ducati is too expensive for me.
  註意：方法 remove() 只刪除第一個指定的值。如果要刪除的值可能在列表中出現多次，就需要使用循環來判斷是否刪除了所有這樣的值。
  將在第七章使用循環處理上述問題 

3.2 組織列表的常見方式：sort()、 倒序打印列表 、 sorted() 、確定列表的長度}

• 使用方法 sort() 對列表元素按字母排序 永久排序
  cars = [‘bmw‘, ‘audi‘, ‘toyota‘, ‘subaru‘]
  cars.sort() #字母順序
  cars.sort(reverse=True) #字母倒序 向 sort() 方法傳遞參數 reverse=True
• 使用方法 reverse() 反轉列表元素的排列順序 永久排序
  cars = [‘bmw‘, ‘audi‘, ‘toyota‘, ‘subaru‘]
  print(cars)
  cars.reverse()
  print(cars)
• 使用sorted()函數進行臨時性排序 格式： 函數名（傳遞給函數的參數）
  sorted(cars)
  [‘audi‘, ‘bmw‘, ‘subaru‘, ‘toyota‘]
• 函數 len() 可快速獲悉列表的長度
  len(cars)

第四章 操作列表

遍歷列表 切片 遍歷切片 復制切片 元組(定義 遍歷 修改元組變量)

4.1 遍歷列表 創建數字列表 列表解析

• 使用for循環遍歷列表中的元素，縮進的代碼行都是循環體的一部分

      magicians = [‘alice‘, ‘david‘, ‘carolina‘]
      for magician in magicians:     ##註意冒號不要丟
              print(magician.title() + ", that was a great trick!")
              print("I can‘t wait to see your next trick, " + magician.title() + ".\n")
      print("Thank you, everyone. That was a great magic show!")  ##循環結束後的語句

• 使用range() 函數生成一系列數字 Python 從你指定的第一個值開始數，並在到達你指定的第二個值後停止，因此輸出不包含第二個值（這裏為 5）

    for value in range(1,5):
            print(value)

• 創建數字列表 使用list()函數將range()的結果轉話為列表，將range()作 為list()的參數，輸出一個數字列表。
  numbers = list(range(1,6)) ##range(1,10,2) 可以指定步長（起始，結束，步長）
  print(numbers)
  創建列表實例:

          squares = [] 
          for value in range(1,11):
                  square = value**2
                  squares.append(square)
          print(squares)
          結果：
          [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

• 簡單統計計算 函數（參數）
  min(digits)
  max(digits)
  sum(digits)
• 列表解析

  要使用這種語法，首先指定一個描述性的列表名，如 squares然後，指定一個左方括號，並定義一個表達式，用於生成你要存儲到列表中的值。
  在這個示例中，表達式為 value**2 ，它計算平方值。
  接下來，編寫一個 for 循環，用於給表達式提供值，再加上右方括號。在這個示例中， for 循環為 for value in range(1,11) ，它將值1~10 提供給表達式 value**2 。

  註意：這裏的 for 語句末尾沒有冒號。
  squares = [value**2 for value in range(1,11)]
  print(squares)
  結果與你在前面看到的平方數列表相同：
  [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

4.2 切片 遍歷切片 復制列表

• 切片：對列表的部分元素進行處理
  players = [‘charles‘, ‘martina‘, ‘michael‘, ‘florence‘, ‘eli‘]
  print(players[0:3])
  print(players[1:4]) #提取列表的第 2~4 個元素
  print(players[:4]) #不指定第一個索引默認為開頭
  print(players[2:]) #到列表末尾
  負數索引返回離列表末尾相應距離的元素，因此你可以輸出列表末尾的任何切片。例如，如果你要輸出名單上的最後三名隊員：
  可使用切片 players[-3:]

• 遍歷切片 在for循環中遍歷切片

      players = [‘charles‘, ‘martina‘, ‘michael‘, ‘florence‘, ‘eli‘]
      print("Here are the first three players on my team:")
      for player in players[:3]:
          print(player.title())

• 復制列表 創建一個包含整個列表的切片，同時省略起始索引和終止索引[:]

  ----------------------------------------------------------------
  my_foods = [‘pizza‘, ‘falafel‘, ‘carrot cake‘]
  friend_foods = my_foods[:]     #起始末尾復制列表
  ----------------------------------------------------------------
  my_foods = [‘pizza‘, ‘falafel‘, ‘carrot cake‘]
  friend_foods = my_foods[:]     #復制列表
  my_foods.append(‘cannoli‘)
  friend_foods.append(‘ice cream‘)
  print("My favorite foods are:")
  print(my_foods)
  print("\nMy friend‘s favorite foods are:")
  print(friend_foods)
  ----------------------------------------------------------------
  friend_foods = my_foods   #僅僅簡單賦值
  my_foods.append(‘cannoli‘)
  friend_foods.append(‘ice cream‘)
  print("My favorite foods are:")
  print(my_foods)
  print("\nMy friend‘s favorite foods are:")
  print(friend_foods)

  註意：這裏將 my_foods 賦給 friend_foods ，而不是將 my_foods 的副本存儲到 friend_foods （見?）。這種語法實際上是讓 Python 將新變量 friend_foods 關聯到包含在 my_foods 中的列表，因此這兩個變量都指向同一個列表。鑒於此，當我們將 ‘cannoli‘ 添加到 my_foods 中時，它也將出現在 friend_foods 中；同樣，雖然 ‘icecream‘ 好像只被加入到了 friend_foods 中，但它也將出現在這兩個列表中。

4.3 元組 （定義 遍歷 修改）

• 元組：
  列表非常適合用於存儲在程序運行期間可能變化的數據集。列表是可以修改的，這對處理網站的用戶列表或遊戲中的角色列表至關重要然而，有時候你需要創建一系列不可修改的元素，元組可以滿足這種需求。 Python 將不能修改的值稱為 不可變的 ，而不可變的列表被稱為 元組。
  dimensions = (200, 50) #（定義元組元素的值，號分割）
  ? dimensions[0] = 250 #不可給元組的元組的元素賦值
  ?處的代碼試圖修改第一個元素的值，導致 Python 返回類型錯誤消息。由於試圖修改元組的操作是被禁止的，因此 Python 指出不能給元組的元素賦值：
  Traceback (most recent call last):
  File "dimensions.py", line 3, in <module>
  dimensions[0] = 250
  TypeError: ‘tuple‘ object does not support item assignment
• for遍歷元組

      dimensions = (200, 50)
      for dimension in dimensions:
          print(dimension)

• 修改元組變量
  雖然不能修改元組的元素，但可以給存儲元組的變量賦值。因此，如果要修改前述矩形的尺寸，可重新定義整個元組：

      dimensions = (200, 50)
      print("Original dimensions:")
      for dimension in dimensions:
          print(dimension)
      dimensions = (400, 100)
      print("\nModified dimensions:")
      for dimension in dimensions:
          print(dimension)

第五章 條件測試if語句

if 語句的核心都是一個值為 True 或 False 的表達式，這種表達式被稱為 條件測試 或者 布爾表達式 ,結果要麽為 True ，要麽為 False 。Python 根據條件測試的值為 True 還是 False 來決定是否執行 if 語句中的代碼如果條件測試的值為 True ， Python 就執行緊跟在 if 語句後面的代碼；如果為 False ， Python 就忽略這些代碼。

5.1簡單示例:

        cars = [‘audi‘, ‘bmw‘, ‘subaru‘, ‘toyota‘]
        for car in cars:
                if car == ‘bmw‘:
                         print(car.upper())
                else:
                         print(car.title())

5.2 常用條件測試

• 字符串比較=或 !=

      car = ‘bmw‘ #定義變量的值   
      car == ‘bmw‘ #邏輯判斷是否相等 結果為True
  
      requested_topping = ‘mushrooms‘
      if requested_topping != ‘anchovies‘:       #if判斷是否不等註意必須：
              print("Hold the anchovies!")
  
      Python 中檢查是否相等時區分大小寫
      car.lower() == ‘audi‘ #先進行轉換然後比較

• 數值比較

  >> age = 19
  >> age < 21
  True
  >> age <= 21
  True
  >> age > 21
  False
  >> age >= 21
  False

• 檢測多個條件 關鍵字and or

  >> age_0 = 22
  >> age_1 = 18
  age_0 >= 21 and age_1 >= 21 ##相當與bash中的&&
  age_0 >= 21 or age_1 >= 21 ##相當與bash中的||

• 檢測特定的值是否在列表中 in 、not in

      banned_users = [‘andrew‘, ‘carolina‘, ‘david‘]
      user = ‘marie‘
      if user not in banned_users:
           print(user.title() + ", you can post a response if you wish.")

• 布爾表達式
  布爾表達式 ，它不過是條件測試的別名。與條件表達式一樣，布爾表達式的結果要麽為 True ，要麽為 False 。可以作為條件。
  game_active = True
  can_edit = False

  5.3 if語句

• if語句
• if-else

      age = 17
      if age >= 18:
              print("You are old enough to vote!")
      else:
              print("Sorry, you are too young to vote.")
              print("Please register to vote as soon as you turn 18!")

• if-elif-else
  Python 只執行 if-elif-else 結構中的一個代碼塊，它依次檢查每個條件測試，直到遇到通過了的條件測試。測試通過後， Python 將執行緊跟在它後面的代碼，並跳過余下的測試

      age = 12
      if age < 4:
              print("Your admission cost is $0.")
      elif age < 18:
              print("Your admission cost is $5.")
      else:
              print("Your admission cost is $10.")

• 多個elif 代碼塊

      age = 12
      if age < 4:
              price = 0
      elif age < 18:
              price = 5
      elif age < 65:
              price = 10
      else:
              price = 5
      print("Your admission cost is $" + str(price) + ".")

• 省略代碼塊
  Python 並不要求 if-elif 結構後面必須有 else 代碼塊。在有些情況下， else 代碼塊很有用；而在其他一些情況下，使用一條 elif 語句來處理特定的情形更清晰
• 測試多個條件
  if-elif-else 結構功能強大，但僅適合用於只有一個條件滿足的情況：遇到通過了的測試後， Python 就跳過余下的測試。這種行為很好，效率很高，讓你能夠測試一個特定的條件。然而，有時候必須檢查你關心的所有條件。在這種情況下，應使用一系列不包含 elif 和 else 代碼塊的簡單 if 語句。在可能有多個條件為 True ，且你需要在每個條件為 True時都采取相應措施時，適合使用這種方法。

   requested_toppings = [‘mushrooms‘, ‘extra cheese‘]
      if ‘mushrooms‘ in requested_toppings:
                  print("Adding mushrooms.")
      if ‘pepperoni‘ in requested_toppings:
                  print("Adding pepperoni.")
      if ‘extra cheese‘ in requested_toppings:
                  print("Adding extra cheese.")
      print("\nFinished making your pizza!")

  5.4 使用if處理列表

• 檢測特殊元素
  如果比薩店的青椒用完了，該如何處理呢？為妥善地處理這種情況，可在 for 循環中包含一條 if 語句：

      requested_toppings = [‘mushrooms‘, ‘green peppers‘, ‘extra cheese‘]
      for requested_topping in requested_toppings:
                  if requested_topping == ‘green peppers‘:
                    print("Sorry, we are out of green peppers right now.")
            else:
                    print("Adding " + requested_topping + ".")
      print("\nFinished making your pizza!")

• 確定列表是否為空
  在 if 語句中將列表名用在條件表達式中時， Python 將在列表至少包含一個元素時返回 True ，並在列表為空時返回 False 。

      requested_toppings = []
      if requested_toppings:
          for requested_topping in requested_toppings:
                  print("Adding " + requested_topping + ".")
                  print("\nFinished making your pizza!")
      else:
          print("Are you sure you want a plain pizza?")

• 使用多個列表

      ? available_toppings = [‘mushrooms‘, ‘olives‘, ‘green peppers‘,
      ‘pepperoni‘, ‘pineapple‘, ‘extra cheese‘]
      ? requested_toppings = [‘mushrooms‘, ‘french fries‘, ‘extra cheese‘]
      ? for requested_topping in requested_toppings:
              ? if requested_topping in available_toppings:
                      print("Adding " + requested_topping + ".")
              ? else:
                      print("Sorry, we don‘t have " + requested_topping + ".")
        print("\nFinished making your pizza!")

  在?處，我們定義了一個列表，其中包含比薩店供應的配料。請註意，如果比薩店供應的配料是固定的，也可使用一個元組來存儲它們。
  在?處，我們又創建了一個列表，其中包含顧客點的配料，請註意那個不同尋常的配料 —— ‘french fries‘ 。
  在?處，我們遍歷顧客點的配料列表。在這個循環中，對於顧客點的每種配料，我們都檢查它是否包含在供應的配料列表中（見?）；
  如果答案是肯定的，就將其加入到比薩中，否則將運行 else 代碼塊（見?）：打印一條消息，告訴顧客不供應這種配料

  5.5 小結

  在本章中，你學習了如何編寫結果要麽為 Ture 要麽為 False 的條件測試。你學習了如何編寫簡單的 if 語句、 if-else 語句和 if-elif-else 結構。
  在程序中，你使用了這些結構來測試特定的條件，以確定這些條件是否滿足。你學習了如何在利用高效的 for 循環的同時，以不同於其他元素的方式對特定的列表元素進行處理。
  你還再次學習了Python 就代碼格式方面提出的建議，這可確保即便你編寫的程序越來越復雜，其代碼依然易於閱讀和理解。
  學習字典讓你能夠模擬更多現實世界的情形。

第六章 字典 bash關聯屬組(創建 添加鍵值對 修改 遍歷字典) 嵌套(列表-字典 字典-列表 字典-字典) 集合

字典類似於列表，但讓你能夠將不同的信息關聯起來。你將學習如何創建和遍歷字典，以及如何將字典同列表和 if 語句結合起來使用。
字典：是一系列 鍵 — 值對 。每個 鍵 都與一個值相關聯，你可以使用鍵來訪問與之相關聯的值。
與鍵相關聯的值可以是數字、字符串、列表乃至字典。事實上，可將任何 Python 對象用作字典中的值。
鍵 — 值 對是兩個相關聯的值。指定鍵時， Python 將返回與之相關聯的值。鍵和值之間用冒號分隔，而鍵 — 值對之間用逗號分隔。

6.1 創建一個簡單的字典 （訪問、添加、修改、刪除字典中的鍵值對）

    alien_0 = {‘color‘: ‘green‘, ‘points‘: 5}  # {}內一組由:號分隔的鍵值對組成字典
    print(alien_0[‘color‘])                    #返回字典 alien_0 中與鍵 ‘color‘ 相關聯的值：
    print(alien_0[‘points‘])
    --------------------------------------------------------------------------------------- 
    alien_0[‘x_position‘] = 0                  #添加鍵 — 值對
    alien_0[‘y_position‘] = 25
    ---------------------------------------------------------------------------------------
    del alien_0[‘points‘]                      #刪除鍵值對
    print(alien_0)
    ---------------------------------------------------------------------------------------
    alien_0 = {}                               #一對空的花括號定義一個字典，再分行添加各個鍵 — 值對。例如，下例演
    alien_0[‘color‘] = ‘green‘
    alien_0[‘points‘] = 5
    print(alien_0)

    alien_0[‘color‘] = ‘yellow‘                #修改鍵的值，（重新定義）
    ---------------------------------------------------------------------------------------
    修改鍵值實例：
    alien_0 = {‘x_position‘: 0, ‘y_position‘: 25, ‘speed‘: ‘medium‘}
    print("Original x-position: " + str(alien_0[‘x_position‘]))
    #  向右移動外星人
    #  據外星人當前速度決定將其移動多遠
    if alien_0[‘speed‘] == ‘slow‘:
            x_increment = 1
    elif alien_0[‘speed‘] == ‘medium‘:
            x_increment = 2
    else:
            #  這個外星人的速度一定很快
            x_increment = 3
            #  新位置等於老位置加上增量
            alien_0[‘x_position‘] = alien_0[‘x_position‘] + x_increment
    print("New x-position: " + str(alien_0[‘x_position‘]))

6.2 遍歷字典 （遍歷鍵值對、 鍵、值）

    user_0 = {
        ‘username‘: ‘efermi‘,
        ‘first‘: ‘enrico‘,
        ‘last‘: ‘fermi‘,
        }                              #創建列表
    for key, value in user_0.items():  #使用字典名\ items()方法 、for循環依次將每個鍵 — 值對存儲到指定的兩個變量中。
        print("\nKey: " + key)
        print("Value: " + value)

    ---------------------------------------------------------------------
    for name in favorite_languages.keys():   
      #使用 字典名.keys（）方法，方法 keys() 並非只能用於遍歷；實際上，它返回一個列表，其中包含字典中的所有鍵
    for name in sorted(favorite_languages.keys()):  
      #按順序遍歷字典中的所有鍵
    ---------------------------------------------------------------------
    favorite_languages = {
        ‘jen‘: ‘python‘,
        ‘sarah‘: ‘c‘,
        ‘edward‘: ‘ruby‘,
        ‘phil‘: ‘python‘,
        }
    print("The following languages have been mentioned:")  
    for language in favorite_languages.values():   #遍歷字典中的所有值
    print(language.title())
    ---------------------------------------------------------------------
    for language in set(favorite_languages.values()):   #將值取出創建一個集合
        #如果被調查者很多，最終的列表可能包含大量的重復項。
        #為剔除重復項，可使用集合（ set ）。 集合 類似於列表，但每個元素都必須是獨一無二的

第七章 用戶輸入和while循環

學習 while 循環以及如何從用戶那裏獲取輸入。以及如何將程序變成交互性的 —— 能夠對用戶輸入作出響應。

7.1 函數input()

函數 input() 讓程序暫停運行，等待用戶輸入，獲取用戶輸入後， Python 將其存儲在一個變量中，以便使用。
Python 2.7 ，使用函數 raw_input() 來提示用戶輸入。

    height = input("How tall are you, in inches? ")    #顯示提示信息，將用戶輸入信息保存在變量中
    height = int(height)                               #函數int(), 改為數值類型
    if height >= 36:
    print("\nYou‘re tall enough to ride!")
    else:
    print("\nYou‘ll be able to ride when you‘re a little older.")
    ----------------------------------------------------------------
    多行提示
    prompt = "If you tell us who you are, we can personalize the messages you see."
    prompt += "\nWhat is your first name? "      # +=

    也可使用\n 換行

7.2 while循環

while條件為真時進行循環，註意避免無限循環
break ：立即退出 while 循環：
continue ：跳至循環體開頭進行下一次循環，不執行循環體contine後續代碼

```
prompt = "\nTell me something, and I will repeat it back to you:"
    prompt += "\nEnter ‘quit‘ to end the program. "
    message = ""
    while message != ‘quit‘:
          message = input(prompt)
          if message != ‘quit‘:
            print(message)
使用標誌：
    prompt = "\nTell me something, and I will repeat it back to you:"
    prompt += "\nEnter ‘quit‘ to end the program. "
    active = True    #####通過改變標誌的值來控制是否進行循環
    while active:
        message = input(prompt)
        if message == ‘quit‘:
            active = False
        else:
            print(message)
```

7.3 while處理列表和字典

```
* 循環列表直到沒有元素，將彈出的列表附加到其他表
    # 首先，創建一個待驗證用戶列表
    # 和一個用於存儲已驗證用戶的空列表
    unconfirmed_users = [‘alice‘, ‘brian‘, ‘candace‘]
    confirmed_users = []

    #循環列表直到沒有元素，將彈出的列表附加到其他表
    while unconfirmed_users:     
        current_user = unconfirmed_users.pop()
        print("Verifying user: " + current_user.title())
        confirmed_users.append(current_user)
    # 顯示所有已驗證的用戶
    print("\nThe following users have been confirmed:")
    for confirmed_user in confirmed_users:
            print(confirmed_user.title())
    ------------------------------------------------------
* 刪除包含特定值的所有列表元素
    pets = [‘dog‘, ‘cat‘, ‘dog‘, ‘goldfish‘, ‘cat‘, ‘rabbit‘, ‘cat‘]
    print(pets)
    while ‘cat‘ in pets:              #pet中沒有cat時推出循環
        pets.remove(‘cat‘)
    print(pets)
    輸出結果：
    [‘dog‘, ‘cat‘, ‘dog‘, ‘goldfish‘, ‘cat‘, ‘rabbit‘, ‘cat‘]
    [‘dog‘, ‘dog‘, ‘goldfish‘, ‘rabbit‘]
    ------------------------------------------------------
* 使用用戶輸入來填充字典
    responses = {}

    #設置一個標誌，指出調查是否繼續
    polling_active = True
    while polling_active:

        #提示輸入被調查者的名字和回答
        name = input("\nWhat is your name? ")
        response = input("Which mountain would you like to climb someday? ")

        #將答卷存儲在字典中
        responses[name] = response

        #看看是否還有人要參與調查
        repeat = input("Would you like to let another person respond? (yes/ no) ")
        if repeat == ‘no‘:
            polling_active = False

    #調查結束，顯示結果
    print("\n--- Poll Results ---")

    for name, response in responses.items():   #
            print(name + " would like to climb " + response + ".")
```

第八章 函數(定義 傳遞參數的不通方式 返回值 傳遞列表 將函數存儲在模塊中)

函數：函數是帶名字的代碼塊，用於完成具體的工作
學習如何編寫主要任務是顯示信息的函數，還有用於處理數據並返回一個或一組值的函數。最後，你將學習如何
將函數存儲在被稱為 模塊 的獨立文件中，讓主程序文件的組織更為有序

8.1定義函數

    def greet_user(username):    #定義函數格式，將實參的存儲在形參中
    """ 顯示簡單的問候語 """
    print("Hello, " + username.title() + "!")
    greet_user(‘jesse‘)

8.2傳遞參數（實參形參 關鍵字實參）

鑒於函數定義中可能包含多個形參，因此函數調用中也可能包含多個實參。向函數傳遞實參的方式很多，可使用 位置實參 ，這要求實參的順序與形參的順序相同；也可使用 關鍵
字實參 ，其中每個實參都由變量名和值組成；還可使用列表和字典。
調用函數時， Python 必須將函數調用中的每個實參都關聯到函數定義中的一個形參。

• 位置實參需要註意順序

  def describe_pet(animal_type, pet_name):
  """ 顯示寵物的信息 """
  print("\nI have a " + animal_type + ".")
  print("My " + animal_type + "‘s name is " + pet_name.title() + ".")
  describe_pet(‘harry‘, ‘hamster‘)

• 關鍵字實參

  註意：使用關鍵字實參時，務必準確地指定函數定義中的形參名。
          def describe_pet(animal_type, pet_name):
          """ 顯示寵物的信息 """
          print("\nI have a " + animal_type + ".")
          print("My " + animal_type + "‘s name is " + pet_name.title() + ".")
          describe_pet(animal_type=‘hamster‘, pet_name=‘harry‘

• 指定形參的默認值
  編寫函數時，可給每個形參指定 默認值 。在調用函數中給形參提供了實參時， Python 將使用指定的實參值；否則，將使用形參的默認值。因此，給形參指定默認值後，可在函數
  調用中省略相應的實參。使用默認值可簡化函數調用，還可清楚地指出函數的典型用法。

          def describe_pet(pet_name, animal_type=‘dog‘):    #定義默認值
          """ 顯示寵物的信息 """
          print("\nI have a " + animal_type + ".")
          print("My " + animal_type + "‘s name is " + pet_name.title() + ".")
          describe_pet(pet_name=‘willie‘)   #調用函數時為默認值時可以省略

• 一些等效的函數調用的實例

          #一條名為 Willie 的小狗
          describe_pet(‘willie‘)
          describe_pet(pet_name=‘willie‘)
          #  一只名為 Harry 的倉鼠
          describe_pet(‘harry‘, ‘hamster‘)
          describe_pet(pet_name=‘harry‘, animal_type=‘hamster‘)
          describe_pet(animal_type=‘hamster‘, pet_name=‘harry‘)

  8.3 返回值

  函數並非總是直接顯示輸出，相反，它可以處理一些數據，並返回一個或一組值。函數返回的值被稱為 返回值 。
  在函數中，可使用 return 語句將值返回到調用函數的代碼行。
  返回值讓你能夠將程序的大部分繁重工作移到函數中去完成，從而簡化主程序。

• 返回處理後的字符串

      def get_formatted_name(first_name, last_name, middle_name=‘‘):
          """ 返回整潔的姓名 """               #“”“函數的註釋信息，介紹實現的功能”“”
          if middle_name:
              full_name = first_name + ‘ ‘ + middle_name + ‘ ‘ + last_name
          else:
              full_name = first_name + ‘ ‘ + last_name
          return full_name.title()             #return返回給調用函數的行
  
      musician = get_formatted_name(‘jimi‘, ‘hendrix‘)
      print(musician)
  
      musician = get_formatted_name(‘john‘, ‘hooker‘, ‘lee‘)
      print(musician)

• 返回字典 函數可返回任何類型的值，包括列表和字典等較復雜的數據結構。

      def build_person(first_name, last_name, age=‘‘):    #包含一個可選的形參
          """ 返回一個字典，其中包含有關一個人的信息 """
          person = {‘first‘: first_name, ‘last‘: last_name}
          if age:      #如果age有值，將鍵值對加入到字典中
              person[‘age‘] = age
          return person
  
      musician = build_person(‘jimi‘, ‘hendrix‘, age=27)
      print(musician)

• 函數與循環結合使用

      def get_formatted_name(first_name, last_name):
          """ 返回整潔的姓名 """
          full_name = first_name + ‘ ‘ + last_name
          return full_name.title()
      while True:
          print("\nPlease tell me your name:")
          print("(enter ‘q‘ at any time to quit)")
          f_name = input("First name: ")                  #定義推出條件
          if f_name == ‘q‘:
          break
          l_name = input("Last name: ")
          if l_name == ‘q‘:
          break
          formatted_name = get_formatted_name(f_name, l_name)
          print("\nHello, " + formatted_name + "!")

  8.4 傳遞列表（在函數中修改列表 以及禁止函數修改原始列表）

  向函數傳遞列表很有用，這種列表包含的可能是名字、數字或更復雜的對象（如字典）。將列表傳遞給函數後，函數就能直接訪問其內容。下面使用函數來提高
  處理列表的效率。

  --------------------------------------------------------------
  #向列表中每個用戶問候
  def greet_users(names):
      """ 向列表中的每位用戶都發出簡單的問候 """
      for name in names:
      msg = "Hello, " + name.title() + "!"
      print(msg)
  usernames = [‘hannah‘, ‘ty‘, ‘margot‘]
  greet_users(usernames)
  --------------------------------------------------------------
  #該腳本定義兩個列表將其傳遞給函數
  def print_models(unprinted_designs, completed_models):
      """
      模擬打印每個設計，直到沒有未打印的設計為止
      打印每個設計後，都將其移到列表 completed_models 中
      """
      while unprinted_designs:
      current_design = unprinted_designs.pop()
      #  模擬根據設計制作 3D 打印模型的過程
      print("Printing model: " + current_design)
      completed_models.append(current_design)
  def show_completed_models(completed_models):
      """ 顯示打印好的所有模型 """
      print("\nThe following models have been printed:")
      for completed_model in completed_models:
      print(completed_model)
  
  unprinted_designs = [‘iphone case‘, ‘robot pendant‘, ‘dodecahedron‘]
  completed_models = []
  
  print_models(unprinted_designs, completed_models)
  show_completed_models(completed_models)
  --------------------------------------------------------------
  #要將列表的副本傳遞給函數，可以像下面這樣做：
  function_name(list_name[:])
  print_models(unprinted_designs[:], completed_models)

  8.5 傳遞任意數量的實參

• 傳遞任意數量的實參
  形參名 中的星號讓 Python 創建一個空元組，並將收到的所有值都封裝到這個元組中。
  例如：def make_pizza(toppings):

• 結合使用位置實參和任意數量實參
  如果要讓函數接受不同類型的實參，必須在函數定義中將接納任意數量實參的形參放在最後。
  def make_pizza(size, *toppings):
  調用函數：
  make_pizza(16, ‘pepperoni‘)
  make_pizza(12, ‘mushrooms‘, ‘green peppers‘, ‘extra cheese‘)

• 使用任意數量的關鍵字實參
  有時候，需要接受任意數量的實參，但預先不知道傳遞給函數的會是什麽樣的信息。
  在這種情況下，可將函數編寫成能夠接受任意數量的鍵 — 值對 —— 調用語句提供了多少就接受多少
  例如一個這樣的示例是創建用戶簡介：你知道你將收到有關用戶的信息，但不確定會是什麽樣的信息。
  註意格式：形參 **user_info 中的兩個星號讓 Python 創建一個名為 user_info 的空字典，並將收到的所有名稱 — 值對都封裝到這個字典中。

  在這個函數中，可以像訪問其他字典那樣訪問 user_info 中的名稱 — 值對。
  在 build_profile() 的函數體內，我們創建了一個名為 profile 的空字典，用於存儲用戶簡介。
  在?處，我們將名和姓加入到這個字典中，因為我們總是會從用戶那裏收到這兩項信息。
  在?處，我們遍歷字典 user_info 中的鍵 — 值對，並將每個鍵 — 值對都加入到字典 profile 中。
  最後，我們將字典 profile 返回給函數調用行。

  示例代碼：
  
      def build_profile(first, last, **user_info):
          """ 創建一個字典，其中包含我們知道的有關用戶的一切 """
          profile = {}
          ? profile[‘first_name‘] = first
          profile[‘last_name‘] = last
          ? for key, value in user_info.items():
          profile[key] = value
          return profile
      user_profile = build_profile(‘albert‘, ‘einstein‘,
                                  location=‘princeton‘,
                                  field=‘physics‘)
      print(user_profile)

  8.6 將函數存儲在模塊中

  函數的優點之一是，使用它們可將代碼塊與主程序分離。通過給函數指定描述性名稱，可讓主程序容易理解得多。還可以更進一步，將函數存儲在被稱為 模塊 的獨立文件中，再將模塊 導入 到主程序中。 import 語句允許在當前運行的程序文件中使用模塊中的代碼。

• 導入整個模塊
  import module_name
  要讓函數是可導入的，得先創建模塊。 模塊 是擴展名為 .py 的文件，包含要導入到程序中的代碼。需要在主程序文件使用import導入。
  示例：

      pizza.py
  
              def make_pizza(size, *toppings):
                  """ 概述要制作的比薩 """
                  print("\nMaking a " + str(size) +
                  "-inch pizza with the following toppings:")
                  for topping in toppings:
                  print("- " + topping)
      接下來，我們在 pizza.py 所在的目錄中創建另一個名為 making_pizzas.py 的文件，這個文件導入剛創建的模塊，再調用 make_pizza() 兩次：
  
      making_pizzas.py
              import pizza
              pizza.make_pizza(16, ‘pepperoni‘)   #主程序調用模塊中的函數
              pizza.make_pizza(12, ‘mushrooms‘, ‘green peppers‘, ‘extra cheese‘)
  
      Python 讀取這個文件時，代碼行 import pizza 讓 Python 打開文件 pizza.py並將其中的所有函數都復制到這個程序中。
      你看不到復制的代碼，因為這個程序運行時， Python 在幕後復制這些代碼。
      你只需知道，在 making_pizzas.py 中，可以使用 pizza.py 中定義的所有函數。
      要調用被導入的模塊中的函數，可指定導入的模塊的名稱 pizza 和函數名 make_pizza() ，並用句點分隔它們。    

• 導入特定的函數
  from module_name import function_namefrom
• 導入任意數量的函數
  from module_name import function_0, function_1, function_2
• 使用 as 給函數指定別名
  如果要導入的函數的名稱可能與程序中現有的名稱沖突，或者函數的名稱太長，可指定簡短而獨一無二的 別名 —— 函數的另一個名稱，類似於外號。
  指定別名的通用語法如下：
  from module_name import function_name as fn #使用 as 給函數指定別名
• 使用 as 給模塊指定別名
  import module_name as mn

• 導入模塊中的所有函數
  使用星號（ * ）運算符可讓 Python 導入模塊中的所有函數：

      from pizza import *          ####
      make_pizza(16, ‘pepperoni‘)
      make_pizza(12, ‘mushrooms‘, ‘green peppers‘, ‘extra cheese‘)
  
      註意:############ import 語句中的星號讓 Python 將模塊 pizza 中的每個函數都復制到這個程序文件中。由於導入了每個函數，可通過名稱來調用每個函數，而無需使用句點表示法。
      然而，使用並非自己編寫的大型模塊時，最好不要采用這種導入方法：如果模塊中有函數的名稱與你的項目中使用的名稱相同，
      可能導致意想不到的結果： Python 可能遇到多個名稱相同的函數或變量，進而覆蓋函數，而不是分別導入所有的函數。
      最佳的做法是，要麽只導入你需要使用的函數，要麽導入整個模塊並使用句點表示法。這能讓代碼更清晰，更容易閱讀和理解。
  

註意：
給形參指定默認值時，等號兩邊不要有空格：
def function_name(parameter_0, parameter_1=‘default value‘)
對於函數調用中的關鍵字實參，也應遵循這種約定：
function_name(value_0, parameter_1=‘value‘)
所有的 import 語句都應放在文件開頭，唯一例外的情形是，在文件開頭使用了註釋來描述整個程序。

第九章 類(創建使用 實例化 繼承 導入類 python標準庫)

可將類視為有關如何創建實例的說明。 讓 Python 知道如何創建表示特定的實例。

類：類是面向對象程序設計中的概念，是面向對象編程的基礎。抽象概念。
方法：類中函數成為方法。只是調用方法不一樣。
屬性：可通過實例訪問的變量稱為 屬性
接口：類和外界發生交互的操作稱為接口。

你將學習編寫類。類將函數和數據整潔地封裝起來，讓你能夠靈活而高效地使用它們。
在面向對象編程中，你編寫表示現實世界中的事物和情景的類，並基於這些類來創建對象。編寫類時，你定義一大類對象都有的通用行為。
基於類創建 對象 時，每個對象都自動具備這種通用行為，然後可根據需要賦予每個對象獨特的個性。

百度百科：
類的實質是一種數據類型，類似於int、char等基本類型，不同的是它是一種復雜的數據類型。因為它的本質是類型，而不是數據，所以不存在於內存中，不能被直接操作，只有被實例化為對象時，才會變得可操作。

類是對現實生活中一類具有共同特征的事物的抽象。如果一個程序裏提供的類型與應用中的概念有直接的對應，這個程序就會更容易理解，也更容易修改。一組經過很好選擇的用戶定義的類會使程序更簡潔。此外，它還能使各種形式的代碼分析更容易進行。特別地，它還會使編譯器有可能檢查對象的非法使用。

類的內部封裝了方法，用於操作自身的成員。類是對某種對象的定義，具有行為(be-havior)，它描述一個對象能夠做什麽以及做的方法(method)，它們是可以對這個對象進行操作的程序和過程。它包含有關對象行為方式的信息，包括它的名稱、方法、屬性和事件。

類的構成包括數據成員和成員函數。數據成員對應類的屬性，類的數據成員也是一種數據類型，並不需要分配內存。成員函數則用於操作類的各項屬性，是一個類具有的特有的操作，比如“學生”可以“上課”，而“水果”則不能。

9.1 創建類根據類創建實例

根據該類創建的實例都存儲名字和年齡，並有兩種方法。

    [root@localhost ~/test/class]# vim dog.py 
    # -*- incoding=UTF-8 -*-
    class Dog():
            """ 一次模擬小狗的簡單嘗試 """

            def __init__(self, name, age):
                    """ 初始化屬性 name 和 age""" 
                    self.name = name     #獲取存儲在形參 name 中的值，並將其存儲到變量 name 中，然後該變量被關聯到當前創建的實例
                    self.age = age

            def prt(self):
                    print(self)                           #一個指向實例的引用
                    print(self.__class__)                 #

            def sit(self):
                    """ 模擬小狗被命令時蹲下 """
                    print(self.name.title() + " is now sitting.")

            def roll_over(self):
                    """ 模擬小狗被命令時打滾 """
                    print(self.name.title() + " rolled over!")
            #類的實例化
            my_dog = Dog(‘willie‘, 6)
            you_dog = Dog(‘willie‘, 6)

            print("My dog‘s name is " + my_dog.name.title() + ".")
            print("My dog is " + str(my_dog.age) + " years old.")

            print(my_dog.name)
            print(you_dog.name)
            print(my_dog.age)
            print(you_dog.age)

            my_dog.sit()
            my_dog.roll_over()

            my_dog.prt()

            輸出###############################輸出
            My dog‘s name is Willie.
            My dog is 6 years old.
            willie
            willie
            6
            6
            Willie is now sitting.
            Willie rolled over!
            <__main__.Dog object at 0x7fcc2b716828>      #print(self)   
            <class ‘__main__.Dog‘>                       #print(self.__class__) 

解釋：
1.init() 是一個特殊的方法，每當你根據 Dog 類創建新實例時， Python 都會自動運行它。
在這個方法的名稱中，開頭和末尾各有兩個下劃線，這是一種約定，旨在避免 Python 默認方法與普通方法發生名稱沖突。

2.Python 調用這個 init() 方法來創建 Dog 實例時，將自動傳入實參 self 。每個與類相關聯的方法調用都自動傳遞實參 self ，它是一個指向實例本身
的引用，讓實例能夠訪問類中的屬性和方法。

3.形參 self 必不可少，還必須位於其他形參的前面，只需給最後兩個形參（ name 和 age ）提供值。
?處定義的兩個變量都有前綴 self 。以 self 為前綴的變量都可供類中的所有方法使用，我們還可以通過類的任何實例來訪問這些變量。 self.name = name 獲取存儲在形
參 name 中的值，並將其存儲到變量 name 中，然後該變量被關聯到當前創建的實例。

4.在 Python 2.7 中創建類時，需要做細微的修改 —— 在括號內包含單詞 object ：
class ClassName(object):
5.訪問屬性 實例名.屬性名
my_dog.name
6.調用方法 實例名.方法名
my_dog.sit()
my_dog.roll_over()

9.2 使用類和實例

* 給屬性指定默認的值

* 修改屬性的值
1.直接通過實例進行修改： my_new_car.odometer_reading = 23
2.通過方法進行設置：
def update_odometer(self, mileage):
    """ 將裏程表讀數設置為指定的值 """
    self.odometer_reading = mileage
my_new_car.update_odometer(23)   #根據事先定義好的方法修改屬性的值
3.通過方法進行遞增（增加特定的值）。
? def increment_odometer(self, miles):
        """ 將裏程表讀數增加指定的量 """
        self.odometer_reading += miles

9.3 繼承

編寫類時，並非總是要從空白開始。如果你要編寫的類是另一個現成類的特殊版本，可使用 繼承 。
一個類 繼承 另一個類時，它將自動獲得另一個類的所有屬性和方法
原有的類稱為 父類 ，而新類稱為 子類 。子類繼承了其父類的所有屬性和方法，同時還可以定義自己的屬性和方法。

• 字類繼承的方法init()

      ? class Car():
          """ 一次模擬汽車的簡單嘗試 """
          def __init__(self, make, model, year):
              self.make = make
              self.model = model
              self.year = year
              self.odometer_reading = 0
          def get_descriptive_name(self):
              long_name = str(self.year) + ‘ ‘ + self.make + ‘ ‘ + self.model
              return long_name.title()
          def read_odometer(self):
              print("This car has " + str(self.odometer_reading) + " miles on it.")
          def update_odometer(self, mileage):
              if mileage >= self.odometer_reading:
                  self.odometer_reading = mileage
              else:
                  print("You can‘t roll back an odometer!")
          def increment_odometer(self, miles):
              self.odometer_reading += miles
  
      ? class ElectricCar(Car):
          """ 電動汽車的獨特之處 """
          def __init__(self, make, model, year):
              """ 初始化父類的屬性 """
              super().__init__(make, model, year)
      my_tesla = ElectricCar(‘tesla‘, ‘model s‘, 2016)
      print(my_tesla.get_descriptive_name())
  
      創建子類時，父類必須包含在當前文件中，且位於子類前面。
      在?處，我們定義了子類 ElectricCar 。定義子類時，必須在括號內指定父類的名稱。
      方法 __init__() 接受創建 Car 實例所需的信息（見?）。
      ?處的 super() 是一個特殊函數，幫助 Python 將父類和子類關聯起來。
      這行代碼讓 Python 調用 ElectricCar 的父類的方法 __init__() ，讓 ElectricCar 實例包含父類的所有屬性。
      父類也稱為 超類 （ superclass ），名稱 super 因此而得名。
          ------------------------------------------------------------
          Python 2.7 中的繼承  與 python3 的不同
          在 Python 2.7 中，繼承語法稍有不同， ElectricCar 類的定義類似於下面這樣：
          class Car(object):
              def __init__(self, make, model, year):
                  --snip--
          class ElectricCar(Car):
              def __init__(self, make, model, year):
                  super(ElectricCar, self).__init__(make, model, year)      #super(ElectricCar, self) 與 super() 
          ------------------------------------------------------------
  
           class Car():
              --snip--
           class ElectricCar(Car):
              """ 電動汽車的獨特之處 """
              def __init__(self, make, model, year):
                  """ 初始化父類的屬性 """
                  super().__init__(make, model, year)
          --snip--
          ------------------------------------------------------------

• 給字類定義屬性和方法
  self.odometer_reading = 0 #設定屬性的初始值後，可不必在創建類時給定形參
• 重寫父類的方法
  對於父類的方法，只要它不符合子類模擬的實物的行為，都可對其進行重寫。
  為此，可在子類中定義一個這樣的方法，即它與要重寫的父類方法 同名 。這樣， Python 將不會考慮這個父類方法，而只關註你在子類中定義的相應方法。

• 將實例用作屬性

  class Car():
      --snip--
  ? class Battery():
      """ 一次模擬電動汽車電瓶的簡單嘗試 """
      ? def __init__(self, battery_size=70):
          """ 初始化電瓶的屬性 """
          self.battery_size = battery_size
      ? def describe_battery(self):
          """ 打印一條描述電瓶容量的消息 """
          print("This car has a " + str(self.battery_size) + "-kWh battery.")
  class ElectricCar(Car):
      """ 電動汽車的獨特之處 """
      def __init__(self, make, model, year):
          """
          初始化父類的屬性，再初始化電動汽車特有的屬性
          """
      super().__init__(make, model, year)
      ? self.battery = Battery()                    #創建一個Battery實例保存在
  
  my_tesla = ElectricCar(‘tesla‘, ‘model s‘, 2016)
  
  print(my_tesla.get_descriptive_name())
  my_tesla.battery.describe_battery()
  
  ? self.battery = Battery() 
  #這行代碼讓 Python 創建一個新的 Battery 實例（由於沒有指定尺寸，因此為默認值 70 ），
  並將該實例存儲在屬性 self.battery 中。每當方法 __init__() 被調用時，都將執行該操作；
  因此現在每個 ElectricCar 實例都包含一個自動創建的 Battery 實例。

9.4 導入類

* 導入單個類
    from car import Car
* 從一個模塊中存儲多個類
    可根據需要在一個模塊中存儲任意數量的類。
* 從一個模塊中導入多個類
    from car import Car, ElectricCar
    調用方式
      my_beetle = Car(‘volkswagen‘, ‘beetle‘, 2016)
* 導入整個模塊
    導入了整個 car 模塊。接下來，我們使用語法 module_name.class_name  訪問需要的類。
    import car
    my_beetle = car.Car(‘volkswagen‘, ‘beetle‘, 2016)   
    print(my_beetle.get_descriptive_name())
* 導入模塊中的所有類
    from module_name import *
    不推薦使用這種導入方式，其原因有二。
    首先，如果只要看一下文件開頭的 import 語句，就能清楚地知道程序使用了哪些類，將大有裨益；
    但這種導入方式沒有明確地指出你使用了模塊中的哪些類。這種導入方式還可能引發名稱方面的困惑。
    如果你不小心導入了一個與程序文件中其他東西同名的類，將引發難以診斷的錯誤。
    這裏之所以介紹這種導入方式，是因為雖然不推薦使用這種方式，但你可能會在別人編寫的代碼中見到它。
    需要從一個模塊中導入很多類時，最好導入整個模塊，並使用 module_name.class_name  語法來訪問類。
* 在一個模塊中調用另一個模塊
* 自定義工作流程

9.5 Python標準庫

Python 標準庫 是一組模塊，安裝的 Python 都包含它。你現在對類的工作原理已有大致的了解，可以開始使用其他程序員編寫好的模塊了。可使用標準庫中的任何函數和類，為此只需在程序開頭包含一條簡單的 import 語句。

9.6 類編碼風格

類名應采用 駝峰命名法 ，即將類名中的每個單詞的首字母都大寫，而不使用下劃線。
實例名和模塊名都采用小寫格式，並在單詞之間加上下劃線。
對於每個類，都應緊跟在類定義後面包含一個文檔字符串。這種文檔字符串簡要地描述類的功能，並遵循編寫函數的文檔字符串時采用的格式約定。每個模塊也都應包含一個文檔字符串，對其中的類可用於做什麽進行描述。
可使用空行來組織代碼，但不要濫用。在類中，可使用一個空行來分隔方法；而在模塊中，可使用兩個空行來分隔類。

需要同時導入標準庫中的模塊和你編寫的模塊時，先編寫導入標準庫模塊的 import 語句，再添加一個空行，然後編寫導入你自己編寫的模塊的 import 語句。在包含多
條 import 語句的程序中，這種做法讓人更容易明白程序使用的各個模塊都來自何方。

第十章 文件和異常

第十一章 測試代碼

python入門到實踐-----筆記