python入門教程二、

python對象的相關術語：

python程序中保存的全部數據都是圍繞對象這個概念展開的：

• 程序中存儲的全部數據都是對象
• 每一個對象都有一個身份、一個類型和一個值

　　　　例如，school='MaGe Linux'會以'MaGe Linux'建立一個字符串對象，其身份是指向它在內存中所處位置的指針(其在內存中的地址),而school就是引用這個具體位置的名稱

• 對象的類型也稱對象的類別，用於描述對象的內部表示及它支持的方法和操做
• 建立特定類型的對象時，有時也將該對象稱爲該類型的實例
• 實例被建立後，其身份和類型就不可改變

　　　　若是對象的值是可修改的，則稱爲可變對象
　　　　若是對象的值不可修改，則稱爲不可變對象

• 若是某個對象包含對其餘對象的引用，則將其稱爲容器
• 大多數對象都擁有大量特有的數據屬性和方法

　　　　屬性：與對象相關的值
　　　　方法：被調用時將在對象上執行某些操做的函數
　　　　使用點(.)運算符能夠訪問屬性和方法

對象的身份與類型：
python內置函數id()可返回一個對象的身份，即該對象在內存中的位置

• is 運算符用於比較兩個對象的身份
• type() 用於返回一個對象的類型
• 對象類型自己也是一個對象，稱爲對象的類

　　　　(1)該對象的定義是惟一的，且對於某類型的全部實例都是相同的
　　　　(2)全部類型對象都有一個指定的名稱，可用於執行類型檢查,如list、dict

示例：
>>> num1 = 5
>>> num2 = 5
>>> num1 == num2 #值比較
>>> True

>>> id(num1)     #內存中的地址
9119808
>>> id(num2)
9119808

>>> num1 is num2 #身份比較
True

>>> type(num1) is type(num2) #類型比較
True

運算符　

1、算數運算：

2、比較運算：

3、賦值運算：

4、邏輯運算：

5、成員運算：

6、身份運算：

7、位運算：

1byte = 8bit

2**8     2**7     2**6    2**5    2**4    2**3    2**2    2**1    2**0

256       128        64        32        16        8          4         2         1

如下實例演示了Python全部位運算符的操做：

  View Code

8、運算符優先級：

更多內容：猛擊這裏

數據類型

核心數據類型：

• 數字：int, long(python3.5已經沒有), float, complex, bool
• 字符：str, unicode
• 列表：list
• 字典：dict
• 元組：tuple
• 集合：set(可變集合),frozenset(不可變集合)
• 文件：file

數字類型：

python的數字字面量：整數，布爾型，浮點數，複數，全部數字類型均爲不可變

int（整型）

　　在32位機器上，整數的位數爲32位，取值範圍爲-2**31～2**31-1，即-2147483648～2147483647
　　在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807

bool(布爾型)

　   真或假

　　1 或 0

float(浮點型)

數字操做：+ , -, *, /, //, **, %, -x, +x

附上源碼：

  View Code

序列類型： 　　

　　序列表示索引爲非負整數的有序對象集合，包括字符串、列表和元組
　　　　字符串是字符的
　　　　列表和元組是任意python對象的序列
　　字符和元組屬於不可變序列，而列表則支持插入、刪除和替換元素等
　　全部序列都支持迭代

序列操做總結：(固然元組是不可變對象,對元素的操做是不支持的,固然了有嵌套列表字典是能夠操做的)

• s + r      鏈接
• s * n     重複s的n次複製
• v1,v2...vn = s     變量解包(unpack)
• s[i]         索引
• s[i:j]                  切片
• s[i:j:stride]         擴展切片
• x in s,x not in s   成員關係
• for x in s:           迭代
• all(s)      若是s中的全部項都爲True，則返回True
• any(s)    若是s中的任意項爲True，則返回True
• len(s)     長度,元素個數
• min(s)    s中的最小項
• max(s)   s中的最大項
• sum(s [,initial])    具備可選初始值的項的和
• del s[i]     刪除一個元素
• del s[i:j]   刪除一個切片
• del s[i:j:stride]    刪除一個擴展切片

