Python 編程：從入門到實戰 讀書筆記

1、.title()  每個單詞首字母大寫
     .upper()  所有字母大寫
     .lower()  所有字母小寫

2、 \t 空白   轉義字符只能用在""內
      \n 換行

3、.rstrip() 刪除末尾空白
     .lstrip() 刪除開頭空白
     .strip()  刪除兩端空白

4、Python將帶小數點的數都稱為浮點數

5、Python的字符串既可以用單引號也可以用雙引號  引號內部還有單引號時，只能用""

     str() 可以將非字符串值表示為字符串   //將23轉為'23',而不能將abc轉為'abc'

     Python 用+來合並字符串  "wanyu" + " " + "shuai"

     創建多行字符串可以用+=運算符

prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "

 

6、單行注釋 #
     多行注釋 """   """  或者  ''' '''

7、[ ] 表示列表  ,分隔其中元素

      訪問元素   正數 [ ]里從0開始   print(bike[0])
                       倒數           -1          print(bike[-1])

      修改元素   指定列表名和元素索引並指定新值      bike[0]='abc'

      添加元素   .append()         在末尾添加元素(可創建空列表然后用一系列.append()語句來添加)      bike.append('bcd')
                       .insert( , )         插入元素，需指定新元素的索引與值    bike.insert(0,'cde')

      刪除元素   del 列表名[]          刪除已知位置的列表元素     del bike[0]
                       列表名.pop()         刪除索引位置並且能夠再次被調用  即彈出效果   bike.pop(2)
                                del和pop()使用后，列表里對應元素均被刪除，但是pop()可以繼續調用  根據刪除后是否還需使用元素選取del和pop
                       列表名.remove()   刪除已知元素值             bike.remove('abc')

8、列表排序（注意有的方法，有的是函數）

   .sort()                                         永久性按字母順序排序     bike.sort()
   .sort(reverse=true)                    永久性按字母倒序排序     bike.sort(reverse=true)
   sorted(列表名)                           臨時性按字母順序顯示     print(sorted(bike))
   sorted(列表名,reverse=True))   臨時性按字母倒序顯示     print(sorted(bike,reverse=True))
   .reverse()                                   永久性按列表倒序排序     bike.reverse()

9、len(列表名)    獲得列表長度

10、for 變量 in 列表：   for循環，且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!")

 

11、創建數值列表
       第一步：創建了從x到y-1的數，步長為z    range(x,y,z):                          range(1,5,1):

       第二步：創建了從x到y-1的列表，步長為z  列表名=list(range(x,y,z))      message=list(range(1,5,1))

       列表解析：將for循環和創建新元素的代碼合並，並自動添加附加新元素        squares=[value**2 for value in range(1,11)]

12、+ - * /    加減乘除
        %          求模            除2取余可以用來判斷奇偶數
        **         表示乘方運算

13、min(列表名)  最小值
       max(列表名)  最大值
       sum(列表名)  求和

14、變量名只包含字母、數字、下划線，但不能以數字打頭，不能包含空格、Python關鍵字和函數名

15、切片：列表名[x:y]   列表里第x+1到第y個元素
          x未寫則表示從頭開始，y未寫則表示到尾結束
          x、y都未寫則可用於列表的復制       friends_foods=my_foods[:]     如果只是簡單的把一個列表賦給一個變量，就不能得到兩個列表
          x若為負數，則為返回列表的后x位

        遍歷切片只需在切片里用for循環    for player in players[0:3]；

16、()表示元組    即不可變的列表，逗號隔開元素,訪問元素與列表相同
                  遍歷元組則用for循環        for bike in bikes:
                  元組的元素不可以被修改，但是整個元組可以被重新賦值       bikes=(200,100)   bikes=(50,100)

17、代碼格式PEP8     https://www.python.org/dev/peps/pep-0008/
                     縮進每次用4個空格
                     利用空行讓代碼看上去整潔
                     ==、>=、<= 兩邊各添加一個空格
                     包含多個函數時，建議每個函數之間空2行

18、if條件語句    ①if + 條件:
                                else:
                            ②if + 條件:
                    　　     elif + 條件:
                    　　     else:

        注意（1）冒號：不能丟
               （2）if、else后面的語句換行寫時要縮進
               （3）elif可以有多句，else可以沒有
               （4）當需要執行多個代碼塊，也可以用多個if語句

requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
if 'mushrooms' in requested_toppings:
    print()     #省略沒寫
elif 'french fries' in requested_toppings:
    print()
