目錄
目錄 1
常用函式 5
input() 5
int() 6
len() 7
list() 與tuple相對 8
tuple() 與list相對 9
sum() 10
max() 11
min() 12
print() 13
range() 14
set() 15
sorted() 16
str() 17
super()----用法暫時空。 18
type() 19
help() 20
常用方法 21
.title() 21
.upper() 22
.lower() 23
.rstrip() 24
.lstrip() 25
.strip() 26
.append() 27
.insert() 28
.pop() 29
.remove() 30
.sort() 31
.reverse() 32
.items() 33
.keys() 34
. values() 35
.count() 36
.extend() 37
.index() 38
.clear() 39
.fromkeys() 40
.get() 41
.setdefault() 42
.update() 43
dict.pop()—字典專用.pop() 44
.popitem() 45
.readlines()—用法暫時為空。 46
.write()—用法暫時為空 47
.split()—用法暫時為空 48
列表 49
訪問列表中的值 49
刪除列表中的值 49
Python所包含的內建函式 49
Python所包含的內建方法 49
元組 51
訪問元組中的值 51
修改元組中的值 51
刪除元組 51
Python所包含的內建函式 53
Python所包含的內建方法 53
字典 54
訪問字典裡的值 54
修改字典 54
刪除字典（或者刪除字典中的元素） 54
Python所包含的內建函式 55
Python所包含的內建方法 55
Python迴圈 57
while迴圈 57
for迴圈 58
break語句 59
continue語句 59
字串 60
Python轉義字元 60
字串運算子 61
字串格式化 62
Python自建函式 63
語法 63
定義一個函式 63
創造一個無形參的引數 63
創造一個有形參的引數 63
位置實參 64
關鍵字實參 64
預設值 65
返回值 65
如何讓引數變成可選的 65
讓函式可以接收列表進行操作 66
傳遞任意數量的實參 66
使用任意數量的關鍵字引數（形成字典） 67
呼叫（封裝到模組內的函式） 68
import XXX 68
from xxx import XXX 68
使用as命令 68
國際慣例 69
類 70
建立一個Dog類 70
訪問屬性 71
呼叫方法 71
修改屬性的值 71
類的繼承 72
給子類新增一個新的屬性和一個新的方法 72
覆蓋父類的方法 72
匯入類 73
檔案的操作 74
讀取檔案 74
寫入檔案 74

常用函式
input()
作用：輸入-停止程式等待使用者輸入-輸入結果為字串。
使用方法：
n = input(‘請輸入您的名字：’)
print(‘您的名字是：’ + n)

int()
作用：將內容轉換為資料，數值。
用法：
n = ‘15’
m = int(n)
print(n)
print(m)

len()
作用：反饋長度函式，經常用於反饋列表等。
語法：len(list)
返回值：列表中元素的個數。
用法：
n = [‘Audi’, ‘BMW’, ‘Benz’]
print(len(n))
>>>
3

>>>
list() 與tuple相對
作用：生成列表，或者轉換為列表。
語法：list(), list(tup)
用法1：
n = [‘Audi’, ‘BMW’, ‘Benz’]

用法2：
n = (1, 2, 3, 4, 5)
m = list(n)
print(n)
print(m)
>>>
(1, 2, 3, 4, 5)
[1, 2, 3, 4, 5]

tuple() 與list相對
作用：生成元組或者改變為元組。
用法：
n = [1, 2, 3, 4, 5]
m = tuple(n)
print(type(n))
print(type(m))
>>>
<class ‘list’>
<class ‘tuple’>

sum()
作用：計算和值。
用法：
n = [1, 2, 3, 4, 5, 6]
print(sun(n))
>>>
21

max()
作用：取得最大值
語法：max(list)，元組也可使用。
返回值：返回最大值
用法：
n = [1, 2, 3, 4, 5, 6]
print(max(n))
>>>
6

min()
作用：取得最小值
語法：min(list),元組也可使用。
返回值：返回最小值。
用法：
n = [1, 2, 3, 4, 5, 6]
print(min(n))
>>>
1

print()
作用：列印內含檔案。
用法1：
print(‘Hello,World’)

用法2：
print(name.title() + ‘,歡迎您！’)

range()
作用：生成序列，經常用於迭代操作。
引數：rang(),函式可以指定步長。
例如：rang(2,11,2),這個是2開始到11，每2進一次。（偶數列表）

用法：
for n in range(1,6):
print(n)
>>>1
>>>2
>>>3
>>>4
>>>5
set()
作用：去重。
返回值型別：返回值型別是一個‘集合’。
用法：
n = [1, 2, 3, 4, 5, 5, 4, 3]
m = set(n)
print(m)
>>>{1, 2, 3, 4, 5}

sorted()
作用：用於排序‘不改變原有列表’
引數：含有引數reverse=True，可進行反向排序。
用法：
n = [6, 3, 2, 1, 5, 5, 7, 3]
print(sorted(n))
print(sorted(n, reverse = True))
print(n)
>>>
[1, 2, 3, 3, 5, 5, 6, 7]
[7, 6, 5, 5, 3, 3, 2, 1]
[6, 3, 2, 1, 5, 5, 7, 3] #用此函式，原有列表順序不更改。 想更改重新賦值即可

str()
作用：修改內容為字串型別。
用法：
n = 23 #此時變數n是int（整數型）
m = str(n) #則將n看作是字串"
print(type(n))
print(type(m))
>>>
<class ‘int’>
<class ‘str’>

