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

一、.title()  每一個單詞首字母大寫
     .upper()  全部字母大寫
     .lower()  全部字母小寫

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

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

四、Python將帶小數點的數都稱爲浮點數

五、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. "

 

六、單行註釋 #
     多行註釋 """   """  或者  ''' '''

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

      訪問元素   正數 [ ]裏從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')

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

   .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()

九、len(列表名)    得到列表長度

十、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!")

 

十一、建立數值列表
       第一步：建立了從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)]

十二、+ - * /    加減乘除
        %          求模            除2取餘能夠用來判斷奇偶數
        **         表示乘方運算

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

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

1五、切片：列表名[x:y]   列表裏第x+1到第y個元素
          x未寫則表示從頭開始，y未寫則表示到尾結束
          x、y都未寫則可用於列表的複製       friends_foods=my_foods[:]     若是隻是簡單的把一個列表賦給一個變量，就不能獲得兩個列表
          x若爲負數，則爲返回列表的後x位

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

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

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

1八、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()

  

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

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

      if + 列表名：    若是列表不爲空，則會返回True;若是列表爲空，返回值爲False

 

20、布爾表達式  True / False

 

2一、字典是放在{}裏的一系列鍵值對，鍵須要加''而值不必定  鍵值之間用:隔開  鍵值對之間用,隔開
        字典名={'鍵':值}    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()):

     關於鍵值重複的問題，鍵從邏輯上講是不能重複的，但重複了不會報錯，只會認爲是對鍵從新賦值，值能夠重複

 

2二、print打印的內容較長時，也能夠將內容分行寫以得到整潔的代碼界面

 

2三、在列表裏存儲字典    將多個字典放入列表中           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'},

 

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

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

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

2五、用好標誌（True,False）能夠簡化判斷、循環語句

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

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

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

2八、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

 

2九、導入模塊，在當前.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()

    編寫類時，應該寫好註釋
    類中，用一個空行分隔方法
    模塊中，用兩個空行分隔類
    導入模塊時，先寫導入標準庫的語句，再寫導入本身編寫的模塊的語句

3一、文件
       讀取文件 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")

 

3二、異常
    當發生錯誤時，若是編寫了處理問題的代碼，程序將繼續運行，若是沒有，程序將會中止，且會返回一個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)

 

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

3四、模塊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()

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

3六、測試代碼

 

歡迎閱讀，有任何錯誤能夠指出，感謝