字符類型：不可變對象

字符串字面量：把文本放入單引號、雙引號或三引號中，python2.x默認不是國際字符集unicode，須要unicode定義時加上u,python3無需加

>>> str1 = u'hello world'
>>> type(str1)
unicode

文檔字串：模塊、類或函數的第一條語句是一個字符的話，該字符串就成爲文檔字符串，可使用__doc__屬性引用

>>> def printName():
       'test function'
       print('hello world')

>>> printName.__doc__

適用於字符串經常使用方法：

str.capitalize()    將字符串的首字母變大寫
str.title()         將字符串中的每一個單詞的首字母大寫
str.upper()         將字符串變成大寫
str.lower()         將字符串變成小寫
str.index()         找出索引對應的字符串
str.find()          同上
str.count()         找出字符串中元素出現的次數
str.format()        也是格式化的一種
str.center()        以什麼字符從字符串兩邊填充
str.join()          以str爲分隔符鏈接字符串
str.split()         以什麼爲分隔符分隔字符串
str.strip()         將字符串兩邊中的空格去掉
str.replace()       查找替換
str.isupper()       判斷是否爲大寫
str.islower()       判斷是否爲小寫
str.isalnum()       判斷是不是字母數字
str.isalpha()       判斷是不是字母下劃線
str.isdigit()       判斷是不是數字
str.isspace()       判斷是否爲空
str.startswith()    找出以什麼爲開頭的字符元素
str.endswith()      找出以什麼爲結尾的字符元素

 附上源碼：

  View Code

列表類型：可變對象

表達式符號：[]

建立列表：

name_list = ['alex', 'seven', 'eric']
或
name_list ＝ list(['alex', 'seven', 'eric'])

容器類型
　　任意對象的有序集合，經過索引訪問其中的元素，可變對象
　　異構混合類型，能夠任意嵌套其它類型

支持在原處修改：
　　修改指定的索引元素，修改指定的分片，刪除語句，類的內置方法

 

適用於列表經常使用方法：

list.insert() 在列表中指定索引位置前插入元素
list.append() 在列表尾部插入
list.remove() 刪除指定的元素
list.pop() 沒有指定索引，則彈出最後一個元素，返回的結果是彈出的索引對應的元素
list.copy() 淺複製,只會複製第一層,若是有嵌套序列則不會複製,若是須要複製則要導入copy模塊
list.extend() 把另一個列表合併，並非追加
list.index() 列表中元素出現的索引位置
list.count() 統計列表中元素的次數
list.reverse() 進行逆序
list.sort() 進行排序,python3沒法把數字和字符串一塊兒排序
l1 + l2 :  合併兩個列表，返回一個新的列表，不會修改原列表
l1 * N :   把l1重複N次，返回一個新列表

 附上源碼：

  View Code

 

#經過索引來修改元素

>>> print(l2)
[1, 2, 3, 4, 5]

>>> l2[1] = 32

>>> print(l2)
[1, 32, 3, 4, 5]

>>> l2[3] = 'xyz'

>>> print(l2)
[1, 32, 3, 'xyz', 5]

>>> print(l1)
[1, 2, 3]

>>> l1[1:] = ['m','n','r']

>>> print(l1)
[1,'m','n','r']

#經過分片進行刪除

>>> l2[1:3]
[32, 3]

>>> l2[1:3] = []

>>> print(l2)
[1, 'xyz', 5]

#經過內置的函數進行刪除

>>> del(l2[1:])

>>> print(l2)
[1]

#經過列表類中的方法進行增刪改

>>> l3 = [1,2,3,4,5,6]

>>> l3.append(77)

>>> print(l3)
[1, 2, 3, 4, 5, 6, 77]

>>> l4 = ['x','y','z']

>>> l3.append(l4)

>>> print(l3)
[1, 2, 3, 4, 5, 6, 77, ['x', 'y', 'z']]

#變量解包