super()----用法暫時空。
作用：類的繼承。
用法：

type()
作用：檢視當前物件的型別。
用法：
n = [1, 2, 3, 4, 5]
m = (1, 2, 3, 4, 5)
o = {1, 2, 3, 4, 5}
p = {1:‘one’, 2:‘two’}
print(type(n))
print(type(m))
print(type(o))
print(type§)
>>>
<class ‘list’>
<class ‘tuple’>
<class ‘set’>
<class ‘dict’>

help()
作用：幫助功能，查詢函式的用法和引數設定。
用法：
help(print)

常用方法
.title()
作用：此方法用於所有單詞進行大寫的操作。
用法：
n = ‘shan mingqi’
print(n.title())
>>>
Shan Mingqi

.upper()
作用： 字母全部大寫。
用法：
n = ‘shan mingqi’
print(n.upper())
>>>
SHAN MINGQI

.lower()
作用：字母全部小寫，經常用於過濾使用者輸入的內容。
用法：
n = ‘SHAN MINGQI’
print(n.lower())
>>>
shan mingqi

.rstrip()
注意此方法不改變原有的值，如需改變請重新賦值。
作用：刪除字串末尾的空白符。
用法：
n = ’ 此字串左右各有兩個空格 ’
n = n.rstrip()
n
>>>
’ 此字串左右各有兩個空格’

.lstrip()
注意此方法不改變原有的值，如需改變請重新賦值。
作用：刪除字串開頭的空白字元。
用法：
n = ’ 此字串左右各有兩個空格 ’
n = n.lstrip()
n
>>>
'此字串左右各有兩個空格 ’

.strip()
注意此方法不改變原有的值，如需改變請重新賦值。
作用：刪除字串兩端的空白字元。
用法：
n = ’ 此字串左右各有兩個空格 ’
n = n.strip()
n
>>>
‘此字串左右各有兩個空格’

.append()
作用：新增新元素到列表最後的方法。
語法：list.append(obj)
引數：引數為新增的內容。
返回值：此方法無返回值。
用法：
n = [‘Audi’, ‘BMW’, ‘Benz’]
n.append(‘Tesla’)
print(n)
>>>
[‘Audi’, ‘BMW’, ‘Benz’, ‘Tesla’]

.insert()
作用：插入新的元素進入列表。
語法：n.insert(索引，內容)
引數：引數1為索引值，引數2為新增的內容。
返回值：此方法無返回值。
用法：
n = [‘Audi’, ‘BMW’, ‘Benz’]
n.insert(0, ‘Tesla’)
print(n)
>>>
[‘Tesla’, ‘Audi’, ‘BMW’, ‘Benz’]

.pop()
作用：彈出列表中的值，此方法刪除列表值的同時可以進行一次賦值操作。返回值是所彈出的元素。
語法：list.pop([index=-1])
引數：引數為索引值。
返回值：返回值為列表中彈出的元素。
系統預設引數為-1，即從最後一位彈出。
用法1：
n = [‘Audi’, ‘BMW’, ‘Benz’]
m = n.pop()
print(n)
print(m)
>>>
[‘Audi’, ‘BMW’]
Benz

用法2：
n = [‘Audi’, ‘BMW’, ‘Benz’]
m = n.pop(0)
print(n)
print(m)
>>>
[‘BMW’, ‘Benz’]
Audi

.remove()
注意：此方法由於返回值為None,所以使用關鍵字進行彈出列表中的內容的時候最好先對一個變數進行賦值，然後用這個變數進行操作。
作用：彈出列表中的值。
語法：list.remove(obj)
引數：obj為要移除的元素
返回值：此方法無返回值
用法：
n = [‘Audi’, ‘BMW’, ‘Benz’]
z = ‘Benz’
c = n.remove(z)
print(n)
>>>
[‘Audi’, ‘BMW’]

.sort()
作用：對列表進行永久排列順序。
語法：list.sort(cmp=None, key=None, reverse=False)
引數：cmp – 可選引數, 如果指定了該引數會使用該引數的方法進行排序。
key – 主要是用來進行比較的元素，只有一個引數，具體的函式的引數就是取自於可迭代物件中，指定可迭代物件中的一個元素來進行排序。
reverse – 排序規則，reverse = True 降序， reverse = False 升序（預設）。

返回值：此方法無返回值。
用法1：
n = [‘Audi’,‘RR’, ‘Benz’]
n.sort()
print(n)
>>>
[‘Audi’, ‘Benz’, ‘RR’]

用法2：
n = [‘Audi’,‘RR’, ‘Benz’]
n.sort(reverse = True)
print(n)
>>>
[‘RR’, ‘Benz’, ‘Audi’]

.reverse()
作用：列表內容直接進行反向排序（注意，此操作是直接反向排序，不是先按其他方式排序後再反向排序）。
二次處理：如果想得到原來的列表，重新執行一次此方法即可。
語法：list.reverse()
返回值：此方法無返回值。
用法：
n = [‘Audi’, ‘RR’, ‘Benz’]
n.reverse()
print(n)
n.reverse() #反向在執行一次，即可得到原列表。
print(n)
>>>
[‘Benz’, ‘RR’, ‘Audi’]
[‘Audi’, ‘RR’, ‘Benz’]

