1.配置等信息

安裝省略

1. 查看python安裝路徑 type -a python輸出：python3 is /usr/local/bin/python3
2. 配置Sublime Text闷盔，選擇菜單Tools=>Build System=>New Build System會打開一個新的配置文件弯洗，輸入（cmd為python的安裝路徑）

{
    "cmd":["/usr/local/bin/python3","-u","$file"],
}

配置文件命名為“Python3.sublime-build”则果，直接保存到默認目錄

2.變量和簡單數(shù)據(jù)類型

1. 字符串既可以使用單引號括起來肠鲫，又可以使用雙引號括起來，這樣在字符串中可以輸入單引號和雙引號
2. 字符串單詞首字母變大寫
   
   name = "ada lovelace"
   
   name.title() 輸出 Ada Lovelace
   
   字符串全部大些 name.upper()
   
   字符串全部小寫 name.lower()
3. 合并字符串（相加）
4. 打印空白 \t 打印換行 \n
   
   刪除空白 rstrip()方法(刪除末尾的空白)疼约，這種方法沒有徹底刪除溺拱，要徹底刪除逃贝，需要重新賦值 name = name.rstrip()
   
   lstrip()刪除字符串
5. 數(shù)字 乘* 指數(shù)** 3**2 = 9
6. 浮點數(shù) ，相加結果包含的小數(shù)位數(shù)可能是不確定的
   
   0.2+0.1 = 0.30000...0004(所有語言都會又這種情況迫摔，暫時忽略多余的小數(shù)位數(shù)即可)
7. str(),字符串和數(shù)字相連沐扳，使用str(數(shù)字)將數(shù)字轉換成字符串
   8.注釋
   
   使用#號標示
   9.Python之禪
   
   在解釋器中執(zhí)行命令import this,會打印出編寫的幾條原則

>>> 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!

3.列表 []

例：bicycles=['trek','cannondale','redline']

1. 訪問列表元素
   下標，bicycles[index]
2. 修改句占、添加和刪除元素
   
   修改 bicycles[0] = 'ducati';
   
   添加（末尾追加）bicycles.qppend('ducati')
   
   插入元素 bicycles.insert(0,'ducati')
   
   刪除 del bicycles[0]
   
   使用pop()刪除元素沪摄，刪除列表末尾的元素（從棧頂取出來）get_last = bicycles.pop()
   
   彈出列表中任何位置的元素，pop(index) 彈出后元素就不再列表中了
   
   根據(jù)值刪除元素bicycles.remove('ducati')(如果該值在列表中存在多個，只刪除第一個值)
3. 組織列表
   
   使用方法sort()對列表進行永久性排序杨拐，按照字母順序排序祈餐，傳如參數(shù)reverse=True，按照與字母順序相反的順序排列bicycles.sort(reverse=True)
   
   使用函數(shù)sorted對列表進行臨時排序哄陶，直接打印new_bycycles=sorted(bicycles,可以傳reverse=True)帆阳，new_bicycles排序是變化了的，但是bicycles的順序是沒有變化的
   
   倒著打印列表屋吨，bicycles.reverse()
   
   列表長度 len(cars)
4. 列表索引
   
   索引-1總是返回最后一個列表元素(當列表為null時會報錯)

4.操作列表

1. 遍歷整個列表

for bicycle in bicycles:
    print(bicycle)

2. 創(chuàng)建數(shù)值列表
   
   使用函數(shù)range()生成一系列數(shù)字 for value in range(1,5):(會打印1蜒谤，2，3离赫，4不會打印5)
   
   將range()作為list()參數(shù)芭逝，輸出一個數(shù)字列表(輸出[1,2,3,4],range()直接賦值打印的還是range())
   
   min(digits) 取出數(shù)字列表的最小值
   
   max(digits) 取出數(shù)字列表的最大值
   
   sum(digits) 輸出數(shù)字列表的和
   
   列表解析squares = [value**2 for value in range(1,11)],for循環(huán)的值賦值給前面的value
3. 使用列表的一部分(切片)
   
   players = [], players[0:3] 輸出下標0-3的值(不包含3)，下標對應0渊胸，1旬盯，2
   
   輸出第2-4個元素，使用players[1:4],輸出下標1翎猛，2胖翰，3(不包含4)
   
   如果沒有指定第一個索引，從列表開頭開始players[:4]輸出下標0切厘，1萨咳，2，3
   
   如果提取第三個元素到列表末尾的所有元素疫稿，使用players[2:]
   
   提取最后單個元素 players[-3:]
   
   遍歷切片 for player in players[:3]:(遍歷前三個值)
   
   賦值列表new_players = players[:],不能使用new_players = players,直接等于培他，倆個變量指向了同一個列表，會同時變化