>>> l1,l2 = [[1,'x','y'],[2,'z','r']]

>>> print(l1)
[1, 'x', 'y']

>>> type(l1)

>>> print(l2)
[2, 'z', 'r']

 #找到列表中的元素並修改

tomcat@node:~/scripts$ cat b.py 
name = [1,2,3,4,5,1,5,6]
if 1 in name:
    num_of_ele = name.count(1)
    position_of_ele = name.index(1)
    name[position_of_ele] = 888
    print(name)

tomcat@node:~/scripts$ python b.py 
[888, 2, 3, 4, 5, 1, 5, 6]

 #找到列表中的元素並批量修改

tomcat@node:~/scripts$ cat b.py 
name = [1,2,3,4,5,1,5,6]

for i in range(name.count(1)):
    ele_index = name.index(1)
    name[ele_index] = 8888888
print(name)
tomcat@node:~/scripts$ python b.py 
[8888888, 2, 3, 4, 5, 8888888, 5, 6]

元組類型：不可變對象

表達式符號：()

建立元組：

ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))

容器類型

　　任意對象的有序集合，經過索引訪問其中的元素，不可變對象
　　異構混合類型，能夠任意嵌套其它類型
　　雖然元組自己不可變，但若是元組內嵌套了可變類型的元素，那麼此類元素的修改不會返回新元組

　　(): 空元組
　　(1,): 單個元組須要尾部加上逗號，若是元素是數字沒有加逗號則不是元組
　　(1,2): 多元素元組
　　1,2,3,4: 在定義變量時沒有加上小括號，默認是元組，最好不建議使用

適用於元組經常使用方法：

tuple.count() 統計元組中元素的個數
tuple.index() 找出元組中元素的索引位置

 

#在沒有嵌套的狀況，元組是不可變對象，可是在嵌套了列表，列表是可變的

>>> t5 = ('x',[1,2,3,4])

>>> print t5
('x', [1, 2, 3, 4])

>>> t5[1].pop()
4

>>> print(t5)
('x', [1, 2, 3])

#元組解包

>>> t1,t2 = ((1,2,3,4,5,'xy'),('s','y','w'))

>>> print(t1)
(1, 2, 3, 4, 5, 'xy')

>>> type(t1)
tuple

>>> print(t2)
('s', 'y', 'w')

字典類型：dict 可變對象

表達式符號：{}

建立字典：

person = {"name": "tomcat", 'age': 18}
或
person = dict({"name": "tomcat", 'age': 18})

　　字典在其餘編程語言中又稱做關聯數組或散列表
　　經過鍵(key)實現元素存取，無序的，可變類型容器，長度可變，異構，嵌套

　　{}: 空字典
　　{'x':32,'y':[1,2,3,4]}

兩種遍歷字典方法：

第一種：
for k,v in dict.items():
    print(k,v)


第二種：高效
for key in dict:
    print(key,dict[key])

適用於字典經常使用方法：

dict.get(key)      取得某個key的value
dict.has_key(key)  判斷字典是否有這個key,在python3中已經廢除,使用in 判斷
dict.keys()        返回全部的key爲一個列表
dict.values()      返回全部的value爲一個列表
dict.items()       將字典的鍵值拆成元組，所有元組組成一個列表
dict.pop(key)      彈出某個key-value
dict.popitem()     隨機彈出key-value
dict.clear()       清除字典中全部元素
dict.copy()        字典複製，d2 = d1.copy(),是淺複製,若是深複製須要copy模塊
dict.fromkeys(S)   生成一個新字典
dict.update(key)   將一個字典合併到當前字典中
dict.iteritems()   生成key-value迭代器，能夠用next()取下個key-value
dict.iterkeys()    生成key迭代器
dict.itervalues()  生成values迭代器

 附上源碼：

  View Code

 

#字典也支持索引的方式獲取,只不過key是他的索引了

>>> d1 = {'x':32,'y':[1,2,3,4]}

>>> d1['x']
32

>>> d1['y']
[1, 2, 3, 4]