elif 'extra cheese' in requested_toppings:
    print()

         第一個mushrooms檢測通過了，程序將跳過下面的elif結構，不再檢查其他內容，所以if-elif-else結構僅適用於只有一個條件滿足的情況

         而想要檢測多個條件滿足的情況應該用多個if語句

requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
if 'mushrooms' in requested_toppings:
    print()     #省略沒寫
if 'french fries' in requested_toppings:
    print()
if 'extra cheese' in requested_toppings:
    print()

  

19、=  賦值
       == 等於   檢查字符是否相等時，會區分大小寫，若要不區分的話，可使用.lower()
       != 不等於
       and 與
       or  或
       in  包含在列表中
       not in  未包含在列表中

>>>bikes=['a','b','c']
>>>'a' in bikes
>>>True

      if + 列表名：    如果列表不為空，則會返回True;如果列表為空，返回值為False

 

20、布爾表達式  True / False

 

21、字典是放在{}里的一系列鍵值對，鍵需要加''而值不一定  鍵值之間用:隔開  鍵值對之間用,隔開
        字典名={'鍵':值}    alien_0={'color':'gerrn','points':5}

        訪問字典值  可依次指定字典名和放在[]的鍵   即  字典名['鍵']     print(alien_0['color'])

        添加鍵值對  依次指定字典名、[]括起來的鍵和關聯的值   即  字典名['鍵']=值
                Python不關心鍵值對的順序，只關心鍵和值的對應關系
                alien_0['x_position']=0
                alien_0['y_position']=25
                很多時候是先建立一個空字典，再分別添加鍵值對       字典名={}

       修改字典值  指定字典名、[]括起來的鍵和關聯的新值   即  字典名['鍵']=新值     alien_0['color']='yellow'

       刪除鍵值對  del 字典名['鍵']       del alien_0['color']

       較長的列表和字典，可以將鍵值對放在不同的行里，注意行前縮進

alien_0={
     'color':'gerrn',
     'points':5,
     'head':'big',
     'phil':'python'}

 

       遍歷字典中鍵值對   for  變量名1,變量名2 in 字典名.items()：   for循環將每個鍵值對存儲到指定的變量中,變量1為鍵，變量2為值

for key,value in user_0.items():
    print("\nKey: " + key)
    print("Value: " + value)

 

     遍歷字典中鍵       for  變量名 in 字典名.keys()       for name in user_0.keys():
     .keys()方法實質上是返回一個列表，包含字典的所有鍵，因此其還可以用於判斷某值是否在字典的鍵里

if 'erin' not in alien_0.keys():
    print()

 

     按順序獲取返回元素可在for里調用sorted()函數         for key in sorted(alien_0.keys()):

     遍歷字典中值       for  變量名 in 字典名.values()        for name in user_0.values():

     如需去掉重復值，則在for里調用set函數                    for name in set(user_0.values()):

     關於鍵值重復的問題，鍵從邏輯上講是不能重復的，但重復了不會報錯，只會認為是對鍵重新賦值，值可以重復

 

22、print打印的內容較長時，也可以將內容分行寫以獲得整潔的代碼界面

 

23、在列表里存儲字典    將多個字典放入列表中           aliens=[alien_0,alien_1,alien_2]
       在字典里存儲列表    即 鍵 對應的 值 可以為列表     

pizza = { 
    'crust': 'thick',
    'toppings': ['mushrooms', 'extra cheese'],
    }

 
      在字典里存儲字典    即鍵對應的值可以為字典

