# python
編譯(compiler):打完全部轉換
c++、C、objective-C、Visual Basic都屬於**編譯**
直譯(interpreter):打完一行轉換一行
所以python、JavaScript、Ruby屬於**直譯**
---
## python應用
人工智慧(人工智慧是指透過普通電腦程式來呈現人類智慧的技術)
股票
晶片
機器人 (人臉辨識)
互聯網
神經網路
創造人:吉多·范羅蘇姆（荷蘭語：Guido van Rossum，1956年1月31日－），生於荷蘭哈勒姆
---
## python簡介
---
### 變數與資料型態
變數與資料是所有程式語言共同的基礎。不同程式語言的資料型態稍有差異但大同小異，不外乎是整數、小數、布林值 （boolean-True false)、字串等。而變數（variables）是一個可以存取資料的地方（或是標籤），而存取的目的是為了之後可以被重複使用。
```python=
#整數型態範例:
a=123
b=456
print(a+b)
#結果:123+456=579
```
```python=
#字串型態範例:
a='123'
b='456'
print(a+b)
#結果:123456
```
---
### 數值型態及各項
字串型態：str, chr
容器型態：list(輸出為中括號，可變動)
dict(字典型態，大括號，可變動)
tuple(輸出為小括號，不可動)
---
## 各項函式
---
### 換行符號:\n、"""
```python=
s = "hello\nWorld!"
print(s)
#output:Hello
# World!
```
或是
```python=
s = """hello
World!"""
print(s)
#output:Hello
# World!
```
---
### 字串中取得某個位置的字元:(x[2])
```python=
s = "nekopara"
# 01234567 對應的位置(index)，從0開始
print(s[2])
#output:k
```
---
### 取得字串中一段子字串:(x[2:4])
```python=
s ="sdfgkhjfjk"
# 0123456789 對應的位置(index)，從0開始
print(s[2:4])
#output:fg
```
此項符號後面得數字會取該數減一的數值 輸入4(編號第四位) 會取3(編號第三位)
此處有個額外的小技巧，s[2:]會出現編號2以後(***含***)的數字，s[:5]會出現編號5(***不含***)之前的數字，公式:
**(string[begin(include):end(not include)]):**
begin不填就是從0開始到end的前一位
end不填就是begin到最後一個
上下兩用法在list都可以使用
---
### 忽視"的意義:\(印出")
```python=
s = "hell"o"
print(s)
#error
#會發現這樣寫跳錯誤，原因就是電腦只讀到"hell"，這時候就要把l和o之間的那個"的(效果)去
#掉，只要在前面加上\就可以了(如下)
```
```python=
s = "hell\"o"
print(s)
#output:hell"o
#(l後面的"失去作用，變成一個字元，印出後自動刪掉兩旁的觸鬚，得hell"o)
```
如果想特別標示o:
```python=
s = "hell\"o\""(加一個"跟\)
print(s)
#output:hell"o"
```
---
### 型別轉換函式:chr(x)
(以 ASCII code 文字代碼轉換當例子)
```python=
c = 66
print(chr(c))
# 答案:B
# 印出來的結果就是將66這個數字以ASCII code轉換成字元的的結果(B)
```
這項函式**無法將英文或標點符號轉換回來**，如果需要這麼做，我們需要以下含式:
---
### 型別轉換函式:ord(x)
跟上面那則函式相反，這個函示是把英文以ASCII方法轉換成數字，跟上面那則函式有些微差距，我們要指定一個變數，**並指定變數為某個英文字，且必須為字串**，才可下去做變換，下面為範例:
```python=
c="f"
print(ord(c))
#答案:102
```
---
### 將浮點數轉換為整數:int()
```python=
floatNum = 55.0
intNum = int(floatNum)
print(floatNum)
print(intNum)
print(type(floatNum))
print(type(intNum))
#答案:55.0 (floatNum的答案)
# 55 (intNum的答案)
# <type 'float'> (數字55.0的形式(TYPE))
# <type 'int'> (數字55的形式)
```
此時 floatNum、intNum可替換任何英文，唯獨第二行右半邊的int()不可換
同理，將**字串**變為整數:
```python=
stringNum = "55"
intNum = int(stringNum)
print(stringNum)
print(intNum)
print(type(stringNum))
print(type(intNum))
#答案:55
# 55
# <type 'str'>
# <type 'int'>
```
這項函式**無法轉換數字以外的事物**
---
### if敘述
根據某個條件來決定是否執行接下來的動作時，就需要用到 if 敘述：
```python=
if condition:
statement (縮排)
```
Python 中要去判斷「哪些程式碼屬於某層級之下」不是使用大括號 {} ，而是使用縮排判斷，只要在同一層縮排就是屬於上方「:」下的內容。因此**縮排在 Python 中是十分重要的(按一下tab)**。(if、elif(else if)、esle)
範例:
```python=
score = int(input("請輸入成績"))
if score >= 60: (注意這裡要打冒號)
print("成績及格!")
#答案:請輸入成績
#(在後面再次輸入數字代表成績)
#例:90 成績及格!
```
請注意!!!if與法理面
input()這個語法，可以用來**使程式讓使用者輸入內容**。當一個變數被指定為 input() 時，預設的型態為 string 。**中文及英文都必須放為字串。**
這裡的"請輸入成績"只是一個代詞，讓使用者知道這裡該輸入甚麼東西
---
### else敘述(記得縮排)
程式在 if 條件不成立時，便去執行 else 底下的動作，判斷條件不成立(if)時就做另外一件事。
```python=
if condition:
statement1 for True condition
else:
statement2 for False condition
```
以下是範例:
```python=
score = int(input("score:"))
if score >= 60:
print("成績及格!")
else:
print("不及格，被當了!")
#答案:score:
#(在後面再次輸入數字代表成績)
#例:90 成績及格!
#例:48 不及格，被當了!
```
input必須打出來，不然電腦無法判斷你的score。第一行的"score:"可以輸入任何事物。
---
### elif(else if)敘述
有的時候需要判斷的可能狀況有很多種時，這時候就可以使用 if-elif-else 結構來描述我們的需求。
```python=
if condition1:
statement1 for True Condition1
elif condition2 :
statement2 for True Condition2
elif condition3 :
statement3 for True Condition3
else: (無須加condition)
statements for Each Condition False
```
elif**無個數上限**，可依照自己需求而定多少數量。
以下以成績高低分成A B C D F:
```python=
score = int(input("score: "))
if score >= 90:
print('Grade is: A')
elif score >= 80:
print('Grade is: B')
elif score >= 70:
print('Grade is: C')
elif score >= 60:
print('Grade is: D')
else:
print('Grade is: F')
#答案:score:
#輸入45 得Grade is: F
#輸入90 得Grade is: A
```
---
### 巢狀if
當我們要在判斷條件中安排更進一步的判斷條件時，就需要用到巢狀 if 結構了。所謂的巢狀 if 敘述是指在 if-else 敘述當中，還有另一組 if、if-else 敘述，例如：
```python=
ID = input("請輸入") #在Output輸入
year = int(ID[1:3]) #先把輸入指定為整數數字(int) #看該數的編號1到編號2(從0開始,左邊開始)
if year < 4: #例:30356 編號1跟2為03，輸出Graduated
print("Graduated")
elif year <= 7 and year >= 4:#先立好範圍
if year == 7: #30723 編號1跟2為07，輸出Freshman
print("Freshman")
elif year == 6:#30623 編號1跟2為06，輸出Sophomore
print("Sophomore")
elif year == 5:#30523 編號1跟2為05，輸出Junior
print("Junior")
elif year == 4:#30423 編號1跟2為04，輸出Senior
print("Senior")
else: #32456 編號1跟2為24 為其他 輸出Not Registered Yet
print("Not Registered Yet")
#答案:請輸入:
#輸入45509，輸出Not Registered Yet
#輸入40678，輸出Sophomore
```
---
### 取得列表長度:len()
```python=
l = [12,23,34,56,78]
lenth = len(l)
print(lenth)
#output:
#5
```
一格數字代表1，從1開始
---
### 拆解字串set()
把**字串**拆成一個集合，特性是不會出現相同元素，python編譯的順序是隨機出現，每次出現都是不同結果。
```python=
s = set("apple")#(必須放字串)**且為小括號**
print(s)
#output
#{'l', 'e', 'p', 'a'}(出現大括號的答案，因為是集合，答案也會是字串)
```
---
### 取最大值(max(x,y))(注意兩個小括號)
```python=
a=3
b=8
print(max(a,b))
#答案:8
```
出現的會是a或b所代表的數，不會出現a或b
相對應，最小值的話，把max改成min
---
### 大寫轉小寫(x.lower)
```python=
str = "THIS IS STRING EXAMPLE....WOW!!!"
print(str.lower())
#答案:this is string example....wow!!!
```
---
### 妥善處理例外情況(try與except)
一個基本的 try-except 的結構如下：
```python=
try:
#嘗試執行的程式碼
except 例外名稱:
#當遇到例外時要執行的程式碼
```
此則算法的用意是，先嘗試執行 try 底下的程式碼，如果無法順利執行，在過程中產生了例外，就會接著執行 except 下的程式碼。except 的區塊也可以有很多個，可以依照個人需求進行使用。
下面的例子，今天想要簡單地請使用者輸入兩個數字，然後輸出兩者相除的結果時，可能會面對到兩種例外：一、使用者拿 0 作為除數。二、使用者輸入錯誤，將數字輸入成英文字母或是其他無法預測的輸入。那麼，為了妥善地處理這兩種不同的例外情況，我們可能會寫出如下的程式碼：
```python=
try:
a = int(input("請輸入"))
b = int(input("輸入"))
print(a/b)
except ZeroDivisionError:#代表輸入函式的時候把0當除數了
print("Cannot divide by 0!")
except:
print("Wrong input")
#答案:
#請輸入:8
#輸入:4
#答案:2.0
```
這邊如果被除數輸入8，除數輸出0，就會跳到第二行的except ZeroDivisionError，答案輸出Cannot divide by 0!
最後一行，我們今天被除數輸入8，除數輸入s，此例外並非上一個區塊指定的例外 ZeroDivisionError，就會印出wrong input
---
### 充分的使用 try-except 的結構(try、except、else、finally)
除了剛才介紹過的 try 和 except 以外，我們也可以再搭配 else 以及 finally 兩個關鍵字。**當 try 當中的程式可以正確地執行**，將會**執行 else 區塊**當中的程式碼；而**無論 try 區塊中的程式碼執行以後有沒有產生例外，都要執行 finally 區塊中的程式碼。**。如果執行的是except，就不會執行else的程式碼
我們再從上面的例子在執行一遍:
```python=
try:
a = int(input("請輸入"))
b = int(input("輸入"))
c = a/b#注意這邊新增了一個變數，下面才可以指定輸出這個答案(字串)
except ZeroDivisionError:
print("Cannot divide by 0!")
except:
print("Wrong input")
else:
print("The answer is " + str(c))#這裡
finally:
print("Program finished")
#答案:
#請輸入:8
#輸入:4
#答案:
#The answer is 2.0
#Program finished
```
---
## 宣告(def)
我們會利用 def 這個關鍵字來定義我們的 function ，包含**函式名稱**以及**這個函式所需的參數**。
---
### def運用
今天我們要一次寫出**分辨平閏年**的含式及**判斷該數乘以9是否等於81**的含式，我們就需要def來指定現在電腦該優先執行哪個:
```python=
def f(i): #其後都必須加冒號
if (i % 400 == 0) or (i % 100 != 0 and i % 4 == 0):
print("閏年")
else:
print("平年")
def r(o):
if (o*9==81):
print("ok")
else:
print("讚")
o=int(input("請輸入"))
r(o)
#答案:"請輸入":9
# 輸出:ok
```
其中這段含式的最後一行 **r(o)的o必須為我們要更改的變數**，r則可以替換數字以外的東西，倒數第二行則為我們對該含式的指令。
---
### 宣告的回傳值(return True、False)(單一及多數)
非常注意!!!!**True跟False第一個字都要大寫**，沒有大寫這含式不成立，這次不讓他直接印出結果，而是回傳給我這個年份 “是不是” 閏年，也就是 True 或 False ：
```python=
def check_leap_year(year):
if (year % 400 == 0) or (year % 100 != 0 and year % 4 == 0):
return True
else:
return False #宣告並呼叫
year = int(input())
print(check_leap_year(year)) #前面的print極度重要
#答案:輸入:2019
#輸出:False
```
還需要特別注意的事情是， return 只能回傳單一的值，它可以回傳一個整數(int) 、一個浮點數(float) 、一個串列(list) 、…等等，他可以回傳許多不同型態的物件，但是都只能回傳一個。
但今天我們想要多回傳一點，也是可以，在return True與return False後面增加一個逗號與你想多回傳的數值，將這些值包成一個元組 tuple 再將之回傳，舉例如下:
```python=
def check_leap_year(year):
if (year % 400 == 0) or (year % 100 != 0 and year % 4 == 0):
return True, "123"
else:
return False, "456"
year = int(input())
print(check_leap_year(year)) #如果你要求回傳True或False的話需要在這邊輸入print，要不然函式不成立
#答案:輸入:400
#輸出:(True, '123')
```
---
### 宣告的回傳值(2)(分配不同變數與其種類)
今天我們想要兩個值分配給不同的變數，在呼叫的地方增加兩個變數讓電腦輸入，方便查看:
```python=(續上題)
year = int(input())
is_leap, a = check_leap_year(year) #右邊看到左邊，is_leap跟a兩個值為check_leap_year(year)運算下來的兩個值
```
以下為範例:
```python=
def check_leap_year(year):
if (year % 400 == 0) or (year % 100 != 0 and year % 4 == 0):
return True, "123"
else:
return False, "456"
year = int(input())
x, y = check_leap_year(year)
print(x, type(x))
print(y,type(y))
#答案:輸入:2019
#輸出:False <class 'bool'>
# 456 <class 'str'>
```
---
### 將a~z轉換成數字(a=1,z=26)並作相對應的計算
```python=
def word2num(s):
total = 0
for x in s.lower():
total += ord(x) - 96
return(total)
mylist = ["pen", "pineapplepen", "pineapple", "applepen", "apple"]
print(sorted(mylist, key=word2num))
#答案:['pen', 'apple', 'applepen', 'pineapple', 'pineapplepen']
```
這邊有幾個重點，
第一，第一行的word2num跟s都可以做更改，當然宣告裡面的也要一起改，這樣函示才會成立。
第二，第三行的迴圈意思是遍歷mylist的各項元素，x把有元素提出，**s.lower是把元素裡可能參雜的大寫在內建裡變成小寫**。
第三，第四行我們要每個字母個別儲存起來，所以必須寫成total=total+ord(x)-96；**-96的原因是經過ASCII的轉換，a是等於97的**，不是我們指定的數字。
第四，第五行的**return是因為要個 別 累 加**，所以必須這樣寫。
---
### 對相同長度的字串以首字母進行排列
當函數 sorted() 要排序一個 tuple 串列時，會先判斷 tuple 當中第一個元素的優先順序，如果相同，會接著判斷下一個元素的優先順序，所以可能會寫出一個 key function 如下：
```python=
def multi_sort(s):
return (len(s), s)
```
這個函式會**回傳字串的長度以及字串本身**，因此 sorted() 得到這個函式的回傳值以後，他會**先比較字串的長度**，若長度相同，會接著依照字母順序比較兩個字串。
```python=
def x(s):
return (len(s), s)#這裡相反過來就變成優先看首字母，在依照長度排序，當然如果首字母一樣，長度也一樣也是在看第二位
mylist = ["pen", "papper", "pineapple", "applepens", "apple"]
print(sorted(mylist,key=x))
#答案:
#['pen', 'apple', 'papper', 'applepens', 'pineapple']
```
---
## 引含式
python裡有許多引含式，方便我們做各種簡單的運算，而不用在打多行函式來麻煩自己
我們該如何叫出模組呢，我們要先從math裡面抽出該數學的英文，我們以階乘輸入當範例，該這樣輸出:
```python=
from math import xxxxxx
#從math這個巨集中提出xxxx這個數學的英文，例如根號為sqrt，階乘為factorial。
print(xxxxxx(數字))
#前面如果需要加字的話應該輸出xxxxx(你想輸出的文字，需要**加字串**，並且加一個**逗號**。
```
---
### 階乘(factorial)
階乘為倒敘方法(5,4,3,2,1)，無法為正敘(1,2,3,4,5)，當今天需要一個大數的階乘，我們可以這樣寫:
```python=
from math import factorial
#中間需要空一行
print(factorial(4))
#答案:24
```
當然有比較簡潔的，我們只需要輸入(import)math就好:
```python=
import math
print(math.factorial(5))
#答案:120
```
當然，factorial這個數學函式是一定要打的，這樣電腦才會知道你要運算甚麼
---
### 根號(sqrt)
```python=
from math import sqrt
print("Y",sqrt(4))
#答案:Y 2.0
```
---
### 最大公因數(gcd)
```python=
from math import gcd
print(gcd(40,80))
#答案:40
```
---
## list的運用
在list的函式運作裡，有一個非常重要的事，一開始的list必須為中括號，這樣才可以做改變，在後面我們欲加的句子呢，則**必須是tuple**，非常重要。
更重要的是，這些含式**無法指定另一個字母來儲存它的變化**，必須在第二行直接範例輸入x.append
---
### 段落內附加**單一個**字串(list.append(欲增加物件))
```python=
thriller = ['Thriller', 'Billie Jean', 'Beat It']
thriller.append('That Girl is Mine') #這邊輸出元素名，注意是小括號!!!!
print(thriller)
#答案:
#['Thriller', 'Billie Jean', 'Beat It', 'That Girl is Mine']
```
此方法會輸出引號，故適合用在本來就有引號的字串框框裡
在這則函式裡，我們不會把我們欲加的元素將它變成一個集合(list)，例如e=['That Girl is Mine']**(中括號)**，並輸入append(e)，這樣的答案會變成['Thriller', 'Billie Jean', 'Beat It', ['That Girl is Mine']]會多出一個中括號。
那如果我們輸入**小括號**n=thriller.append("fuck you")，接著輸入print(n)，答案會變成**None**，需要注意。
該函式無法指定位置，必須使用下一則函式:
---
### 指定欲增加物件插入的位置(list.insert(position,欲增加物件))
```python=
t=["apple","tomato","banana"]
t.insert(2,"grape")
print(t)
#答案:
#['apple', 'tomato', 'grape', 'banana']
```
需要注意的是，這裡如果我們使用insert指定位置並加入bad_2，會出現**整個list**插進去的答案:
```python=
bad_1 = ['Bad', 'Smooth Criminal','Speed Demon']
bad_2 = ['Man in the Mirror', 'Dirty Diana']
bad_1.insert(1, bad_2)
print(bad_1)
#答案:
#['Bad', ['Man in the Mirror', 'Dirty Diana'], 'Smooth Criminal', 'Speed Demon']
```
有包含中括號，通常這種答案不會是題目要的
---
### 兩個或以上list以元素方式加入(list1.extend(list2)
如果一次想加入很多個值、或是想將某個 list 中的元素加到另一個 list 的時候，可以用 extend 這個方法:
```python=
bad_1 = ['Bad', 'Smooth Criminal','Speed Demon']
bad_2 = ['Man in the Mirror', 'Dirty Diana']
bad_1.extend(bad_2) #這邊只能輸出集合的名字
print(bad_1)
#答案:
#['Bad', 'Smooth Criminal', 'Speed Demon', 'Man in the Mirror', 'Dirty Diana']
```
此方法也可以直接寫出:
```python=
print(bad_1+bad_2)
```
該函式是把第二段，也就是extend後面括號裡的list加到前面的list裡，**答案是印出前者**
有趣的是，我們如果要extend整串的話會變成這樣:
```python=
thriller = ['Thriller', 'Billie Jean', 'Beat It']
thriller.extend('That Girl is Mine')
print(thriller)
#答案:['Thriller', 'Billie Jean', 'Beat It', 'T', 'h', 'a', 't', ' ', 'G', 'i', 'r', 'l', ' ', 'i', 's', ' ', 'M', 'i', 'n', 'e']
```
會變成一個字母一個字母輸出，需要注意一下此則訊息。
---
### 移除元素(list.remove(元素名)
在 remove 後面的括號中輸入想要移除的元素，即可移除。
下面的例子，我們想要將 "Smooth Criminal" 這首歌從 bad 清單中刪去:
```python=
bad = ['Bad','Smooth Criminal','Speed Demon','Man in the Mirror','Dirty Diana']
bad.remove('Smooth Criminal')
print(bad)
#答案:
#['Bad', 'Speed Demon', 'Man in the Mirror', 'Dirty Diana']
```
---
### 移除list的最後一個元素(list.pop())
該函式也是在不知道列表多長的狀況下，直接選取最後一位:
```python=
bad = ['Bad','Smooth Criminal','Speed Demon','Man in the Mirror','Dirty Diana']
popped = bad.pop()
print(bad) #(這裡要注意，Dirty Diana已被移除)
print(popped) #(此答案為bad列表最後一個元素)
#答案:
#['Bad', 'Smooth Criminal', 'Speed Demon', 'Man in the Mirror']
#Dirty Diana
```
---
### 排序list(正)(list.sort())
括號內不加字的話，字串會照字母順序排列(首個英文字)、數字則會是遞增排列。
以下為英文字排列:(需放字串)
```python=
bad = ['Bad','Smooth Criminal','Speed Demon','Man in the Mirror','Dirty Diana']
bad.sort()
print(bad)
#答案:
#['Bad', 'Dirty Diana', 'Man in the Mirror', 'Smooth Criminal', 'Speed Demon']
```
這則函式需要注意的是，如果**其中一個字串的開頭是小寫，就算他的順序在s前面，他也會被sort在s開頭的字的後面。非常重要**
以下為數字範例:
```python=
t=[6,3,7.8,94,56]
t.sort()
print(t)
#答案:
#[3, 6, 7.8, 56, 94]
```
---
### 排序list(反)(list.sort(reverse=True))
當一個序列很亂的時候，需要快速排列大小，從小排到大在上則函式已講到，這邊提供由大到小:
以下為英文範例:(需放字串)
```python=
i=["umbrella","zebra","alarm","cheese","dog"]
i.sort(reverse=True)
print(i)
#答案:
#['zebra', 'umbrella', 'dog', 'cheese', 'alarm']
```
以下為數字範例:
```python=
i=[45,90,34,67,89.9]
i.sort(reverse=True)
print(i)
#答案:
#[90, 89.9, 67, 45, 34]
```
---
### 倒轉list(list.reverse())
跟由大排到小的函式(list.sort(reverse=True)不一樣，這個函式是把**整個函式倒轉過來**。
```python=
bad = ['Bad','Smooth Criminal','Speed Demon','Man in the Mirror','Dirty Diana']
bad.reverse()
print(bad)
#答案:
#['Dirty Diana', 'Man in the Mirror', 'Speed Demon', 'Smooth Criminal', 'Bad']
```
此方法跟sorted的reverse=True不太一樣，這個是把所有在tuple裡面的元素全部倒轉，**不是sorted一樣會看開頭字母進行倒轉**
---
### list的查找(list.index(element))
在這個函式，我們必須在element的地方輸入想找的東西，不能輸入編號，以 bad 這個 list 為例，如果想要知道 Dirty Diana 這首歌的索引值:
```python=
bad = ['Bad','Smooth Criminal','Speed Demon','Man in the Mirror','Dirty Diana']
print(bad.index("Dirty Diana"))
#答案:4
```
該答案為**Dirty Diana的位置**，這個含式**必須直接印出來**，不能在第二行先index(x)，需要注意。
---
### list的總和(sum(list))
此函式跟迴圈不一樣，sum不可用其他字替代:
```python=
num = [23, 4, 53, 5 ,35, 6]
print(sum(num))
#答案:126
```
迴圈方法:
```python=
o = [23, 4, 53, 5 ,35, 6]
for i in o:
print(sum(o))
#答案:
#126
#126
#126
#126
#126
#126
```
會輸出跟list裡的數值相對應的次數，通常不會是題目要的。
---
### 同時取得一個元素在一個 list 中的 index 與他的值(*for* i , x *in enumerate*(list)): print(i,x)
此用法較為少見，出現在比較雞婆的題型，會輸出該元素的編號跟元素名:
```python=
o=["snake","key","dinner","breakfast","lunch"]
for p,g in enumerate(o):
print(p,g)
#答案:
#0 snake
#1 key
#2 dinner
#3 breakfast
#4 lunch
```
---
### 更改index的起始值(enumerate(list,start=1))
繼上則函式的輸出，初始設定都是從0開始，我們可以在函式的後面再加上start=1來指定電腦優先輸出哪一個數字:
```python=
o=["snake","key","dinner","breakfast","lunch"]
for p,g in enumerate(o,start=2):
print(p,g)
#答案:
#2 snake
#3 key
#4 dinner
#5 breakfast
#6 lunch
```
---
### 讓list元素變成字串以指定的符號隔開(x=','.join(list))
如果我們想要把 Dangerous 這張專輯輸出成一個用**逗號所隔開**的字串，可以另外產生一個變數x ，並且令他的值為 ','.join(dangerous) ，把 list 的值用逗號串在一起:
```python=
o=["snake","key","dinner","breakfast","lunch"]
i="/".join(o)
print(i)
#答案:
#snake/key/dinner/breakfast/lunch
#引號內輸出斜線，答案也出現斜線
```
該函式引號內為我們指定的標點符號，可根據自己的喜好或便於分類來改變
其中，**這則函式僅限於英文字**，**數字不能使用**
---
### 隔開之後再變回原本的list(list.split("先前指定的符號"))
文章說很常用到，但我她媽想不到哪裡可以使用到，先打以免忘記
上則函式把list變為字串，這則函式則是**把字串重新變為最初的list**，我們使用**split**來把我們指定的分隔符號削掉:
```python=
o=["snake","key","dinner","breakfast","lunch"]
i="/".join(o)
#(空一行方便辨識)
j=i.split("/")
print(j)
#答案:['snake', 'key', 'dinner', 'breakfast', 'lunch']
```
---
### 將散落的數字或單字以**字串型態**裝進list(input("請輸入").split())
可以先把input想成一個字串，並輸入函式，電腦會幫我們input的東西以空白做分隔，分成**一個一個字串**，裝進list中
以下為數字範例:
```python=
i= input("請輸入").split()#注意引號
print(i)
#答案:請輸入:2 3 4 5 6
#輸出:['2', '3', '4', '5', '6']
```
如果現在我們要分割一個詞的每格字，我們要再輸入的時候，每個字之間要**隔一個空白鍵**，才可以輸出每個**單一的**字串。
以下為英文輸出:
```python=
#請輸入:a p p l e
#輸出:['a', 'p', 'p', 'l', 'e']
```
---
### 將散落數字以**整數型態**裝進list list=[int(i) for i in input().split()]
上則函式我們提到把散落數字以**字串型態**裝進list中，這則函式則是以整數型態裝進list中:
```python=
i=[int(o) for o in input("請輸入").split()]#(int指定只能輸入數字，後面輸入元素，並split分開)
print(i)
#答案:請輸入:2 3 4 5 6
#輸出:[2, 3, 4, 5, 6]
```
注意!!!該格子有**int這個函式**，其輸出一定要為數字，這是跟上則函式不同的原因
---
## 基本運算
---
### 加法:
```python=
x = 3
y = x + 1 (可以縮減為x+=1)
print(y) #這時候x的值是4，因為程式會先做右邊再把答案放到左邊的變數
#output:4
```
段落內增加數字:
```python=
l = [12,23,34,56,78]
print(l)
l = l+[33,44]
print(l)
#output:
#[12, 23, 34, 56, 78]
#[12, 23, 34, 56, 78, 33, 44]
```
---
### 減法:
```python=
x=5
x=x-7(從右邊運算回來左邊)
print(x)
#output:-2
```
---
### 乘法:
```python=
s = "rero!"
ss = s * 3
print(ss)
#output:rero!rero!rero!
```
段落內的字增加一倍:
```python=
l = [12,23,34,56,78]
print(l)
l = l*2
print(l)
#output:
#[12,23,34,56,78]
#[12,23,34,56,78,12,23,34,56,78]
```
---
### 除法:/、//(取整數)
```python=
a=7.0/2.0
print(a)
#答案:3.5
#(此處必須加小數點，**因有整數除整數獲得整數的設計**)
a=7.0//2.0
print(a)
#答案:3.0
#(注意此處是3.0，**保留取整數的設計**)
```
---
### 次方(1):**
```python=
a=2**3(2的三次方)
print(a)
#答案:8
```
### 次方(2):pow()(或以上次方)
```python=
s=pow(4,3)(4的3次方，逗號記得半形，後面的三代表三次方)
print(s)
#答案:64
```
---
### 開根號:pow(X,0.5)
```python=
s=pow(64,0.5)(64開根號，逗號記得半形)
print(s)
#答案:8.0
```
---
## 無函式的操作及較難公式
---
### 交換位置:swap(僅限中括號，小括號無法更動)
```python=
a=[123,234,1,2,3]
a[4],a[0]=a[0],a[4]
print(a)
#答案:a=[3,234,1,2,123]
```
C++的解法:
```cpp=
#include <iostream>
using namespace std;
int main()
{
int a[5] = {123,234,1,2,3};
int x = a[0];
a[0] = a[4];
a[4] = x;
for(int i=0;i<5;i++) cout<<a[i]<<' ';
}
//答案:a=[3,234,1,2,123]
```
---
### 直接取得列表的最後一個數值(print(x[-1])
在我們不知道該列表有多長的情況下，我們可以在編號輸出-1，電腦會幫我們自動選擇該列表的最後一個數字
```python=
x = ['Thriller', 'Billie Jean', 'Beat It']
print(x[-1]) #(外面小括號裡面中括號)
#答案:Beat It
```
---
### 刪除某個(段)元素
```python=
l = [12,23,34,56,78]
# 0 1 2 3 4
print(l)
l[1:3]=[]
print(l)
#output:
#[12, 23, 34, 56, 78]
#[12, 56, 78]
```
刪除了編號1到編號3(的前一格)
刪除單個選項的話:
```python=
l = [12,23,34,56,78]
# 0 1 2 3 4
print(l)
l[2:3]=[]#(後面數字為前者加一)
print(l)
#答案:[12,23,56,78]
```
這個函式不管打英文或數字，**不能只填一個數去刪除一個指定的位置**，一定要打兩個數字
**再行更改的話，必須把立場放在最新的答案中**
(續上題)
```python=
l=[12,23,56,78]
# 0 1 2 3
print[2:3]=[]
print(l)
#答案:[12,23,78]
```
---
### 修改某索引的元素值
如果必須修改列表中的某幾個位置，可以直接輸入x[0]=某數
必須注意!!這樣會**直接蓋掉原本的值**。如果要增加更改的數值，可以輸入在l[0] = 69之下再行更改
```python=
l = [12,23,34,56,78]
print(l)
l[0] = 69
print(l)
#答案:[12, 23, 34, 56, 78]
# [69, 23, 34, 56, 78]
```
此則函式也是一樣，要打英文的話必須指定兩個數字的位置，**或者，直接輸入"英文"，不要在增加中括號**
---
### 多層列表
列表裡面放列表，取值的話就用兩個[]，例子如下:
```python=
l = [[123,456,789],[234,567,890]]
# 0 1
# 0 1 2
print(l)
#第一段 全印
print(l[0])
#第二段，先看最外面的中括號，並對應第一個井字號，得出答案
print(l[0][2]) 注意此處無:的號，必須照著數字取樣
#第三段，取第二段[0]的格子，對應第二個井字號，取出編號2的數字，得出答案
#output:
#[[123, 456, 789], [234, 567, 890]]
#[123, 456, 789]
#789
```
小題目:
```python=
l = [[123,456,789],[234,567,890]]
l[0][0:2] = [5,5,5]
print(l[0])
答案:(5,5,5,789)
```
第二行解釋:把前半段的第0項[0]跟第1項[0:2]刪去並**改成5,5,5**
---
### 費式數列
```python=
nterms = int(input("How many terms? "))
#輸入我們要取費式數列的第幾位，從1開始
n1, n2 = 0, 1#指定該數列的第一(0)位跟第二(1)位為0跟1，費是數列都是先從0跟1開始。
count = 0#**從0開始**，這樣就不用換算成程式的位置，我們想讓程式輸出多少個數字一目了然，如果今天從1開始，我們輸入3，就只會出現兩個數字
if nterms <= 0:
print("Please enter a positive integer")
#如果我們輸出0，印出"請輸入正整數"。
elif nterms == 1:
print("Fibonacci sequence upto",nterms,":")
print(n1)#數列的第一(0)位跟第二(1)位已經被指定好，需印出n1得值，否則答案就只會輸出:Fibonacci sequence upto 1(nterms) :(":")
else:
print("Fibonacci sequence:")#例:輸入3，輸出Fibonacci sequence:
#0
#1
#1
#因為沒有強制不換行，所以輸出是分行的
while count < nterms:#當輸入的數字大於0
print(n1)#輸出0(n1)
nth = n1 + n2#第一波n1+n
n1 = n2
n2 = nth
count += 1
```
這則含式有個重點，我們一開始輸入1，會出現一個數字，輸入2出現兩個，以此類推，**不要跟python得從0開始搞混了**
---
## 迴圈
for 和 in 是迴圈的關鍵字，這兩個關鍵字**之間**會放我們自訂的變數(x)，而 in的後面則可接一個序列 (Sequence)，迴圈會依序從序列 (例如: 一連串清單資料，一組數字或一個名單) 裡按照順序取得元素，並將元素指派給前面自訂的變數(x)，然後執行迴圈裡的內容
---
### 按照順序印出或根據範圍大小印出(for x in x)
```python=
for i in x:
print(i)
```
例如，[1,2,3,4,5]此語法可建立1,2,3,4,5共五個元素，下面是一個使用 for-loop 將 list 中的序列性資料**逐一**列印出來的例子：
```python=
sequences = [0, 1, 2, 3, 4, 5]
for i in sequences:
print(i) print(sequences)
#答案:0 [0, 1, 2, 3, 4, 5]
# 1 [0, 1, 2, 3, 4, 5]
# 2 [0, 1, 2, 3, 4, 5]
# 3 [0, 1, 2, 3, 4, 5]
# 4 [0, 1, 2, 3, 4, 5]
# 5 [0, 1, 2, 3, 4, 5]
```
以下為文字型態:
```python=
theBeatles = ['John Lennon', 'Paul McCartney', 'Ringo Starr', 'George Harrison']
for beatle in theBeatles:
(i) (x)
print (beatle) print (theBeatles)
#答案:
#John Lennon ['John Lennon', 'Paul McCartney', 'Ringo Starr', 'George Harrison']
#Paul McCartney 以下省略三次
#Ringo Starr
#George Harrison
```
此項函式的作用是**遍歷序列中的元素，不用打每個序列就可以出現全部，可以用在print多個數量**。
一開始，電腦會先執行i=0的編號，執行完之後回去for i in sequences，在執行一次，這次是i=1，重複執行，直到數列結束，這個行為叫迴圈。
跟直接print sequence**不同的是**，直接印出來會把中括號印出來，結果是橫向的，並根據列表內的字元數印出相對的數量，**迴圈的話，答案會是直的。**(除非另加指令，後期會提到)
串列裡面可以是數字以外的文字，但必須放字串(")
如果不需要取某幾位(編號)(此方法也可適用於英文字串):
```python=
sequences = [ 1, 2, 3, 4, 5]
for i in sequences:
if i!=sequences[3]: #(冒號要打)(這裡代表i不等於sequences的編號第三位，出現False，不會印出來)
print(i)#(**記得在縮排一次**)
#答案:
#1
#2
#3
#5
```
---
### 有規定次數的迴圈 for x in range()
現在，有個狀況，我們必須印出hello一百次，我們該怎麼做呢:
```python=
sequences = "hello"
for i in range(100): (冒號記得)
print(sequences) (縮排)
#答案:hello
#下面省略99次
```
這邊要注意，我們要的是sequences的次數，如果我們在最下面指定print輸出i的話:
```python=
sequences = "hello"
for i in range(100):
print(i)
#答案:
#0
#1
#2
#3
.
.
.
#99
```
答案會是不同的，這邊輸出的是100個數字是hello的**編號**，而不是單純的0~99
---
### 建立整數(含遞增減 序列for x in range() print(x, end="")
在 Python 程式語言中，range()函式可以很有效率地協助我們創建一個整數序列，用法為 (起始值, 終止值, 遞增(減)值)，例如：
range(10)：產生從0到9的整數序列。
range(1, 11)：產生從1到10的整數序列(未指定遞增值的情況下，其遞增值預設為1)。
range(0, 10, 2)：產生從0, 2, 4, 6, **8**的整數序列(遞增值為2)。
利用range() 函式，可以很方便的建立出一個整數序列
純終點值:
```python=
for i in range(10):(最重要的冒號)
print(i, end=" ")
#答案:0 1 2 3 4 5 6 7 8 9
```
有起點與終點值:
```python=
for i in range(2,12):
print(i,end=" ")
#答案:2 3 4 5 6 7 8 9 10 11
```
含初始值、終點值、遞**減**值
```python=
for i in range(20, 2, -2):
print(i, end=" ")
#答案:20 18 16 14 12 10 8 6 4
```
---
### 巢狀迴圈
特性是在**迴圈裡面又包覆著其他的迴圈。**
內層迴圈只是外層迴圈內所要執行的一段程式敘述而已；因此外層迴圈每動作一次，內層迴圈就會把整個迴圈執行一遍，執行完畢後才跳回到外層迴圈準備下一次的動作。
前面所提到的單層迴圈適用於**單一控制變數的反覆計算**，這個控制變數的意義可以是迴圈執行的**次數**或是任意連續變化的物理量。
如果今天我們所要處理的問題具有**重複執行某段敘述的特性**，而且這些敘述受到**兩個 (或兩個以上) 的變數來分別控制其變化**，此時使用巢狀迴圈的技巧來撰寫功能需求會是最適合的方式。
九九乘法的資料共有九列九行資料，所以這是一個使用兩層巢狀迴圈結構來撰寫的良好案例：
```python=
for x in range(1, 10): #直向數據
for y in range(1, 10):#橫向數據
if y == 9:
print("\t", x*y) # y == 9時，換行
else:
print("\t", x*y, end = '') # y < 9時，不換行
答案:
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81
```
**這裡的\t為一個tab，用途是使每個數字之間都有適當的距離**。
**那end=""則是規定程式不要換行**
---
### 規則或不規則的迴圈結束(break 和 continue)
**規則**的結束方式是當迴圈的判斷條件不再符合時，迴圈自然結束。
而**不規則**的迴圈結束則是在迴圈自然結束前，我們已經得到想要的運算結果，利用強制中斷的方式來結束迴圈。
break：中斷迴圈的執行
continue：不會讓迴圈結束；只跳過迴圈內 continue 後面的剩餘敘述，接著繼續執行下一次的迴圈運作。它的目的是為了讓程式不執行迴圈結構內的某些敘述
以下為break的範例:(break函式無!=的使用)
```python=
for i in "Hey Jude":#(冒號)
if i == "u":#(冒號)(縮排)
break#(再縮一次)
print(i)#(縮排*1)
#答案:
#H
#e
#y
#j
```
以下為continue的範例:
```python=
for i in "hello world":
if i =="r":
continue
print(i)
#答案:
#h
#e
#l
#l
#o
#w
#o
#l
#d
```
如果使用(!=)
可看成與==完全相反的答案
```python=
for i in "hello world":
if i !="r":
continue
print(i)
#答案:
#r
```
---
### 重覆某些運算，出現指定的特殊狀況時才停止(while)
一般而言，for-loop(for x in) 比較適用在「已知迴圈數」的問題，而 while-loop 則適用在「無法預知迴圈數」的問題上。
while-loop 在執行其內部敘述之前，都會先檢查條件判斷式，如果**其判斷值為真 (True)，則執行迴圈內部的敘述**；**否則就結束 while-loop。**
若我們要產生一筆 1, 2, 3, …, 10 的序列，用 while-loop 可以這樣寫：
```python=
i = 1 #(起點數字1)
while i <= 10: #(加冒號)
print(i, end=" ")
i = i + 1
#答案:
#1 2 3 4 5 6 7 8 9 10
```
---
### 計算一個數列的加總
利用 while-loop 計算 1 加到 10 的和，並將每次累加之後的值列印出來：
```python=
sum = 0 #(紀錄累加的結果)
i = 1 #(數列的初始值)
while i <= 10:
sum = sum + i #(須注意是i,不是1) #(第一次運算:0+1=1，記錄到sum)
i = i + 1 #(這裡加一)
print(sum, end= " ") #(這邊不能縮排)
#答案:55
```
倒數兩行可直接寫作:print(sum)
如果打出end=""就必須加print()
其中，sum在這裡只是一個代詞，可換成任意字
**以下為使用for 的語法:**
```python=
t=0 #(累加的結果)
for i in range(1,11):
t=t+i
print(t)
#答案:55
```
---
### while與continue、break的合併使用
今天我們一樣要列出1~10的序列，但我們中間想忽略掉某數，該怎麼做:
```python=
i = 0
while i < 10: #(運算下來，i+1會等於10，所以無需輸入等於)
i = i + 1
if i == 4:
continue
print (i, end = " ")
#答案:
#1 2 3 5 6 7 8 9 10
```
這邊提供一個遞減的數列:(9~0並跳過4)
```python=
i = 10
while i > 0:
i = i - 1
if i == 4:
continue
print(i, end = " ")
#答案:
#9 8 7 6 5 3 2 1 0
```
---
### 階乘(2)第一個在引含式
```python=
v=int(input("請輸入"))
total=1
for i in range(1,v+1):
total=total*i #total一開始乘i的1，算到右邊的total
#設v=5
#1.1(t)*1(i)=1 total等於1
#2.1*2=2
#3.2*3=6
#4.6*4=24
#5.24*5=120
i=i+1
print(total)
#答案:120
```
---
### 字典裡的指定值迴圈(key)
這裡的答案跟dict.key的答案不一樣，這個答案純粹輸出key，無任何的小括號，而且換行排列:
```python=
f={"d":"h","aaaaaaa":"peko","幹":"粉紅jet"}
for i in f:
print(i)
#答案:
#d
#aaaaaaa
#幹
```
---
### 字典裡的指定值迴圈(2)(key,value)(for i,j in dict.items())
這個函式也跟dict.items()不一樣，而且key值跟value值中間會有空格，比較好查看:
```python=
f={"d":"h","aaaaaaa":"peko","幹":"粉紅jet"}
for i,j in f.items():
print(i,j)
#答案:
#d h
#aaaaaaa peko
#幹 粉紅jet
```
但這個函式有幾個需要注意的地方，因為key值跟value值式兩個變數，我們需要建立**兩個變數儲存它**，還有items**後面要加個裡面無東西的小括號**，才不會出現錯誤。
---
## 集合、字典的基本運算
dictionary 是一種較為複雜的資料結構，對於資料的查找很方便。
舉例來說，一部電影會有導演、演員、年份、得到的獎項等等資訊，如果要把資訊整合在一起、使寫程式時表示起來比較方便查詢時，我們就會使用 dictionary 來儲存與這部電影相關的資訊。
---
### 判斷某資料是否在集合中(元素 in 集合)or(元素 not in 集合)
```python=
s1 = {6,3,4,2,9} #注意是大括號
print(3 in s1) #這裡是小括號
print(87 in s1)
print(3 not in s1)
print(87 not in s1)
#output:
#True
#False
#False
#True
```
這邊有一個集合s1，我想知道3和87是否在集合中，所以用in這個語法去檢查。
3有，所以會輸出True
87不在集合中，所以會輸出False
not in 就是檢查3和87是否不在集合中
3是有在集合中的，所以"3不再集合中"這個敘述是錯誤的，因此輸出False
87確實不在集合中，因此輸出True
---
### 交集(&)(找出重複)
有時必須找出兩個集合的共通數字，此時第一次使用大括號以及&
```python=
s1 = {6,3,4,2,9}
s2 = {2,3,4,6,1}
s3 = s1&s2(&為取共通數字的符號)
print(s3)
#output:
#{2, 3, 4, 6}
```
明顯的，s1和s2交集(重複的元素)有2,3,4,6這四個元素。
---
### 反交集(^)(找出不重複)
找出兩個集合裡**沒重複**的數據:
```python=
s1 = {6,3,4,2,9}
s2 = {2,3,4,6,1}
s3 = s1 ^ s2
print(s3)
#output:
#{1, 9}
```
---
### 聯集(輸出全部但不重複)(|)
聯集(兩個集合中所有元素，**不會重複**)，聯集要用|這個語法。
```python=
s1 = {6,3,4,2,9}
s2 = {2,3,4,6,1}
s3 = s1|s2
print(s3)
#output:
#{1, 2, 3, 4, 6, 9}
```
適合使用在需快速排列兩串數字的排序及大小
---
### 差集(從s1中刪去**和s2重複**的元素)(-)
**從s1中刪去*和s2重複*的元素**
必這邊可以看到s1和s2重複的元素有2,3,4,6，因此s1和s2做差集的運算後會得到~~6~~,~~3~~,~~4~~,~~2~~,9，只剩下{9}，
```python=
s1 = {6,3,4,2,9}
s2 = {2,3,4,6,1}
s3 = s1 - s2
print(s3)
#output:
#{9}
```
---
### 指定輸出全部key值(dict.keys())
```python=
d={"carpenter":"wood",'評偉':'你在大聲甚麼拉', '國棟': 'aaaaaaa'}
print(d.keys())#須注意key要加s，不管你有幾個key值
#答案:dict_keys(['carpenter', '評偉', '國棟'])
#答案輸出前面會自動出現dict_keys
```
此方法可以使用迴圈完成，地點在迴圈方格裡
---
### 指定輸出全部value值(dict.values())
有key就會有value值，重點跟上則函式一樣
```python=
d={"carpenter":"wood",'評偉':'你在大聲甚麼拉', '國棟': 'aaaaaaa'}
print(d.values())
#答案:dict_values(['wood', '你在大聲甚麼拉', 'aaaaaaa'])
```
此方法不可以使用迴圈完成
---
### 印出字典裡所有元素(集合名.items())
需要注意的是，這個跟直接print集合名不一樣，此則函式輸出的會是由**小括號框起來**的答案，開頭還會幫你輸出dict_items，適合快速查看key值跟value值關聯
```python=
d={"carpenter":"wood",'評偉':'你在大聲甚麼拉', '國棟': 'aaaaaaa'}
print(d.items())
#答案:dict_items([('carpenter', 'wood'), ('評偉', '你在大聲甚麼拉'), ('國棟', 'aaaaaaa')])
```
此方法可以使用迴圈完成，地點在迴圈空格裡
---
### 輸出指定value值(集合名[key值])
寫法:字典名={“key1值” : “key1值對應到的值”,“key2值” : “key2值對應到的值”,…}
對應到的值可能是字串、整數…等等，不一定只是數字。
(**對應值、KEY值除數字外，都必須加"變字串**)
```python=
d = {"ahoy!":"寶鐘瑪琳","peko!":"兔田配可拉","A":"噶嗚·古拉"}#(注意字串)
print(d["A"])#(中間是中括號)
#output:
#噶嗚·古拉
```
印出d裡面"A"對應到的值，輸出噶嗚·古拉
輸入對應值，不會出現KEY值，**會出現錯誤**
---
### 輸入錯誤key值並避免出現錯誤(或指定)訊息(list.get("錯誤key"))
```python=
d = {"ahoy!":"寶鐘瑪琳","peko!":"兔田配可拉","A":"噶嗚·古拉"}
print(d.get("幹"))#這邊有個重點，外部跟內部的括號都是小括號
#output:none
```
那如果今天我們需要輸出指定的字呢，很簡單，只需要在錯誤的KEY值後面加個逗號並輸入指定的字樣就好。
```python=
d = {"ahoy!":"寶鐘瑪琳","peko!":"兔田配可拉","A":"噶嗚·古拉"}
print(d.get("幹","你好"))
#答案:你好
```
同樣的方法也運用在宣告得回傳值中
---
### 在字典中新增新的key值跟value值(原集合名[新增的key值]=新增的value值)(少數)
當今天字典需要增加一些元素時，不需要像其他含式一樣在下面撰寫過多的code，只需要直接在集合後面寫key跟=value就可以了，非常的快速跟簡單。
```python=
movie_1 = {'name': 'Saving Private Ryan','year': 1998,'director': 'Steven Spielberg'}
movie_1['star'] = "Tom Hank"
print(movie_1)
#答案:{'name': 'Saving Private Ryan', 'year': 1998, 'director': 'Steven Spielberg', 'star': 'Tom Hank'}
```
---
### 在字典中新增新的key值跟value值(多數)(original_dict.update(new_dict)
今天我們需要快速合併兩個字典，我們可以使用update這個函式
```python=
h={"name":"hi","a":"gura","gp":"ame"}
g={"polite":"ahoy","評偉":"你在大聲甚麼拉","國棟":"aaaaaaa"}
h.update(g)#注意後面有一個點
print(h)
#答案:{'name': 'hi', 'a': 'gura', 'gp': 'ame', 'polite': 'ahoy', '評偉': '你在大聲甚麼拉', '國棟': 'aaaaaaa'}
```
在h.update那一行，誰放在前面，**輸出的時候就會在前面**，print也是印**前面的字典名**
---
### 判斷字典中是否存在某key值(in / not in)
這裡只能判斷KEY值，不能判斷對應值
```python=
d = {"ahoy!":"寶鐘瑪琳","peko!":"兔田配可拉","A":"噶嗚·古拉"}
print("peko!" in d)
print("Watame" in d)
print("寶鐘瑪琳" in d)#(不能判斷對應值，出現false)
#output:
#True
#False
#False
```
尋找是否有key值為寶鐘瑪琳，會發現雖然有對應到的值裡面有寶鐘瑪琳，但是key值中並沒有，因此輸出False
---
### 判斷兩個字典的相同相異(==，!=，is)
再分辨兩個字典的差異時，需要注意，前面兩者(==，!=)是不會在乎順序的，如果**key值跟value值互相對應都是一模一樣**，**但順序不同**，輸出還會是**True**
但第三個函式(is)就會看順序了，兩個字串必須一模一樣才會輸出True，下面演示兩個不同的函示:
```python=
d={"carpenter":"wood",'評偉':'你在大聲甚麼拉', '國棟': 'aaaaaaa'}
h={'評偉':'你在大聲甚麼拉',"carpenter":"wood", '國棟': 'aaaaaaa'}
print(d==h)
print(d!=h)
#答案:
#True
#False
```
上面是== !=的輸出答案
下面給is的輸出答案，但我在輸出的時候發現字典不管怎麼改都是false，只有單個字串("l","p")的時候才會出現true，等我考證。
```python=
d={"carpenter":"wood",'評偉':'你在大聲甚麼拉', '國棟': 'aaaaaaa'}
h={'評偉':'你在大聲甚麼拉',"carpenter":"wood", '國棟': 'aaaaaaa'}
print(d is h)
#答案:False
```
---
### 刪除字典中元素(del 字典名稱[“key值”])
```python=
d = {"ahoy!":"寶鐘瑪琳","peko!":"兔田配可拉","A":"噶嗚·古拉"}
print(d)
del d["peko!"]#這裡為中括號
print(d)
#output:
#{'ahoy!': '寶鐘瑪琳', 'peko!': '兔田配可拉', 'A': '噶嗚·古拉'}
#{'ahoy!': '寶鐘瑪琳', 'A': '噶嗚·古拉'}
```
同樣只能刪除key值，對應值會連同被刪，如果想刪除兩段，需在del d["peko!"]下再增加一段
---
### 刪除字典中的元素並回傳該key值的value(dict.pop(欲刪除的key值))
跟上面的函式不太一樣的事，此則函式會回傳我們刪除的值，此種用法可避免我們忘記我們刪除甚麼，非常好用
```python=
g={"polite":"ahoy","評偉":"你在大聲甚麼拉","國棟":"aaaaaaa"}
y=g.pop("polite")
print(g)#g字典的元素已經被刪掉
print(y)#為y(g集合中被刪掉的value)值
#答案:{'評偉': '你在大聲甚麼拉', '國棟': 'aaaaaaa'}
#ahoy
```
---
### 字典生成式(字典名稱 = 變數 : 變數 for 變數 in 列表)
```python=
d = {i:i*i for i in [2,3,4]}
print(d)
#output:
#{2: 4, 3: 9, 4: 16}
```
從右邊開始看(for i in [2,3,4])，意思是i分別入2,3,4進去，使用迴圈(for i in)，就會變成2:2x2 , 3:3x3 , 4:4x4
---
### 字典生成式(2)(dict[l]=l*2)
此方法也是使用迴圈來建立字典，但比較不一樣的事此則是建立在較複雜的迴圈裡面，較推薦上面的函式，下面是建立的函式:
```python=
d = {}
for i in range(6):
d[i] = i*2#讓電腦輸出i=0,1,2,3,4,5，然後value對應前面六個數字，得出結果
print(d)
#答案:
#{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10}
```
可以將上面的答案更詳細化:
```python=
for i in d:
print("key is",i,"value is ",d[i])
#答案:
#{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10}
#key is 0 value is 0
#key is 1 value is 2
#key is 2 value is 4
#key is 3 value is 6
#key is 4 value is 8
#key is 5 value is 10
```
---
## 排序(sorted)
有時候我們需要對我們所擁有的資料進行排序，以便後續的查找以及使用。和其他語言可能**需要自己寫一個排序演算法不同**，Python 提供了幾個便捷的函式供大家使用。**list.sort()** 以及 **sorted()**，兩者的差別在於，前者需要額外多一行含式:
```python=
l=["apple","ant","banana","zoo","nurse"]
l.sort()
print(l)
#答案:
#['ant', 'apple', 'banana', 'nurse', 'zoo']
```
至於sorted的部分只需直接印出來就好:
```python=
l=["apple","ant","banana","zoo","nurse"]
print(sorted(l))
#答案:
#['ant', 'apple', 'banana', 'nurse', 'zoo']
```
這邊讓我們從 sorted() 的用法開始，官方文件上面的使用方法介紹如下：
```python=
sorted(串列名稱, reverse=False, key=rule_fn)
```
sorted() 有三個參數，第一個參數是要排序的串列名稱，要注意的地方是，電腦無法判斷整數與字串之間的優先順序，因此，我們要用來**排序的串列內容**必須都是相**同型態的元素**。
第二個參數則是**是否要反轉 reverse**，預設是 False。簡單來說，假如今天我們要排序的是一個整數串列， **reverse=False** 的意思就是由**小到大排**，反之，當 reverse=**True** 時則代表這個串列要由**大到小排**。
而最後一個參數則是 key ，就是指我們所要用來排序的規則。當串列是一個數字串列時（意即元素型態皆為 int 或是 float 這類的數值型態），預設的規則就是依照**數值大小進行排序**；而當串列的元素都是字串 str 時，預設的規則是**字母順序**，也就是英文字典的排序規則。
需要注意的是，reverse跟key都有**內建的參數**，並且中間都以**逗號間隔**，reverse內建為從小到大，如果有**特別指定再行設定即可**。
---
### (未)設定的sorted(正序)(sorted(list))
以下為數字版，未經設定就是由小到大:
注意!!一開始的list為中括號，要sorted的時候要用小括號圈住需要分類的list名
```python=
c=[1,5,3,8,6]
c=sorted(c)
print(c)
#答案:
#[1, 3, 5, 6, 8]
```
由大到小:
```python=
d=[1,5,3,8,6]
d=sorted(d,reverse=True)
print(d)
#答案:
#[8, 6, 5, 3, 1]
```
英文版:
```python=
s=["zebra","banana","cook","gym"]
s=sorted(s,reverse=True)
print(s)
#答案:
#['zebra', 'gym', 'cook', 'banana']
```
---
### **字典**的key值排序
字典一樣比較特殊，我們排序該字典的key值，有時候我們會希望**依照特定的順序來取用字典中的內容**，這個就很有幫助。
舉一個字典來說:
```python=
c={"2017":"haha","2016":"cacac","2015":"lplp","2014":"gygy"}
g=sorted(c)#也可以輸入print(sorted(c.keys()))
print(g)
#答案:
#['2014', '2015', '2016', '2017']
```
為甚麼這裡不能輸入c=keys()呢?因為sorted內定是有順序的，我們直接輸入c=keys()的話電腦就會照順序輸出出來，必須注意。
可以看見我們讓它排序key值，value值一樣也可以單獨被輸出，我們利用**迴圈**把key值跟value值一起輸出:
```python=
c={"2017":"haha","2016":"cacac","2015":"lplp","2014":"gygy"}
for i in sorted(c):
print(i,":",c[i])#裡面c[i]為中刮號，同時逗號可換成加號
#答案:
#2014 : gygy
#2015 : lplp
#2016 : cacac
#2017 : haha
```
---
### 字典的value值排序
```python=
c={"2017":"haha","2016":"cacac","2015":"lplp","2014":"gygy"}
print(sorted(c.values()))#全部都是小括號，需要注意
#答案:
#['cacac', 'gygy', 'haha', 'lplp']
```
當你要倒轉時，可以把他們寫在一起節省空間:
```python=
c={"2017":"haha","2016":"cacac","2015":"lplp","2014":"gygy"}
print(sorted(c.values(),reverse=True))
#答案:['lplp', 'haha', 'gygy', 'cacac']
```
---
## sorted的key指令
---
### 對字典的key值測量長度(key=xxxx)
串列名稱, reverse=False 都已經簡單介紹過了，現在就是重頭戲:key=xxx，舉個簡單的例子:
```python=
c={"2017333":"haha","20163":"cacac","201111115":"lplp","20178794":"gygy"}
c=sorted(c,key=len)
print(c)
#答案:
#['20163', '2017333', '20178794', '201111115']
```
key=len的意思是依照c字典裡的key值下去比照長度大小，可以看見大小順序為5、7、8、9位數
我們得到了一個由小到大，依照字串長度進行排序的串列。在 sorted() 函數當中，我們會稱呼 key 後面的函數為 key function ，也就是排序依據的函數。當 sorted() 與 key function 搭配使用， sorted() 將會把所要排序的標的串列當中的元素一個一個丟進 key function 當中，然後得到和串列元素一樣多的回傳值，再根據這些回傳值，對原串列進行排序。
---
### value的排序，同時輸出對應的key值(x.items(),key=lambda x:x[1])
```python=
c= {"2017": "The Shape of Water", "2016": "Moonlight", "2014": "Birdman", "2015": "Spotlight"}
print(sorted(c.items(),key=lambda x:x[1]))#其後的x:x[1]的x可隨意調換
#答案:
#[('2014', 'Birdman'), ('2016', 'Moonlight'), ('2015', 'Spotlight'), ('2017', 'The Shape of Water')]
```
---
### 依照字串長度進行排序(list,key=len)
依照單字的長度進行排列，而不是取首個字母，須注意:
```python=
mylist = ["pen", "papper", "pineapple", "applepens", "apple"]
print(sorted(mylist, key = len))
#答案:
#['pen', 'apple', 'pineapple', 'pineapple', 'applepens']
```
上則函式我們可以發現到，pineapple跟applepens是同樣長度，電腦依照我們優先輸入哪一個單字下去做排列，如果我們希望相同長度的字串也要進行排列，我們應該要怎麼做呢?
**(跳到宣告欄位，對相同長度的字串以首字母進行排列)**
Sign in with Wallet
Connect another wallet