Python 學習筆記一
字串 str
作用：用來記錄文字(文字)資訊 字串的表示方法：在非註釋中，凡是用引號(’, “, ‘’’, “””)括起來的部分都是字串。 空字串的字面值表示方式：
' '
" "
' ' ' ' ' '
" " " " " "
非空字串的字面值表示方式：
'hello'
"hello"
'''hello'''
"""hello"""
單引號和雙引號的區別： 單引號內的雙引號不算結束符；雙引號內的單引號不算結束符。 三引號字串： 作用：三引號字串的換行會自動轉換為換行符’\n’，三引號內可以包含單引號和雙引號。
print('''I like cat I like food I like coffee''')
用轉義序列代表特殊字元
字串字面值中，用字元反斜槓()後跟一些字元代表一個字元。 字串中的轉義字元表
\' 代表一個單引號 \'' 一個雙引號 \\ 代表一個反斜槓 \n 換行 \r 返回游標至行首 \f 換頁 \t 水平製表符 \v 垂直製表符 \b 倒退 \0 空字元，字元值為0 \0oo oo為兩位八進位制表示的字元 \xXX XX為兩位十六進位制表示的字元 \uXXXX Unicode16的十六進位制表示的字元 \uXXXXXXXX Unicode32的十六進位制表示的字元
ASCII 編碼
ASCII 字元表 我們可以看到輸出的資料都是以ascii碼形式進行儲存的，輸入如下指令可以檢視到ascii對照表。
man ascii
raw 字串(原始字串)
字面值格式：
r'字串內容'
r"字串內容"
r'''字串內容'''
r"""字串內容"""
作用：讓轉義字元\無效 示例：
a = 'C:\newfile\test.py' print(a) print(len(a)) # 得到字串的長度 a = r'C:\newfile\test.py' print(a) print(len(a))
字串的運算
算術運算子:
# + 加號運算子用於字串的拼接
x = 'abcd' + 'efg'
print(x) # abcdefg
x += '123'
print(x) # abcdefg123
* 運算子用於生成重複的字串
x = '123'
y = x * 2 # y = '123123'
x *= 3 # x = 123123123
字串的比較運算
運算子：
>; >=; <; <=; ==
示例：
'A' < 'B' # True
'B' < 'a' # True
'ABC' > 'AB' # True
'AD' < 'ABC' # False 首先比較A和A，然後比較D和B，D>B所以返回False不再進行第三位比較
'ABC' == 'abc' # False
比較的時候是ascii編碼做比較。 序列的比較以及元祖的比較規則與字串的比較規則完全相同。
in 和 not in
作用：in 用於序列，字典，集合中，用於判斷某個值是否存在於容器中，如果存在則返回True，否則返回False 格式：物件 in 容器 示例：
s = 'welcome to tarena'
'to' in s # True
'class' in s # False
'to' not in s # False
'class' not in s # True
字串的索引操作
python 字串str是不可以改變的字元序列
索引語法：字串[整數表示式]
說明：python序列都可以用索引(index)來訪問序列中的物件(元素)。
python序列的正向索引是從0開始的，第二個索引為1，最後一個索引為len(s)-1。python序列的反向索引是從-1開始的，-1代表最後一個，-2代表倒數第二個，第一個是-len(s)
切片 slice
作用：從字串序列中去除一部分相應的元素重新組成一個字串 語法：字串[(開始索引b):(結束索引e)(:(步長s))] ()內括起來的部分代表可以省略。 說明：
- 開始索引是切片開始切下的位置0代表第一個元素，-1代表最後一個元素。
- 結束索引是切片的終止索引(但不包含終止索引)
- 步長是切片每次獲取完當前索引後移動的方向和偏置量，沒有步長，相當於取值完成後向後移動一個索引的位置(預設為1)；當步長為正整數時，取正向切片，步長預設值為1，開始索引預設值為0，結束索引的預設值為len(s)；當步長為負整數時，取反向切片，反向切片時，預設的起始位置為最後一個元素，預設的終止位置為第一個元素的前一個位置。 示例：
s = 'ABCDE'
a = s[1:4] # a = 'BCDE'
a = s[1:] # a = 'BCDE'
a = s[:2] # a = 'AB'
a = s[:] # a = 'ABCDE'
a = s[4:2] # a = ''
a = s[2:1000] # a = 'CDE' 開始索引和結束索引可以越界
a = s[1:4] # a = 'BD'
a = s[::2] # a = 'ACE'
a = s[1::2] # a = 'BD'
a = s[::-1] # a = 'EDCBA'
a = s[::-2] # a = 'ECA'
a = s[4:0:-2] # a = 'EC'
常用的序列函式
len(seq) # 返回序列的長度
max(x) # 返回序列的最大值元素，根據ascii編碼值的大小進行比較
min(x) # 返回序列的最小值元素
字串編碼轉換函式
ord(c) # 返回一個字串的Unicode編碼值
chr(i) # 返回i這個值所對應的字元
示例：
整數轉換為字串函式
hex(i) # 將整數轉換為十六進位制的字串 oct(i) # 將整數轉換為八進位制字串 bin(i) # 將整數轉換為二進位制字串
字串的構造(建立)函式 str
str(obj = ‘’) # 將物件轉換為字串 示例：
s = 123
print(str(s) + '456') # '123456'
str(None) # 'None'
常用字串方法
字串方法的呼叫語法：物件.方法名(方法傳參) 注：方法的呼叫屬於表示式，通常可以返回一個None
S.isdigit() # 判斷字串中的字元是否全為數字
S.isalpha() # 判斷字串是否全為英文字母
S.islower() # 判斷字串所有字元是否全為小寫英文字母
S.isupper() # 判斷字串所有字元是否全為大寫英文字母
S.isspace() # 判斷字串是否全為空白字元
S.center(width[, fill]) # 將原字串居中，左右預設填充空格
S.count(sub[, start[, end]]) # 獲取一個字串中子串的個數
S.find(sub[, start[, end]]) # 獲取字串中子串sub的索引，失敗返回-1
S.strip() # 返回去掉左右空白字元的字串
S.lstrip() # 返回去掉左側空白字元的字串
S.rstrip() # 返回去掉右側空白字元的字串
S.upper() # 生成將英文轉換為大寫的字串
S.lower() # 生成將英文轉換為小寫的字串
S.replace(old, new[, count]) # 將原字串的old用new代替，生成一個新的字串
S.startwith(prefix[, start[, end]]) # 返回S是否是以prefix開始，如果以prefix開始返回True
S.endswith(suffix[, start[, end]]) # 返回S是否是以suffix結尾，如果以suffix結尾返回True
S.title() # 生成每個英文單詞的首字母大寫字串
S.isnumeric() # 判斷字串是否全為數字字元
help(str) # 檢視字串的文件幫助
空白字元是指空格，水平製表符(\t)，換行符(\n)等不可見的字元。
字串格式化表示式
運算子: % 作用：生成一定格式的字串 語法： 格式字串 % 引數值 格式字串 % (引數值1, 引數值2, …) 格式字串中 % 為佔位符，佔位符的位置將用引數值替換 示例：
fmt = "姓名: %s, 年齡: %d"
name = input("請輸入姓名: ")
age = int(input("請輸入年齡: "))
s = fmt % (name, age)
'name: %s, age: %d' % ('cat', 1)
"aaaa%dddd" % 10
格式化字串中的佔位符和型別碼
佔位符 意義 %s 字串，使用str函式轉換 %r 字串，使用repr函式轉換 %c 整數轉為單個字元 %d 十進位制整數 %o 八進位制整數 %x 十六進位制整數(a-f小寫) %X 十六進位制整數(A-F大寫) %e 指數型浮點數(e小寫) 如：2.8e+10 %E 指數型浮點數(E大寫) 如：2.9E + 10 %f, %F 浮點進十制形式 %g, %G 十進位制形式浮點數或指數浮點數自動轉換 %% 等同於一個%字元
佔位符和型別碼之間的格式語法
% [格式語法] 型別碼 格式語法：- 左對齊 + 顯示正號 0 補零 寬度(整數) 寬度*精度(整數) 示例：
'%10d' % 123 # ‘ 123'
'%-10d' % 123 # '123 '
'%10s' % 'abc' # ' abc'
'%-5s' % 'abc' # 'abc '
'%05d' % 123 # '00123'
# 寬度 精度
'%7.3f' % 3.1415926 # ' 3.142'
# 輸入三行文字，讓這些文字一次以最長字元的寬度右對齊輸出
s1 = input("Please input string1: ")
s2 = input("Please input string2: ")
s3 = input("Please input string3: ")
m = max(len(s1), len(s2), len(s3))
fmt = "%%%ds" % m
print(fmt)
print(fmt % s1)
print(fmt % s2)
print(fmt % s3)
while語句
作用：根據一定條件，重複的執行一條語句或多條語句 語法： while 真值表達式: 語句塊1 else: 語句塊2 while 語句語法說明：
- 先執行真值表達式，判斷True/False
- 如果為True則執行語句塊1 ，然後跳轉到第一步
- 如果為False則執行else子句部分的語句塊2，然後結束此while語句
- else子句部分可以省略（同if語句類似） while注意事項： （1)要注意控制真值表達式來避免死迴圈 （2)通常用真值表達式內變數來控制迴圈條件 （3)通常要在迴圈語句塊內改變迴圈變數來控制迴圈的次數和變數的走向
while語句巢狀
while 語句本身是語句，和其他語句一樣可以放在其它複合語句內部 while巢狀示意： while 真值表達式1： … while 真值表達式2: … else: … else: … 示例：
# 用while實現列印三角形，要求輸入一個整數表示三角形的高度
h = int(input("Please input height"))
# 第一種三角形
i = 1
while i <= h:
print(' ' * (h - i) + '*' * i)
i = i + 1
else:
print()
# 第二種三角形
j = h
while j >= 1:
print('*' * j + ' ' * (h - j))
j = j - 1
else:
print()
break 語句
作用：用於迴圈語句(while, for語句)中，用來終止當前迴圈語句的執行 break 說明： （1）當break語句執行後 ，此迴圈語句break之後的語句將不再執行 （2）break語句通常和if語句組合使用 （3）break語句終止迴圈時，迴圈語句else子句的語句將不會再執行 （4）break語句只能終止當前迴圈語句的執行，如果有迴圈巢狀時，不會跳出巢狀的外重迴圈 （5）break語句只能在迴圈語句(whlie或for)語句內部使用 示例：
n = int(input("please input a number: "))
j = 1
while j <= n:
pass
i = 1
while i <= n:
print(i, end=' ')
i = i + 1
else:
print()
if j == 4:
break
j = j + 1
死迴圈
死迴圈是指迴圈條件一直成立的迴圈；死迴圈通常用break語句來終止迴圈；死迴圈的else子句永遠不會執行。 示例：
sum = 0
while True:
n = int(input("Please input n"))
if n < 0:
break
sum = sum + n
print(sum)
for 語句
作用：用來遍歷可迭代物件的資料元素 可迭代物件是指能依次獲取資料元素的物件，可迭代物件包括： 字串：str 列表：list 元祖：tuple 字典：dict 集合：set
for語句語法： for 變數列表 in 可迭代物件： 語句塊1 else： 語句塊2 for 語法說明： (1) 可迭代物件每次提供一個元素依次賦值給變數列表中的變數,賦值完畢後執行語句塊1，重複執行此步驟，知道可迭代物件不能提供資料為止。 (2) 可迭代物件提供完所有的元素後，執行else子句部分的語句塊2，然後退出此for語句。 (3) else 子句部分可以省略(同while類似) (4) 當在迴圈內部用break終止迴圈時，else子句部分語句不會執行。 示例：
# 計算一個輸入的字串中有多少個空格
s = input("input a string")
count = 0
for ch in s:
if ch == ' ':
count = count + 1
print(count)
range 函式
help(range) 函式：range(stop)從零開始，每次生成一個整數後加1操作，知道stop為止(不包含stop) range(start, stop[, step])，從start開始，每次生成一個整數後移動step，直到stop為止(不包含stop，且step可以是負整數)。 作用：用來建立一個生成一系列整數的可迭代物件(也叫整數序列生成器) 說明：range返回的物件是可迭代物件，可以用於for語句中 示例：
range(4) # 生成0,1,2,3
range(3, 6) # 生成3，4,5
range(1, 10, 2) # 生成1,3,5,7,9
range(5, 0, -2) # 生成5,3,1
range(4, 0) # 空
for i in range(101):
if i * (i + 1) % 11 == 8:
print(i)
for 語句的巢狀
for 語句內部可以放任何語句，包括for語句和while語句
示例：
w = 5
k = 1
for i in range(1, w+1):
for j in range(k, w + k):
print(j, end=' ')
else:
print()
k = k + 1
continue 語句
作用：用於迴圈語句(while, for 語句)中，不再執行此次迴圈內continue之後的語句，重新開始一場新的迴圈 說明： (1) 在while 語句中，執行continue語句將會直接跳轉到while語句的真值表達式處重新判斷迴圈條件 (2) 在for語句中，執行continue語句，將會從可迭代物件中取下一個元素，繫結變數後再次進行迴圈 示例：
# 打印出偶數
begin = int(input("input number1: "))
end = int(input("input number2: "))
for i in range(begin, end + 1):
if(i % 2 == 1):
continue
else:
print(i)
示例：
# 用在while語句中
i = -1
while i < 10:
if i % 2 == 1:
i = i + 1
continue
else:
print(i)
i = i + 1
列表 list
列表是由一系列特定元素組成的，元素和元素之間沒有任何關聯關係，但他們之間有先後順序關係； 列表是一種容器； 列表是序列的一種； 列表是可以被改變的序列
python中序列型別簡介(sequence)
字串：str 列表：list 元祖：tuple 位元組串：bytes 位元組陣列：bytearray
建立一個空列表 L = [ ] # L繫結空列表 建立一個非空列表： L = [1, 2, 3, 4] L = [“A”, “B”, “C”, “D”] L = [1, “two”, 3, “四”] L = [1, 2, [3.1, 3.2, 3,3], 4] 列表中元素個數：len(L) 示例：
# 列表的構造（建立）函式
list() # 生成一個空列表，等同於[ ]
list(iterable) # 用可迭代物件建立一個列表
L = list() # []
L = list("ABCD") # ['A', 'B', 'C', 'D']
L = list(range(1, 10, 2)) # [1, 3, 5, 7, 9]
列表的運算
列表的算術運算
示例：
算術運算： + += * *=
+ 用於拼接列表：
x = [1, 2, 3]
y = [4, 5, 6]
z = x + y # [1, 2, 3, 4, 5, 6]
+= 用於原列表與左側可迭代物件進行拼接，生成新的列表, 右側必須是可迭代物件
x = [1, 2, 3]
x += [4, 5, 6] # [1, 2, 3, 4, 5, 6]
x = [1, 2, 3]
x += ["ABC"] # [1, 2, 3, 'ABC']
x = [1, 2, 3]
x += "ABC" # [1, 2, 3, 'A', 'B', 'C']
* 生成重複的列表
x = [1, 2, 3] * 2 # [1, 2, 3, 1, 2, 3]
*= 生成重複的列表，同時用變數繫結新列表
x = [1, 2, 3]
x *= 3 # [1, 2, 3, 1, 2, 3, 1, 2, 3]
列表的比較運算
示例：
運算子：
< <= > >= == !=
x = [1, 2, 3]
y = [2, 3, 4]
x != y # True
x > [1, 2] # True
x < y # True
[1, 3, 2] > [1, 2, 3] # True
['AB', 'CD'] > ['AC', 'BD'] # False
[1, 'two'] > ['two', 1] # TypeError, 數字不能和字串比較
列表的基本操作
列表的in/not in
判斷一個數據元素是否存在於容器(列表)內，如果存在返回True，否則返回False，not in的返回值與in運算子相反。 示例：
x = [1, 'Two', 3.14, '四']
1 in x # True
2 in x # False
3 not in x # True
'四' not in x # False
列表的索引(index)和切片(slice)操作
列表的索引取值語句：列表[整數表示式] 用法：列表的索引取值與字串的索引取值規則完全相同；列表的索引分為正向索引和反向索引 示例：
L = ['A', 2, 'B', 3]
print(L[1]) # 2
print(L[2]) # 'B'
列表的索引賦值語句： 列表是可變的序列，可以通過索引賦值改變列表中的元素 語法：列表[索引] = 表示式 示例：
x = [1, 2, 3, 4]
id(x)
x[2] = 3.14 # [1, 2, 3.14, 4] 改變了第三個元素
id(x)
列表的切片
列表[:] 列表[::] 列表的切片值返回一個列表，規則等同於字串的切片規則 示例：
x = list(range(9))
y = x[1:9:2] # [1, 3, 5, 7]
y = x[:] # [0, 1, 2, 3, 4, 5, 6, 7, 8]
y = x[5::2] # [5, 7]
列表的切片賦值語法
列表[切片] = 可迭代物件 說明：切片賦值的賦值運算子右側必須是一個可迭代物件 示例：
L = [2, 3, 4]
L[0:1] = [1.1, 2.2] # [1.1, 2.2, 3, 4]
L = [2, 3, 4]
L[:] = [7, 8] # [7, 8]
L = [2, 3, 4]
L[1:2] = [3.1, 3.2, 3,3] # [2, 3.1, 3.2, 3, 3, 4]
L = [2, 3, 4]
L[1:1] = [3.1, 3.2, 3.3] # [2, 3.1, 3.2, 3.3, 3, 4] 在原列表中增加元素
L = [2, 3, 4]
L[3:3] = [5, 6] # [2, 3, 4, 5, 6] 在原列表後增加元素
L = [2, 3, 4]
L[0:0] = [0,1] # [0, 1, 2, 3, 4] 在原列表起始位置增加元素
L = [2, 3, 4]
L[1:2] = [] # [2, 4] 刪除列表中的元素
L = [1, 2, 3, 4, 5, 6, 7, 8]
L[1::2] = [2.2, 4.4, 6.6, 8.8] # [1, 2.2, 3, 4.4, 5, 6.6, 7, 8.8] 切片步長不為1的切片規則
切片注意事項： 對於步長不為1的切片賦值，賦值運算子的右側的可迭代物件提供元素的個數一定要等於切片切出的段數。 如： L = [1, 2, 3, 4, 5, 6] L[::2] = ‘ABCD’ # 錯的 L[::2] = ‘ABC’ # 對的
列表的del語句
del語句用於刪除列表中的元素 語法：del 列表[索引] del 列表[切片] 示例：
L = [1, 2, 3, 4, 5, 6]
del L[0] # [2, 3, 4, 5, 6]
del L[-1] # [2, 3, 4, 5]
L = [1, 2, 3, 4, 5, 6]
del L[::2] # [2, 4, 6]
python3 中常用的序列函式
len(x) # 返回序列的長度
max(x) # 返回序列的最大值元素
min(x) # 返回序列的最小值元素
sum(x) # 返回序列中所有元素的和(元素必須是數值型別)
any(x) # 真值測試，如果列表中其中一個值為真值則返回True，否則返回False
all(x) # 真值測試，如果列表中所有值都為真值，則返回True，否則返回False
常用的列表方法
L.index(v[, begin[, end]]) # 返回對應元素的索引下標，begin為開始索引，end為結束索引，當value不存在時觸發ValueError錯誤
L.insert(index, obj) # 將某個元素插放到列表中指定位置
L.count(x) # 返回列表中元素的個數
L.remove(x) # 從列表中刪除第一次出現在列表中的值
L.copy() # 複製此列表(只複製一層，不會複製深層物件)
L.append(x) # 向列表中追加單個元素
L.extend(lst) # 向列表中追加另一個列表
L.clear() # 清空列表，等同於L[:] = []
L.sort(reverse=False) # 將列表中的元素進行排序，預設順序按值的小到大順序排列
L.reverse() # 列表的反轉，用來改變原序列的先後順序
L.pop([index]) # 刪除索引對應的元素，如果不加索引，預設刪除最後元素，並返回刪除的元素