>>> d1['y'][3:]
[4]

>>> len(d1)
2

#變量解包1

>>> d1.items()
[('y', [1, 2, 3, 4]), ('x', 32)]

>>> t1,t2 = d1.items()

>>> print(t1)
('y', [1, 2, 3, 4])

>>> print(t2)
('x', 32)

#變量解包2

>>> d3,d4 = {'x':32,'y':80}

>>> print(d3)
y

>>> print(d4)
x

#合併字典，可是在有相同的key時會覆蓋原有的key的值

>>> d1 = {'x':1,'y':2}

>>> d2 = {'m':21,'n':76,'y':44}

>>> d1.update(d2)

>>> print(d1)
{'y': 44, 'x': 1, 'm': 21, 'n': 76}

集合類型：set()可變對象,frozenset()不可變對象

表達式符號：{}

建立集合：

s = {"tom","cat","name","error"}
或
s = set({"tom","cat","name","error"})

集合是一組無序排序的可哈希hash的值,不重複
　　支持集合關係測試:
　　支持成員關係測試：in , not in
　　支持迭代

　　不支持：索引、元素獲取、切片

　　{"a",123,"b"}或者set()空集合

沒有特定語法格式，只能經過工廠函數建立set，像字符串則直接建立便可
set集合必須中的元素必須是可迭代對象,全部元素不會重複,不像list列表是能夠重複

集合運算符：

s | t   s和t的並集
s & t   s和t的交集
s - t   求差集
s ^ t   求對稱差集
len(s)  集合中項數
max(s)  最大值
min(s)  最小值    

適用於可變集合經常使用方法：

s.add(item)     將item添加到s中。若是item已經在s中，則無任何效果
s.remove(item)  從s中刪除item。若是item不是s的成員，則引起KeyError異常
s.discard(item) 從s中刪除item.若是item不是s的成員，則無任何效果
s.pop()         隨機刪除一個任意集合元素，並將其從s刪除,若是有變量接收則會接收到刪除到的那個元素
s.clear()       刪除s中的全部元素
s.copy()        淺複製
s.update(t)     將t中的全部元素添加到s中。t能夠是另外一個集合、一個序列或者支持迭代的任意對象

s.union(t)        求並集。返回全部在s和t中的元素
s.intersection(t) 求交集。返回全部同時在s和t中的都有的元素
s.intersection_update(t)   計算s與t的交集，並將結果放入s
s.difference(t)            求差集。返回全部在set中，但不在t中的元素
s.difference_update(t)     從s中刪除同時也在t中的全部元素
s.symmetric_difference(t)  求對稱差集。返回全部s中沒有t中的元素和t中沒有s中的元素組成的集合
s.sysmmetric_difference_update(t) 計算s與t的對稱差集，並將結果放入s

s.isdisjoint(t)   若是s和t沒有相同項，則返回True
s.issubset(t)     若是s是t的一個子集，則返回True
s.issuperset(t)   若是s是t的一個超集，則返回True

 附上源碼：

  View Code

 

不可變集合：
help(frozenset)

 

練習：尋找差別

# 數據庫中原有
old_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }
}
# cmdb 新彙報的數據
new_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },
    "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }
}
old_set=set(old_dict)
new_set=set(new_dict)
 
del_set=old_set.difference(new_set)
add_set=new_set.difference(old_set)
flush_set=old_set.intersection(new_set)
 
for i in del_set:
    old_dict.pop(i)
 
for i in add_set:
    old_dict[i]=new_dict[i]
 
for i in flush_set:
    old_dict[i] = new_dict[i]
print(old_dict)

  View Code

深拷貝淺拷貝

　　拷貝意味着對數據從新複製一份，對於拷貝有兩種深拷貝，淺拷貝兩種拷貝，不一樣的拷貝有不一樣的效果。拷貝操做對於基本數據結構須要分兩類進行考慮，一類是字符串和數字，另外一類是列表、字典等。若是要進行拷貝的操做話，要import copy。

一、數字和字符串　　