4. 元組(不可變的列表被稱為元組)
   
   定義遗座，使用（）圓括號舀凛，列表使用方括號 dimensions = (200,50),使用下標獲取對應的元素dimensions0
   
   遍歷元組中的所有值，使用for循環(huán) for dimension in dimensions:
   
   修改元組變量途蒋，不能修改遠足的元素猛遍，但可以給存儲元組的變量賦值dimensions = (400,100),重新賦值（在生命周期中，一組值不可變号坡，使用元組）
5. 設置代碼格式
   
   每級縮進四個空格
   
   使用空行將不同部分分開

5. if語句

例：

for car in cars:
   if car == 'bmw':

檢查不想等 !=

1. 檢查多個條件
   
   使用and age_0 >=21 and age_1>=21
   
   使用or age_0>=21 or age_1 >=21
   
   檢查特定值是否包含在列表中 if 'bw' in cars:
   
   檢查特定值不包含在列表中 if 'bw' not in cars:
2. if-else語句(if-elif-else)

if age >= 18:

else:

3. 確定列表不是空的

cars = []
if cars:
#不為空
else:
#為空

6.字典(鍵-值對)

1. 簡單的字典 alien_ = {'color':green,'points':5} alien_0['color']輸出green
2. 添加鍵-值對 alien_0['x_position'] = 0,alien_0['y_position']=25
3. 創(chuàng)建一個空字典 alien_0 ={},再添加鍵-值對懊烤，alien_0['color'] = 'green',alien_0['points'] = 5
4. 修改字典中的值 alien_0['color'] = 'yellow'
5. 刪除鍵-值對(永遠刪除) del alien_0['points']
6. 遍歷字典 for key,value in user_0.items()
7. 遍歷字典中所有鍵 for key in user_0.keys():
8. 判斷字典是否包含某個鍵 if 'color' in user_0.keys()
9. 按順序遍歷字典中所有鍵（獲取字典的元素時，獲取順序時不可預測的）宽堆，按順序使用sorted()函數(shù)腌紧，for key in sorted(user_0.keys())
10. 遍歷字典中所有值(不考慮是否有重復)for value in user_0.values():
    
    獲取不重復的值，for value in set(user_0.values())(獲取到的接口時一個不重復的列表)
11. 嵌套（將一系列字典存儲在列表中畜隶，或?qū)⒘斜碜鳛橹荡鎯υ谧值渲校?br>
    例字典列表

alien_0={'color':'green','point':5}
alien_1={'color':'yellow','point':10}
alien_2={'color':'red','point':15}
aliens = [alien_0,alien_1,alien_2]

列表存儲在字典中

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

字典中存儲字典

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

遍歷：for username,user_info in users.items():

7.用戶輸入和while循環(huán)

1. input()函數(shù)工作原理
   等待用戶輸入一些文本壁肋，獲取用戶輸入后逮光，將其存入到一個變量中
   
   message = input("這里是讓用戶輸入的提示語：")
   
   提示語換行操作

prompt = "If you tell us who you are, we can personalize the messages you see." prompt += "\nWhat is your first name? "
name = input(prompt)

2. 用int()來獲取數(shù)值輸入(input是獲取字符串輸入)(函數(shù)int()，讓python將輸入視為數(shù)值墩划，函數(shù)int()將數(shù)字的字符串轉換為數(shù)值表示)

>>> age = input("How old are you? ")
How old are you? 21 ?>>> age = int(age)
>>> age >= 18 
True

3. 求模運算符(%)返回余數(shù)
4. while循環(huán)

current_number = 1
while current_number <= 5:
    current_number+=1

輸入退出

message = ""
while message !='quit':
    message = intput("請輸入：")

使用break退出循環(huán)(在任何Python循環(huán)中都可使用break語句涕刚。例如，可使用break語句來退出遍歷列表或字典 的for循環(huán)乙帮。)

while True:
    message = input("請輸入")
    if message == 'quit':
        break

在循環(huán)中使用continue(根據(jù)條件測試結果決定是否繼續(xù)執(zhí)行循環(huán))