users = {'aeinstein': {'first': 'albert',
                       'last': 'einstein',
                       'location': 'princeton'},
         'mcurie': {'first': 'marie',
                    'last': 'curie',
                    'location': 'paris'},

 

24、 input()函數用來等待用戶輸入，括號里可以為字符串變量也可以為字符串。其返回的值永遠是用戶輸入的字符串
        input("\nTell me something, and I will repeat it back to you: ")

        int()函數可以將input的字符串轉為數值，以達到相應的要求   

age=input("How old are you ?")
year=int(age)

25、用好標志（True,False）可以簡化判斷、循環語句

26、while循環：while 語句 :
        break終止整個循環，continue退出當前循環，返回到循環開頭
        注意避免無限循環，可以用ctrl+c退出

27、while 列表:   或   while 變量 in 列表:  對列表的循環

while unconfirmed_users:
    current_user = unconfirmed_users.pop()
while 'cat' in pets:
    pets.remove('cat')

28、def 函數名(參數):    函數的語句要縮進

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('harry', 'hamster')
    關鍵字實參   describe_pet(animal_type='hamster', pet_name='harry')   關鍵字實參即指定實參的形參類型，所以就無需區分位置

    編寫函數時，還可以給某一形參給定默認值，在調用函數時，就無需再指定此形參的實參，函數會使用默認值。
    注意：在編寫函數時，形參列表中必須先列出沒有默認值的形參，再列出有默認值的形參。
          在指定默認值時，等號兩邊不要有空格，調用時也是如此，當然如果不適用默認值，那么就可以重新傳遞新的實參

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')     #使用默認值
describe_pet('harry', 'hamster')    #不使用默認值，傳遞位置實參
describe_pet(pet_name='harry', animal_type='hamster')   #不使用默認值，傳遞關鍵字實參
describe_pet(animal_type='hamster', pet_name='harry')   #不使用默認值，傳遞關鍵字實參

    有時候需要將函數的實參變成可選的，因為函數的參數並不是所有情況下都需要，這時可以將那個不一定需要的形參設為空，即''，再來個判斷語句

def get_formatted_name(first_name,last_name,middle_name='')
    if middle_name:
        print()
    else:
        print()        

函數形參過多時，導致代碼長度超出80，不符合PEP8，可將   形參都放到下一行，甚至下幾行，要注意縮進(2個tab)

def fuction_name(
        a,b,c,
        d,e.f):
    fuction body...

 

    函數的返回值可以任何類型的值  結構為 return 返回內容
    返回簡單值  return full_name.title()

    返回字典    

def build_person(first_name, last_name, age=''):
    person = {'first': first_name, 'last': last_name}
    return person

 

    函數的參數也可以是一個列表，即傳遞列表
           

def greet_users(names):
    for name in names:
        msg = "Hello, " + name.title() + "!"
        print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)

 

    有時候需要禁止函數修改列表，則傳遞列表時可以利用切片傳遞列表的副本，即  function_name(list_name[:])   這樣就可以保留原始列表的內容
    除非有充分理由使用副本，否則少使用，提高效率。函數使用現成列表可以避免浪費時間和內存創建副本，尤其處理大型列表時

    函數傳遞任意數量的實參，可將函數的形參設為 *名稱         def pizza(*pizzas)：
    這樣就創建了一個名為pizzas的空元組，函數能將所有收到的實參都放進這個元組里

    想讓函數接受不同類型的實參時，必須將任意數量實參放到最后，Python將先匹配位置實參和關鍵字實參，余下的實參將收集到最后一個形參中去

def make_pizza(size,*toppings)
    print()
make_pizza(16,'mushrooms','cheese')

 

   使用任意數量的關鍵字實參，可傳遞給函數鍵值對，將形參設為**名稱，再利用for循環

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

 

29、導入模塊，在當前.py的目錄中再創建一個.py的文件，里面可以放函數，然后在當前py里導入這個模塊,語句為import  所有的import語句放在開頭
       再調用函數時，其前面還需要加上模塊名，即   模塊名.函數名
       比如  pizza.py文件里定義了一個函數   def do_pizza(size, *toppings):   （內容此處省略）
       則在pizza.py文件的目錄里的另一個文件make_pizza里可以導入模塊

import pizza
pizza.do_pizza()

      也可以導入指定模塊的指定函數,格式為       from module_name import function_0,function_1
      使用*可以導入模塊中的所有函數                 from module_name import *
      這樣在調用模塊中的函數時就無需寫模塊.函數，直接調用函數名，但一般不推薦使用，因為如果不是自己寫的模塊，可能會有很多函數重名

      as可以給指定模塊和函數起別名，就可以用別名來調用函數和模塊
      from module_name import function_name as fn
      import module_name as mn

 

30、類
       創建類   class 名稱():         class Dog():         注意：名稱的首字母要大寫
       類里可以定義不同的方法   def 方法名稱():
       第一個定義的方法一般是_init_()   當我們使用類時，Python會自動運行它，注意其名稱，且其形參第一個為self，之后為其他信息
       且用句點表示法獲取值

def __init__(self, name, age):
    self.name = name
    self.age = age

 

      之后可以定義其他的方法，如果不需要其他的信息，方法的形參只有一個self

def sit(self):
    print(self.name.title() + " is now sitting.")
def roll_over(self):
    print(self.name.title() + " rolled over!")

 

    根據類創建實例,Python將使用實參調用類中的方法_init_()創建表示特定的實例，並自動返回給一個變量，這個變量可以自己設置
    my_dog = Dog('willie', 6)

    創建完之后，可以訪問實例的屬性，其為句點表示法 變量.屬性

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

 

    還可以調用類中定義的方法，仍然為句點表示法

my_dog = Dog('willie', 6)
my_dog.sit()

 

    當需要給某個屬性添加默認值時，就無需包含為它提供初始值的形參