　　對於數字和字符串而言，深拷貝，淺拷貝沒有什麼區別，由於對於數字數字和字符串一旦建立便不能被修改，假如對於字符串進行替代操做，只會在內存中從新生產一個字符串，而對於原字符串，並無改變，基於這點，深拷貝和淺拷貝對於數字和字符串沒有什麼區別，下面從代碼裏面說明這一點。

import copy
s='abc'
print(s.replace('c','222'))         # 打印出 ab222
print(s)                            # s='abc' s並無被修改
s1=copy.deepcopy(s)
s2=copy.copy(s)
 
#能夠看出下面的值和地址都同樣，因此對於字符串和數字，深淺拷貝不同，數字和字符串同樣就不演示了，你們能夠去試一下
print(s,id(s2))                     # abc 1995006649768
print(s1,id(s2))                    # abc 1995006649768
print(s2,id(s2))                    # abc 1995006649768

二、字典、列表等數據結構　　

對於字典、列表等數據結構，深拷貝和淺拷貝有區別，從字面上來講，能夠看出深拷貝能夠徹底拷貝，淺拷貝則沒有徹底拷貝，下面先從內存地址分別來講明，假設 n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}。

　　　　　　　　淺拷貝在內存中只額外建立第一層數據　　　　　　　　　　　　　　　　　深拷貝在內存中將全部的數據從新建立一份

　　　　 

下面從代碼上來進行說明，copy.copy()與list.copy(),dict.copy()都屬於淺複製

import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2=copy.copy(n1)　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 # 淺拷貝
n3=copy.deepcopy(n1)　　　　　　　　　　　　　　　　　　　　　　　　　　　　# 深拷貝
print(n1,id(n1),id(n1['k1']),id(n1['k3']))
print(n2,id(n2),id(n2['k1']),id(n2['k3']))
print(n3,id(n3),id(n3['k1']),id(n3['k3']))
 
# 從下面打印的值結合上面的圖就能夠很好的理解，
# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713748822024 2713753080528 2713755115656　　　　　　
# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713755121416 2713753080528 2713755115656
# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713753267656 2713753080528 2713754905800

補充

一 、enumrate

　　爲一個可迭代的對象添加序號，可迭代的對象你能夠理解成能用for循環的就是可迭代的。默認是編號是從0開始，能夠設置從1開始

li = ["手機", "電腦", '鼠標墊', '遊艇']
for k, i in enumerate(li，1):
    print(k,i)
1 手機
2 電腦
3 鼠標墊
4 遊艇

2、range和xrange

　　在python2中有xrange和range，其中range會一次在內存中開闢出了所需的全部資源，而xrange則是在for循環中循環一次則開闢一次所需的內存，而在Python3中沒有xrange，只有range ，可是python3的range表明的就是xrange。range用來指定範圍，生成指定的數字。

for i in range(10):     #循環輸出所生成的 0-9
    print(i)
 
for i in range(1,10,2): #輸出所生成的 1 3 5 7 9
    print(i)

練習：

1、元素分類

　　有以下值集合 [11,22,33,44,55,66,77,88,99]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。即： {'k1': 大於66的全部值, 'k2': 小於66的全部值}

l= [11,22,33,44,55,66,77,88,99]
bignum=[]
smallnum=[]
dir={}
for num in l:
    if num>66:
        bignum.append(num)
    if num<66:
        smallnum.append(num)
    else:
        pass
dir['k1']=bignum
dir['k2']=smallnum
print(dir)

2、查找

　　查找元素，移動空格，並查找以 a或A開頭 而且以 c 結尾的全部元素。

　　　　li = ["alec", " aric", "Alex", "Tony", "rain"]

　　　　tu = ("alec", " aric", "Alex", "Tony", "rain") 

　　　　dic = {'k1': "alex", 'k2': ' aric',  "k3": "Alex", "k4": "Tony"}

li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric',  "k3": "Alex", "k4": "Tony"}
 
for i in li:
    if i.strip().capitalize().startswith('A') and i.strip().endswith('c'):
        print(i)