current_number = 0
while current_number < 10:
    current_number +=1
    if current_number % 2 == 0:
        #讓python忽略余下代碼杜漠，并返回到循環(huán)的開頭
        continue
    print(current_number)

最終打印1，3察净，5驾茴，7，9

進入無限循環(huán)氢卡，終端使用command(ctrl)+c,或關閉窗口锈至，編輯器直接關閉窗口

5. 使用while循環(huán)來處理列表和字典
   
   例驗證用戶

# 首先，創(chuàng)建一個待驗證用戶列表
# 和一個用于存儲已驗證用戶的空列表 
unconfirmed_users = ['alice', 'brian', 'candace']
confirmed_users = []
# 驗證每個用戶译秦，直到?jīng)]有未驗證用戶為止
# 將每個經(jīng)過驗證的列表都移到已驗證用戶列表中 
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())

刪除包含特定值的所有列表元素(前面提到的remove()只能刪除第一個峡捡，不能刪除所有)

pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
print(pets)
while 'cat' in pets: 
    pets.remove('cat')
print(pets)

使用用戶輸入來填充字典

responses = {}
# 設置一個標志，指出調(diào)查是否繼續(xù) 
polling_active = True
    while polling_active:
    # 提示輸入被調(diào)查者的名字和回答
        name = input("\nWhat is your name? ")
        response = input("Which mountain would you like to climb someday? ")
        # 將答卷存儲在字典中
        responses[name] = response
        # 看看是否還有人要參與調(diào)查
        repeat = input("Would you like to let another person respond? (yes/ no) ")
        if repeat == 'no': 
            polling_active = False
        # 調(diào)查結束筑悴，顯示結果
        print("\n--- Poll Results ---")
        for name, response in responses.items():
            print(name + " would like to climb " + response + ".")

8.函數(shù)

1. 定義函數(shù)
   
   例打印問候語的簡單函數(shù)

def greet_user():
    print("hello")

greet_user()

向函數(shù)傳遞信息(帶參函數(shù))

def greet_user(username):
    print("hello"+username.title())
    
greet_user('jesse')

實參和形參们拙，上面username是形參,'jesse'是形參

2. 傳遞實參
   
   位置實參，多個參數(shù)阁吝，位置相對應（保證實參的順序?qū)艺_）
   
   關鍵字實參greet_user(username='ydx',work='it')
   
   默認值(使用默認值時,在形參列表中必須先列出沒有默認值的形參砚婆，再列出有默認值的形參)

# 指定寵物類型默認是dog
def describe_pet(pet_name, animal_type='dog'):

等效的函數(shù)調(diào)用，對于上面創(chuàng)建的寵物類型是dog的默認方法突勇，舉一下例子

# 一條名為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')

3. 返回值
   
   例

def get_formatted_name(first_name, last_name): 
"""返回整潔的姓名"""
    full_name = first_name + ' ' + last_name
        return full_name.title()
musician = get_formatted_name('jimi', 'hendrix') 
print(musician)

讓實參變成可選的(給實參指定默認值空字符串)

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()
musician = get_formatted_name('jimi', 'hendrix') 
print(musician)
musician = get_formatted_name('john', 'hooker', 'lee') 
print(musician)

返回字典

def build_person(first_name, last_name): """返回一個字典装盯，其中包含有關一個人的信息"""
    person = {'first': first_name, 'last': last_name} 
        return person
musician = build_person('jimi', 'hendrix')
print(musician)

4. 傳遞列表(參數(shù)是列表)
   
   在函數(shù)中修改列表，在函數(shù)中對列表所做的任何修改都是永久性的
   
   禁止函數(shù)修改列表(不影響原件甲馋，將列表的副本傳遞給函數(shù))function_name(list_name[:]),這樣不會對原列表埂奈，list_name產(chǎn)生影響
5. 傳遞任意數(shù)量的實參

def make_pizza(*toppings)
    for topping in toppings:
        print()
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

結合使用位置實參和任意數(shù)量實參

def make_pizza(size,*toppings):

使用任意數(shù)量的關鍵字實參(**表示參數(shù)為字典形式，采用arg1=value1,arg2=value2這樣的形式)

def build_profile(first,last,**user_info):
    for key, value in user_info.items():

user_profile = build_profile('albert','einstein',location='princeton',field='physics')

