引言：

“人生苦短，我用python”
python之禪：Simple is better than complex

目錄：

1. 輸入函數輸出函數
2. 數據類型（字符串、數值、列表、元組、字典）
3. 結構語句（if條件語句、for循環、while循環）
4. 函數定義和類定義
5. 文件操作

1.輸出函數&輸入函數

• 輸出函數：
  print（變量）
• 輸入函數：
  變量=input（向用戶顯示的提示）
  input()函數讓程序暫停運行，等待用戶輸入文本。獲取用戶輸入后，python將其存儲在一個變量中。
  input()得到的變量總是解讀為字符串，需使用**int()**函數將輸入轉為數值。

2.數據類型

• 字符串：
  在python中，字符串變量可用單引號或雙引號括起。
  支持的方法：
  .title()：首字母大寫
  .upper()：全部大寫
  .lower()：全部小寫
  .strip()：剔除兩端空白
  .lstrip()：剔除開頭空白
  .rstrip()：剔除末尾空白
• 數值：
  整數和浮點數
  支持+、-、*、/、**(乘方)、%(取余)
  使用str()函數可將數值轉變為字符串
• 列表：
  由一系列元素組成
  在python中，用方括號[ ]表示列表，并用逗號分隔
  索引從0開始，支持-1索引，表示倒數第一個
  訪問：list[index]
  添加：list.append(value) ; list.insert(index,value)
  刪除：del list[index] ; list.pop() ; list.pop(index) ; list.remove(value)
  排序：永久 list.sort() ; 臨時 sorted(list)
  確定長度：len(list)
  使用range()函數生成一系列數字：range(1,5)=1,2,3,4
  生成數字列表：list(range(1,5,2))=[1,3]
  列表解析：list=[value**2 for value in range(1,3)] 此時list=[1,4]
  切邊：list[0:3]，即取列表中索引值從0到3的元素構成一個列表
  可使用切片復制列表
• 元組：
  值不可修改的列表被稱為元組
  在python中，用方括號( )表示元組，并用逗號分隔
  訪問元素和列表一樣
  雖然不可修改元組的值，但可給存儲元組的變量重新賦值
• 字典：
  字典是一系列鍵-值對，鍵-值對應，與鍵對應的值可以是數字、字符串、列表、字典
  字典放在{ }內，鍵值之間用：分隔，而鍵值對之間用逗號分隔
  訪問：value=dic[key]
  添加：dic[key]=value
  刪除：del dic[key]
  遍歷所有鍵值對：for key,value in dic.items()
  遍歷所有鍵: for key in dic.keys() ; for key in dic
  遍歷所有值：for value in dic.values()
  嵌套：字典作為列表元素；列表作為字典值；字典作為字典值

3.結構語句

（1）if語句
if 條件測試1：
\t語句1
elif 條件測試2：
\t語句2
else：
\t語句3

條件測試：
相等：==
不相等：！=
比較：< >
and 和 or 鏈接多個測試
in ; not in 判斷特定值是否包含在列表中
列表是否為空

（2）for循環
列表遍歷
for value in list:
\t語句
字典遍歷
for value in dic:
\t語句
（3）while循環
while 條件測試：
\t語句

可使用break退出循環
使用continue退出本次循環

4.函數定義&類定義

• 函數定義：
  函數定義
  def fun():
  \t語句
  函數調用
  fun()
  傳遞實參
  位置實參：要求實參的順序和形參相同
  關鍵字實參：每個實參由變量名和值組成
  可以傳遞列表，此時對列表會做出永久性修改，若不修改，可傳遞列表切片
  傳遞任意數量的實參：fun(*par) *讓python創建一個名為par的空元組，將所有的值都傳遞到這個元組中。
  傳遞任意數量的關鍵字實參：fun(**par) **讓python創建一個名為par的字典，將所有的名稱-值對裝到這個字典中。
  函數（fun1）可以存儲在模塊（case1.py）中：
  當在case2.py中調用fun1：
  import case1 as c1
  from case1 import fun1 as f1
  from case1 import *