for i in tu:
    if i.strip().capitalize().startswith('A') and i.strip().endswith('c'):
        print(i)
for i in dic.values():
    if i.strip().capitalize().startswith('A') and i.strip().endswith('c'):
        print (i)

3、輸出商品列表，用戶輸入序號，顯示用戶選中的商品

 　　商品 li = ["手機", "電腦", '鼠標墊', '遊艇']

#方法一
l1=[1,2,3,4]
l2=["手機", "電腦", '鼠標墊', '遊艇']
d=dict(zip(l1,l2))
print(d)
num=input("請輸入商品編號：")
print("你選擇的商品爲 %s" %d[int(num)])
 
#方法二
li = ["手機", "電腦", '鼠標墊', '遊艇']
for k, i in enumerate(li):
    print(k,i)
k=input("請輸入商品編號：")
print("你選擇的商品爲 %s" % li[int(k)])

 

  購物車遊戲

4、購物車

功能要求：

• 要求用戶輸入總資產，例如：2000
• 顯示商品列表，讓用戶根據序號選擇商品，加入購物車
• 購買，若是商品總額大於總資產，提示帳戶餘額不足，不然，購買成功。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

product  =  [      ( "iphone" , 5800 ),      ( "watch" , 380 ),      ( "bike" , 800 ),      ( "book" , 120 ),      ( "computer" , 4000 ) ]   shopping_car  =  []   salary  =  input ( "input your salary: " ) if  salary.isdigit():      salary  =  int (salary)      while  True :          for  i  in  enumerate (product):              print (i)            user_choice  =  input ( ">>>或者q:" )            if  user_choice.isdigit():              user_choice  =  int (user_choice)              if  user_choice > =  0  and  user_choice <  len (product):                  p_item  =  product[user_choice]                  if  salary > =  p_item[ 1 ]:                      shopping_car.append(p_item[ 0 ])                      salary  - =  p_item[ 1 ]                      print ( "你購買了\033[32m%s\033[0m,你的餘額剩餘\033[31m%s\033[0m"  %  (p_item[ 0 ], salary))                  else :                      print ( "\033[31m你的餘額不足\033[0m" )              else :                  print ( "你輸入的項目[%s]不存在,請從新輸入"  %  user_choice)          elif  user_choice  = =  'q' :              print ( "你購買了這些商品:" .center( 30 , "-" ))              for  i  in  shopping_car:                  print ( "\033[32m%s\033[0m"  % i)              print ( "\033[31m餘額%s\033[0m"  % salary)              exit()          else :              print ( "你輸入的[%s]不存在"  %  user_choice) else :      print ( "你輸入的金額不正確！請從新輸入金額！" )

　　

5、用戶交互，顯示省市縣三級聯動的選擇

dic = {
    "河北": {
        "石家莊": ["鹿泉", "藁城", "元氏"],
        "邯鄲": ["永年", "涉縣", "磁縣"],
    },
    "湖南": {
        "長沙":['a','b','c'],
        "株洲":['d','e','f']
    },
    "湖北": {
        "武漢":['g','h','i'],
        "黃石":['j','k','l']
    }
}
for k in dic.keys():
    print(k)
flag=True
while flag:
    n=input("請輸入你所在省：")
    for k in dic.keys():
        if n in dic.keys():
            if k == n:
                for i in dic[n].keys():
                    print(i)
                w = input("請輸入你所在的城市：")
                for i in dic[n].keys():
                    if w in dic[n].keys():
                        if i == w:
                            for k in dic[n][w]:
                                print(k)
                            s=input("請輸入你所在的縣：")
                            for j in dic[n][w]:
                                if s in dic[n][w]:
                                    if j==s:
                                        print("你所在的位置是：%s省%s市%s縣" % (n,w,s))
                                        flag = False
                                        break
                                else:
                                    print('不存在，請從新輸入')
                                    break
                    else:
                        print('不存在，請從新輸入')
                        break
        else:
            print('不存在，請從新輸入')
            break