.items()
作用：遍歷字典內鍵值對的方法。
語法：
引數：NA
用法：
n = {‘型號：’: ‘A8’, ‘顏色：’: ‘black’, ‘停放位置：’: 125}
for k,v in n.items():
print(‘關鍵字：’ + k)
print(‘儲存的資料：’ + str(v))
>>>
關鍵字：型號：
儲存的資料：A8
關鍵字：顏色：
儲存的資料：black
關鍵字：停放位置：

.keys()
作用：以列表的方法，返回字典內所有鍵
語法：dict.keys()
引數：NA
返回值：
返回一個字典所有的鍵。
用法1：
n = {‘姓名’: ‘單鳴祺’, ‘年齡’: 26}
print(n.keys())
>>>
dict_keys([‘姓名’, ‘年齡’])

用法2：
n = {‘型號：’: ‘A8’, ‘顏色：’: ‘black’, ‘停放位置：’: 125}
for k in n.keys():
print(‘關鍵字：’ + k)
>>>
關鍵字：型號：
關鍵字：顏色：
關鍵字：停放位置：

. values()
作用：字典，值的方法。
引數：NA
用法：
n = {‘型號：’: ‘A8’, ‘顏色：’: ‘black’, ‘停放位置：’: 125}
for v in n.values():
print(‘值：’ + str(v))
>>>
值：A8
值：black
值：125

.count()
作用：統計列表中某元素出現的次數。
語法：list.count(obj)
引數：為元素。
返回值：返回元素在列表中出現的次數。
用法：
n = [1, 2, 3, 4, 5, 5, 5, 5, 5, 6]
m = n.count(5)
print(m)
>>>
5

.extend()
作用：向列表中新增一個序列的元素到列表的末尾。
語法：list.extend(seq)
引數：seq為序列
返回值：無
用法：
n = [1, 2, 3, 4, 5, 5, 5, 5, 5, 6]
m = [0, 0, 0]
n.extend(m)
print(n)
print(m)
>>>
[1, 2, 3, 4, 5, 5, 5, 5, 5, 6, 0, 0, 0]
[0, 0, 0]

.index()
作用：index() 函式用於從列表中找出某個值第一個匹配項的索引位置。
語法：list.index(obj)
引數：obj為查詢的物件
返回值：該方法返回查詢物件的索引位置，如果沒有找到物件則丟擲異常。
用法：
n = [1, 2, 3, 4, 5, 5, 5, 5, 5, 6]
m = n.index(5)
print(m)
>>>
4

.clear()
作用：刪除字典內的所有元素。
語法：dict.clear()
返回值：此方法無返回值。
用法：
n = {‘姓名’: 川普’, ‘年齡’: 26}
n.clear()
print(n)
>>>
{}

.fromkeys()
作用：以seq序列為鍵，可選引數value為預設值，新建一個字典。
語法：dict.fromkeys(seq[, value])
引數：seq – 字典鍵值列表。
value – 可選引數, 設定鍵序列（seq）的值。

返回值：返回值為新建的字典。
用法：
n = [‘姓名’, ‘年齡’, ‘性別’, ‘體重’]
m = dict.fromkeys(n)
c = dict.fromkeys(n, 10)
print(m)
print©
>>>
{‘姓名’: None, ‘年齡’: None, ‘性別’: None, ‘體重’: None}
{‘姓名’: 10, ‘年齡’: 10, ‘性別’: 10, ‘體重’: 10}

.get()
作用：查詢鍵的值，如果查詢的鍵不在字典中返回值為default內的值，預設為None
語法：dict.get(key, default=None)
引數：key – 字典中要查詢的鍵。
default – 如果指定鍵的值不存在時，返回該預設值值。

返回值：返回查詢鍵的值，如果查詢的鍵不在字典中返回值為default內的值，預設為None
用法：
n = {‘姓名’: ‘川普’, ‘年齡’: 26}
print(n.get(‘姓名’, ‘查不到此資訊’))
print(n.get(‘性別’, ‘查不到此資訊’))
>>>
川普查不到此資訊

.setdefault()
作用：.setdefault() 函式和g.et() 方法類似, 如果鍵不存在於字典中，將會新增鍵並將值設為預設值。
語法：dict.setdefault(key, default=None)
引數：key為查詢的關鍵字（如果查詢不到則新增），第二引數為預設值。
返回值：如果字典中包含有給定鍵，則返回該鍵對應的值，否則返回為該鍵設定的值。
用法：
n = {‘姓名’: ‘川普’, ‘年齡’: 26}
n.setdefault(‘姓名’, ‘劉萌萌’)
n.setdefault(‘性別’, ‘男’)
print(n)
>>>
{‘姓名’: ‘川普’, ‘年齡’: 26, ‘性別’: ‘男’}