• 類定義：
  類定義：
  class Cla():
  \t def init(self,par1,par2): #定義屬性
  \t\t 語句1
  \t def way1(self): #定義方法
  \t\t 語句2
  創建實例：
  obj=Cla(pal1,pal2)
  屬性和方法調用：
  Cla.par1
  Cla.par2
  Cla.way1()
  繼承：
  一個類繼承另一個類時，自動獲得另一個類的所有屬性和方法，同時還可以定義自己的屬性和方法。
  class Cla2(Cla1):
  \t def init(self,par1,par2,par3):
  \t\t super().init(par1,par2) #調用父類的初始化函數
  \t\t 語句
  類的屬性可接受一個實例
  導入類：
  from case1 import Cla1
  from case1 import *
  import case1

5.文件操作

讀取整個文件
with open(‘路徑’) as file_object:
\t contents=file_object.read()
\t print(contents)
逐行讀取
with open(‘路徑’) as file_object:
\t for line in file_object:
\t print(line)
創建一個包含文件各行內容的列表
with open(‘路徑’) as file_object:
\t lines=file_object.readlines()
\t for line in lines:
\t\t print(line.rstrip())
讀取文件時，python將其中所有文本解讀為字符串

寫入文件
with open(‘路徑’，‘w’) as file_object:
\t file_object.write(value)
寫入多行
with open(‘路徑’，‘w’) as file_object:
\t file_object.write(value\n)
\t file_object.write(value\n)
附加到文件
不會覆蓋原有內容
with open(‘路徑’，‘a’) as file_object:
\t file_object.write(value\n)
\t file_object.write(value\n)

6.python代碼實例：

#用到列表解析

def quicksort(arr):
    '''快速排序法'''
    if len(arr)<2:
        return arr
    else:
        pivot=arr[0] 
        less=[i for i in arr[1:] if i<pivot] #列表解析
        larger=[i for i in arr[1:] if i>pivot]
        return quicksort(less)+[pivot]+quicksort(larger)
print(quicksort([1,5,3,2]))

#for循環

def findsmallest(arr):
    '''找列表中最小值'''
    smallest=arr[0]
    smallest_index=0
    for i in range(1,len(arr)):
        if arr[i]<smallest:
            smallest=arr[i]
            smallest_index=i
    return smallest_index
def selectionsort(arr):
    '''選擇排序'''
    new_arr=[]
    for i in range(0,len(arr)):
        smallest_index=findsmallest(arr)
        new_arr.append(arr.pop(smallest_index))
    return new_arr
print(selectionsort([1,5,4,2]))

#while循環

def binary_search(list,item):
    '''二分查找'''
    low=0 #起點
    high=len(list)-1 #終點
    while high>=low:
        mid=low+int((high-low)/2) #中間值
        if item==list[mid]:
            return mid
        elif item>list[mid]:
            low=mid+1;
        else:
            high=mid-1;
    return None
list=[1,2,3,6,9,10]
print(str(binary_search(list,6)))
print(str(binary_search(list,4)))

#字典

from collections import deque
'''圖的形成'''
graph={}
graph["you"]=["alice","bob","claire"]
graph["bob"]=["anuj","peggy"]
graph["alice"]=["peggy"]
graph["claire"]=["thom","jonny"]
graph["anuj"]=[]
graph["peggy"]=[]
graph["thom"]=[]
graph["jonny"]=[]
print(graph)
'''廣度優先搜索'''
def person_is_seller(name):
    '''定義一個供應商確定函數'''
    return name[-1]=="m"
def BFsearch(name):
    '''借助隊列'''
    search_queue = deque()
    search_queue += graph[name]
    searched = []
    while search_queue:
        person = search_queue.popleft()
        if person not in searched:
            '''判斷是否重復'''
            if person_is_seller(person):
                print(person+" is a seller!")
                return True
            else:
                '''否的話要將其朋友拉入隊列'''
                search_queue += graph[person]
                searched.append(person)
    
    return False
print(BFsearch("you"))