python中單行的註釋是用#
# 這是一個註釋
print("Hello, World!")
Python中多行的註釋是用三個單引號‘’‘或三個雙引號「」「將註釋括起來
#單引號：
'''
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號
'''
print("Hello, World!")
#雙引號：
"""
這是多行註釋，用三個雙引號
這是多行註釋，用三個雙引號
這是多行註釋，用三個雙引號
"""
print("Hello, World!")
位運算子
將數位轉換爲二進制進行計算
a=60 ,b=13
即，
a = 0011 1100
b = 0000 1101
a&b = 0000 1100 #&：參與運算的兩個值,如果兩個相應位都爲1,則該位的結果爲1,否則爲0（交集）
a|b = 0011 1101 # | ：只要對應的二個二進位有一個爲1時，結果位就爲1（並集）
a^b = 0011 0001 #^：當兩對應的二進位相異時，結果爲1
~a = 1100 0011 #~：對數據的每個二進制位取反,即把1變爲0,把0變爲1
<< 左移動運算子：運算數的各二進位全部左移若幹位，由 << 右邊的數位指定了移動的位數，高位丟棄，低位補0
a = 0011 1100
a<<2
a = 11110000
a = 240
>> 右移動運算子：把">>"左邊的運算數的各二進位全部右移若幹位，>> 右邊的數位指定了移動的位數
a = 0011 1100
a>>2
a = 00001111
a = 15
邏輯運算子
and，or，not
and運算
| 邏輯量1 | 邏輯量2 | 結果 |
|---|---|---|
| ture | ture | ture |
| ture | false | false |
| false | ture | false |
| false | false | false |
or運算
| 邏輯量1 | 邏輯量2 | 結果 |
|---|---|---|
| false | false | false |
| ture | false | ture |
| false | ture | ture |
| ture | ture | ture |
成員運算子
in，not in
身份運算子
| is | is 是判斷兩個識別符號是不是參照自一個物件 x is y, 類似 id(x) == id(y) , 如果參照的是同一個物件則返回 True，否則返回 False |
|---|---|
| is not | is not 是判斷兩個識別符號是不是參照自不同對象 x is not y ， 類似 id(a) != id(b)。如果參照的不是同一個物件則返回結果 True，否則返回 False。 |
算數運算子
| /浮點數除法 | 100/5=20.0 |
|---|---|
| //整數除法 | 100//5=20（向左取證） -3//2=-2 |
| %模（求餘） | 9%4=1 |
| **冪 | 2**3=8 |
關係運算符(還有大於等於)（單等=是賦值）
() xy x等於y 「ABCD」==」ABCDEF」 False
(!=) x!=y x不等於y 「ABCD」!=」abcd」 True
當字串和字串進行比較的時候，比較的是ASCII碼錶 碼表
例如：」123」與」23」 對第一個字元進行ASCII碼錶 碼表進行比較
2的ASCII碼錶 碼表值大於1，所以
「123」<=」23」
運算子的優先順序和結合性：
| 運算級 | 運算子 | 描述 | 結合性 |
|---|---|---|---|
| 1 | +x,-x | 正，負 | |
| 2 | x**y | 冪 | 從右向左 |
| 3 | x*y,x/y,x%y | 乘，除，取模 | 從左向右 |
| 4 | x+y,x-y | 加，減 | 從左向右 |
| 5 | x<y,x<=y,x==y,x!=y,x>=y,x>y | 比較 | 從左向右 |
| 6 | not x | 邏輯否 | 從左向右 |
| 7 | x and y | 邏輯與 | 從左向右 |
| 8 | x or y | 邏輯或 | 從左向右 |
數位型別：整型，浮點型，複數
整數（int）
預設情況下，整數爲十進制
int函數：
>>>int(x,base = 10)
#x：字串或數位
#base：進位制數，預設十進制
>>>int('12',16) #16進位制的12轉化成10進位制數
18
>>> int('0xa',16) #16進位制的16轉化成10進位制數
10
>>> int('10',8) #8進位制的10轉化成10進位制數
8
浮點數（float）
取值範圍與精度都有限制
小數：1.23,3.14，-9.01
科學計數法： 1.23e9 1.23*10**9
1.2e-5 1.2*10負五次方
浮點數運算存在不確定尾數，有誤差
round（0.1+0.2,2） 計算0.1+0.2，並保留兩位小數
複數
實部和虛部組成
虛部用j來表示
a= complex(1,2)
a(1+2j)
常用的進位制
| 二進制 | 0b或0B | 0b10 | 2 |
|---|---|---|---|
| 八進制 | 0o或0O | 0o10 | 8 |
| 十六進制 | 0x或0X | 0x或0X | 16 |
進位制的轉換
輸入一個整數和進位制，轉換成十進制輸出
s=input()
a=s.split(',')
print(int(a[0],int(a[1])))
hex 函數：用於將10進位制整數轉換成16進位制，以字串形式表示。
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'>
oct 函數：將一個整數轉換成 8 進位制字串。
>>> oct(10)
'012'
>>> oct(20)
'024'
>>> oct(15)
'017'
可以直接使用的數學函數：
| 作用 | 形式 | |
|---|---|---|
| abs | 返回數位的絕對值 | abs( x ) |
| cmp | 比較2個物件，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 | cmp( x, y ) |
| int | 將x轉換爲一個整數 | int(x [,base ]) |
| long | 將x轉換爲一個長整數 | long(x [,base ]) |
| float | 將x轉換到一個浮點數 | float(x ) |
| complex | 建立一個複數 | complex(real [,imag ]) |
| str | 將物件 x 轉換爲字串 | str(x ) |
| repr | 將物件 x 轉換爲表達式字串 | repr(x ) |
| eval | 用來計算在字串中的有效Python表達式,並返回一個物件 | eval(str ) |
| tuple | 將序列 s 轉換爲一個元組 | tuple(s ) |
| list | 將序列 s 轉換爲一個列表 | list(s ) |
| chr | 將一個整數轉換爲一個字元 | chr(x ) |
| unichr | 將一個整數轉換爲Unicode字元 | unichr(x ) |
| ord | 將一個字元轉換爲它的整數值 | ord(x ) |
| hex | 將一個整數轉換爲一個十六進制字串 | hex(x ) |
| oct | 將一個整數轉換爲一個八進制字串 | oct(x ) |
| round | 返回浮點數x的四捨五入值，n代表舍入到小數點後的位數 （若答案爲兩位小數，則用round無法保留超過兩位的小數） | round（x{ ，n}） |
| divmod | 返回x和y的商和餘數 | divmod（x，y） |
eval函數:用來執行一個字串表達式，並返回表達式的值。
\>>>x = 7
\>>> eval( '3 * x' )
21
\>>> eval('pow(2,2)') #pow是冪次
4
\>>> eval('2 + 2')
4
\>>> n=81
\>>> eval("n + 4")
85
pow函數：冪次
#pow(x,y):這個是表示x的y次冪。
<<<pow(2,4)
<<<16
#pow(x,y,z)：這個是表示x的y次冪後除以z的餘數
<<<pow(2,4,5)
<<<1
<<<pow(2,4)
<<<16
pow(x,y,z)：這個是表示x的y次冪後除以z的餘數
<<<pow(2,4,5)
<<<1
math模組：
模組提供了許多對浮點數的數學運算函數。（要先匯入math模組）
import math
| 函數 | 作用 | 形式 | 備註 |
|---|---|---|---|
| e | 自然常數 | ||
| pi | 圓周率 | ||
| ceil | 返回數位的上入整數 | math.ceil( x ) | # x=13.5 輸出：14 x=-45.17 輸出：-45 |
| exp | 返回x的指數,e**x | math.exp( x ) | |
| fabs | 返回數位的絕對值 | math.fabs( x ) | #math.fabs(-10) 返回10.0 |
| floor | 返回數位的下舍整數 | math.floor( x ) | # x=13.5 輸出：13 x=-45.17 輸出：-46 |
| log | 返回 x 的自然對數 | math.log(x[, base]) | #base – 可選，底數，預設爲 e |
| modf | 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示 | math.modf( x ) | #math.modf(100.12) : (0.12000000000000455, 100.0) |
| acos | 返回x的反餘弦弧度值 | acos(x) | |
| asin | 返回x的反正弦弧度值 | acos(x) | |
| atan | 返回x的反正切弧度值 | atan(x) | |
| degrees | 將弧度轉換爲角度 | math.degrees(x) | |
| radians | 將角度轉換爲弧度 | math.radians(x) |
亂數模組：
| random.random() | 返回一個介於左閉右開[0.0,1.)區間的浮點數 | random.random() |
|---|---|---|
| random.uniform(a,b) | 返回一個介於[a,b]的浮點數 | random.uniform(1,10) |
| random.randint(a,b) | 返回[a,b]的一個隨機整數 | random.randint(15,30) |
| random.randrange([start],stop[,step]) | 從指定範圍內，獲取一個亂數 | random.randrange(10,30,2) |
| random.choice(sequence) | 從序列中獲取一個隨機元素 | random.choice([3,78,43,7]) |
| random.shuffle(x) | 用於將一個列表中的元素打亂，即將列表的元素隨機排列 | random.shuffle(l),l是序列 |
| random.sample(sequence,k) | 從指定序列中隨機獲取長度爲k的序列並隨機排列 | random.sample([1,4,5,89,7],3) |
| random.seed(n) | 對亂數生成器進行初始化的函數，n代表隨機種子。參數爲空時，隨機種子爲系統時間 | random.seed(2) |
shuffle函數：隨機打亂列表順序
>>> import random
>>> random.shuffle(t)
>>> t
[9, 4, 7, 5, 2, 3, 6] #排列隨機，使用一次變化一次
>>> random.shuffle(t)
>>> t
[3, 9, 4, 6, 7, 5, 2]
choice函數：隨機選擇列表中的元素
>>> t
[3, 9, 4, 6, 7, 5, 2]
>>> random.choice(t)
3
>>> random.choice(t)
4
>>> random.choice(t)
4
random函數：隨機取得一個0-1之間的浮點數
>>> random.random()
0.01992198919664634
>>> random.random()
0.12040606605813042
>>> random.random()
0.5497462876939886
randint函數：在範圍內隨機取得一個整數
>>> random.randint(1,100)
54
>>> random.randint(1,100)
33
>>> random.randint(1,100)
44
seed函數：有一個確定的值，也會獲得一個確定的值（確定的輸入得到確定的輸出）用seed（0），randint設定10個數據之後，再用seed（0）會輸出同樣的10個數據。如果用seed（1）就會生成新的數據
>>> random.seed(0)
>>> random.randint(1,100)
50
>>> random.randint(1,100)
98
>>> random.seed(0)
>>> random.randint(1,100)
50
>>> random.randint(1,100)
98
若文字中有雙引號，可以用單引號括起來
若文字中有單引號，可以用雙引號括起來
既有單引號又有雙引號，可用三引號
布爾值
布爾值：Ture，False
邏輯運算和關係運算的結果是布爾值
跳脫字元
| 符號 | 作用 | 符號 | 作用 |
|---|---|---|---|
| \ | 反斜槓符號 | \v | 縱向製表符 |
| ’ | 單引號 | \t | 橫向製表符 |
| ‘’ | 雙引號 | \r | 回車 |
| \a | 響鈴 | \f | 換頁 |
| \b | 退格 | \ooo | 最多三位八進制，例如：\12代表換行 |
| \n | 換行 | \xyy | 十六進制，yy代表的字元，例如：\xOa代表換行 |
應用
\’ ：可以代表單引號’本身，並不作爲字串結束的標誌
>>> 'It\'s a good day.'
"It's a good day."
\n:回車換行
>>> 'this is a line\nand another line'
'this is a line\nand another line'
>>> s = 'this is a line\nand another line'
>>> print(s)
this is a line
and another line
\t:製表符，製表位：讓下一個字元出現在某一個特定的位置上
>>> s = 'this is a tab \tin the line'
>>> print(s)
this is a tab in the line
三引號的使用：（字串內容可以跨行，換行的過程也會用反斜槓記錄下來）
>>> s = '''i
love
you
baby
'''
>>> s
'i\nlove\nyou\nbaby\n'
>>> print(s)
i
love
you
baby
直接使用反斜槓\：（不進行換行，下一行的會緊緊連線在上一行上面）
>>> s = 'this\
is\
a\
test.\
'
>>> s
'this is a test. '
在單引號’前面加r：（會使字串中的反斜槓\保留在字串裡）
r： 這個字串表示原式的字串
這個字串中的反斜槓\不會被當做跳脫字元的字首
字串中的反斜槓\會被python的直譯器重新還原成兩個反斜槓\的跳脫字元的形態
>>> s = r'this\nis\na\ntest/'
>>> s
'this\\nis\\na\\ntest/' #print\\時會輸出\
>>> print(s)
this\nis\na\ntest/
字串運算子（可以正向也可以反向）
設s=」abcdefgh」
a b c d e f g h
0 1 2 3 4 5 6 7 正向
-8 -7 -6 -5 -4 -3 -2 -1 反向
| 索引 | 在【】中給出序號 | s[0]=’a’ s=[-1]=’h’ |
|---|---|---|
| 切片 | 在【:】中給出切片序號範圍 | s[1:5]=’bcde’ |
| + | 連線字串 | ‘hello’+‘world’=‘helloworld’ |
| * | 複製字串 | ‘ab’*=‘ababab’ |
若省略冒號後面的數位[a:]，則代表從第a+1個字元取到末尾字元
若省略冒號前面的數位[:b],則代表從第一個字元取到第b個字元
>>> '2020 welcome u'[4:]
' welcome u'
>>> '123456789'[:5]
'12345'
>>> '123456789'[2:]
'3456789'
在字串的運算中
百分號%：字串的格式化運算子
如果百分號的左邊是一個字串，它就要做字元號的百分號運算
在百分號前面的字串裏面放一些格式限定符，這些格式限定符將來會被百分號右邊的數據給替換掉
>>> 'I am %d years old.'%18
'I am 18 years old.'
>>> 'I am %d years old and weight %d kg.'%(18,65)
'I am 18 years old and weight 65 kg.'
>>> 'it is %.1fC.'%30.5 #%.nf ---保留n位小數，並且答案會進行四捨五入
'it is 30.5C.'
>>> 'it is %.1fC.'%30.1314
'it is 30.1C.'
>>> 'it is %.1fC.'%30.7914
'it is 30.8C.'
>>> ' I am %10d year old.'%18 #代表百分號到d（18）之間有8個空格
' I am 18 year old.' （數據要輸出的時候要保留多少位置）
>>> 'it is %10.1fC.'%30.7914
'it is 30.8C.'
f-string（f-fast）
new file:
name = 'Eric'
age = 74
print(f"Hello,{name}.You are {age}.")
Hello,Eric.You are 74.
>>> f"{2*7}"
'14'
>>> comedian = {'name':'Jame','age':74}
>>> f"The comedian is {comedian['name']},aged{comedian['age']}."
'The comedian is Jame,aged74.'
字串的格式化輸出：
| %c | 格式化字元及其ASCII碼 |
|---|---|
| %s | 格式化字串 |
| %d | 格式化整數 |
| %u | 格式化無符號整型 |
| %o | 格式化無符號八進制數 |
| %x | 格式化無符號十六進制數 |
| %X | 格式化無符號十六進制數（大寫） |
| %f | 格式化浮點數位，可指定小數點後的精度 |
| %e | 用科學計數法格式化浮點數 |
| %E | 作用同%e，用科學計數法格式化浮點數 |
| %g | %f和%e的簡寫 |
| %G | %F 和 %E 的簡寫 |
| %p | 用十六進制數格式化變數的地址 |
字串函數：
capitalize函數：將字串的第一個字母變成大寫,其他字母變小寫。對於 8 位位元組編碼需要根據本地環境。
center函數：返回一個原字串居中,並使用空格填充至長度 width 的新字串。預設填充字元爲空格。
str.center(width[, fillchar])
width -- 字串的總寬度。
fillchar -- 填充字元。
count函數：用於統計字串裡某個字元出現的次數。可選參數爲在字串搜尋的開始與結束位置。
str.count(sub, start= 0,end=len(string))
sub -- 搜尋的子字串
start -- 字串開始搜尋的位置。預設爲第一個字元,第一個字元索引值爲0
end -- 字串中結束搜尋的位置。字元中第一個字元的索引爲 0。預設爲字串的最後一個位置。
decode函數：以 encoding 指定的編碼格式解碼字串。預設編碼爲字串編碼。（不會）
encode函數： 以 encoding 指定的編碼格式編碼字串。errors參數可以指定不同的錯誤處理方案。（不會）
endswith函數：用於判斷字串是否以指定後綴結尾，如果以指定後綴結尾返回True，否則返回False。可選參數"start"與"end"爲檢索字串的開始與結束位置。
startswith函數：用於檢查字串是否是以指定子字串開頭，如果是則返回 True，否則返回 False。如果參數 beg 和 end 指定值，則在指定範圍內檢查。
str.endswith(suffix[, start[, end]])
suffix -- 該參數可以是一個字串或者是一個元素。
start -- 字串中的開始位置。
end -- 字元中結束位置。
str = "this is string example....wow!!!"
print(str.endswith('r',1,11))
輸出:Ture
str = "this is string example....wow!!!"
print(str.endswith('r',1,12))
輸出:False
expandtabs函數:把字串中的 tab 符號('\t')轉爲空格，tab 符號('\t')預設的空格數是 8。
str.expandtabs(tabsize=8)
tabsize -- 指定轉換字串中的 tab 符號('\t')轉爲空格的字元數。
str = "this is\tstring example....wow!!!"
>>> print ("Double exapanded tab: " + str.expandtabs(16))
Double exapanded tab: this is string example....wow!!!
>>> print ("Double exapanded tab: " + str.expandtabs(1))
Double exapanded tab: this is string example....wow!!!
>>> print ("Double exapanded tab: " + str.expandtabs(8))
Double exapanded tab: this is string example....wow!!!
>>> print ("Double exapanded tab: " + str.expandtabs(9))
find函數：在字串當中查詢子字串的位置 s.find(sub,[,start[,end]])
rfind函數：在字串當中查詢子字串最後出現的位置
>>> s = 'Lionel Messi'
>>> s
'Lionel Messi'
>>> s.find('Messi') #第一個是零號，空格也佔用一個編號
7
>>> s.find('on')
2
>>> s.find('aa') #若要查詢的子字串不存在，則會返回-1
-1
>>> 'hello world'.find('l') #當一個字串內同時存在多個相同字元
2 #出現的編號是從左邊開始，出現的第一個該字元的位置
>>> 'hello world'.find('l',3) #第二個參數表示find函數從哪個編號開始找
3
>>> 'hello world'.find('l',4)
9
isalnum函數:檢測字串是否由字母和數位組成。
如果 string 至少有一個字元並且所有字元都是字母或數位則返回 True,否則返回 False
str.isalnum()
str = "this2009"; # 字元中沒有空格
print (str.isalnum())
輸出：Ture
str = "this is string example....wow!!!" # 字元中有空格
print (str.isalnum())
輸出：False
isalpha函數:檢測字串是否只由字母組成。
如果字串至少有一個字元並且所有字元都是字母則返回 True，否則返回 False。
str.isalpha()
isdigit函數：檢測字串是否只由數位組成
str = "123456"; # Only digit in this string
print str.isdigit() #Ture
str = "this is string example....wow!!!";
print str.isdigit() #False
isdecimal函數：檢查字串是否只包含十進制字元。這種方法只存在於unicode物件。
注意:定義一個十進制字串，只需要在字串前新增 'u' 字首即可。
str.isdecimal()
str = u"this2009";
print (str.isdecimal())
輸出：False
str = u"23443434";
print (str.isdecimal())
輸出:Ture
islower函數:檢測字串是否由小寫字母組成
str.islower()
isnumeric函數:檢測字串是否只由數位組成
str.isnumeric()
isspace函數：檢測字串是否只由空格組成。
str.isspace()
istitle函數：檢測字串中所有的單詞拼寫首字母是否爲大寫，且其他字母爲小寫
str.istitle()
title函數：所有單詞的首個字母轉換爲大寫，其餘字母均爲小寫
str.title()
isupper函數：檢測字串中所有的字母是否都爲大寫
str.isupper()
upper函數：將字串中的小寫字母轉爲大寫字母
str.upper()
join函數： 用於將序列中的元素以指定的字元連線生成一個新的字串。
返回通過指定字元連線序列中元素後生成的新字串。
str.join(sequence)
sequence -- 要連線的元素序列。
str = "-"
seq = ("a","b","c")
print(str.join(seq))
輸出：a-b-c
ljust函數：返回一個原字串左對齊,並使用填充字元填充至指定長度的新字串。
rjust函數：返回一個原字串右對齊,並使用填充字元填充至指定長度的新字串。
如果指定的長度小於原字串的長度則返回原字串。
str.ljust(width[, fillchar])
width -- 指定字串長度。
fillchar -- 填充字元，預設爲空格。
str = "this is string example....wow!!!"
print (str.ljust(50, 'a'))
輸出：this is string example....wow!!!aaaaaaaaaaaaaaaaaa
輸出：aaaaaaaaaaaaaaaaaathis is string example....wow!!!（rjust）
lower函數：轉換字串中所有大寫字元爲小寫
返回將字串中所有大寫字元轉換爲小寫後生成的字串。
str.lower()
lstrip函數：用於截掉字串左邊的空格或指定字元
rstrip函數：用於截掉字串末尾的空格或指定字元
strip函數：用於截掉字串頭尾的空格或指定字元
str.lstrip([chars])
chars --指定擷取的字元。
返回截掉字串左邊的空格或指定字元後生成的新字串。
str = "8888888this is string example...wow!!!8888888"
print(str.lstrip("8"))
輸出：this is string example...wow!!!8888888
maketrans函數:建立字元對映的轉換表，兩個字串的長度必須相同，爲一一對應的關係
str.maketrans(intab, outtab)
intab -- 字串中要替代的字元組成的字串。
outtab -- 相應的對映字元的字串。
返回字串轉換後生成的新字串。
replace函數：替換一段字串爲其他的內容 s.replace(old,new[,max])
old -- 將被替換的子字串。
new -- 新字串，用於替換old子字串。
max -- 可選字串, 替換不超過 max 次
>>> s = ' hello world '
>>> s.replace(' ','-') #將字串中的空格全部轉換成減號-
'-hello-world-'
>>> s = ' hello world '
>>> s.replace(' ','--') #將字串中的空格全部轉換成兩個減號--
'--hello--world--'
>>> s = ' hello world '
>>> s.replace(' ','') #將字串中的空格全部轉換成空字元
'helloworld' （即去掉字串中的空格，但與strip不同，strip只去除兩端的空格）
translate函數：根據參數table給出的表(包含 256 個字元)轉換字串的字元,要過濾掉的字元放到 deletechars 參數中
str.translate(table)
bytes.translate(table[, delete])
bytearray.translate(table[, delete])
table -- 翻譯表，翻譯表是通過 maketrans() 方法轉換而來。
deletechars -- 字串中要過濾的字元列表。
intab = "abcdefg"
outtab = "1234567"
a = str.maketrans(intab,outtab)
str = "this is a very beautiful girl"
print(str.translate(a))
輸出：this is 1 v5ry 251uti6ul 7irl
split函數：通過指定分隔符對字串進行切片
如果第二個參數 num 有指定值，則分割爲 num+1 個子字串
str.split(str="", num=string.count(str))
str -- 分隔符，預設爲所有的空字元，包括空格、換行(\n)、製表符(\t)等。
num -- 分割次數。預設爲 -1, 即分隔所有。
str = "this is string example....wow!!!"
print (str.split( )) # 以空格爲分隔符
print (str.split('i',1)) # 以 i 爲分隔符
print (str.split('w')) # 以 w 爲分隔符
輸出：
['this', 'is', 'string', 'example....wow!!!']
['th', 's is string example....wow!!!']
['this is string example....', 'o', '!!!']
splitlines函數： 按照行('\r', '\r\n', \n')分隔，返回一個包含各行作爲元素的列表
如果參數 keepends 爲 False，不包含換行符，如果爲 True，則保留換行符
str.splitlines([keepends])
keepends -- 在輸出結果裡是否去掉換行符('\r', '\r\n', \n')
預設爲 False，不包含換行符，如果爲 True，則保留換行符
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
swapcase函數：用於對字串的大小寫字母進行轉換。
str.swapcase()
str = "this is string example....wow!!!"
print (str.swapcase())
輸出：THIS IS STRING EXAMPLE....WOW!!!
str = "This Is String Example....WOW!!!"
print (str.swapcase())
輸出：tHIS iS sTRING eXAMPLE....wow!!!
str函數：將物件轉化爲適於人閱讀的形式
>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
repr函數：將物件轉化爲供直譯器讀取的形式
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
zfill函數:返回指定長度的字串，原字串右對齊，前面填充0。
str.zfill(width)
str = "this is string example from runoob....wow!!!"
print("str.zfill:",str.zfill(50))
輸出：str.zfill: 000000this is string example from runoob....wow!!!
列表定義
由一系列按照指定順序排列的順序組成的，列表當中的元素可以是不同的型別
列表是用方括號把字元括起來，字串是用引號把字元括起來
列表之間的元素是用逗號進行分割
>>> a = 6
>>> b= 8
>>> t = [a,b]
>>> t
[6, 8]
>>> t = [a+2,b-a]
>>> t
[8, 2]
>>> t = list('this is a strin')
>>> t
['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 's', 't', 'r', 'i', 'n']
#字串當中的每一個字元都變成了列表當中的 item，空格也不例外
列表的常用函數
append函數：在列表末尾增加一個元素或一個列表(增加的元素爲一個列表時，則新的元素爲一個列表）
>>> t1
[1, 2, 3]
>>> t1.append(5)
>>> t1
[1, 2, 3, 5]
>>> t1 = [1,2,3]
>>> t1.append([4,5,6])
>>> t1
[1, 2, 3, [4, 5, 6]] #有4個元素
extend函數：在列表後面增加元素或列表（類似於加號使用）
>>> t1
[1, 2, 3, 5]
>>> t1.extend([4,5,6])
>>> t1
[1, 2, 3, 5, 4, 5, 6]
insert函數：在某個位置之間插入一個元素或一個列表（當insert的位置超過最大的數之後，會加在最後）
>>> t1
[1, 2, 3, 5, 4, 5, 6]
>>> t1.insert(1,9) #在編號1前面（第2個元素前面）增加一個元素9
>>> t1
[1, 9, 2, 3, 5, 4, 5, 6]
remove：刪除值爲多少的單個的元素
>>> t1
[1, 2, 3, [4, 5, 6]]
>>> t1.remove(2)
>>> t1
[1, 3, [4, 5, 6]]
>>> t = [1,2,3,1,2,3,1,2,3,1,2,3,1,2,3]
>>> t.remove(2)
>>> t
[1, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
pop函數：帶有返回的刪除參數所屬元素（不帶參數時刪除最後一個）
>>> a = [1,2,3]
>>> a.pop() #返回3
3
>>> a #得到除了3,剩下的元素
[1, 2]
>>> a = [1,2,3,4,5,6,7,8,9]
>>> a.pop(3)
4
>>> a
[1, 2, 3, 5, 6, 7, 8, 9]
reverse函數：顛倒列表中函數的順序
>>> a
[1, 2, 3, 5, 6, 7, 8, 9]
>>> a.reverse()
>>> a
[9, 8, 7, 6, 5, 3, 2, 1]
list函數：根據傳入的參數建立一個新的列表（將元組或字串轉換爲列表）
index函數：查詢元素是否存在於列表裏面（得到爲該元素第一次出現的位置）
rindex函數：查詢元素是否存在於列表裏面（得到爲該元素最後一次出現的位置）
該方法與 python find()方法一樣，只不過如果str不在 string中會報一個異常。
>>> a
[9, 8, 7, 6, 5, 3, 2, 1]
>>> a.index(5)
4 #得出5在4號位上
列表函數的補充：
| L.clear（） | 移除列表L的所有元素 |
|---|---|
| L.count（x） | 計算列表L中x出現的次數 |
| L.copy（） | 列表L的備份 |
| L.index（value【，start【，stop】】） | 計算在指定範圍內value的下標 |
| L.sort（） | 對列表元素排序 |
| max（） | 求最大值 |
| min（） | 求最小值 |
| 求得字串（列表）長度 |
列表和字串之間的轉換：
>>> s = 'this is a test'
>>> s.split() #split函數：每一個單詞都變成一個item
['this', 'is', 'a', 'test'] #（split可以通過空格進行分割）
>>> list(s) #list函數：每一個字元都變成一個item
['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't']
>>> s = '12:35' #split函數可以增加字元，字元代表什麼作爲分隔（可以是多個字元）
>>> s.split(':')
['12', '35']
>>> s = '12::35'
>>> s.split('::')
['12', '35']
>>> s = '12::35' #兩個分隔符若相連，則會有空的item
>>> s.split(':')
['12', '', '35']
>>> s = '12356982259265625212' #字元多次出現則有多個分隔
>>> s.split('2')
['1', '35698', '', '59', '656', '5', '1', '']
>>> s = 'this is a test' #join函數：把列表中的元素組成一個大的字串
>>> t = s.split()
>>> t
['this', 'is', 'a', 'test']
>>> ' '.join(t)
'this is a test'
>>> t
['this', 'is', 'a', 'test']
列表切片
切片：在一個序列中取出一個連續的片段的操作
[a-1:b]既把輸入值的第a到b項切出，方括號內的冒號形成了切片
例：[2:6]
0 1 2 3 4 5 6 7
在第2個後面和第6個前面各切一刀 得：2 3 4 5
字串取出一段還是字串，列表取出一段還是列表
>>> month = ['JAN','FEB','MAR','APR','MAY','JUN','JUL','AUG','SEP','OCT','NOV','DEC']
>>> month
['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
>>> month[4:8]
['MAY', 'JUN', 'JUL', 'AUG']
>>> 'zhejiang'[3:7]
'jian'
>>> 'zhejiang'[3:8]
'jiang'
用負數的切片可以省略字串後面的字元 #空格也佔一個編號
>>> '26C' [0:-1]
'26'
>>> '8C'[0:-1]
'8'
>>> '2020 welcome u '[4:-1] #u後面還有一個空格
' welcome u'
>>> '2020 welcome u'[4:-1]
' welcome '
列表的元素可以是其他列表，但是要判斷子列表是否在內，應該在列表中依然以列表形式存在
>>> t1 = [1,2,3]
>>> 1 in t1
True
>>> [1,2]in t1
False
>>> [1,2] in [[1,2],3]
True
>>> [1] in [1,2,3]
False
第一個就是第零號或第-n號
>>> t1 = [[1,2,3],[4,5],6]
>>> t1[0]
[1, 2, 3]
>>> t1[1]
[4, 5]
>>> t1[2]
6
>>>t1[-1]
[6]
>>> t1[0]
[1, 2, 3]
>>> t1[1]
[4, 5]
>>> t1[2]
6
>>>t1[-1]
[6]
可以通過下標來找到改列表中某個元素並改變它的值：
>>>s1 = [1,2,3,4,5]
>>>s1
[1, 2, 3, 4, 5]
>>> s1[1]
2
>>> s1[1] = 2.1
>>> s1
[1, 2.1, 3, 4, 5]
元組tuple（列表和字串以外的序列容器）
元組的字面量用的是圓括號（）
列表的字面量用的是方括號【】
（）圓括號表達元組 【】方括號表達列表 {}大括號表達集合和字典
元組是一種不可修改的數據（無法進行修改）
>>> t = [1,2,3]
>>> t
[1, 2, 3]
>>> p = (1,2,3)
>>> p
(1, 2, 3)
>>> t[0] = 4
>>> t
[4, 2, 3]
>>> p[0] = 4
'tuple' object does not support item assignment #（元組不支援元素的賦值）
>>> min(p)
1
>>> len(p)
3
>>> p[0]
1
部分列表函數在元組中可以使用，但會對列表（元組）內部進行修改的函數在元組中不能使用
>>> p = (1,2,3)
>>> t.append(4)
>>> t
[4, 2, 3, 4]
>>> p.append(4)
'tuple' object has no attribute 'append' #元組中沒有append這種操作（屬性）
將元組發給別人，別人無法修改元組的值
可以將列表數據轉換成元組
>>> t = [1,2,3,4]
>>> t
>>> p = tuple(t)
>>> p
(1, 2, 3, 4)
如果有用逗號分隔的量，會被認爲是元組
>>> p = 3,4
>>> p
(3, 4)
元組內建函數：
| 函數 | 作用 |
|---|---|
| len(tuple) | 計算元組元素個數。 |
| min(tuple) | 返回元組中元素最小值。 |
| max(tuple) | 返回元組中元素最大值。 |
| tuple（iterable） | 將可迭代系列轉換爲元組。 |
字典是另一種可變容器模型，且可儲存任意型別物件。
字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
>>> d = {'one':1,'two':2}
>>> d
{'one': 1, 'two': 2}
兩個條目：one和two
one是鍵，1是值，one對應1
建立了字典之後，可以不通過函數去增加，可以直接方括號賦值
>>> d['three'] = 3
>>> d['three']
3
刪除條目：
用del語句，刪除指定鍵的字典條目
>>> d
{'one': 1, 'two': 2, 'three': 3}
>>> del d['two']
>>> d
{'one': 1, 'three': 3}
但不能刪除不存在的條目
>>> del d['four']
KeyError: 'four'
刪除字典元素
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 刪除鍵 'Name'
dict.clear() # 清空字典
del dict # 刪除字典
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
字典函數
clear：用於刪除字典內所有元素
dict.clear()
copy：返回一個字典的淺複製
dict.copy()
fromkeys:建立一個新字典，以序列seq中元素做字典的鍵，value爲字典所有鍵對應的初始值
dict.fromkeys(seq[, value])
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("新的字典爲 : %s" % str(dict))
#輸出：新的字典爲 : {'age': None, 'name': None, 'sex': None}
dict = dict.fromkeys(seq, 10)
print ("新的字典爲 : %s" % str(dict))
#輸出：新的字典爲 : {'age': 10, 'name': 10, 'sex': 10}
get：返回指定鍵的值，如果鍵不在字典中返回預設值
dict.get(key, default=None)
key – 字典中要查詢的鍵。
key in dict #判斷鍵是否存在於字典中，如果鍵在字典 dict 裡返回 true，否則返回 false。
default – 如果指定的鍵不存在時，返回該預設值值。
dict = {'Name': 'Runoob', 'Age': 27}
print ("Age 值爲 : %s" % dict.get('Age'))
print ("Sex 值爲 : %s" % dict.get('Sex', "NA"))
輸出：Age 值爲 : 27
輸出：Sex 值爲 : NA
items：以列表返回可遍歷的(鍵, 值) 元組陣列
dict.items()
dict = {'Name': 'Runoob', 'Age': 7}
print ("Value : %s" % dict.items())
#輸出：Value : dict_items([('Name', 'Runoob'), ('Age', 7)])
setfault：與find作用相似，若鍵不存在，輸出default
dict.setdefault(key, default=None)
key -- 查詢的鍵值。
default -- 鍵不存在時，設定的預設鍵值。
update：把字典參數dict2的key/value對更新到字典dict裡
dict.update(dict2)
dict2 -- 新增到指定字典dict裡的字典。
values：返回迭代器
dict.values()
dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print ("字典所有值爲 : ", list(dict.values()))
#輸出：字典所有值爲 : ['female', 7, 'Zara']
pop：刪除給定key的值，若沒有key，則返回default
若要刪除的key不存在，則需要新增預設值default，否則會報錯
pop（key【，default】）
>>> site= {'name': '菜鳥教學', 'alexa': 10000, 'url': 'www.runoob.com'}
>>> pop_obj=site.pop('name')
>>> print(pop_obj)
#輸出：
菜鳥教學
popitem：隨機返回並刪除字典中的最後一對鍵和值
若字典已空，呼叫此方法，就會報出KeyError異常
popitem（）
site= {'name': '菜鳥教學', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.popitem()
print(pop_obj)
print(site)
#輸出：
('url', 'www.runoob.com')
{'name': '菜鳥教學', 'alexa': 10000}
len（dict）：計算字典元素個數，鍵的總數
str（dict）：輸出字典，以可列印的字串表示
type（variable）：返回輸入的變數型別，如果變數是字典就返回字典型別
字典可以賦值，可以增加也可以修改（用方括號）
>>> d['one'] = 11
>>> d
{'one': 11, 'three': 3}
其他函數：
>>> len(d) #獲得字典中條目的數量
2
>>> min(d) #求字典中最小的key
'one'
>>> sum(d) #無法相加
unsupported operand type(s) for +: 'int' and 'str'
獲得字典中某個key對應的值：get函數
>>> d
{'one': 11, 'three': 3}
>>> d.get('one')
11
>>> d.get('ok') #當條目在字典中不存在時，會沒有輸出
>>> d.get('ok',1) #當條目在字典中不存在時，會輸出後面的數據
1
用大括號（唯一性，丟入大量數據後剩下的數據唯一）
特點：
1.集閤中沒有重複的元素
2.集閤中數的順序不重要
不重複性：
>>> s = {1,2,3,3,4}
>>> s
{1, 2, 3, 4}
無序性：（程式設計師無法指定數的順序）
>>> s = {1,3,2,5,4}
>>> s
{1, 2, 3, 4, 5}
可以增加元素（可變，但是不會重複）
>>> s = {1,3,2,5,4}
>>> s.add(0)
>>> s
{0, 1, 2, 3, 4, 5}
>>> s.add(3)
>>> s
{0, 1, 2, 3, 4, 5}
列錶轉換爲集合：(set函數)
>>> t = [1,3,2,5,4]
>>> s1 = set(t)
>>> s1
{1, 2, 3, 4, 5}
>>> t
[1, 3, 2, 5, 4]
frozenset函數：返回一個凍結的集合，凍結後集合不能再新增或刪除任何元素。
>>>a = frozenset(range(10)) # 生成一個新的不可變集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob')
>>> b
frozenset(['b', 'r', 'u', 'o', 'n']) # 建立不可變集合
兩個空大括號連起來不是集合，是字典
>>> {}
{}
>>> type({})
<class 'dict'>
建立空的集合：
>>> set()
set()
>>> type(set())
<class 'set'>
集合內建函數：
copy函數：拷貝一個集合
set.copy()
difference函數：返回集合的差集(會返回第一個集閤中第二個集合沒有的元素）
set.difference(set)
difference_update函數：移除第一個集閤中第二個集合有的相同元素（直接在原來集閤中移除元素，沒有返回值）
set.difference_update(set)
intersection函數：返回集合的交集（返回一個新的集合）
set.intersection(set1, set2 ... etc)
intersection_update函數：返回集合的交集（返回一個新的集合）
set.intersection_update(set1, set2 ... etc)
isdisjoint函數:判斷兩個集合是否包含相同的元素（不包含則返回True，包含則返回False）
set.isdisjoint(set)
issubset函數：判斷集合所有元素是否都包含在指定集閤中（前面的集合是否包含在後面的集合裡，是則返回True，否則返回False）
set.issubset(set)
issuperset函數：判斷集合所以元素是否都包含在原始的集閤中(後面的集合是否包含在前面的集合裡，是則返回True，否則返回False)
set.issuperset(set)
symmetric_difference函數：返回兩個集閤中不重複的元素集合(返回一個新的集合)
set.symmetric_difference(set)
symmetric_difference_update函數：移除當前集閤中在另外一個指定集合相同的元素，並將另外一個指定集閤中不同的元素插入到當前集閤中
set.symmetric_difference_update(set)
set union函數：返回兩個集合的並集，即包含所有集合的元素，重複的元素只會出現一次
set.union(set1,set2...)
set1----必需，合併的目標集合
set2----可選，其他要合併的集合，可以多個，多個使用逗號隔開
（返回一個新集合）
不能存取集閤中的第n號元素
>>> s[0]
TypeError:'set' object does not support indexing（集合的物件不可以取下標）
無法指定集閤中元素的位置，所以不能通過位置存取集閤中的元素
可以輸出集閤中的元素：
>>>s = {1,2,3}
>>> for x in s:
print(x)
1
2
3
可以判斷集閤中是否存在某個元素：
>>> s = {1,2,3,4,5,6,7,8,9}
>>> 3 in s
True
>>> 10 in s
False
可以判斷兩個集合是否相等
>>> s = {1,2,3,4,5,6,7,8,9}
>>> t = {1,2,3,5,6}
>>> s == t
False
判斷集合之間的包含關係（包含或不包含）
>>> s = {1,2,3,4,5,6,7,8,9}
>>> ss = {1,3,4} （真子集）
>>> ss < s
True
>>> {1,3,4}<ss
False
>>> {1,3,4}<=ss （子集）
True
並集|：
>>> s1 = {1,2,3}
>>> s2 = {4,5,6}
>>> s1 | s2
{1, 2, 3, 4, 5, 6}
交集&：
>>> s1 = {1,2,3}
>>> s2 = {4,5,6}
>>> s3 = {1,2,4,5,7,8}
>>> s1 & s3
{1, 2}
>>> s1 & s2 #沒有相同的元素（交集爲空集）
set()
對稱差^：把集合取並集，再去掉交集的部分
>>> s1
{1, 2, 3}
>>> s3
{1, 2, 4, 5, 7, 8}
>>> s1 ^ s3
{3, 4, 5, 7, 8}
在一個集閤中去掉某個集合（差集）：
>>> s1
{1, 2, 3}
>>> s3
{1, 2, 4, 5, 7, 8}
>>> s1 - s3
{3}
條件語句的三種格式：
1.基本的條件語句：
if 條件：
語句塊1
2. 有分支的條件語句：
if 條件：
語句塊1
else：
語句塊2
3.連綴的if-elif-else：
if 條件1：
語句塊1
elif 條件2：
語句塊2
...
elif 條件n：
語句塊n
else：
語句塊n+1
if邏輯表達式後面和else後面要加入冒號：
當邏輯表達式爲真的時候，則會實行語句塊1
當邏輯表達式爲假的時候，則會實行語句塊2
一次執行一項，要麼執行語句塊1，要麼執行語句塊2，不會同時執行
但是多次執行當中，語句塊1,2都有可能會執行
當條件爲0時，條件必然不成立
當條件爲1時，條件必然成立
#例：
x = int(input())
if x>0:
print('POS') #要有tab進行縮排
else: #else和if是並列的關係，當if的條件不滿足時，會執行else的條件
print('NEG') #一個語句塊可以進行多個操作（帶多條語句）
同時輸入兩個數，輸出更大的數據
x,y = map(int,input().split())
if x>y:
print(x)
else:
print(y)
輸入 3（x） 5（y）
輸出 5
巢狀條件例子：
x,y = map(int,input().split())
if x>y: #程式中可進行超過一次的if函數判斷
if x>0: #巢狀的if語句
print(x) #可以在if後面增加if語句
else:
print(-x)
else: #也可以在else後面增加if語句
if y>0:
print(y)
else:
print(-y)
輸入： -6（x） -10（y）
輸出： 6
while語句
（可以配合continue和break進行使用）
無限回圈：如果條件判斷語句永遠爲 true，回圈將會無限的執行下去 #以上的無限回圈你可以使用 CTRL+C 來中斷回圈。
#具體解析例子：求一大串數據的平均數
s = 0 #設s爲和
n = 0 #設n爲個數
while True: #進入回圈
x = int(input()) #將數值輸入
if x!=-1: #當輸入的數值不等於-1時
s += x #和數每次加入數值
n += 1 #沒加入一個數值，個數每次加一
else: #當輸入的數值等於-1
break #打破回圈
if n>0: #如果輸入數據的個數大於0
print(s/n) #輸出總數除以個數的值（平均數）
else： #如果輸入的數據個數爲0
print（0） #輸出0
#範例：
#while …else在回圈條件爲 false 時執行 else 語句塊：
count = 0
while count < 5:
print (count, " is less than 5")
count = count + 1
else:
print (count, " is not less than 5")
#輸出：
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5
當回圈條件爲while 1時，回圈必定成立
i = 1
while 1: # 回圈條件爲1必定成立
print i # 輸出1~10
i += 1
if i > 10: # 當i大於10時跳出回圈
break
for語句
for的其中一種形式：
for後面的變數先被賦予一個值，並執行下面 下麪的程式碼塊
然後被賦予變數的第二個值，並再次執行程式碼塊
這個過程一直繼續
for variable（變數） in 列表:
語句塊
#有多少個值，語句塊就會重複多少次
#一般其他語言的方法：
x = int(input()) #輸入一個x
isprime = True #設定isprime爲正確
for k in range(2,x): #讓k進入2~x-1的回圈
if x%k == 0: #如果x除以k餘數爲0
isprime = False #（if語句與回圈語句加起來即x有沒有除1和本身之外的公約數）
break #當成立，則isprime爲錯誤，並跳出回圈
if isprime: #如果isprime正確
print('is prime') #輸出'is prime'
else: #如果isprime錯誤
print('is not prime') #輸出'is not prime'
#python的方法 for—else語句
x = int(input())
isprime = True
for k in range(2,x):
if x%k == 0:
isprime = False
break
else: #如果進入回圈後，如果進行了break，則else不會被實行
print('isprime')
#當輸入的數值爲素數，則輸出isprime；若不是素數，則不會有任何輸出
for—else：
如果這個回圈正常結束，那麼else後面的句子會執行；若有break，則else後面的句子不會執行
x = int(input()) #輸入一個x
isprime = False #給isprime賦值False
for k in range(2,x): #使k進入回圈
if x%k == 0: #當x除以k的餘數爲0時
break #退出回圈
else: #若無退出回圈
isprime = True #則isprime賦值True
if isprime: #如果isprime成立
print('is prime') #輸出is prime
else: #如果isprime不成立
print('is not prime') #輸出is not prime
range函數：
產生數列
range(start,stop,step) #括號內三個爲參數
start：計數從start開始。預設是從0開始。
例如：range（5）等價於range（0,5）
stop：計數到stop結束，但不包括stop。
例如：list（range（0,5））是[0,1,2,3,4]沒有5
step：步長，預設爲1.
例如：range（0,5）等價於range（0,5,1）
>>> for i in range(5):
print(i)
0
1
2
3
4
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(2,10)) #兩個參數range（a，b+1）（從a到b）
[2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(2,20,2)) #三個參數range（a，b+1，c）（從a到b，步長爲c）
[2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> list(range(21,2,-1)) #從大到小（21—2）的遞減（公差爲1）的列表
[21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3]
#得到1到100之間的所有的偶數：
1.>>> [i for i in range(1,101) if i%2==0]
2.>>> list(range(2,101,2))
回圈巢狀
你可以在回圈體內嵌入其他的回圈體，如在while回圈中可以嵌入for回圈， 反之，你可以在for回圈中嵌入while回圈。
#while—while
i = 2
while(i < 100):
j = 2
while(j <= (i/j)):
if not(i%j): break
j = j + 1
if (j > i/j) : print i, " 是素數"
i = i + 1
print "Good bye!"
#for—for
for i in range(3): #外層回圈
for j in range(10): #內層回圈
print(str(i)+str(j),end=' ')
print() #換行
#執行結果：
00 01 02 03 04 05 06 07 08 09
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
#print語句執行次數：30
#巢狀回圈也可for和while混合實現：
for i in range(1,4):
j = 0
while j<i:
print(j,end=' ')
j+=1
print()
break語句：
break語句用來終止回圈語句，即回圈條件沒有False條件或者序列還沒被完全遞回完，也會停止執行回圈語句。
break語句用在while和for回圈中。
如果您使用巢狀回圈，break語句將停止執行最深層的回圈，並開始執行下一行程式碼。
continue語句：
continue語句用來跳出本次回圈剩餘的語句，進行下一次的回圈
continue語句和break語句的區別：
continue語句是跳過本次回圈
break語句是跳出整個回圈
pass語句：
pass 函數：不做任何事情，一般用做佔位語句。
#例子：
for letter in 'Python':
if letter == 'h':
pass
print '這是 pass 塊'
print '當前字母 :', letter
print "Good bye!"
輸出：
當前字母 : P
當前字母 : y
當前字母 : t
這是 pass 塊
當前字母 : h
當前字母 : o
當前字母 : n
Good bye!
迭代器是一個可以記住遍歷的位置的物件。
迭代器物件從集合的第一個元素開始存取，直到所有的元素被存取完結束。迭代器只能往前不會後退。
迭代器兩種基本方法：iter（）和next（）
>>> list=[1,2]
>>> it = iter(list) # 建立迭代器物件
>>> print (next(it)) # 輸出迭代器的下一個元素
1
>>> print (next(it))
2
當全部都輸出時再列印會報錯
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
print(next(it))
StopIteration
迭代器物件可以用for語句進行遍歷：
list=[1,2,3,4]
it = iter(list) # 建立迭代器物件
for x in it:
print (x, end=" ")
輸出：1 2 3 4
也可以使用next函數：
import sys # 引入 sys 模組
list=[1,2,3,4]
it = iter(list) # 建立迭代器物件
while True:
try:
print (next(it))
except StopIteration:
sys.exit() #退出程式，退出程式後不會執行後面的程式碼
print("hi") #因爲退出了程式，所以不會輸出（如果用break打破回圈則會輸出）
輸出：
1
2
3
4
StopIteration函數：
異常用於標識迭代的完成，防止出現無限回圈的情況
在 next() 方法中我們可以設定在完成指定回圈次數後觸發 StopIteration 異常來結束迭代。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
輸出：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
生成器：
使用了yield函數
返回迭代器的函數，只能用於迭代操作
呼叫一個生成器函數，返回的是一個迭代器物件
使用yield來實現斐波那契數列：
import sys
def fibonacci(n): # 生成器函數 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一個迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
輸出：
0 1 1 2 3 5 8 13 21 34 55
函數定義：
函數程式碼塊以 def 關鍵詞開頭，後接函數識別符號名稱和圓括號 ()。
任何傳入參數和自變數必須放在圓括號中間，圓括號之間可以用於定義參數。
函數的第一行語句可以選擇性地使用文件字串—用於存放函數說明。
函數內容以冒號起始，並且縮排。
return [表達式] 結束函數，選擇性地返回一個值給呼叫方。不帶表達式的return相當於返回 None。
#函數語句：
def函數名（參數列表）：
函數體
# 計算面積函數：
def area(width, height):
return width * height
def print_welcome(name):
print("Welcome", name)
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
函數呼叫：
定義一個函數，完成該函數基本結構以後，可以用另一個函數呼叫執行
例如建立一個printme（）函數：
# 定義函數
def printme( str ):
# 列印任何傳入的字串
print (str)
return
# 呼叫函數
printme("我要呼叫使用者自定義函數!")
printme("再次呼叫同一函數")
#輸出：
#我要呼叫使用者自定義函數!
#再次呼叫同一函數
參數
呼叫函數時可使用的正式參數型別：
必須參數：
须以正確的順序傳入函數。呼叫時的數量必須和宣告時的一樣。
def potato( str ):
"列印任何傳入的字串"
print (str)
return
potato("你好")
#輸出：你好
關鍵字參數：
關鍵字參數和函數呼叫關係緊密，函數呼叫使用關鍵字參數來確定傳入的參數值。
使用關鍵字參數允許函數呼叫時參數的順序與宣告時不一致，因爲 Python 直譯器能夠用參數名匹配參數值。
def potato( str ):
"列印任何傳入的字串"
print (str)
return
potato(str = "你好")
#輸出：你好
預設參數：
呼叫函數時，如果沒有傳遞參數，則會使用預設參數。
def potato( name, age = 25 ):
"列印任何傳入的字串"
print ("名字: ", name)
print ("年齡: ", age)
return
potato( age=16, name="hahaha" ) #均使用傳遞參數
print ("------------------------")
potato( name="good" ) #age沒傳遞參數，使用預設參數
#輸出：
#名字: hahaha
#年齡: 16 #輸出實參16
#------------------------
#名字: good
#年齡: 25 #輸出預設參數25
不定長參數：
你可能需要一個函數能處理比當初宣告時更多的參數。這些參數叫做不定長參數，和上述 2 種參數不同，宣告時不會命名。
加了星號 * 的參數會以元組(tuple)的形式匯入，存放所有未命名的變數參數
def potato( a, *b ):
"列印任何傳入的參數"
print (a)
print (b)
potato( 70, 60, 50 )
#輸出:
#70
#(60, 50)
如果在函數呼叫時沒有指定參數，它就是一個空元組
def potato( a, *b ):
"列印任何傳入的參數"
print (a)
print (b)
potato(70)
#輸出：
#70
#()
帶兩個*的參數（**）會以字典的形式匯入：
def potato( a, **b ):
"列印任何傳入的參數"
print (a)
print (b)
potato(1, c=2,d=3)
#輸出：
#1
#{'c': 2, 'd': 3}
強制位置參數：
斜槓/ 用來指明函數形參必須使用指定位置參數，不能使用關鍵字參數的形式（對前面）
星號* 用來指明函數形參必須使用關鍵字參數，不能使用位置參數的形式（對後面）
範例：
a,b必須使用位置參數
c，d可以使用位置參數也可以使用關鍵字參數
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
正確輸入：
f(10, 20, 30, d=40, e=50, f=60) #c,d可以使用位置參數也可以使用關鍵字參數
錯誤輸入：
f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用關鍵字參數的形式
f(10, 20, 30, 40, 50, f=60) # e 必須使用關鍵字參數的形式
參數傳遞：
strings, tuples, 和 numbers 是不可更改的物件(不可變型別)
而 list,dict 等則是可以修改的物件(可變型別)
不可變型別：變數賦值 a=5 後再賦值 a=10，這裏實際是新生成一個 int 值物件 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。
可變型別：變數賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
不可變：值傳遞，呼叫後不會改變實參
可變：形式傳遞，呼叫後會改變實參
def demo(a):
print("原值: ",a)
a += a
print("==========不可變==========")
b = "你好"
print("呼叫前:",b)
demo(b)
print("呼叫後:",b)
print("==========可變===========")
c = ["你好"]
print("呼叫前:",c)
demo(c)
print("呼叫後:",c)
#輸出：
#==========不可變==========
#呼叫前: 你好
#原值: 你好
#呼叫後: 你好
#==========可變===========
#呼叫前: ['你好']
#原值: ['你好']
#呼叫後: ['你好', '你好']
匿名函數：
lambda函數:建立匿名函數，不用def來定義函數
lambda [arg1 [,arg2,…argn]]:expression
範例：
sum = lambda arg1, arg2: arg1 + arg2
# 呼叫sum函數
print ("相加後的值爲 : ", sum( 10, 20 ))
print ("相加後的值爲 : ", sum( 20, 20 ))
輸出：
相加後的值爲 : 30
相加後的值爲 : 40
return語句：
用於退出函數，選擇性地呼叫方返回一個表達式
不帶參數值的return語句返回None
#不帶return函數：
def sum(a,b):
c = a+b
print("函數內:",c)
c = sum(20,50)
print("函數值:",c)
輸出：
函數內: 70
函數值: None
#帶return函數：
def sum(a,b):
c = a+b
print("函數內:",c)
return c
c = sum(20,50)
print("函數值:",c)
輸出：
函數內: 70
函數值: 70
列表：
將列表當做堆疊使用：
堆疊作爲特定的數據結構，最先進入的元素最後一個被釋放（後進先出）
用 append() 方法可以把一個元素新增到堆疊頂
用不指定索引的 pop() 方法可以把一個元素從堆疊頂釋放出來
範例：
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
將列表當作佇列使用：
只是在佇列裡第一加入的元素，第一個取出來
在列表的最後新增或者彈出元素速度快，然而在列表裏插入或者從頭部彈出速度卻不快（因爲所有其他的元素都得一個一個地移動）
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
>>> queue = deque([「Eric」, 「John」, 「Michael」])
>>> queue.append(「Terry」) # Terry arrives
>>> queue.append(「Graham」) # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
‘Eric’
>>> queue.popleft() # The second to arrive now leaves
‘John’
>>> queue # Remaining queue in order of arrival
deque([‘Michael’, ‘Terry’, ‘Graham’])
列表推導式
每個列表推導式都在 for 之後跟一個表達式，然後有零到多個 for 或 if 子句。
返回結果是一個根據表達從其後的 for 和 if 上下文環境中生成出來的列表
希望表達式推導出一個元組，就必須使用括號
將列表中每個數值乘三，獲得一個新的列表：
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
可以對同一個元素輸出多個值：
>>>vec = [2, 4, 6]
>>>[[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> [3*x for x in vec]
[6, 12, 18]
可以對同一個元素輸出多個值：
>>> vec = [2, 4, 6]
>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
可以對序列裡每一個元素進行逐個呼叫某方法：
>>>freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> freshfruit
[' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip()for weapon in freshfruit] #呼叫序列中每一個元素，刪除元素頭尾的空格
['banana', 'loganberry', 'passion fruit']
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip(' t')for weapon in freshfruit]
['banana', 'loganberry', 'passion frui']
序列中可以使用if子句來作爲過濾器：
>>> best = [1,5,8]
>>> [3*x for x in best if x>3] #if子句作爲過濾器(過濾掉x<=3的元素)
[15, 24]
序列回圈：
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> [x*y for x in a for y in b ]
[4, 5, 6, 8, 10, 12, 12, 15, 18]
>>> [x*y for x in a for y in b if x>1]
[8, 10, 12, 12, 15, 18]
>>> [a[i]*b[i] for i in range(len(a))]
[4, 10, 18]
列表推導式可以使用複雜表達式或巢狀函數：
>>> [str(round(355/113,i)) for i in range(1,6)] #i是小數個數
['3.1', '3.14', '3.142', '3.1416', '3.14159']
巢狀列表解析：
列表可以巢狀
建議一個3×4的矩陣：
>>> matrix = [
... [1,2,3,4],
... [5,6,7,8],
... [9,10,11,12]
]
>>> matrix
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
將3×4矩陣轉換爲4×3矩陣：
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
也可以：
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
另一種實現的方法：
>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
del語句：
使用 del 語句可以從一個列表中依索引而不是值來刪除一個元素。
這與使用 pop() 返回一個值不同。（pop函數會返回一個元素）
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
也可以用del刪除實體變數
>>> del a
集合的推導式：
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
字典的推導式：
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
如果關鍵字只是簡單的字串，使用關鍵字參數指定鍵值對有時候更方便：
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
遍歷技巧：
在字典中遍歷時，關鍵字和對應的值可以使用 items() 方法同時解讀出來：
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
>>> a = {'ab':123,'cd':456,'ef':789}
>>> for x,y in a.items():
print(x,y)
ab 123
cd 456
ef 789
在序列中遍歷時，索引位置和對應值可以使用 enumerate() 函數同時得到：
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
同時遍歷兩個或更多的序列，可以使用 zip() 組合：
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
a = [1,2,3]
b = [4,5,6]
for x,y in zip(a,b):
print("{0} != {1}".format(x,y))
要反向遍歷一個序列，首先指定這個序列，然後呼叫 reversed() 函數：
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
要按順序遍歷一個序列，使用 sorted() 函數返回一個已排序的序列，並不修改原值：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
模組就是程式
匯入模組：
1.import 模組名
2.from 模組名 import 函數名
from modname import name1[, name2[, … nameN]]
匯入模組內的一些函數，可以直接使用
from modname import *
匯入模組內所有的函數，但容易導致混亂一般不使用
3.import 模組名 as 新名字（更爲方便）
匯入數學庫的sqrt函數：
>>> sqrt(100)
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
sqrt(100)
NameError: name 'sqrt' is not defined
>>> from math import sqrt
>>> sqrt(100)
10.0
>>>import math as m
>>>print(m.sqrt(100))
自定義模組：
1.模組程式和執行程式放在同一個資料夾，執行程式可以直接匯入模組程式
2.模組程式和執行程式不在同一個資料夾內，執行程式時需要加入模組程式的路徑
同一個資料夾
#模組程式：
def area(width,height):
'''計算正方形面積'''
w = width
h = height
a = w * h
print (a)
#執行程式：
import love
love.area(10,10)
輸出：100
加入測試程式碼：
#不用if __name__ == '__main__'（會執行測試程式碼）
def area(width,height):
'''計算正方形面積'''
w = width
h = height
a = w * h
print (a)
def text():
area(10,10)
text()
執行程式碼（會把執行測試程式碼）
import love
love.area(10,10)
輸出：
100
100
#使用if __name__ == '__main__'（不會執行測試程式碼）
def area(width,height):
'''計算正方形面積'''
w = width
h = height
a = w * h
print(a)
def text():
area(10,10)
if __name__ == '__main__':
text()
執行程式：
import love
love.area(10,10)
輸出：
100
搜尋路徑：（\可以用/來代替）
sys模組 path變數
python會從以上路徑去搜尋是否擁有尋找的模組
找到會匯入模組，找不到就會匯入失敗
一般模組可以放到site—packages資料夾
也可以自己建立資料夾來放入模組
>>> import sys
>>> sys.path
['', 'D:\\遊戲啊\\python\\Lib\\idlelib', 'D:\\遊戲啊\\python\\python37.zip', 'D:\\遊戲啊\\python\\DLLs', 'D:\\遊戲啊\\python\\lib', 'D:\\遊戲啊\\python', 'D:\\遊戲啊\\python\\lib\\site-packages']
沒有相應路徑時無法匯入該檔案的模組
>>> import love
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
import love
ModuleNotFoundError: No module named 'love'
append函數：可以加入該路徑再匯入模組（直接關閉後不會儲存路徑）
>>> sys.path.append("D:\\遊戲啊\\python\\模組")
>>> sys.path
['', 'D:\\遊戲啊\\python\\Lib\\idlelib', 'D:\\遊戲啊\\python\\python37.zip', 'D:\\遊戲啊\\python\\DLLs', 'D:\\遊戲啊\\python\\lib', 'D:\\遊戲啊\\python', 'D:\\遊戲啊\\python\\lib\\site-packages', 'D:\\遊戲啊\\python\\模組']
此時可以直接匯入該路徑內的模組：
>>> import love
>>> love.area(10,10)
remove函數：也可以刪除掉路徑
>>> sys.path.append("D:\\遊戲啊\\python\\模組")
>>> sys.path
['', 'D:\\遊戲啊\\python\\Lib\\idlelib', 'D:\\遊戲啊\\python\\python37.zip', 'D:\\遊戲啊\\python\\DLLs', 'D:\\遊戲啊\\python\\lib', 'D:\\遊戲啊\\python', 'D:\\遊戲啊\\python\\lib\\site-packages', 'D:\\遊戲啊\\python\\模組']
>>> sys.path.remove("D:\\遊戲啊\\python\\模組")
>>> sys.path
['', 'D:\\遊戲啊\\python\\Lib\\idlelib', 'D:\\遊戲啊\\python\\python37.zip', 'D:\\遊戲啊\\python\\DLLs', 'D:\\遊戲啊\\python\\lib', 'D:\\遊戲啊\\python', 'D:\\遊戲啊\\python\\lib\\site-packages']
>>> import love
Traceback (most recent call last):
File "<pyshell#12>", line 1, in <module>
import love
ModuleNotFoundError: No module named 'love'
dir()函數：
內建函數dir（）可以找到模組內定義的所有名稱，以一個字串列表的形式返回
>>> dir(sys)
['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_enablelegacywindowsfsencoding', '_framework', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth', 'get_coroutine_wrapper', 'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']
>>> dir(love)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'area', 'text']
包（package）：
1.建立一個資料夾，用於存放相應的模組，資料夾米名字即包的名字
2.資料夾內建立一個__init__.py的模組檔案，內容可以爲空
3.將相應模組放入資料夾中
格式化輸出：
format()函數：
基本格式：str.format（）
>>>x = 3.14159
>>>y = 2*x*3
>>>print("{0:.2f}{1:.2f}".format(x,y))
3.14 18.85
>>>y = 2x3
>>>print("{0:.2f}{1:.2f}".format(x,y))
3.14 18.85
0和1表示format函數中的第一和第二個參數
.2f表示小數部分保留兩位，四捨五入
| 3.1415926 | {:.2f} | 3.14 | 保留小數點後兩位 |
|---|---|---|---|
| 3.1415926 | {:+.2f} | +3.14 | 帶符號保留小數點後兩位 |
| -1 | {:+.2f} | -1.00 | 帶符號保留小數點後兩位 |
| 2.71828 | {:.0f} | 3 | 不帶小數 |
| 5 | {:0>2d} | 05 | 數位補零 (填充左邊, 寬度爲2) |
| 5 | {:x<4d} | 5xxx | 數位補x (填充右邊, 寬度爲4) |
| 10 | {:x<4d} | 10xx | 數位補x (填充右邊, 寬度爲4) |
| 1000000 | {:,} | 1,000,000 | 以逗號分隔的數位格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指數記法 |
| 13 | {:>10d} | 13 | 右對齊 (預設, 寬度爲10) |
| 13 | {:<10d} | 13 | 左對齊 (寬度爲10) |
| 13 | {:^10d} | 13 | 中間對齊 (寬度爲10) |
str()： 函數返回一個使用者易讀的表達形式。
repr()： 產生一個直譯器易讀的表達形式。
>>> hello = 'nihao,doubi\n ,buhao'
>>> a = str(hello)
>>> a
'nihao,doubi\n ,buhao'
>>> print(a)
nihao,doubi
,buhao
>>> hellos = repr(hello)
>>> print(hellos)
'nihao,doubi\n ,buhao'
輸出平方和立方的表：
>>> for i in range(1,11):
print(repr(i).rjust(2),repr(i**2).rjust(3),end = '')
print(repr(i**3).rjust(4))
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 1001000
>>> for x in range(1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
如果在 format() 中使用了關鍵字參數, 那麼它們的值會指向使用該名字的參數。
>>> print('{name}網址： {site}'.format(name='菜鳥教學', site='www.runoob.com'))
菜鳥教學網址： www.runoob.com
位置及關機子參數可以任意結合
>>> print('站點列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
站點列表 Google, Runoob, 和 Taobao。
如果你有一個很長的格式化字串, 而你不想將它們分開, 那麼在格式化時通過變數名而非位置會是很好的事情。
最簡單的就是傳入一個字典, 然後使用方括號 [] 來存取鍵值 :
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
Runoob: 2; Google: 1; Taobao: 3
也可以通過在 table 變數前使用 ** 來實現相同的功能：
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3
讀和寫檔案
open() 將會返回一個 file 物件，基本語法格式如下:
open(filename, mode)
filename：包含了你要存取的檔名稱的字串值。
mode：決定了開啓檔案的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數是非強制的，預設檔案存取模式爲只讀®。
| r | 以只讀方式開啓檔案。檔案的指針將會放在檔案的開頭。這是預設模式。 |
|---|---|
| rb | 以二進制格式開啓一個檔案用於只讀。檔案指針將會放在檔案的開頭。 |
| r+ | 開啓一個檔案用於讀寫。檔案指針將會放在檔案的開頭。 |
| rb+ | 以二進制格式開啓一個檔案用於讀寫。檔案指針將會放在檔案的開頭。 |
| w | 開啓一個檔案只用於寫入。如果該檔案已存在則開啓檔案，並從開頭開始編輯，即原有內容會被刪除。如果該檔案不存在，建立新檔案。 |
| wb | 以二進制格式開啓一個檔案只用於寫入。如果該檔案已存在則開啓檔案，並從開頭開始編輯，即原有內容會被刪除。如果該檔案不存在，建立新檔案。 |
| w+ | 開啓一個檔案用於讀寫。如果該檔案已存在則開啓檔案，並從開頭開始編輯，即原有內容會被刪除。如果該檔案不存在，建立新檔案。 |
| wb+ | 以二進制格式開啓一個檔案用於讀寫。如果該檔案已存在則開啓檔案，並從開頭開始編輯，即原有內容會被刪除。如果該檔案不存在，建立新檔案。 |
| a | 開啓一個檔案用於追加。如果該檔案已存在，檔案指針將會放在檔案的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該檔案不存在，建立新檔案進行寫入。 |
| ab | 以二進制格式開啓一個檔案用於追加。如果該檔案已存在，檔案指針將會放在檔案的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該檔案不存在，建立新檔案進行寫入。 |
| a+ | 開啓一個檔案用於讀寫。如果該檔案已存在，檔案指針將會放在檔案的結尾。檔案開啓時會是追加模式。如果該檔案不存在，建立新檔案用於讀寫。 |
| ab+ | 以二進制格式開啓一個檔案用於追加。如果該檔案已存在，檔案指針將會放在檔案的結尾。如果該檔案不存在，建立新檔案用於讀寫。 |
read函數：讀取檔案內的數據（若代入參數，參數爲輸出長度）
若使用UTF-8編碼，則要輸出encoding = 「UTF-8」
f = open("D:\\遊戲啊\\python\\你好.txt",encoding = "UTF-8")
str = f.read()
print(str)
f.close()
>>> f = open("D:\\遊戲啊\\python\\你好.txt",encoding = "UTF-8")
>>> f.read(5)
'今天是星期'
當讀取時，讀到哪指針就會插到哪，下次直接讀取會從指針位置讀起
>>> f = open("D:\\遊戲啊\\python\\你好.txt",encoding = "UTF-8")
>>> f.read()
'今天是星期幾呢？\n今天是星期天'
>>> f.read()
''
tell函數：指出當前檔案指針位置（UTF-8編碼中文字元佔三個位元組）
>>> f = open("D:\\遊戲啊\\python\\你好.txt",encoding = "UTF-8")
>>> f.read(5)
'今天是星期'
>>> f.tell()
15
seek函數：
移動檔案中的指針位置，從from（0代表檔案起始位置，1代表當前位置，2代表檔案末尾）偏移offset個位元組
f.seek(offset, from）
seek(x,0) ： 從起始位置即檔案首行首字元開始移動 x 個字元
seek(x,1) ： 表示從當前位置往後移動x個字元
seek(-x,2)：表示從檔案的結尾往前移動x個字元（未懂）
>>> f = open("D:\\遊戲啊\\python\\你好.txt",encoding = "UTF-8")
>>> f.seek(9)
9
>>> f.read()
'星期幾呢？\n今天是星期天'
readline函數：讀取檔案中單獨一行
f = open("D:\\遊戲啊\\python\\你好.txt",encoding = 'UTF-8')
str = f.readline()
print(str)
f.close()
#輸出：
#今天是星期幾呢？
readlines函數：返迴檔案中包含的所有行
f = open("D:\\遊戲啊\\python\\你好.txt",encoding = 'UTF-8')
str = f.readlines()
print(str)
f.close()
輸出：
['今天是星期幾呢？\n', '今天是星期天']
close函數：
處理完一個檔案後，呼叫close來關閉檔案並釋放系統的資源
如果嘗試再呼叫該檔案，則會拋出異常
>>> f = open("D:\\遊戲啊\\python\\你好.txt",encoding = 'UTF-8')
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<pyshell#34>", line 1, in <module>
f.read()
ValueError: I/O operation on closed file.
write函數：使用close函數後txt文件中會出現「學習」兩個字（要在w，a下才能 纔能輸入）
>>> f = open("D:\\遊戲啊\\python\\你好.txt","w",encoding = 'UTF-8')
>>> f.write("學習")
2 #輸入的字元數
>>> f.close()
>>> f = open("D:\\遊戲啊\\python\\你好.txt","a",encoding = 'UTF-8')
>>> f.write("我超喜歡的")
5
>>> f.close()
文字文件：
學習我超喜歡的
writelines函數：
向檔案寫入一個序列字串列表，如果需要換行則要自己加入每行的換行符
輸出檔案內每一行內容：
>>> for each_line in f:
print(each_line)
輸出：
今天是星期幾呢？
今天是星期天
分割檔案：
將檔案內內容分割並放到不同檔案內
例：按girl和boy以及=分割，結果會生成六個資料夾
檔案內容：
girl:Hello,how old are you?
boy:1000years old!
gilr:…
=========================================
girl:Excuse me,can you tell me the way to the ocean?
boy:Sorry, I do not know the way.
girl:Thank you._
========================================
boy:Hello
girl:Hello
def save_file(boy,girl,count):
file_name_boy = "boy_" + str(count) + ".txt"
file_name_girl = "girl_" + str(count) + ".txt"
boy_file = open(file_name_boy,'w')
girl_file = open(file_name_girl,'w')
boy_file.writelines(boy)
girl_file.writelines(girl)
boy_file.close()
girl_file.close()
f = open('test_2.txt',encoding = "UTF-8")
boy = []
girl = []
count = 1
for each_line in f:
num = each_line.find("======")
if num == -1:
(role,line_spoken) = each_line.split(":",1)
if role == "boy":
boy.append(line_spoken)
if role == "girl":
girl.append(line_spoken)
else:
save_file(boy,girl,count)
boy = []
girl = []
count += 1
save_file(boy,girl,count)
f.close()
pickle模組：（要以二進制形式）
實現了基本的數據序列和反序列化
通過pickle模組的序列化操作我們能夠將程式中執行的物件資訊儲存到檔案中去，永久儲存。
通過pickle模組的反序列化操作，我們能夠從檔案中建立上一次程式儲存的物件。
存放：pickle.dump(obj, file, [,protocol])
讀取：x = pickle.load(file)
用pickle模組儲存，可以永久儲存
>>> city = ["s ads",54541,2434,[544,4545]]
>>> import pickle
>>> pickle_file = open("city.pkl",'wb') #後綴名可以自己輸入
>>> pickle.dump(city,pickle_file) #預設儲存在當前檔案中
>>> pickle_file.close()
>>> pickle_file = open("city.pkl",'rb')
>>> city2 = pickle.load(pickle_file)
>>> print(city2)
['s ads', 54541, 2434, [544, 4545]]
使用os模組要先匯入os模組
os模組：
getcwd函數：返回當前工作目錄
>>> import os
>>> os.getcwd()
'D:\\遊戲啊\\python'
chdir函數：更改目錄位置
>>> os.chdir("D:/遊戲啊/python/檔案分割")
>>> os.getcwd()
'D:\\遊戲啊\\python\\檔案分割'
listdir函數：列舉指定目錄中的檔名（沒有指定就會輸出預設目錄的檔案）
>>> os.listdir()
['boy_1.txt', 'boy_2.txt', 'boy_3.txt', 'girl_1.txt', 'girl_2.txt', 'girl_3.txt', 'test.py', 'test_1.txt', 'test_2.txt', '~$test_1.txt']
>>> os.listdir("D:/遊戲啊/python/idle 專案")
['hello.py', '五角星py.py', '聖誕樹.py', '嘗試.py', '新建文字文件.txt', '練習.py', '試題.py']
mkdir函數：相應路徑會生成一個空白目錄（不能在不存在的目錄裏面生成）
>>> os.mkdir("D:/遊戲啊/A")
>>> os.mkdir("D:/遊戲啊/python/A")
makedirs函數：遞回生成多個目錄（可以建立一個不存在的目錄並在裏面建立目錄）
>>> os.makedirs("D:/遊戲啊/python/建立目錄/A")
remove函數：刪除檔案（無法刪除目錄）
>>> os.remove("D:/遊戲啊/python/A/123.txt")
rmdir函數：刪除目錄（裏面有檔案則無法刪除）
>>>os.rmdir("D:/遊戲啊/python/A")
removedirs函數：遞回刪除目錄（目錄非空則拋出異常）
>>> os.mkdir("D:/遊戲啊/python/A")
>>> os.mkdir("D:/遊戲啊/python/A/B")
>>> os.removedirs("D:/遊戲啊/python/A/B") #A和B都刪除
rename函數:將檔案重新命名（A改名爲B）
>>> os.rename("D:/遊戲啊/python/A","D:/遊戲啊/python/B")
system函數：執行系統的shell命令
>>> os.system("cmd") #開啓cmd命令指示器
>>> os.system("calc") #開啓計算器
curdir函數：指代當前目錄
>>> os.curdir
'.'
>>> os.listdir(os.curdir) #輸出當前目錄的檔案
['boy_1.txt', 'boy_2.txt', 'boy_3.txt', 'girl_1.txt', 'girl_2.txt', 'girl_3.txt', 'test.py', 'test_1.txt', 'test_2.txt', '~$test_1.txt']
pardir函數：指代上一級目錄
>>> os.pardir
'..'
>>> os.listdir(os.pardir) #輸出上一級目錄的檔案
['B', 'buhao.txt', 'DLLs', 'Doc', 'idle 專案', 'include', 'Lib', 'libs', 'LICENSE.txt', 'NEWS.txt', 'pycharm', 'python-3.7.0', 'python-3.7.0.rar', 'python.exe', 'python3.dll', 'python37.dll', 'pythonw.exe', 'Scripts', 'tcl', 'Tools', 'vcruntime140.dll', '你好.txt', '建立目錄', '檔案分割', '模組', '專案']
name函數：檢視當前操作系統
>>> os.name
'nt' #windows系統
os.path模組：
basename函數：去除目錄路徑，返迴檔名
>>> os.path.basename("D:/遊戲啊/python/A")
'A'
dirname函數：去除檔名，返回目錄路徑
>>> os.path.dirname("D:/遊戲啊/python/A")
'D:/遊戲啊/python'
join函數：將各部分組合成一個路徑
>>> os.path.join("D:\\","A","B","C")
'D:\\A\\B\\C'
split函數：將檔名和路徑分割
>>> os.path.split('D:\\A\\B\\C.txt')
('D:\\A\\B', 'C.txt')
splitext函數：將檔名與擴充套件名分離
>>> os.path.splitext('D:\\A\\B\\C.txt')
('D:\\A\\B\\C', '.txt')
>>> os.path.splitext('D:\\A\\B\\C')
('D:\\A\\B\\C', '')
getsize函數：返迴檔案的尺寸（大小）
>>> os.path.getsize("D:/遊戲啊/python/模組/love.py")
196
getalime函數：返迴檔案最近存取時間
getclime函數：返迴檔案建立時間
getmlime函數：返迴檔案最近修改時間
>>> os.path.getatime("D:/遊戲啊/python/模組/love.py")
1596863412.4359403 #返回浮點型秒數，可用time模組的gmtime或localtime換算
>>> os.path.getctime("D:/遊戲啊/python/模組/love.py")
1596797589.1672275
>>> os.path.getmtime("D:/遊戲啊/python/模組/love.py")
1596863412.4359403
#time模組
localtime是當地時間
gmtime是格林尼治時間
>>> import time
>>> time.gmtime(os.path.getmtime("D:/遊戲啊/python/模組/love.py"))
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=8, tm_hour=5, tm_min=10, tm_sec=12, tm_wday=5, tm_yday=221, tm_isdst=0)
2020年8月8日5點10分12秒
修改一下love.py
>>> time.localtime(os.path.getmtime("D:/遊戲啊/python/模組/love.py"))
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=11, tm_hour=0, tm_min=32, tm_sec=55, tm_wday=1, tm_yday=224, tm_isdst=0)
2020年8月11日0點32分55秒
相對路徑：不是從根目錄開始 #遊戲啊/python/模組/love.py
絕對路徑：從根目錄開始 #D:/遊戲啊/python/模組/love.py
返回True或False的函數：（os.path函數）
os.path.exists(path) #路徑存在則返回True,路徑損壞返回False
os.path.isabs(path) #判斷是否爲絕對路徑
os.path.isfile(path) #判斷路徑是否爲檔案
os.path.isdir(path) #判斷路徑是否爲目錄
os.path.islink(path) #判斷路徑是否爲鏈接(快捷方式)
os.path.ismount(path) #判斷路徑是否爲掛載點(盤）
>>> os.path.ismount("D://")
True
全域性變數和區域性變數：
定義在函數內部的變數擁有一個區域性作用域，定義在函數外的擁有全域性作用域。
區域性變數只能在其被宣告的函數內部存取，而全域性變數可以在整個程式範圍內存取。呼叫函數時，所有在函數內宣告的變數名稱都將被加入到作用域中。
total = 0 # 這是一個全域性變數
# 可寫函數說明
def sum( arg1, arg2 ):
#返回2個參數的和."
total = arg1 + arg2 # total在這裏是區域性變數.
print ("函數內是區域性變數 : ", total)
return total
#呼叫sum函數
sum( 10, 20 )
print ("函數外是全域性變數 : ", total)
try—except函數：程式的保護機制 機製，當程式出現異常時不會終止
當try步驟出現異常，則會跳過後面步驟，進入except步驟（如果try中有異常，try會進行到異常步驟）
#範例：
x = int(input()) #輸出x
t = [1,2,3,4,5] #給與t賦值爲一個列表
try: #嘗試（檢驗程式是否出現異常）
print(t[x]) #輸出列表t的x標號（第x-1個）元素
print('hello') #輸出‘hello’（若程式出現異常則跳過此步）
except: #除外：（若程式出現異常則會跳到該步驟）
print('x is not a valid index') #輸出'x is not a valid index'
else: #其他的：（若程式沒出現異常，則輸出完try後跳到此步驟）
print('nothing') #輸出'nothing'
finally: #最後：（無論程式中是否存在異常均會輸出該步驟）
print('anyway') #輸出'anyway'
輸入的數據不同，會出現兩種情況
異常情況：
try正常——try異常——except——finally
輸入：10（在print(t[x])處出現異常）
輸出：
x is not a valid index
anyway
正常情況：
try——else——finally
輸入：3（在try步驟中沒有出現異常）
輸出：
4
hello
nothing
anyway
異常的處理：
try： #做句子（步驟）
語句塊1 #可能步驟中會出現異常
except 異常型別1： #一般會給出異常的型別
語句塊2
except 異常型別2：
語句塊3
...
except 異常型別N：
語句塊N+1
except： #普通的except（無論什麼異常都在這裏進行）
語句塊N+2
else： #若無異常則執行完try之後執行else
語句塊N+3
finally： #無論有沒有異常，都要執行finally
語句塊N+4
異常名稱：
SystemExit 直譯器請求退出
FloatingPointError 浮點計算錯誤
OverflowError 數值運算超出最大限制
ZeroDivisionError 除（或取模）零（所有數據型別）
Keyboardlnterrupt 使用者中斷執行（通常是輸入^C）
ImportError 匯入模組/物件失敗
IndexError 序列中沒有此索引（index）
RuntimeError 一般的執行時錯誤
AttributeError 物件沒有這個屬性
IOError 輸入/輸出操作失敗
OSError 操作系統錯誤
KeyError 對映中沒有這個鍵
TypeError 對型別無效的操作
ValueError 傳入無效的參數
類定義（語法格式）：
class ClassName: #類名
'''類的幫助資訊''' #類文件字串
<statement-1> #由類變數、方法和屬性等定義語句組成（可以用pass代替）
.
.
.
<statement-N>
類物件：
支援兩種操作：屬性參照和範例化
class MyClass:
"""一個簡單的類範例"""
i = 12345
def f(self):
return 'hello world'
# 範例化類
x = MyClass()
# 存取類的屬性和方法
print("MyClass 類的屬性 i 爲：", x.i)
print("MyClass 類的方法 f 輸出爲：", x.f())
#輸出：
#MyClass 類的屬性 i 爲： 12345
#MyClass 類的方法 f 輸出爲： hello world
類的特殊方法（構造方法）：
init(self)
類範例化時會自動呼叫__init__（）方法
class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i) # 輸出結果：3.0 -4.5
類的方法與普通的函數只有一個特別的區別
它們必須有一個額外的第一個參數名稱, 按照慣例它的名稱是 self
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
#輸出：
#<__main__.Test instance at 0x100771878>
#__main__.Test
#self是類的範例，代表當前物件的地址，而self.class則指向類
#可以用別的單詞代替self但一定要有self參數
類的方法：
在類的內部，使用 def 關鍵字來定義一個方法，與一般函數定義不同
類方法必須包含參數 self, 且爲第一個參數，self 代表的是類的範例
#類定義
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部無法直接進行存取
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
# 範例化類
p = people('runoob',10,30)
p.speak()
#輸出：
#runoob 說: 我 10 歲。
類的繼承：
class DerivedClassName(BaseClassName1):
<statement-1>
.
.
.
<statement-N>
#若子類出現與父類別相同名字的方法或屬性，則會覆蓋父類別的方法或屬性
#即會用子類的方法或屬性
如果在子類中需要父類別的構造方法就需要顯式地呼叫父類別的構造方法，或者不重寫父類別的構造方法。
子類不重寫 init，範例化子類時，會自動呼叫父類別定義的 init。
class Father(object):
def __init__(self, name):
self.name=name
print ( "name: %s" %( self.name) )
def getName(self):
return 'Father ' + self.name
class Son(Father):
def getName(self):
return 'Son '+self.name
if __name__=='__main__':
son=Son('runoob')
print ( son.getName() )
#輸出：
#name: runoob (子類沒有定義__init__，直接呼叫父類別的__init__)
#Son runoob (子類重新定義了getName)
super函數：呼叫父類別(超類)的一個方法
super(type[, object-or-type])
#type -- 類。
#object-or-type -- 類，一般是 self
#範例1
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) #輸出 3
#範例2
class FooParent(object):
def __init__(self):
self.parent = 'I\'m the parent.'
print ('Parent')
def bar(self,message):
print ("%s from Parent" % message)
class FooChild(FooParent):
def __init__(self):
# super(FooChild,self) 首先找到 FooChild 的父類別（就是類 FooParent）
#然後把類 FooChild 的物件轉換爲類 FooParent 的物件
super(FooChild,self).__init__() #應用了父類別的__init__
print ('Child')
def bar(self,message):
super(FooChild, self).bar(message)
print ('Child bar fuction')
print (self.parent)
if __name__ == '__main__':
fooChild = FooChild()
fooChild.bar('HelloWorld')
#輸出：
#Parent
#Child
#HelloWorld from Parent
#Child bar fuction
#I'm the parent.
如果重寫了__init__ 時，要繼承父類別的構造方法，可以使用 super 關鍵字：
super(子類，self).__init__(參數1，參數2，....)
還有一種經典寫法：
父類別名稱.__init__(self,參數1，參數2，...)
#範例：
class Parent: # 定義父類別
def myMethod(self):
print ('呼叫父類別方法')
class Child(Parent): # 定義子類
def myMethod(self):
print ('呼叫子類方法')
c = Child() # 子類範例
c.myMethod() # 子類呼叫重寫方法
super(Child,c).myMethod() #用子類物件呼叫父類別已被覆蓋的方法
#輸出：
#呼叫子類方法
#呼叫父類別方法
單繼承範例：
#範例1：
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部無法直接進行存取
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
#範例2：
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#呼叫父類別的構函
people.__init__(self,n,a,w)
self.grade = g
#覆寫父類別的方法
def speak(self):
print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()
多繼承範例：
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部無法直接進行存取
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
#單繼承範例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#呼叫父類別的構函
people.__init__(self,n,a,w)
self.grade = g
#覆寫父類別的方法
def speak(self):
print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
#另一個類，多重繼承之前的準備
class speaker():
topic = ''
name = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一個演說家，我演講的主題是 %s"%(self.name,self.topic))
#多重繼承
class sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，預設呼叫的是在括號中排前地父類別的方法
#輸出：
#我叫 Tim，我是一個演說家，我演講的主題是 Python
類的私有屬性：
__private_attrs：兩個下劃線開頭，宣告該屬性爲私有
不能在類的外部被使用或直接存取
在類內部的方法中使用時 self.__private_attrs。
#範例：
class JustCounter:
__secretCount = 0 # 私有變數
publicCount = 0 # 公開變數
def count(self):
self.__secretCount += 1
self.publicCount += 1
print (self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount) # 報錯，範例不能存取私有變數
#輸出：
1
2
2
（最後一個輸出會報錯，不能直接存取到私有變數）
Traceback (most recent call last):
File "test.py", line 16, in <module>
print (counter.__secretCount) # 報錯，範例不能存取私有變數
AttributeError: 'JustCounter' object has no attribute '__secretCount'
類的專有方法
（還沒具體範例進行使用）
__init__ : 建構函式，在生成物件時呼叫
__del__ : 解構函式，釋放物件時使用
__repr__ : 列印，轉換
__setitem__ : 按照索引賦值
__getitem__: 按照索引獲取值
__len__: 獲得長度
__cmp__: 比較運算
__call__: 函數呼叫
__add__: 加運算
__sub__: 減運算
__mul__: 乘運算
__truediv__: 除運算
__mod__: 求餘運算
__pow__: 乘方