文章目錄
前言
本文針對《Python語言程序設計基礎 （第2版）》——嵩天 禮欣 黃天羽，此書進行簡單知識總結。
本文總結了華農python期末部分常見考點，對信息學院的同學幫助不大，適合其他學院同學參考。
本人只是單純的想進行分享，並沒有炫耀自己的意思，如果讓您心情不悅我感到很抱歉。
本文可能對編程編寫有所幫助，但是理論知識還需要大家多刷題，多看定義。
因本人精力、能力有限，文章不足之處還請指正。
此外，大家可以將需求、遺漏的地方或疑問寫在評論區，後期會及時進行補充，解答疑問。
建議參考B站小甲魚視頻輔助學習，點擊這裏跳轉。
碼字不易，大家如果本文感覺有幫助的話，請三連！哪怕一連、二連也行呀！
注：歡迎富婆、小哥哥打賞！
複習要點
-縮進、註釋、命名、變量、保留字
-數據類型、字符串、 整數、浮點數、列表、字典
-賦值語句、分支語句、函數
-input( )、print( )、eval( )、 print( )及其格式化
組合數據類型
注： 詳細內容請看後面幾段
序列類型通用操作符和函數
| 操作符 | 描述 |
|---|---|
| x in s | 如果x是s的元素，返回True，否則返回False |
| x not in s | 如果x不是s的元素，返回True，否則返回False |
| s + t | 連接 s 和 t |
| s * n 或 n * s | 將序列 s 複製 n 次 |
| s[i] | 索引，返回序列第 i - 1個元素 |
| s[i : j] | 切片，不包括第 j 位元素 |
| s[i : j : k] | 步驟切片，k表示步長，不寫默認爲1 |
| len(s) | 序列 s 的長度 |
| min(s) | 序列 s 的最小元素 |
| max(s) | 序列 s 的最大元素 |
| s.index(x) | 序列 s 中從左往右第一次出現 x 的索引 |
| s.rindex(x) | 序列 s 中從右往左第一次出現 x 的索引 |
| s.count(x) | 序列 s 中出現 x 的總次數 |
注： 序列類型是可迭代對象，可以直接使用for循環操作。
a=[1,2,3,4,5]
for i in a:
print(i,end='**') #end是可選參數，不寫默認爲換行符'\n'
#得到1**2**3**4**5**
集合類型
類似數學上的集合概念元素具有單一性，但是默認會以遞增的順序排列元素。
常用於： 去除列表中的相同元素
list1=[5,1,3,7,9,9,2]
list1=list(set(list1))
print(list1) #得到[1, 2, 3, 5, 7, 9]
# 大家看呀，這個就自動給你排序了。
映射類型
需要了解：
①怎樣增刪鍵值對
②怎樣得到字典中鍵，值，鍵值對應的元組
③一個鍵只能對應一個值
注： 鍵(key)就是冒號左側的值。值(value)就是冒號右面的數值。
數值操作
運算符
| 算數運算符 | 描述 |
|---|---|
| x%y | 求得商的餘數。例如：5%2結果爲1 |
| x//y | 求得x除y商的整數位，簡稱整除。例如x//y結果爲2 |
| x**y | 求得x的y次冪。例如4**(1/2)結果爲2，3**2結果爲9 |
| 比較運算符 | 描述 |
|---|---|
| x==y、x!=y | 判斷x是否相等或者不相等，符合條件返回True，否則返回False |
| x>y、x<y | 判斷x是否大於或小於y，符合條件返回True，否則返回False |
| x<=y、x>=y | 判斷x是否大於等於或小於等於y，同樣返回布爾值 |
| 賦值運算符 | 描述 |
|---|---|
| x=y | 將y的值賦值給x，注意：當y是複雜數據類型時要使用.copy()的方法 |
| x+=1 | 等價於x=x+1 |
| x-=1 | 等價於x=x-1 |
| x*=2 | 等價於x=x*2 |
| x/=2 | 等價於x=x/2 |
字符串操作
字符串切片
基本切片操作
格式：<需要處理的字符串>[M:N]。
M缺失表示至開頭，N缺失表示至結尾。
注意：①兩種索引方式可以混用；②切片得到的結果不包含N索引的值。
a='〇一二三四五六七八九'
print(a[1:3])#得到 一二
print(a[1:-1])#得到 一二三四五六七八
print(a[-3:-1])#得到 七八
print(a[:3])#得到 〇一二
print(a[4:])#得到 四五六七八九
高級切片操作
格式：<需要處理的字符串>[M:N:K]。
根據步長K對字符串切片。不寫K時默認爲1，與[M:N]等價。
a='〇一二三四五六七八九'
print(a[1:8:2])#得到 一三五七
#分析過程：在一~七中，索引從1開始，依次加2，即a[1]，a[3]，a[5]，a[7]，將其拼接在一起得到一三五七
''' —————————————————————————————————美麗的分隔線—————————————————————————————————————— '''
print(a[::-1])#得到 九八七六五四三二一〇
#得到逆序字符串，格式固定。可簡單理解爲從右至左操作選定的字符串片段[M:N]。
''' —————————————————————————————————美麗的分隔線—————————————————————————————————————— '''
操作、相關函數、相關使用方法
| 操作符 | 描述 |
|---|---|
| x+y | 連接兩個字符串 |
| x*n | 複製n次字符串x |
| x in s | 返回布爾值，如果字符串x在s內，則返回True，否則返回False |
| 相關函數 | 描述 |
|---|---|
| len(x) | 返回字符串的長度。例如：len(‘我愛帥帥龍’)結果爲5 |
| str(x) | 將任意類型數據轉爲字符串。例如：str(123)結果爲字符串"123"，str([1,2])結果爲字符串"[1,2]" |
| chr(x) | 返回Unicode編碼的單字符。例如：chr(65)得到字母"A" |
| ord(x) | 返回單字符對應的Unicode編碼。例如：ord(“a”)得到數字97 |
| 相關方法 | 描述 |
|---|---|
| str.lower() 、str.upper() | 返回將字符串全部變成小寫或大寫的副本。 例：‘abc’.upper()的結果爲:‘ABC’ |
| str.isalpha() | 返回布爾值，判斷字符串str是否全部爲字母 |
| str.islower、str.isnumeruic() | 返回布爾值，判斷字符串str是否全部爲小寫或數字 如果記不住函數名。建議用循環和比較大小的方式判斷每個字符是否符合標準 |
| str.split(sep) | 將字符串按sep進行分割，當sep不填的時候默認以空格分割。 例：‘A,B,C’.split(’,’)結果爲:[‘A’,‘B’,‘C’] |
| str.strip() | 將字符串左右兩邊的空字符去掉，\n,\t,空格等。 例：’ \n我愛帥帥龍’.strip()結果爲:‘我愛帥帥龍’ |
| str.replace(old,new) | 返回副本，將字符串str中old字符替換爲new字符。 例：詳細講解在下面 |
字符串格式化（不需要花費太多時間）
| 類型 | 格式規則 |
|---|---|
| f | 格式化爲浮點數 |
| d | 格式化爲十進制整數 |
| s | 格式化爲字符串 |
format{}格式化
a=1.666
print('{0:-^20.1f}'.format(a)) # 得到--------1.7---------
0表示索引
:是引導符號
-是填充字符
^表示居中
20是輸出總長度
.1表示保留一位小數
%格式化
參考c語言格式化方法，此處不做過多介紹
a=1.555
print('%10.2f'%a) # 得到 1.55
%表示引導符號
10表示寬度
.2表示保留兩位小數
f表示轉爲浮點型
列表
注： 在文章開頭已經介紹了通用函數了，大家記得爬樓。
| 函數 | 描述 |
|---|---|
| ls[i]=x | 將列表索引爲 i 的元素更新爲 x |
| ls.append(x) | 在列表最後添加 x |
| ls.insert(i,x) | 在列表的第 i 位添加元素x |
| del ls[i] | 刪除列表索引爲 i 的元素 |
| ls.remove(x) | 刪除列表中從左到右第一次出現的元素 x |
| ls.copy() | 得到列表的副本，對其操作不會影響原數據 |
| ls.sort() | 將列表從小到大排序 |
| ls.reverse() | 將列表反轉 |
| mylist=sorted(ls) | 將列表的副本從小到大排序，不會影響原順序 |
一些要注意的地方
列表中可以存放任意數據類型，但是不建議將其它數據類型強轉爲列表，而應該使用ls.append()的方法
print(list('我愛阿龍')) # 得到['我', '愛', '阿', '龍']
ls=[]
ls.append('我愛阿龍')
print(ls) # 得到['我愛阿龍']
將列表排序和反轉，實際上是調用了sort()方法和reverse()方法，它是沒有返回值的，如果輸入會得到None。
a=[1,3,2,6]
print(a.sort()) # 得到None
a.sort()
print(a) # 得到[1,2,3,6]
# reverse同理
列表推導式：（有能力就掌握一下）
ls=[i for i in range(11)] # 得到[0,1,2,3,4,5,6,7,8,9,10]
ls=[i for i in range(11) if i%5==0] # 得到[5,10]
ls=[(i , j) for i in range(3) for j in range(11,13)]
# 得到[(0, 11), (0, 12), (1, 11), (1, 12), (2, 11), (2, 12)]
字典
dict1={'張瑞龍':'帥','劉浩':'醜'}
如上所示，冒號左邊的爲鍵，冒號右邊的是鍵所對應的值。例如，張瑞龍對應的是帥，劉浩對應醜。
注意： ①鍵的存在是單一的，即一個字典一個鍵只能出現一次。
②鍵和值的類型可以是任意類型，但通常爲字符型
③在字典中添加元素時，鍵與值出現是成對出現的。
| 函數 | 描述 |
|---|---|
| dict1[key]=value | 在字典中添加元素，如果key存在，則覆蓋原來對應的值 |
| list(dict1.keys()) | 得到字典所有鍵的列表 |
| list(dict1.values()) | 得到字典所有值的列表 |
| list(dict1.items()) | 得到字典所有元組類型鍵，值的列表 |
| dict1.get(key,default) | 如果鍵存在則返回對應的值，不存在則賦值爲default |
| del dict1[key] | 刪除這個鍵值對 |
| key in dict1 | 如果鍵在字典中則返回True，否則爲False |
一些要注意的地方
字典作爲可迭代對象，其實是它的鍵值
dict1={'張瑞龍':'帥','劉浩':'醜'}
for i in dict1:
print(i)
# 得到：張瑞龍，劉浩
統計出現次數並從大到小輸出
可以說是最經典的一種考題了，下面分塊操作。
①統計出現次數
法一
list1=[1,1,1,2,5,3,3,10,5,6,8,9,9,11]
dict1={} #創建一個空字典
for i in list1:
dict1[i]=dict1.get(i,0)+1 # dict1.get(i,0)表示如果有鍵爲i則返回對應的值，否則返回0
print(dict1)
法二
list1=[1,1,1,2,5,3,3,10,5,6,8,9,9,11]
dict1={} #創建一個空字典
for i in list1:
if i in dict1: # 如果字典中有鍵爲i
dict1[i]+=1 # 對應的值加一
else: # 如果字典中沒有鍵爲i
dict1[i]=1 # 創建鍵值對，值爲1，因爲這是第一次出現
print(dict1)
②lambda表達式排序
mylist=list(dict1.items())
mylist.sort(key=lambda x:(-x[1],x[0]))
# 當寫成mylist.sort(key=lambda x:(x[1],x[0]))是根據值從小到大排序
# 當寫成mylist.sort()是根據鍵從小到大排序
print(mylist) # 在此處可以直接根據需求進行其他操作，而不一定要轉爲字典
dict1=dict(mylist) # 將列表轉爲字典
print(dict1)
因爲介紹起來很繁瑣，大家記住這個格式就好了，有問題建議直接連麥滴滴我，Q3181314768。
③綜上,代碼彙總
list1=[1,1,1,2,5,3,3,10,5,6,8,9,9,11]
dict1={} #創建一個空字典
for i in list1:
dict1[i]=dict1.get(i,0)+1 # dict1.get(i,0)表示如果有鍵爲i則返回對應的值，否則返回0
mylist=list(dict1.items())
mylist.sort(key=lambda x:(-x[1],x[0]))
dict1=dict(mylist) # 將列表轉爲字典
print(dict1)
元組、集合
不是重點，但是需要簡單瞭解。
元組： 可以被列表所代替，操作與列表操作相似，唯一不同的是元組不能修改，即不能增刪元素，但可以使用切片和加法進行更新。
集合： 常用於清除相同元素，並且會自動排序。
list1=[5,1,3,7,9,9,2]
list1=list(set(list1))
print(list1) #得到[1, 2, 3, 5, 7, 9]
# 大家快看呀，這個就自動給你排序了。
選擇結構
運行過程
這個判斷到底是怎麼個流程呢？我來簡單說一下。
其實判斷的標準是布爾值，即是False還是True，例如下面這個程序。
if '龍' in '帥帥龍':
print('good')
#運行結果是good
print('龍' in '帥帥龍') # 輸出的結果是True
程序執行過程中，會先判斷後面的條件代表的是True還是False
‘龍’ in '帥帥龍’會返回True，因此執行下面的程序
在python中，一些其他的東西也可以等價爲布爾值
| 等價爲True | 等價爲False |
|---|---|
| 數字 1 | 數字 0 |
| 非空字符串 | 空字符串 |
| 非空列表 | 空列表 |
| 非空元組 | 空元組 |
| 非空字典（集合） | 空字典（集合） |
| None |
if 1:
print('帥帥龍')
#運行結果是帥帥龍
if - elif - else分支
編譯器從上往下尋找符合條件的分支，當進入此分支後便不會再進入其他分支。
多個判斷條件是，要寫 if - elif - else分支語句，if 和 elif 後面要加條件，else後面不需要加條件。
如果不寫成多分支而寫成多個if，有時會出錯，如下：
a=1
if a==1:
print('a是1')
if a==2:
print('a是2')
# 運行結果是a是1 a是2
a=1
if a==1:
print('a是1')
elif a==2:
print('a是2')
# 運行結果是a是1
大家可以思考一下問題出在哪裏
邏輯運算符
| a and b | 當 a 和 b 都爲真，才返回真。任意一個爲假就返回假 |
| a or b | 當 a 和 b 任意一個爲真，就返回真。全爲才返回假 |
| not a | 返回和a相反的布爾值，如果a表示真，則返回假 |
循環結構
continue與break
continue：終止本層循環，繼續下一層循環
break：終止循環，直接退出
for i in range(3):
if i==1:
continue
print(i)
# 結果爲0 2
###########################
for i in range(3):
if i==1:
break
print(i)
# 結果爲0
for 循環：常用於已知循環次數
①for i in range(x):
for 循環其實是while循環的簡化形式，for循環可以做到的while也能做到。
range是一個迭代器，可以得到可迭代對象，大家可以輸出這句話看看print(list ( range(10) ) )
for i in range(10):# 循環10次
print(i)
mylist=[0,1,2,3,4]
for i in range(len(mylist)):
print(mylist[i])
②for i in x:
mystr='我愛帥帥龍'
for i in mystr:
print(i)
while循環：常用於滿足某個條件
形式爲while + 條件判斷語句。當條件返回True，則繼續循環，否則結束循環。與if語句判斷過程相似。
while 1: 和 while True:可以表示死循環，需要用 break 跳出循環
x=0
while x<=5:
print(x)
x+=1
#結果爲0 1 2 3 4 5
while - else語句（瞭解一下就行）
當while語句執行完沒有被中斷，則會進入else語句。
如果while語句中途被中斷了，則不會進入else語句。
x=0
while x<=5:
print(x)
x+=1
else:
print('進入else啦')
# 輸出結果爲0 1 2 3 4 5 進入else啦
###########################
x=0
while x<=5:
if x==1:
print(i)
break
print(x)
x+=1
else:
print('進入else啦')
# 輸出結果爲0 1
函數
函數就是把代碼放在一起了，提高了代碼可讀性，讓代碼可以複用，其實很簡單，不要有畏難情緒。
函數一般定義在調用之前，通常放在程序頭頂
return 與 print
函數常常將結果通過return返回，當執行到函數的return語句後，函數其他部分將不會再執行。
但是函數可以沒有return語句，可以直接執行輸出語句，但如果想輸出return的值需要用print，說的可能有點蒙了，看代碼吧。
def test():
return '我愛阿龍'
print(test()) #會輸出我愛阿龍
test() #啥也不會輸出
###########################
def test():
print('我愛阿龍')
print(test()) #會輸出我愛阿龍 和 None #因爲函數並沒有傳遞值給函數外print，所以爲None
test() #會輸出我愛阿龍
函數的參數
簡單數據類型作爲參數
def test(x):
x='我愛帥帥龍'
return x
a='富婆'
a=test(a)
print(a) # 輸出爲我愛帥帥龍
複雜數據類型作爲參數
這裏需要注意，因爲複雜數據類型作爲參數時是以地址進行傳遞的（就是C/C++的那個地址，沒聽說過沒關係），對函數裏的複雜數據類型進行操作，會直接影響原數據，應該使用ls.copy()方法（詳情見下文）
def test(x):
x.append('帥哥')
return x
a=['富婆']
a=test(a)
print(a) # 輸出爲['富婆', '帥哥']
########################### 也可以像下面一樣
def test(x):
x.append('帥哥')
a=['富婆']
test(a)
print(a) # 輸出爲['富婆', '帥哥']
可缺省參數
參數分爲形參與實參，形參就是在定義函數是括號內的參數，實參就是調用函數的參數。
但有時候實參是不定長的，這是因爲在定義函數的時候對應的形參有默認值，當你調用函數的時候省略該參數，則執行過程中該參數爲默認值，這就是傳說的可缺省參數。
print()中其實有end這個參數，當你不寫則默認爲’\n’，即輸出完之後會自動輸出一個換行。
def test(x='帥哥',y='富婆'):
for i in [x,y]:
print(i,end='---')
test() # 得到結果爲 帥哥---富婆---，因爲你不寫，他就有默認值
test('帥帥') # 得到結果爲 帥帥---富婆---
test('帥帥','美美') # 得到結果爲 帥帥---美美---
test(y='帥帥',x='美美') # 得到結果爲 美美---帥帥---，可以指定對應參數
注： 可缺省參數應放在最右面，函數調用時，參數是從左往右調用的。
global語句（瞭解一下）
在函數中引入全局變量，可以直接對其進行修改。
全局變量：在主程序中定義的變量，既能在一個函數中使用，也能在其他的函數中使用
局部變量：只能在一部分代碼中使用，例如for i in range(3)的 i 就是局部變量
def test():
global a
a='富婆' #將a變爲'富婆'，這裏的a，其實是主函數的a
a='我愛' # 這裏的a就是全局變量
test()
print(a) # 輸出爲富婆
###########################
def test():
a='富婆'
a='我愛'
test()
print(a) # 輸出爲我愛
遞歸（瞭解一下）
遞歸其實就是重複調用函數的過程，遞歸需要可以設置結束遞歸的條件，有默認最大遞歸深度（自己可以重新設置），當你未設置時，超出最大深度會報錯。遞歸的作用可以使用循環來達到。
下面是一個求階乘的遞歸
def jiecheng(n):
if n==1:
return 1
else:
return n*jiecheng(n-1)
print(jiecheng(5)) # 得到的結果爲120
當你調用這個函數時，會進入這個函數，首先判斷n的值是否爲1，如果爲1就返回1，
不是則返回n*jiecheng(n-1)，即繼續往下調用函數。
本次調試中，n爲5，即結果爲5*jiecheng(4)，而jiecheng(4)代表的是4*jiecheng(3)，
即此時返回的結果由5*jiecheng(4)變爲5*4*jiecheng(3)，同理依次往下調用，直到結束遞歸，即n==1，
最後結果爲5*4*3*2*1
txt文件讀寫
文件操作我們沒考編程題，大家還是最好弄清楚考試範圍（雖然一般情況老師會說學的都考）
這裏其實並不難，只涉及文件的讀和寫，記得要用close()方法釋放文件的使用權（忘了也沒啥事）。
| 打開模式 | 描述 |
|---|---|
| r | 以只讀的方式打開（常用） |
| w | 覆蓋寫，文件不存在則會創建，存在則直接覆蓋（常用） |
| a | 追加寫，文件不存在會創建，存在則在文檔末尾追加寫 |
| 讀文件的方法 | 描述 |
|---|---|
| f.read() | 返回一個字符串，內容是文件全部內容 |
| f.readlines() | 返回一個列表，每一行的內容爲每個元素（常用） |
| 寫文件的方法 | 描述 |
|---|---|
| f.write(x) | 將字符串x寫入，\n即爲在文件中換行（常用） |
注： 寫入的只能是字符串
寫的示範
f=open('data.txt','w') # 別忘了寫文件後綴名
# 如果讀入的數據和看到的數據不一樣，那就這樣寫f=open('data.txt','w',encoding='utf-8')
data=['春眠不覺曉，','處處蚊子咬。','夜來大狗熊，','看你往哪跑。']
for i in data:
f.write(i+'\n') #不加\n就全都寫在一行了
f.close()
讀的示範
爲了讀取方便，我直接使用上方代碼創建名爲data.txt的文件
f=open('data.txt','r') # 別忘了寫文件後綴名
# 如果讀入的數據和看到的數據不一樣，那就這樣寫f=open('data.txt','r',encoding='utf-8')
data=f.readlines()
data=[strip(i) for i in data] #使用列表推導式更新data的內容，目的是爲了去除換行符
for i in data:
print(i)
f.close()
# 不使用f.read()是因爲返回的是一坨字符串，不方便操作
注： 文件讀寫主要是分析文本結構，記得把\n和\t放在寫入的字符串內，否則可能不會達到你的預期效果。
一些函數
後期可以根據大家需求再添加，大家可以私戳我或者評論區留言。
.copy()淺複製（可以不做了解）
def test(x):
x='我愛帥帥龍'
a='富婆'
test(a)
print(a) # a仍然爲'富婆'
將a變爲複雜數據類型（列表、字典…）的話，結果就不一樣了。
def test(x):
x=['我愛帥帥龍']
a=['富婆']
test(a)
print(a) # a變成了['我愛帥帥龍']
這是爲什麼呢？
原因是編譯器爲了節省內存，當簡單數據類型傳遞時，只是傳遞的數值。但是複雜數據類型佔用空間大，傳遞的是地址，這樣節省了內存的使用，但是對複雜數據類型操作會直接改變原數據內容。
問題的解決就需要使用.copy()函數。
它會將複雜數據類型的數據複製一份給對應變量，從而達到不改變原數據的目的。
def test(x):
x=x.copy()
x=['我愛帥帥龍']
a=['富婆']
test(a)
print(a) # a仍爲['富婆']
字符串的replace方法
str.replace(old,new[,count])，返回副本，把old字符串替換爲new字符串，count表示替換前幾次，不寫count默認爲全部替換。
萬能方法：mystr=mystr.replace(old,new,1) 對後面內容感興趣的同學可以看看，不感興趣可以跳過了
mystr='112'
mystr.replace('1','2')
print(mysrt) # 得到的結果仍爲112
爲什麼失效了呢？其實只是我們的使用方法不對，因爲replace返回的是原字符串副本，
上面已經說過副本這個概念了，即不會對原數據造成影響，因此直接寫mystr.replace並不會修改原字符串
修改後的代碼如下：
mystr='112'
mystr=mystr.replace('1','2')
print(mysrt) # 得到的結果爲222
題目要求： 將字符串中字母替換爲空格
a='df23A？45cde0@a' # 這個測試數據有沒有感覺很熟悉？？ 沒有當我沒說哈。
for i in a:
if not ('a'<=i<='z' or 'A'<=i<='Z'):
a=a.replace(i,' ')
print(a) # 結果爲df A cde a
直接傻用replace會不會把數據弄髒呢，會也不會，來看代碼。（強烈建議大家不要看，記住萬能公式就好了）
# 把2替換爲1
a='21122'
for i in a: # 因爲字符串是簡單數據類型，其實這裏等價於for i in '21122':
print(i)
if i=='2':
print(a)
a=a.replace('2','1') #因爲我沒寫count，因此，他會把所有的2都替換掉
# i依次輸出爲2 1 1 2 2
# a依次輸出爲21122 11111 11111
# 因爲循環的時候，其實程序已經確定好i依次代表什麼了，因此更新a，不會影響程序
isinstance()判斷數據格式
type判斷一個變量是什麼類型不太方便，於是就有了isinstance()這個函數，它會返回布爾值。
a=1
print(isinstance(a,int)) # 輸出結果爲True
Python標準庫
引入方式
import math
引入數學庫，可以調用數學庫的函數
import math
print(math.pow(2,3)) # 得到8.0
from math import pow
從數學庫中引入pow函數，不引入其他函數
import math
print(pow(2,3)) # 得到8.0。注意，少了math.
#但是使用其他函數會報錯
print(abs(-3)) # 會報錯
from math import *
從數學庫中引入所有函數
import math
print(pow(2,3)) # 得到8.0。注意，少了math.
print(abs(-3)) # 得到3
math庫
首先要在程序開頭引入數學庫。使用方法：import math
| 常用函數 | 描述 |
|---|---|
| abs(x) | 得到x的絕對值 |
| pow(x,y) | 得到x的y次冪，返回浮點型 |
| sqrt(x) | 將x開平方，也可以直接x**(1/2) |
| pi、e | 得到精確數值π、e |
random庫
| 常用函數 | 描述 |
|---|---|
| seed(x) | 當x確定時，產生隨機數的順序其實已經確定了 |
| randint(a,b) | 生成[a,b]之間的隨機整數（這裏是兩個閉區間！） |
| choice(seq) | 從序列類型seq中隨機選取一個元素 |
| shuffle(seq) | 將序列類型seq隨機打亂 |
| random() | 生成[0.0,1.0)之間的隨機小數 |
| uniform(a,b) | 生成[a,b]之間的隨機小數（這裏是兩個閉區間！） |
from random import *
seed(10) #當seed一定時，產生隨機數的順序就一定了！
a=int(input('n:'))
mylist=[]
for i in range(a):
mylist.append(randint(100,200))
mylist.sort()
for i in mylist:
print(i)
jieba庫（不作重點）
| 常用函數 | 描述 |
|---|---|
| jieba.lcut(s) | 將字符串分詞，返回一個列表 |
| jieba.lcut(s , cut_all=True) | 全模式，返回字符串中字可能組成的所有詞 |
| jieba.add(s) | 在詞庫中添加詞語 s |
time庫
| 常用函數 | 描述 |
|---|---|
| sleep(x) | 程序暫停x秒，常用在循環裏 |
一些編程技巧
IDE的選擇
好的IDE是成功的一半，大部分下載的IDE都有代碼自動補全的功能、錯誤警告、會自動聯想對應的函數和變量的功能，十分方便。
大家如果還在使用python自帶的IDE，不妨輸入’pr’再按一下鍵盤的Tab鍵，你可能會有新發現哦。
建議一：使用spyder編譯器。
理由一：下載方便，直接百度搜索Anaconda進入官網即可下載。
理由二：不需要配置自己編譯器
理由三：許多第三方庫都是Anaconda自帶的，不需要額外安裝
建議二：使用pycharm編譯器。
理由一：長的好看
理由二：無
理由三：無
注： 如果只是爲了考試，可以去官網下載社區版，這個足夠用了。如果想體驗專業版何以去官網用學生郵箱註冊，還可以去微信公衆號：軟件安裝管家處白嫖破解版。
判斷一個字符串中有幾個大寫字母
有的時候記不住字符串那麼多判斷方法怎麼辦？沒關係，其實可以直接進行比較。
a='aAfSSaDhQoTn'
count=0
for i in a:
if 'a'<=i<='z': # 因爲比較的時候比較的是ASCII碼（小寫字母比大寫字母大，可以輸入ord('a')查看）
count+=1
print(count) # 結果爲6
判斷一個數是不是素數
def sushu(n):
for i in range(2,n): # 這是無腦的寫法，大家也可寫成for i in range(2,int(n**(1/2))+1):
if n%i==0:
return False
return True
a=int(input('輸入一個數:'))
print(sushu(a))
flag的小應用
有時候，通過可以設置flag來達到條件判斷的目的。
問題描述： 判斷一個字符串中有沒有數字
flag=False
mystr='fahu57486sge'
for i in mystr:
if '0'<=i<='9':
flag=True
if flag:
print('有')
else:
print('沒有')
還可以通過設置多個flag來達到判斷密碼強度的作用。
廣闊天地，大有作爲，我在這裏拋磚引玉，快發動你的小腦筋吧。
結語
💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋
💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