.update()
作用：把字典dict2的鍵/值對更新到dict裡。
語法：dict.update(dict2)
引數：dict2 – 新增到指定字典dict裡的字典。
返回值：此方法無返回值。
用法：
n = {‘姓名’: ‘川普’, ‘年齡’: 26}
m = {‘性別’: ‘男’}
n.update(m)
print(n)
print(m)
>>>
{‘姓名’: '川普, ‘年齡’: 26, ‘性別’: ‘男’}
{‘性別’: ‘男’}

dict.pop()—字典專用.pop()
作用：刪除字典給定鍵 key 及對應的值，返回值為被刪除的值。key 值必須給出。 否則，返回 default 值。
語法：pop(key[,default])
引數：key: 要刪除的鍵值
default: 如果沒有 key，返回 default 值
返回值：返回被刪除的值,如未找到鍵則返回defalut的值。
用法：

n = {‘姓名’: ‘川普’, ‘年齡’: 26}
m = n.pop(‘年齡’)
c = n.pop(‘性別’, ‘沒有查詢到此鍵’)
print(n)
print©
>>>
{‘姓名’: ‘川普’}
沒有查詢到此鍵

.popitem()
作用：隨機刪除一個鍵值對，如字典已經空了則報出異常。
語法：dict.popitem()
引數：NA
返回值：隨機刪除一個鍵值對，如字典已經空了則報出異常。
用法：
n = {‘姓名’: ‘川普’, ‘年齡’: 26}
n.popitem()
print(n)
n.popitem()
print(n)
n.popitem()
print(n)
>>>
{‘姓名’: ‘川普’}
{}
Traceback (most recent call last):
File “c:/Users/kadsm/OneDrive/Learning/Python/learn/2/驗證想法.py”, line 6, in
n.popitem()
KeyError: ‘popitem(): dictionary is empty’

.readlines()—用法暫時為空。
作用：從檔案中讀取每一行，並將它存在列表中。

.write()—用法暫時為空
作用：寫入檔案的方法。

.split()
作用：字串方法，用於對字串進行切片。
根據一個字元建立一個列表。
語法：str.split(引數1，引數2)
引數1為分隔引數，以什麼為界進行分隔。
引數2為分割次數，例如一共5個t，如果設定分割次數為1，就第一個t被分割。
用法：
a = ‘www.baidu.com’
print(a.split(’.’))
print(a.split(’.’, 1))
>>>
[‘www’, ‘baidu’, ‘com’]
[‘www’, ‘baidu.com’]

.repalce()
作用： 字串替換舊的字串。
語法： str.replace(old, new[,max])
第一引數，老的字元，要被替換的。
第二引數，新的字元，要替換的內容。
第三引數，替換幾次。
用法：
a = ‘There is apples’
b = a.replace(‘is’, ‘are’)
print(a)
print(b)
>>>There is apples
>>>There are apples

列表
列表在python裡是一種序列，序列可以進行的操作包括：索引，切片，加，乘，檢查成員（in和not in 返回布林值）。
列表的索引值是0開始的。

訪問列表中的值
語法：list[索引值]

刪除列表中的值
可以利用方法.pop(索引值_預設值為-1)和.remove(關鍵字)，來刪除。
也可以使用del語句來刪除，如下：
n = [‘Audi’, ‘RR’, ‘Benz’]
del n[0]
print(n)
del n[:]
print(n)
>>>
[‘RR’, ‘Benz’]
[]

Python所包含的內建函式
函式名 作用 語法 備註
cmp() 比較列表 cmp(list1, list2)
len() 返回列表長度 len(list)
max() 返回最大值 max(list)
min() 返回最小值 min(list)
list() 返回列表 list(tup)

Python所包含的內建方法
方法名 作用 語法 備註
.append() 向列表中新增元素 list.append(obj) 此方法沒有返回值
.count() 統計列表中某元素出現的次數 list.count(obj) 返回值為次數
.extend() 想列表中新增一個序列的元素，新增到列表的末尾 list.extend(seq) 此方法沒有返回值
.index() 得到列表中某元素的第一個匹配項的索引值。 list.index(obj) 返回值為數字，是索引值。
.pop() 彈出某個元素，預設彈出列表末尾最後一個。 list.pop([index=-1]) 返回值為彈出的物件。
.remove() 移除引數所設定的元素。 list.remove(obj) 此方法無返回值。
.reverse() 永久改變列表中元素的順序，改變標準是倒敘。如想得到原來列表，重新執行此操作即可。 list.reverse() 此方法無返回值。
.sort() 對列表進行排序。
引數用法請檢視方法詳情。 list.sort(cmp=None, key=None, reverse=False) 此方法無返回值。

元組
元組在python裡是一種特殊的序列，跟列表極其相似。最大的不同時不支援任何方法對其內部進行修改。元組標識為()小括號。

元組在python裡是一種序列，序列可以進行的操作包括：索引，切片，加（連線符），乘，檢查成員（in和not in 返回布林值）。
列表的索引值是0開始的。

Ps.特例：如果元組中只有一個元素請在元素後邊新增,—例：n = (1, )

元組的索引從0開始
訪問元組中的值
語法：tup[索引值]

修改元組中的值
元組理論上是不支援修改的，但是我們可以通過重新賦值（給一個新的元組貼上老的標籤）的方式修改。或者，如果有新增值得需求我們可以通過 + 運算子來合成兩個元組。
例1：
n = (1, 2, 3, 4, 5, 5, 5, 5, 5, 6)
n = (0,)
print(n)
>>>
(0,)
例2：
n = (1, 2, 3, 4, 5, 5, 5, 5, 5, 6)
m = (0,)
c = n + m
print©
>>>
(1, 2, 3, 4, 5, 5, 5, 5, 5, 6, 0)
刪除元組
n = (1, 2, 3, 4, 5, 5, 5, 5, 5, 6)
del n

Python所包含的內建函式
函式名 作用 語法 備註
cmp() 比較列表 cmp(tuple1, tuple2)
len() 返回列表長度 len(tuple)
max() 返回最大值 max((tuple)
min() 返回最小值 min((tuple)
list() 返回列表 list((tuple)

Python所包含的內建方法
方法名 作用 語法 備註
.count() 統計列表中某元素出現的次數 tuple.count(obj) 返回值為次數
.index() 得到列表中某元素的第一個匹配項的索引值。 tuple.index(obj) 返回值為數字，是索引值。

字典
字典是一種可變的容器，內部可儲存任意格式的資料。
字典的每個鍵值 key=>value 對用冒號 : 分割，每個鍵值對之間用逗號 , 分割，整個字典包括在花括號 {} 中。

字典的注意事項：

1. 值無限制，但是鍵只能在一個字典中出現一次，如果多次出現，後者覆蓋前者。
2. 因為鍵必須是個確定值，所以鍵不能是列表。
   訪問字典裡的值
   n = {‘Name’: ‘smq’, ‘age’: ‘26’}
   print(n[‘Name’])
   print(n[‘age’])
   >>>
   smq
   26

修改字典
n = {‘姓名’: ‘川普’, ‘年齡’: 26}
n[‘年齡’] = 27 #修改值
n[‘性別’] = ‘男’ #新增新的鍵和值
print(n)
>>>
{‘姓名’: ‘川普’, ‘年齡’: 27, ‘性別’: ‘男’}

刪除字典（或者刪除字典中的元素）
一共三種，分別為：del dict[key]， .clear() , del dict
1：
n = {‘姓名’: ‘川普’, ‘年齡’: 26}
del n[‘年齡’]
print(n)
>>>
{‘姓名’: ‘川普’}

2：
n = {‘姓名’: ‘川普’, ‘年齡’: 26}
n.clear()
print(n)
>>>
{}

3：
n = {‘姓名’: ‘川普’, ‘年齡’: 26}
del n

Python所包含的內建函式
函式名 作用 語法 備註
cmp() 比較列表 cmp(dict)
len() 返回列表長度 len(dict) 返回的是鍵的個數

Python所包含的內建方法
方法名 作用 語法 備註
.clear() 清空字典 dict.clear() 此方法無返回值
.fromkeys() 以seq序列為鍵，新建一個字典，可選引數value為預設值。 dict.fromkeys(seq[, value]) 此方法返回一個新的字典。
.get() 返回指定鍵的值，如果值不存在則返回default內的值。 dict.get(key, default=None) 返回值為所查詢鍵的值，如果查不到返回第二引數的內容預設為None
.items() 此方法以列表的方式，返回可遍歷的鍵值對。 dict.items() 返回可遍歷的(鍵, 值) 元組陣列。
.keys() 返回一個列表的所有鍵。 dict.keys() 返回一個列表內所有鍵。
.values() 返回一個列表的所有值。 dict.values() 返回一個列表的所有值。
.setdefault() 和get方法類似，如果沒查詢到鍵，則新增這個鍵。 dict.setdefault(key, default=None) 如果字典中包含有給定鍵，則返回該鍵對應的值，否則返回為該鍵設定的值。
.update() 新增一個字典2到字典1中去。 dict.update(dict2) 此方法無返回值。

.pop() 刪除引數關鍵字的鍵值對。如果沒有找到關鍵字則返回第二引數內的內容。 pop(key[,default]) 返回被彈出的鍵值，如果沒有找到則返回第二引數的值。
.popitem() 隨機刪除一個鍵值對，如果字典為空呼叫此方法則報出異常。 dict.popitem() 返回被刪除的鍵值對，如果字典為空時執行此方法則報出異常。
.has_key()
python3無此方法 查詢某個鍵是不是在字典中是鍵。 dict.has_key(key) 返回值為布林值。

Python迴圈
Python內建了3中迴圈體，分別為while迴圈，for迴圈和巢狀迴圈（就是在一個迴圈體中在巢狀一個迴圈體）
Python還內建了，3中對迴圈進行控制的語句，分別是：break , continue , pass
break語句用於終止迴圈過程，跳出迴圈。
continue語句用於終止當前迴圈，重新開始迴圈。
pass用於補充語法空白無實際意義。
while迴圈
#設計一個列印雙數的程式
n = [1, 2, 3, 4, 5, 6, 7, 8, 9]
d_num = []
s_num = []
while len(n) > 0:
l_num = n.pop()
if l_num % 2 == 0:
d_num.append(l_num)
else:
s_num.append(l_num)

兩個迴圈控制符的用法
#設計一個程式用於測試break和continue的用法。
#先用break來終止迴圈,程式是把雙數列印一遍，到100的時候停止。
i = 0
while True:
i += 1
if i % 2 == 0:
print(i)
elif i % 2 != 0:
pass
if i > 100:
break

for迴圈
基本上就是用於遍歷東西使用。

break語句
Python break語句，就像在C語言中，打破了最小封閉for或while迴圈。
break語句用來終止迴圈語句，即迴圈條件沒有False條件或者序列還沒被完全遞迴完，也會停止執行迴圈語句。
break語句用在while和for迴圈中。
如果您使用巢狀迴圈，break語句將停止執行最深層的迴圈，並開始執行下一行程式碼。
#設計一個程式用於測試break和continue的用法。
#先用break來終止迴圈,程式是把雙數列印一遍，到100的時候停止。
i = 0
while True:
i += 1
if i % 2 == 0:
print(i)
elif i % 2 != 0:
pass
if i > 100:
break

break語句，停止的是最深層的迴圈，就是說如果巢狀n層迴圈，想要停止所有迴圈就需要n個break語句。

continue語句
#再用continue的方式來列印單數。
i = 0
while i < 100:
i += 1
if i % 2 == 0:
continue
else:
print(i)

continue重啟的迴圈是最大的迴圈，就是說嵌套了n層迴圈，continue重啟的是第一層最淺層，也就是最大的那個迴圈。

字串
Python轉義字元
在使用特殊符號的時候，可能需要對特殊符號進行轉義，使其能為我們所用。
轉義字元 描述
\（在行尾時） 續行符
\ 反斜槓符號
\’ 單引號
\’’ 雙引號
\a 響鈴
\b 退格(Backspace)
\e 轉義
\000 空
\n 換行
\v 縱向製表符
\t 橫向製表符
\r 回車
\f 換頁
\oyy 八進位制數，yy代表字元，例如：\o12代表換行
\xyy 十六進位制數，yy代表字元，例如：\x0a代表換行
\other 其他的字元以普通格式輸出

字串運算子
以下例項，a為字串’Hello’,b為’World’
操作符 描述 例項

• 字串連線 >>>a + b
  ‘HelloWorld’

• 重複輸出字串 >>>a * 2
  ‘HelloHello’
  [] 通過索引獲取字串中的字元 >>>a[1]
  ‘e’
  [:] 通過切片擷取字串中的一部分 >>>a[1:4]
  ‘ell’
  in 成員運算子，如果含有則返回True >>>“H” in a
  True
  not in 成員運算子，如果不含有則返回True >>>“M” not in a
  True
  r ‘xx’ 原始字串，在字串前加r，就是一切都按字面意思來，不存在任何其他東西。 print(r’\n’)
  >>>
  \n
  % 格式字串 見下一頁

字串格式化
Python 支援格式化字串的輸出 。儘管這樣可能會用到非常複雜的表示式，但最基本的用法是將一個值插入到一個有字串格式符 %s 的字串中。
例如：
name = ‘shan mingqi’
age = 26
print(‘姓名：%s,年齡：%d’ % (name,age))
>>>
姓名：shan mingqi,年齡：26

格式化操作符的含義
符號 說明
%c 格式化字元及其 ASCII 碼
%s 格式化字串
%d 格式化證書
%o 格式化無符號的八進位制數
%x 格式化無符號的十六進位制數
%X 格式化無符號的十六進位制（大寫）
%f 格式化浮點數字，可指定小數點的精度
%e 用科學計數法格式化浮點數
%E 作用通%e，用科學計數法格式浮點數
%g 根據值的大小決定使用 %f 或 %e
%G 作用同 %g，根據值的大小決定使用 %f 或者 %E
%p 用十六進位制數格式化變數的地址

格式化操作符的輔助指令

• 定義寬度或者小數點的精度

• 用作左對齊

• 在正數前邊顯示空格
  在正數前邊顯示空格

在八進位制數前邊顯示（'0’）,在十六進位制前面顯示’0x’或者‘0X’

0 在現實的數字面前填充’0’而不是預設的空格
% %%輸出一個單一的%
(var) 對映變數（字典引數）
m.n. m是顯示的最小總寬度，n是小數點後的位數（如果可用的話）

Python自建函式
語法
def functionname( parameters ):
‘’’函式_文件字串’’’
function_suite
return [expression]
定義一個函式
你可以定義一個由自己想要功能的函式，以下是簡單的規則：
函式程式碼塊以 def 關鍵詞開頭，後接函式識別符號名稱和圓括號()。
任何傳入引數和自變數必須放在圓括號中間。圓括號之間可以用於定義引數。
函式的第一行語句可以選擇性地使用文件字串—用於存放函式說明。
函式內容以冒號起始，並且縮排。
return [表示式] 結束函式，選擇性地返回一個值給呼叫方。不帶表示式的return相當於返回 None。

創造一個無形參的引數
def a():
‘’‘呼叫這個函式就是列印‘大家好，我是一個列印引數’’’’
print(‘大家好，我是一個列印引數’)
a()
>>>
大家好，我是一個列印引數

創造一個有形參的引數
def sum_1(num_1, *num_2):
‘’‘這是一個求和函式，’’’
sum_s = 0
for num_z in num_2:
sum_s += num_z
sum_z = sum_s + num_1
return sum_z
print(sum_1(1,2,3,4,5))
>>>
15

位置實參
通過位置來確定實參與形參的對應位置。
def cars(car_num, car_type, car_xinghao):
‘’‘顯示車輛資訊’’’
print(‘車輛編號是：’ + str(car_num))
print(‘車輛品牌是：’ + car_type)
print(‘車輛型別：’ + car_xinghao)
cars(‘No.001’, ‘奧迪’, ‘A8’)
cars(‘No.002’, ‘賓士’, ‘S600’)
>>>
車輛編號是：No.001
車輛品牌是：奧迪
車輛型別：A8
車輛編號是：No.002
車輛品牌是：賓士
車輛型別：S600

關鍵字實參
通過關鍵字來確定實參和形參的關係，如果用此方法來編輯函式，是非常繁瑣的但是這樣定義實參和形參的關係是非常顯而易見的，明確的。
def cars(car_num, car_type):
‘’‘顯示車輛資訊’’’
print(‘車輛編號是：’ + str(car_num))
print(‘車輛品牌是：’ + car_type)
cars(car_num = ‘No.001’, car_type = ‘奧迪’)
cars(car_num = ‘No.002’, car_type = ‘賓士’)
>>>
車輛編號是：No.001
車輛品牌是：奧迪
車輛編號是：No.002
車輛品牌是：賓士

預設值
我們可以在形參裡定義好預設值，這樣做有兩點好處，1是在某種條件下可以減少實參的輸入，2是可以避免忘記輸入實參的時候不會報錯。
def cars(car_num, car_type=‘奧迪’):
‘’‘顯示車輛資訊’’’
print(‘車輛編號是：’ + str(car_num))
print(‘車輛品牌是：’ + car_type)
cars(‘No.001’)
cars(car_num = ‘No.001’)
>>>
車輛編號是：No.001
車輛品牌是：奧迪
車輛編號是：No.001
車輛品牌是：奧迪

返回值
每一個函式都有返回值，在編寫函式的時候你可以自己定義函式的返回值，也可以不定義（這個時候返回值為None）。如果你的函式是執行某個動作或者某個操作，並沒有返回值使用的必要，這時候你可以不寫返回值。如果你的函式是在實參帶入形參後進行了運算或者其他操作，最後返回某一個值，這時候你將需要自己定義一個返回值。
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)
>>>
Jimi Hendrix

如何讓引數變成可選的
有時候我們會遇到，引數為不確定項，可能要填寫，可能不需要填寫。這時候我們就需要定義一個可選形參，思路如下：給可選引數設定一個預設值，預設值為空。
def car(pinpai, xinghao, yanse=’’):
‘’‘這是一個列印車輛資訊的函式，車輛的顏色為可
選項，如果填寫了則列印全部，如果不填寫則不列印顏色’’’
if yanse :
print(pinpai,xinghao,yanse)
else:
print(pinpai,xinghao)

car(‘audi’, ‘a8’)
car(‘audi’,‘a8’,‘black’)
>>>
audi a8
audi a8 black

讓函式可以接收列表進行操作
def get_renming_gsh(listnames):
‘’‘對列表內的使用者進行問候,引數請傳入列表’’’
for a in listnames:
print(‘歡迎光臨：’ + a.title() + ‘!’)

n = [‘peter’, ‘tony’, ‘jack’]
get_renming_gsh(n)
>>>
歡迎光臨：Peter!
歡迎光臨：Tony!
歡迎光臨：Jack!

傳遞任意數量的實參
def sum_1(*numbers):
‘’‘傳遞任意數量的實參，進行求和’’’
sum_l = 0
for num_l in numbers:
sum_l += num_l
return sum_l

print(sum_1(1,2,3,4,5))
>>>
15
另一種方法見上邊“創造一個有形參的引數”
使用任意數量的關鍵字引數（形成字典）
def car_info(pinpai, chexing, **qita):
car_qita_xinxi = {}
car_qita_xinxi[‘品牌’] = pinpai
car_qita_xinxi[‘車型’] = chexing
for key, value in qita.items():
car_qita_xinxi[key] = value
return car_qita_xinxi
n = car_info(‘奧迪’, ‘A8’, 排量 = ‘4.2’, 車長 = ‘5500’)
print(n)
>>>
{‘品牌’: ‘奧迪’, ‘車型’: ‘A8’, ‘排量’: ‘4.2’, ‘車長’: ‘5500’}

呼叫（封裝到模組內的函式）
我們經常把一類或者一個函式，封裝到一個模組中（.py的程式），這樣我們的主程式就可以減少程式碼量，顯得更加簡潔，把功能性的操作或者函式封裝到獨立的模組中。

import XXX
語法：import xxx
作用：匯入xxx模組內的所有函式，此匯入方式是隱形的你看不見的，當然你也不需要知道。在程式中呼叫的時候請使用’.’—點句號來呼叫。
用法：
①import XXX
(省略副檔名)
②XXX.函式名(引數)
---------例如---------
import pizza
pizza.make_pizza(16, ‘芝士’)

from xxx import XXX
語法：from xxx import XXX
作用：匯入xxx模組中的XXX函式，此函式可以使多個，中間用,隔開。在呼叫函式的時候直接使用函式名稱即可，不用點句號’.’來使用。
用法：
#例如現在有個模組，內含很多函式，我們只調用其中一個。
from pizza import make.pizza_0, make.pizza_1, make.pizza_2
make.pizza_0(16,‘芝士’）
make.pizza_1(16,‘芝士’, ‘大蒜’, ‘鰻魚’)

使用as命令
我們可以使用as命令來簡化函式名稱。
from pizza import make_pizza as mp
mp(16, ‘芝士’, ‘大蒜’, ‘鰻魚’)
我們還使用as命令來簡化模組名稱，這樣可以在呼叫函式的時候更加簡潔。
import pizza as p
p.make_pizza(16, ‘芝士’)
國際慣例

1. 匯入模組中所有函式還有一種語法： from XXX import *
   如果是匯入模組中的函式，請使用import語句來匯入模組，使用點句號來進行函式的呼叫這樣程式碼易懂，便於維護。
   如果強行使用from 語句來匯入所有函式，在使用函式的時候是方便了，但是後期的維護將更加困難。
2. 在使用關鍵字實參的時候，請不要使用空格。
3. 在給定形參預設值的時候，請不要使用空格。
4. 程式碼長度不要過長，不要超過79個字元。
5. 如果編寫模組的時候，會編寫很多函式，請每個函式中間加兩個空行。
6. 所有import語句請放在檔案開頭。

類
在程式設計的時候可能會遇到一些，有共同特性的物件。python是一個面向物件程式設計的語言。我們在面對擁有很多相同物件的時候，我們就會使用類。

語法：
class Xxx():
def init(self, xx, xxx) #__init__是一個特殊的方法，self是必要引數。

PS.我們建立類的時候使用的名稱，首字母進行大寫操作。

建立一個Dog類
我們建立一個狗狗類，內含2個方法（翻身，和打滾），內含屬性名字，年齡，品種，毛色。
#我們建立一個狗狗類，內含2個方法（翻身，和打滾），內含屬性名字，年齡，品種，毛色。
class Dog():
def init(self, name, age):
self.name = name
self.age = age
self.pinzhong = None
self.maose = None

def sit(self):
    '''執行坐下'''
    print('系統提示您：狗狗已經坐下了')

def roll(self):
    '''執行打滾'''
    print('系統提醒您：狗狗正在打滾')

def add_pinzhong(self, new_pinzhong):
    self.pinzhong = new_pinzhong

def add_age(self, new_age):
    self.age = new_age

訪問屬性
import dog
n = dog.Dog(‘peter’, 16)
print(n.name)
>>>
peter

呼叫方法
import dog
n = dog.Dog(‘peter’, 16)
n.sit()
n.roll()
>>>
系統提示您：狗狗已經坐下了
系統提醒您：狗狗正在打滾

修改屬性的值
方法1：
import dog
n = dog.Dog(‘peter’, 16)
print(n.age)
n.age = 18
print(n.age)
>>>
16
18

方法2：
就是建立類的時候多建立一個能夠直接修改值得方法，類似於上邊的，add_age()

類的繼承
我們經常需要建立一個類以後，會有新的需求這樣可能會建立子類，用來繼承很多父類已經擁有的屬性和方法。
語法：
class Xxx(Xx):
def init_(self, name, age):
super().init_(name,age)
用法
class Dog():
def init(self, name, age):
.
.
.
class Dog2ha(Dog):
def init(self, name, age):
super().init(name, age)

然後呼叫新子類的時候和之前的呼叫方法一樣。

給子類新增一個新的屬性和一個新的方法
class Dog2ha(Dog):
def init(self, name, age):
super().init(name, age)
self.sex = None

def add_sex(self, new_sex):
    self.sex = new_sex

覆蓋父類的方法
用相同的方法名稱重寫即可。

匯入類
匯入單個類 from car import Car 如果匯入子類，自帶父類內容，無需匯入父類。
匯入多個類 from car import Car, ElectricCar 匯入多個類，用,分開。
模組名.類名()
匯入整個模組 import car 下邊呼叫類，需要使用點句表示法來呼叫。
匯入整個模組2 from car import * 同函式模組呼叫函式一樣，不要使用此方法匯入模組。
這裡僅僅是為了能讀懂而已，請不要使用。

檔案的操作
讀取檔案
使用函式open()來開啟檔案。
還可以是用close()來關閉檔案。方法：(file.close())，關閉檔案。
注意關閉檔案的時候要分情況，如果流程中可能會多次用到檔案，則不關閉，等待python的回收機制自動關閉。如果是大型服務可能會出現，必須手動關閉的情況，如果不手動關閉可能造成資源的流失和浪費甚至是伺服器資源的耗盡。

語法：
with open(‘xxx.txt’) as file_object:
contents = file_object.read()
print(contents)

如果檔案不在根目錄，則
file_lujing = ‘E:\OneDrive\Learning\Python\learn\2\123.txt’
with open(file_lujing) as file_object:
contents = file_object.read()
print(contents)

寫入檔案
使用open()函式的第二引數，可選引數為(w,r,a)
w為寫入，注意此寫入會覆蓋原有檔案。
r為只讀模式。
a為附加模式，此模式會把寫入的東西附加到末尾。
open()函式裡新增一個實參’w’
寫入模式 with open(‘password.txt’, ‘w’) as pass_oj:
pass_oj.write(‘siaa1111\n’)
pass_oj.write(‘siaa2222\n’)
pass_oj.write(‘siaa3333\n’)
open()函式裡新增一個實參’r’
只讀模式 省略
open()函式裡新增一個實參’a’
附加模式 with open(‘password.txt’, ‘a’) as pass_oj:
pass_oj.write(‘siaa1111\n’)
pass_oj.write(‘siaa2222\n’)
pass_oj.write(‘siaa3333\n’)

JSON
Python內建的JSON庫，僅有兩種函式（方法）。

json.dumps(): 對資料進行編碼。
json.loads(): 對資料進行解碼。

RE正則表示式
正則表示式是一個特殊的字元序列，它能幫助你方便的檢查一個字串是否與某種模式匹配。

re.match函式
re.match 嘗試從字串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match()就返回none。

語法：re.match(pattern, string, flags=0)
使用方法：pattern是匹配的正則表示式
string是要匹配的字串
flage是標誌位，用於控制正則表示式的匹配方式，比如：是否區分大小寫，多行匹配等等。詳見，正則表示式修飾符-可選標誌。.
返回值：如果匹配成功了，就返回匹配的物件，否則則返回none

匹配物件方法 描述
group(num=0) 匹配的整個表示式的字串，group() 可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組。
groups() 返回一個包含所有小組字串的元組，從 1 到 所含的小組號。