class Car():
    def __init__(self, manufacturer, model, year):
        self.manufacturer = manufacturer
        self.model = model
        self.year = year
        self.odometer_reading = 0    #此值設為默認值，所以在設置形參時沒有設置這個量

 

    有時候需要修改屬性的值，有三種方法
    （1）直接修改屬性的值，通過實例直接訪問（基於上面定義過的方法舉例）

my_new_car=Car('audi','24',2016)
my_new_car.odometer_reading=23      #這樣就直接修改了默認值0

 

    （2）通過方法修改屬性的值  即定義一個修改屬性的方法

def update_odometer(self,mileage):
    self.odometer_reading = mileage
my_new_car.update_odometer(23)      #也修改了默認值0

 

    （3）通過方法對屬性的值進行遞增/遞減

def increment_odometer(self,miles)
    self.odometer_reading += miles
my_new_car.increment_odometer(100)  #通過+=改變了屬性值

 

     繼承
     編寫一個類的時候可以繼承另一個類，原先的類稱為父類，新的類稱為子類。子類可以自動獲得父類的全部屬性和方法，同時還可以定義自己的屬性和方法
     創建子類時，父類必須在此文件中，且必須在子類的前面   格式為   class 子類名(父類名):

class Car():    #省略了父類的內容
class ElectricCar(Car)：

 

    子類需要寫繼承父類屬性的語句（舉例接着上面的內容）   即調用super()函數

class Car():    #省略了父類的內容
class ElectricCar(Car)：
    def __init__(self, manufacturer, model, year):      #初始化父類的屬性
    super().__init__(manufacturer, model, year)     #此行代碼調用父類的方法_init_()

 

    super()函數調用之后，可添加新屬性和新方法

class Car():    #省略了父類的內容
class ElectricCar(Car)：
    def __init__(self, manufacturer, model, year):      #初始化父類的屬性
        super().__init__(manufacturer, model, year)     #此行代碼調用父類的方法_init_()
        self.battery_size = 70                         #添加了子類的新屬性
    def describe_battery(self):                         #添加了新方法
        print()

 

    父類的方法沒有任何用處時，你可以重寫它。語句就是普通的定義

class ElectricCar(Car)：
    def fill_gas_tank():                               #重新定義父類的方法
        print()

 

 

    可以定義一個新的類，作為另一個類的一個屬性

class Battery():
    def __init__(self, battery_size=60):
        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, manufacturer, model, year):
        super().__init__(manufacturer, model, year)
        self.battery = Battery()                      #屬性是一個類
my_tesla = ElectricCar('tesla','model s',2016)
my_tesla.battery.describe_battery()                   #調用實例的battery屬性里的方法

    導入類，將一個類寫在一個.py文件里，在另一個.py文件里導入這個類  格式為  from 模塊名 import 類名
    舉例   Car類在car.py里，則在my_car.py里導入Car可寫為  from car import Car
    可以導入一個模塊的多個類    from 模塊名 import 類名1,類名2     在調用類時，直接建立實例就可以，不需要其他格式

    當然也可以導入整個模塊，格式為  import 模塊名
    但是在建立實例時，就需要用點號表達式   my_beetle = car.Car()

    編寫類時，應該寫好注釋
    類中，用一個空行分隔方法
    模塊中，用兩個空行分隔類
    導入模塊時，先寫導入標准庫的語句，再寫導入自己編寫的模塊的語句

31、文件
       讀取文件 with open('路徑') as 變量:

with open('pi_digits.txt') as file_object:    #關鍵字with在不再需要訪問文件后將文件關閉
    contents = file_object.read()             #方法.read()讀取文件的全部內容
    print(contents)

 

    上例open()函數里只有文件名，是因為其和.py文件在相同目錄。()里也可以放文件的絕對路徑
    但絕對路徑在windows系統里，是用\隔開，例如D:\code_work\Python\pi_digits.txt
    過長的路徑影響美觀，所以可以將其放在一個變量里

file_path = 'D:\code_work\Python\pi_digits.txt'    #注意一定是字符串
with open(file_path) as file_project:

 

    逐行讀取文件只需使用for循環將每一行的內容放到變量中即可
    for line in file_object:           #每一行的內容就放到了line中

    使用關鍵字with時，open()返回的文件對象只能在with代碼塊中使用，要想在代碼塊外訪問文件內容，可將文件的各行存儲在一個列表里，並在代碼塊外使用該列表

with open('pi_digits.txt') as file_object:
    lines = file_object.readlines()           #用方法readlines()將每一行的內容放到了lines列表中