6. 將函數(shù)存儲在模塊中(代碼與主程序分離摔刁，將函數(shù)存儲在被稱為模塊的獨立文件中挥转，使用import導入到當前的程序文件中)
   
   導入整個模塊海蔽，pizza.py中創(chuàng)建make_pizza函數(shù)共屈，在pizza.py所在目錄中創(chuàng)建另一個名為makeing_pizzas.py的文件，在making_pizzas.py文件中党窜，使用import pizza導入拗引，使用pizza.make_pizza(16,'pepperoni')調(diào)用方法
   
   導入特定的函數(shù)(使用的時候直接使用方法名，不需要函數(shù)名.方法名) from module_name import function_name:
   
   導入多個函數(shù)幌衣，使用逗號分割 from module_name import function_0,function_1,function2
   
   使用as給函數(shù)指定別名 from pizza import make_pizza as mp:(將make_pizza()重命名mp())
   
   使用as給模塊指定別名 import pizza as p 使用p.make_pizza
   
   導入模塊所有函數(shù) from pizza import *

9.類

1. 創(chuàng)建和使用類
   例：創(chuàng)建Dog類

class Dog():
    #init倆邊倆個_,相當于構造方法,形參self必不可少矾削，必須位于其他形參前面
    def __init__(self,name,age):
        """初始化屬性那么和age"""(參數(shù)關聯(lián)到創(chuàng)建的實例當中)
        self.name = name
        self.age = age
        
    def sit(self):
        """模擬小狗被命令時蹲下"""
        print(self.name.title() + " is now sitting.")
        
    def roll_over(self):
        """模擬小狗被命令時打滾"""
        print(self.name.title()+"rolled over!")

根據(jù)類創(chuàng)建實例(創(chuàng)建多個實例)

my_dog = Dog('willie',6)#創(chuàng)建實例
print("My dog's name is " + my_dog.name.title() + ".")#訪問屬性
print("My dog is " + str(my_dog.age) + " years old.")
my_dog.sit()#調(diào)用方法

2. 使用類和實例

class Car():
    """一次模擬汽車的簡單嘗試""" 5
    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() 9
 my_new_car = Car('audi', 'a4', 2016) print(my_new_car.get_descriptive_name())

修改屬性的值

直接修改my_new_car.odometer_reading = 23

通過方法修改壤玫，創(chuàng)建修改方法

def update_odometer(self, mileage): 
    """將里程表讀數(shù)設置為指定的值"""
    self.odometer_reading = mileage

通過方法對屬性的值進行遞增

def increment_odometer(self, miles):
    """將里程表讀數(shù)增加指定的量""" 
    self.odometer_reading += miles

3. 繼承
   
   創(chuàng)建子類的實例時，Python首先需要完成的時給父類的所有屬性賦值

# ElectricCar 是Card的子類
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())

創(chuàng)建子類時哼凯，父類必須包含在當前文件中欲间，且位于子類前面

在子類中，可添加區(qū)分子類和父類所需的新屬性和方法