for line in lines:
    print()

 

    讀取文本文件時，Python 將其中所有內容都解讀為字符串，如果要作為數值使用，就必須用int()或者float()轉換

    寫入文件格式為  with open(文件,‘w’) as 變量:               'r' 讀取模式 'w'寫入模式 'a'附加模式  'r+' 讀取和寫入模式   若省略模式參數，則默認為讀取模式
    如果寫入的文件不存在，Python將自動創建它。如果寫入的文件存在，那么將在返回對象前清空文件
    寫入的語句用放方法.write()

file_path = 'D:\code_work\Python\pi_digits.txt'
with open(file_path,'w') as file_object:
    file_object.write('I lOVE YOU')                   #如果要寫入多行語句，則需要添加換行符號

 

   'w'寫入模式將原文件內容清空，寫入新的語句，如果不想清空原文件，則可以使用'a'附加模式，寫入的內容將會被添加到文件末尾

with open('programming.txt', 'a') as file_object:
    file_object.write("I also love finding meaning in large datasets.\n")

 

32、異常
    當發生錯誤時，如果編寫了處理問題的代碼，程序將繼續運行，如果沒有，程序將會停止，且會返回一個traceback
    處理問題的代碼塊為  try-except
    print(5/0)  將會返回一個traceback，里面的ZeroDivisionError則是一個異常對象，那么就要對異常進行處理

try:
    print(5/0)
except ZeroDivisionError:
    print("you can't divide by zero !")

 

    找不到文件的異常對象為FileNotFoundError
   

filename = 'alice.txt'try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except FileNotFoundError as e:
    msg = "Sorry, the file " + filename + " does not exist."
    print(msg)

 

    try-except-else 代碼塊，適用於包含正常情況發生的代碼
   

while True:
    first_number = input("\nFirst number: ")
    if first_number == 'q':
        break
    second_number = input("Second number: ")
    try:
        answer = int(first_number) / int(second_number)
    except ZeroDivisionError:
        print("You can't divide by 0!")
    else:
        print(answer)

 

    可以將try-except-else結構寫為函數，多處使用
    如果希望程序在碰到異常對象時一聲不吭，則可以在except的語句里寫pass，當這種錯誤發生的時候，既沒有traceback，也沒有任何輸出

while True:
    first_number = input("\nFirst number: ")
    if first_number == 'q':
       break
    second_number = input("Second number: ")
    try:
       answer = int(first_number) / int(second_number)
    except ZeroDivisionError:
        pass
    else:
        print(answer)

 

33、方法split()以空格為分隔符將字符串分拆為多個部分，並將這些部分都存儲到一個列表中

34、模塊json能將簡單的Python數據結構轉儲到文件中，並在程序再次運行時加載文件中的數據
        json模塊里有json.dump()函數，接受兩個實參，要存儲的數據和可用於存儲數據的文件對象   dump：轉儲

import json                                   #導入json模塊
numbers = [2, 3, 5, 7, 11, 13]                #創建一個數字列表
filename = 'numbers.json'                     #指定所存儲的文件名稱
with open(filename, 'w') as file_object:      #以寫入模式打開文件，讓json能夠將數據寫入其中
    json.dump(numbers, file_object)           #使用json.dump()函數將數字列表存儲到文件中

 

    json模塊里有json.load()函數，能夠加載文件中的數據

import json                                   #導入模塊
filename = 'numbers.json'                     #之前寫入的文件
with open(filename) as file_object:           #讀取模式打開文件
    numbers = json.load(file_object)          #使用ison.load()加載存儲在文件里的信息，並將其存儲到變量numbers中
print(numbers)

 

    使用json保存用戶的數據很方便，便於儲存和記憶
   

import json

def get_stored_username():
    """Get stored username if available."""
    filename = 'username.json'
    try:
        with open(filename) as f_obj:
            username = json.load(f_obj)
    except FileNotFoundError:
        return None
    else:
        return username

def get_new_username():
    """Prompt for a new username."""
    username = input("What is your name? ")
    filename = 'username.json'
    with open(filename, 'w') as f_obj:
        json.dump(username, f_obj)
    return username

def greet_user():
    """Greet the user by name."""
    username = get_stored_username()
    if username:
        print("Welcome back, " + username + "!")
    else:
        username = get_new_username()
        print("We'll remember you when you come back, " + username + "!")

greet_user()

35、重構：將代碼分為一系列完成具體工作的函數，使得代碼更清晰、更易於理解、更容易擴展

36、測試代碼

 

歡迎閱讀，有任何錯誤可以指出，感謝