class ElectricCar(Car):
    """Represent aspects of a car, specific to electric vehicles."""
    def __init__(self, make, model, year):
        """電動汽車的獨特之處 初始化父類的屬性断部，再初始化電動汽車特有的屬性 """
        super().__init__(make, model, year) 
        self.battery_size = 70
    
    def describe_battery(self): 
        """打印一條描述電瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

重寫父類方法(假設Car類有一個名為fill_gas_tank()的方法猎贴，它對全電動汽車來說毫無意義)

def fill_gas_tank():
    """電動汽車沒有油箱"""
    print("This car doesn't need a gas tank!")

將實例用做屬性(將Battery類作為參數(shù))

class ElectricCar(Car): 
    """電動汽車的獨特之處"""
    def __init__(self, make, model, year):
        """ 初始化父類的屬性，再初始化電動汽車特有的屬性 """
        super().__init__(make, model, year)
        self.battery = Battery()

4.導入類(將類存儲在模塊中蝴光，在主程序中導入所需的模塊)

Car類存儲在car.py模塊中她渴，導入from car import Car

一個模塊中存儲多個類

從一個模塊中導入多個類from car import Car,ElectricCar

導入整個模塊，import car 使用car.Car()

導入模塊中的所有類 from moudle_name import *

在一個模塊中導入另一個模塊(一個模塊中的類依賴于另一個模塊中的類蔑祟。在這種情況 下趁耗，可在前一個模塊中導入必要的類。)

5. Python 標準庫(Python的內(nèi)置模塊)
   
   collections中的類OrderedDict記錄鍵-值對的添加順序

from collections import OrderedDict

favorite_languages = OrderedDict()

favorite_languages['jen'] = 'python' 
favorite_languages['sarah'] = 'c' 
favorite_languages['edward'] = 'ruby' 
favorite_languages['phil'] = 'python'

for name, language in favorite_languages.items(): 
    print(name.title() + "'s favorite language is " +language.title() + ".")

按照添加的順序打印出來

random 模塊包含以各種方式生成隨機數(shù)的函數(shù)

from random import randint 
    x = randint(1, 6)

6. 編碼風格
   
   可使用空行來組織代碼疆虚，但不要濫用苛败。在類中，可使用一個空行來分隔方法;而在模塊中径簿，可使用兩個空行來分隔類著拭。
   
   需要同時導入標準庫中的模塊和你編寫的模塊時，先編寫導入標準庫模塊的import語句牍帚，再 添加一個空行儡遮，然后編寫導入你自己編寫的模塊的import語句。

10.文件和異常

1. 從文件中讀取數(shù)據(jù)
   
   讀取整個文件

with open('pi_digits.txt') as file_object:#open()打開指定文件暗赶，返回代表文件的對象鄙币，賦值給file_object
    contents = file_object.read()
    print(contents)

不需要手動調(diào)用close，程序會在適當?shù)臅r候自動關閉

read()到達文件末尾時會返回一個空字符串蹂随，將這個空字符串顯示出來就是一個空行刪除這個空行十嘿，使用contents.rstrip()

指定文件路徑(可指定絕對路徑或相對路徑)，Linus和OSX中岳锁，with open('text_files/filename.text'),在Windows中使用‘\’

逐行讀取

with open(filename) as file_object:
    for line in file_object:
        print(line)

每一行后面都有空白行绩衷，使用line.rstrip()去除空白行

在with代碼塊外，我們依然可以使用with里面創(chuàng)建的變量

在讀取文件時激率，Python將其中的所有文本都解讀為字符串咳燕，如果讀取的是數(shù)字，使用函數(shù)int()將其轉換成正數(shù)乒躺，或使用函數(shù)float()將其轉換為浮點數(shù)

判斷輸入是否在讀取出的字符串中 if birthday in pi_string:

2. 寫入文件
   
   寫入空文件

with open(filename,'w') as file_object:
    file_object.write("把這句話寫到文件里面去")

參數(shù)2(w,以寫入模式打開文件招盲，r,讀取模式，a附加模式嘉冒，r+讀取和寫入模式曹货，默認以只讀模式打開)

如果要寫入的文件不存在咆繁，函數(shù)open()將自動創(chuàng)建它，以寫入（w）模式打開文件時顶籽，如果文件已經(jīng)存在玩般，函數(shù)將在返回文件對象前清空該文件

python只能將字符串寫入文本文件，要將數(shù)值存儲到文本文件中礼饱，必須先使用函數(shù)str()將其轉換為字符串格式

寫入多行壤短，直接多個write不會自動換行，需要在write()語句中包含換行符（‘\n’）

附加到文件（給文件添加內(nèi)容慨仿，而不是覆蓋原有內(nèi)容久脯，使用附加模式打開文件，寫入的行都將添加到文件末尾）with open(filename, 'a') as file_object:

3. 異常(使用try-except代碼塊處理)

try:
    print(5/0)
except ZeroDivisionError:
    print("這里是發(fā)生異常后執(zhí)行的操作")

else代碼塊(依賴于try代碼塊成功執(zhí)行的代碼都應放到else代碼塊中:)

try:
    answer = int(first_number) / int(second_number)
except 
    ZeroDivisionError: 
    print("You can't divide by 0!")
else: 
    print(answer)

處理FileNotFoundError異常

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

4. 存儲數(shù)據(jù)
   
   使用模塊json來存儲數(shù)據(jù)(文件是.json)

import json
numbers = [2, 3, 5, 7, 11, 13]

filename = 'numbers.json'

with open(filename, 'w') as f_obj: 
    json.dump(numbers, f_obj)

最終的存儲格式和python中一樣[2, 3, 5, 7, 11, 13]

使用json.load()將這個列表讀取到內(nèi)存中

with open(filename) as f_obj:
    numbers = json.load(f_obj)

保存和讀取用戶生成的數(shù)據(jù)