1，字符串：
name="ada lovelace"
name=" ada lovelace "
str():
age=23
2.列表
color=['red','yellow','blue',black]
列表排序：
數值列表
使用列表中的一部分--切片
復制列表：
3 元組：
定義元組：
dimensions=(200,50)
print(dimensions[0])
遍歷元組中的所有值：
for dimension in dimensions：
print(dimension)
修改元組變量：
dimensions=(200,50)
for dimension in dimensions：
print(dimension)
dimensions=(200,55)
for dimension in dimensions：
print(dimension)
4.字典
字典和字典，字典和列表，列表和列表，可以嵌套使用。。。
5函數
函數和模塊：模塊為擴展名為.py的文件，函數位於模塊中
6類
__init__()類似於java中的構造方法，形參self必不可少，還必須放在其他的形參的前邊。為何必須在方法定義中包含形參self呢？ 因為Python調用這個__init__() 方法來創建Dog 實例時， 將自動傳入實參self 。 每個與類相關聯的方法調用都自動傳遞實參self ， 它是一個指向實例本身的引用， 讓實例能夠訪問類中的屬性和方法。 我們創建Dog 實例時， Python將調用Dog 類的方法__init__() 。 我們將通過實參向Dog() 傳遞名字和年齡； self 會自動傳遞，因此我們不需要傳遞它。 每當我們根據Dog 類創建實例時， 都只需給最後兩個形參（ name 和age ） 提供值。
之前總結的直接搬過來了，嘻嘻嘻
Python list列表 定義格式 a=[1,2,'X'] 修改 a[1]=3 添加 append()
會在後面直接插入元素 元素如果是個地址(如列表)，會直接不進行拆分直接添加地址
extend()
會在後面直接插入元素 元素如果是個地址(如列表)，會進行拆分並逐個添加地址內元素
a3=[1,2] a4=[1,3] a4.extend(a3) print(a4)#[1, 3, 1, 2] a5=[1,5] a4.append(a5) print(a4)#[1, 3, 1, 2, [1, 5]] 但是 如內元素內依然有地址則不會拆分
a2=[1,2] a3=[1,a2] a4=[1,3] a4.extend(a3) a4.extend(a3) print(a4)#[1, 3, 1, [1, 2]] 刪除 pop()
輸入角標 刪除指定角標處元素
如不輸入刪除最後一個
a1=[1,2,1,3,1,3] a1.pop(0) print(a1)#[2, 1, 3, 1, 3] a1.pop() print(a1)#[2, 1, 3, 1] remove()
刪除指定元素 如有多個刪除第一個
a2=[1,2,1,3,1,3] a2.remove(1) print(a2)[2, 1, 3, 1, 3] 切塊 arr[X:Y]獲取列表中從x到y(有x無y)中的元素
a1[1:3] 獲取地址 id(a1) 復制 直接使用等於獲取的是地址
修改列表時原列表也會發生改變
用copy方法獲取的是新的指針方向
但是如果列表內嵌套了列表
修改 嵌套內的列表時 原列表也會發生改變
屬於淺copy
a3=[1,2] a4=[1,a3] print(a4)#[1, [1, 2]] a5=a4.copy() a5[1].append(5) print(a4)#[1, [1, 2, 5]] 使用 deepcopy()方法可進行深copy
即使修改列表內的列表值原列表也不會發生改變
需要導包（from copy import deepcopy）
from copy import deepcopy a6 = deepcopy(a4) a6[1].append(3) print(a6)#[1, [1, 2, 5, 3]] print(a4)#[1, [1, 2, 5]] 遍歷 簡單列表 例如
list1=[“a”,“b”,“c”,“d”]
for i in list1: print(i)
列表中元素為元組時： 例如
list2=[(“a”,1),(“b”,2),(“c”,3),(“d”,4)]
for x,y in list2: print(x,y) 輸出為：
a 1
b 2
c 3
d 4
列表中元素為集合時： 例如：
list3=[{“a”,1},{“b”,2},{“c”,3},{“d”,4}]
for x,y in list3: print(x,y) 輸出為：
1 a
2 b
3 c
4 d
注意：集合中的元素是無序的，所以打印出來也是隨機排列的。
列表中的元素為字典時： 例如：
list4=[{“a”:1},{“b”:2},{“c”:3},{“d”:4}]
for x in list4: print(x)
輸出結果為：
{“a”:1}
{“b”:2}
{“c”:3}
{“d”:4}
方法 population 隨機數
random.sample(population, k)
population：列表 k：隨機返回的個數 reverse()內元素倒置 a1 = [1, 2, 1, 3, 1, 3] a1.reverse() print(a1)#[3, 1, 3, 1, 2, 1]
sort 排序 如果元素為數字按數字大小排序
a1 = [1, 2, 1, 3, 1, 3] a1.sort()#默認等同a1.sort(reverse=False) print(a1)#[1, 1, 1, 2, 3, 3] a1 = [1, 2, 1, 3, 1, 3] a1.sort(reverse=Ture) print(a1)#[3, 3, 2, 1, 1, 1]
如果元素為字符按字符第一個大小排序順延
a1 = ['SDS','AC','AAD','ASDASD','SDS'] a1.sort() print(a1)#['AAD', 'AC', 'ASDASD', 'SDS', 'SDS']
不可數字字符混用
有更加具體的排序請自行搜索 以上只是一部分
count 計數 獲取指定字符出現的次數
index 角標索引 獲取指定字符第一次出現的位置
index(x,y,z)
獲取指定字符x 從y到z區域中第一次出現的位置
a=(1,2,1,1,1) print(a.count(1))#4 print(a.index(2))#1 print(a.index(1,0,3))#0
字典 定義 用大括號包住
key 對應 元素
a1={1:2, 3:4} print(a1)
獲取
print(a1[1])#{1:2,3:4}
方法 刪除相關 pop() 若無參數則報錯
若有會返回對應值
popitem() 刪除最後一個元素並返回元素（元組）
a={ 1:2, 2:5 } a.pop(1) print(a)#{2: 5}
a={ 1:2, 2:5 } print(a.popitem())#(2, 5)
clear() 刪除 刪除全部
a={ 1:2, 2:5 } a.clear() print(a)#{}
獲取相關 keys()獲取鑰匙 valus()獲取值 get() 獲取對應值 通過鍵獲取值 可以防止報錯
.get(X,若無返回的值默認none)
a={ 1:2, 2:5 } print(a.keys())#dict_keys([1, 2]) print(a.values())#dict_values([2, 5]) print(a.get(3))#None
items()獲取 獲取字典中所有元素 以元組返回
list() 可以將類似的轉換為list
setdefault()獲取傳入 獲取對應值若有則獲取若無則傳入傳入默認為None
setdefault(key,valus)
a={ 1:2, 2:5 } print(a.setdefault(3))#None print(a)#{1: 2, 2: 5, 3: None'}
添加相關 update() 將元素添加入字典
或將其他字典裡的元素添加進入
a={ 1:2, 2:5 } b={} b.update(a) b.update([(5,6),(9,7)]) print(b)#{1: 2, 2: 5, 5: 6, 9: 7} b[8]=7 print(b)#{1: 2, 2: 5, 5: 6, 9: 7, 8: 7}
10 b[key]=valus
可以直接添加
集合 定義 無序不重復
b={1,2,3,4,2} print(b)#{1, 2, 3, 4}
因為無序直接獲取會報錯
print(b[0])#TypeError: 'set' object is not subscriptable
定義空集合方法
a=set()#空集合 print(a,type(a))#set() <class 'set'>
直接為空是字典
c={} print(c,type(c))#{} <class 'dict'>
方法 傳入相關 add()
b={1,2,3,4,2} d=(1,2) e={5:6} f=[7,8] b.add(d)# print(b)#{1, 2, (1, 2), 3, 4} #傳入字典和列表時候會報錯
刪除相關 clear() 刪除 刪除全部
discard()
刪除一個
fruits = {"apple", "banana", "cherry"}
fruits.discard("banana")
print(fruits)#{'cherry', 'apple'}
獲取相關 update()並集合 實例 把集合 y 中的項目插入集合 x：
x = {"apple", "banana", "cherry"} y = {fruits = {"apple", "banana", "cherry"} x.update(y) print(x)#{'banana', 'google', 'microsoft', 'cherry', 'apple'}
intersection()返回交集 x = {"apple", "banana", "cherry"} y = {"google", "microsoft", "apple"}
z = x.intersection(y)
print(z)#{'apple'}
issubest() 如果集合 y 中存在集合 x 中的所有項目，則返回 True：
x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"}
z = x.issubset(y)
print(z)#True
基本運用 字符串去重
S = 'lsdljfjaldfaowioueroiuwoe' A = set(S) print(A)#{'d', 'j', 'l', 'w', 'a', 'i', 'e', 'r', 'f', 'o', 'u', 's'} B = list(A) print(''.join(A))#djlwaierfous B.sort(key=S.index) print(B)#['l', 's', 'd', 'j', 'f', 'a', 'o', 'w', 'i', 'u', 'e', 'r'] print(''.join(B))#lsdjfaowiuer
運算符 Python 在以下組中劃分運算符：
算術運算符 賦值運算符 比較運算符 邏輯運算符 身份運算符 成員運算符 位運算符 Python 算術運算符 算術運算符與數值一起使用來執行常見的數學運算：
運算符 名稱 實例
加 add x + y
減 sub x - y
乘 mul x * y / 除 floordiv x / y % 取模 mod x % y ** 冪 pow x ** y // 地板除（取整除）div x // y Python 賦值運算符 賦值運算符用於為變量賦值：
運算符 實例 等同於 = x = 5 x = 5 += x += 3 x = x + 3 -= x -= 3 x = x - 3 *= x *= 3 x = x * 3 /= x /= 3 x = x / 3 %= x %= 3 x = x % 3 //= x //= 3 x = x // 3 = x = 3 x = x ** 3 &= x &= 3 x = x & 3 Python 比較運算符 比較運算符用於比較兩個值：
運算符 名稱 實例 == 等於 eq x == y != 不等於 ne x != y
大於gt x > y < 小於lt x < y = 大於或等於ge x >= y <= 小於或等於le x <= y Python 邏輯運算符 邏輯運算符用於組合條件語句：運算符 描述 實例 and 如果兩個語句都為真，則返回 True。 x > 3 and x < 10 or 如果其中一個語句為真，則返回 True。 x > 3 or x < 4 not 反轉結果，如果結果為 true，則返回 False not(x > 3 and x < 10) Python 身份運算符 身份運算符用於比較對象，不是比較它們是否相等，但如果它們實際上是同一個對象，則具有相同的內存位置：
運算符 描述 實例 is 如果兩個變量是同一個對象，則返回 true。 x is y is not 如果兩個變量不是同一個對象，則返回 true。 x is not y Python 成員運算符 成員資格運算符用於測試序列是否在對象中出現：
運算符 描述 實例 in 如果對象中存在具有指定值的序列，則返回 True。 x in y not in 如果對象中不存在具有指定值的序列，則返回 True。 x not in y Python 位運算符 位運算符用於比較（二進制）數字：
運算符 描述 實例 & AND 如果兩個位均為 1，則將每個位設為 1。 | OR 如果兩位中的一位為 1，則將每個位設為 1。 ^ XOR 如果兩個位中只有一位為 1，則將每個位設為 1。 ~ NOT 反轉所有位。 << Zero fill left shift 通過從右側推入零來向左移動，推掉最左邊的位。
Signed right shift 通過從左側推入最左邊的位的副本向右移動，推掉最右邊的位。 數據 Python為我們提供了強大的內置函數和格式化數字的方法去實現進制轉換的功能，下面一一介紹。 先將所有的函數羅列出來，如下：↓ 2進制 8進制 10進制 16進制 2進制 - bin(int(n,8)) bin(int(n,10)) bin(int(n,16)) 8進制 oct(int(n,2)) - oct(int(n,10)) oct(int(n,16)) 10進制 int(n,2) int(n,8) - int(n,16) 16進制 hex(int(n,2) hex(int(n,8) hex(int(n,10)) -
2進制 2進制轉換成其他進制：
2進制轉換成8進制：oct(int(n,2)) n=input() print(oct(int(n,2)))
輸入: 1010 輸出: 0o12
2進制轉換成10進制：int(n,2) n=input() print(int(n,2))
輸入：1010 輸出：10
2進制轉換成16進制：hex(int(n,2)) n=input() print(hex(int(n,2)))
輸入：1010 輸出：0xa
8進制 8進制轉換成其他進制：
8進制轉換成2進制：bin(int(n,8)) n=input() print(bin(int(n,8)))
輸入：1010 輸出：0b1000001000
8進制轉換成10進制：int(n,8) n=input() print(int(n,8))
輸入：1010 輸出：520
8進制轉換成16進制：hex(int(n,16)) n=input() print(hex(int(n,8)))
輸入：1010 輸出：0x208
10進制 10進制轉換成其他進制： 說明：10進制轉換可以直接采取上述表格中的形式，讀入字符串，先轉換為10進制的數，再用函數進行操作轉換成其他進制。 但同時可以這樣操作，讀入的時候直接進行強制類型轉換操作，轉為int類型(python中的int類型的數據就是10進制)
10進制轉換成2進制：bin(n) n=int(input()) print(bin(n))
輸入：10 輸出：0b1010
10進制轉換成8進制：oct(n) n=int(input()) print(oct(n))
輸入：10 輸出：0o12
10進制轉換成16進制：hex(n) n=int(input()) print(hex(n))
輸入：10 輸出：0xa
16進制 16進制轉換成其他進制：
16進制轉換成2進制：bin(int(n,16)) n=input() print(bin(int(n,16)))
輸入：a 輸出：0b1010
16進制轉換成8進制：oct(int(n,16)) n=input() print(oct(int(n,16)))
輸入：a 輸出：0o12
16進制轉換成10進制：int(n,16) n=input() print((int(n,16)))
輸入：a 輸出：10
去頭綴 注意：我們可以發現，除了轉換成10進制的數，其他的進制轉換結果都帶有前綴，2進制是0b，8進制是0o，16進制是0x。但是我們在絕大部分使用進制轉換後的數據時，是不需要它的前綴的。所以筆者這裡介紹兩種方法，去掉它的前綴。
方法一：使用字符串切片操作 原理：就是將進制轉換後得到的結果對其進行字符串切片操作，將得到的結果從第三個字符開始取結果即可，這樣我們可以得到不帶前綴的結果
舉例：
//10進制轉換成2進制 n=int(input()) print(bin(n)[2:])//切片操作
輸入：10 輸出：1010
//10進制轉換成8進制 n=int(input()) print(oct(n)[2:])//切片操作
輸入：10 輸出：12
//10進制轉換成16進制 n=int(input()) print(hex(n)[2:])//切片操作
輸入：10 輸出：a
筆者這裡以10進制轉換其他進制進行了舉例，其他的情況類比即可。
方法二：使用format函數進行格式化數字操作 說明：首先，筆者在前面說過，不同類型的進制轉換的原理時先轉換為十進制，然後再用相關的函數進行禁止轉換操作，而format函數裡面有格式化數字的方法可以直接實現進制轉換的功能，下面一一介紹：
其他類型轉換為2進制： 操作：在format函數的槽中添加一個b 即可實現其他類型對2進制的轉換，下面舉例說明
n=input() print("{:b}".format(int(n,8))) //先將8進制的數轉換為10進制， //然後在format的槽中添加一個b，等價於實現了bin函數的功能 //但是此結果是不帶有0b前綴的
輸入：1010 輸出：1000001000
其他類型轉換為8進制：
操作：在format函數的槽中添加一個o 即可實現其他類型對8進制的轉換，下面舉例說明
n=input() print("{}".format(int(n,16))) //先將一個16進制數轉換為10進制 //然後利用format函數格式化數字方法轉換即可
輸入：a 輸出：12
其他類型轉換為16進制： 操作：在format函數的槽中添加一個x 即可實現其他類型對2進制的轉換，下面舉例說明
n=input() print("{:x}".format(int(n,8))) //先將一個8進制的數轉換為16進制 //然後原理同上
輸入：1010 輸出：208
注意：由於轉換成10進制本來就是不帶前綴的，無需用format格式化數字方法控制
方法 python格式化輸出內容 以下是 print() 方法的語法:
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
參數 objects – 復數，表示可以一次輸出多個對象。輸出多個對象時，需要用 , 分隔。 sep – 用來間隔多個對象，默認值是一個空格。 end – 用來設定以什麼結尾。默認值是換行符 \n，我們可以換成其他字符串。 file – 要寫入的文件對象。 flush – 輸出是否被緩存通常決定於 file，但如果 flush 關鍵字參數為 True，流會被強制刷新。 range range(X,Y,Z)
X到Y 隔z個
for i in range(9,0,-1): print(i) 9 8 7 6 5 4 3 2 1
錯誤與異常 錯誤 是不可運行的 在運行之前就會報錯 通常是語法錯誤
編譯失敗 不可被處理
異常 可以運行到異常地點 之後報錯
可以被處理
例1 被除數為0
1/0 #ZeroDivisionError: division by zero
語法 try 獲取異常0
try: 要執行語句 except 異常類型 as 給異常改名: 處理異常的語句 else: 沒有遇到異常執行語句 finally: 無論如何都執行的語句
excent 處理任意異常
as 給異常改名
finally 結束輸出
try: 1/0 except: print('分母不能為0')
Exception 處理
try: print(111) 1/0 except Exception: print('分母不能為0')
常見異常 列表超出索引 元組不可改變 字典 key不存在 文件 說明 oprn:打開 open(file,encoding=“編碼格式”,) 以什麼演的形式打開 讀或寫 read ,write r 以讀的方式 默認的 w 以寫的方式打開 x 創建一個新文件,並以寫的方式打開 a 以追加的方式去寫 b 二進制方式 t 文本方式 默認的
/ +以讀或者寫打開一個磁盤
file(): 文件，路徑+文件名 mode(): 模式 buffering: 保存 encoding(*) 編碼 如 UTF-8 errors: 錯誤處理方式 newline 新行 closefd 關閉文件描述符
語法 fi=open("file.txt",encoding="UTF-8") da=fi.read() print(da) fi.close()
注意
fi=open("file.txt",encoding="UTF-8") da=fi.read() da1=fi.read() print(da)#你好啊 print(da1)# 空 因為已經讀到了文章末尾 fi.close()
寫入 write
writelines
多行輸入
f2.writelines("\n".join(["1","2"])) 1 w 會直接刪除 並寫入
fa=open("file.txt","w",encoding="UTF-8") fa2=fa.write("111111") print(fa2) fa.close()
a 會追加 並寫入
fa=open("file.txt","a",encoding="UTF-8") fa2=fa.write("2222") print(fa2) fa.close()
/ + 加號不可以單獨使用
復制 f1=open("1.png","rb") F1=f1.read() f2=open("6.png","wb") f2.write(F1) f2.close() f1.close()
或者
f1=open("1.png","rb") F1=f1.read() with open("5.png","wb") as f2: f2.write(F1) f2.close() f1.close()
read 讀取 read 讀取全部
read(n) /*讀取n個字節
readline() //讀取一行
readlines()//讀取所有行
readlines(n) 根據字節讀取整行 且第二次讀取從下一行開始
#如 第一行有6個 字節第二行有8個 字節 #n=8則讀取了兩行 小於等於6+1則只有第一行 f1=open("file.txt","rb") F1=f1.readlines(8) print(F1)#[b'222210\r\n', b'22221022\r\n'] f1.close()
模塊 導入全部 間接用
import python2 print(python2.a)
導入局部 可以直接用
from python2 import a print(a)
導入*
from python2 import *
獲取除了下劃線開頭的所有屬性
主運行 _ name_ (無空格)
一個模塊被另一個程序第一次引入時，其主程序將運行。如果我們想在模塊被引入時，模塊中的某一程序塊不執行，我們可以用_ _name__屬性來使該程序塊僅在該模塊自身運行時執行。
#!/usr/bin/python3
Filename: using_name.py
if name == 'main': print('程序自身在運行') else: print('我來自另一模塊')
os 語法 使用 os
import os
輸入輸出 輸入 語法 xxx=input("XXXXX")
讀取到一定是字符串，如果想使用實際數據類型，需要做類型轉換
int(), float(), tuple(), list()
輸出 語法 print("XXXX","SSSS")#屏幕輸出 print("XXXX","file.txt")#文件內輸出
格式化輸出 舊版 占位符號
%d:digit 整形
%f:float 浮點型
%s: string 字符串
date=1 date1=1.1 date2="11" print("date is %d,date2 is %.1f,date2 is %s"%(date,date1,date2)) #date is 1,date2 is 1.1,date2 is 11
固定輸出占位
%4d 右對齊 占4位
%-4d 左對齊 占4位
%8.4f 右對齊 占8位 有效數字小數後4位
%+10d 右對齊 占10位輸出帶加號
新版 date=1 date1=1.1 date2="11" print(f"date is {date},date2 is {date1},date2 is {date2}") #date is 1,date2 is 1.1,date2 is 11
{date:4} 占4位右對齊 默認等同{date:>4}
{date:<4} 占4位左對齊
{date:^4} 占4位中間對齊
{date:*^4}占4位中間對齊 空白用 * 號填充 此處星號可變為單字符
{date:x^4}占4位中間對齊 空白用 x 填充
date = ["張三", 20, "西安的"] print("姓名：{a},年齡：{b},家庭地址:{c}".format(a=date[1],b=date[1],c=date[2]))#姓名：20,年齡：西安的,家庭地址:張三
注 此處date 為變量名 可靈活改變
字符串 方法 切塊 a. 使用切片倒序輸出 b. 使用切片取出偶數的數字 c. 使用切片取出奇數的數字 d. 取出後5位字符
s = "123456789" print(s[::-1])#987654321 print(s[::2])#13579 print(s[1::2])#2468 print(s[-5:])#56789
x::y
從x開始 每隔y個獲取 x默認為0 y默認為1
lower 字符串小寫
str="aBcD" print(str.lower())#abcd
upper 字符串大寫
str="aBcD" print(str.upper())#ABCD
capitalize 首字母大寫
str="aBcD" print(str.capitalize())#Abcd
對齊方式 str="aBcD" print(str.center(10,""))#占位居中對齊填充**aBcD* print(str.ljust(10,""))#占位左對齊填充aBcD* print(str.rjust(10,""))#占位右對齊填充***aBcD
count 字符串中某字符個數
str="aBcD" print(str.count("a"))#1
字符串中從第二個字符以後某字符個數
str="aBcD" print(str.count("a",2))#0 print(str.count("c",2))#1
len 獲取字符創的長度
str="aBcD" print(len(str))#4
字符串下標 獲取字符串下標為1的字符
str="aBcD" print(str[1])#B
endswith 字符串是否以什麼什麼結尾的
str="aBcD" print(str.endswith("D"))#True
rstrip 去除末尾的字符或者特定符號
str="aBcD" print(str.rstrip("cD"))#aB
replace 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.
str="zzsaixuexi" print(str.replace('z','a',1))#azsaixuexi
format date = ["王五五五五五五五五", 280, "山西的老百姓"] print("{},{},{}".format(date[0],date[1],date[2])) #傳入參數格式化輸出 print("{1},{0},{2}".format(date[0],date[1],date[2])) #按照下標順序輸入
結果
王五五五五五五五五,280,山西的老百姓 280,王五五五五五五五五,山西的老百姓
replace(self, old, new, count=-1, /) 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.
str="zzsaixuexi" print(str.replace('z','a',1))#azsaixuexi
join(self, iterable, /) join() 方法用於將序列中的元素以指定的字符連接生成一個新的字符串。
srg=["ZZS","AI","XUEXI"] str = "-"; print(str.join(srg))
isdigit 如果字符串只包含數字則返回 True 否則返回 False。
str="zzsaixuexi" print(str.isdigit())#False
isalpha 如果字符串至少有一個字符並且所有字符都是字母則返回 True，否則返回 False。
str="zzsaixuexi" print(str.isalpha())#True
isalnum 如果 string 至少有一個字符並且所有字符都是字母或數字則返回 True,否則返回 False
str="zzsaixuexi" print(str.isalnum())#True
strip 返回移除字符串頭尾指定的字符生成的新字符串。
str = "00000003210ZZSAXX01230000000"; print(str.strip('0')) # 去除首尾字符 0 #3210ZZSAXX0123 str2 = " ZZSAIXX " # 去除首尾空格 print(str2.strip()) #ZZSAIXX
split 參數 str – 分隔符，默認為所有的空字符，包括空格、換行(\n)、制表符(\t)等。 num – 分割次數。默認為 -1, 即分隔所有。 返回值 返回分割後的字符串列表。
str = "Line1-abcdef \nLine2-abc \nLine4-abcd" print(str) print(str.split( )) # 以空格為分隔符，包含 \n print(str.split(' ', 1 ))# 以空格為分隔符，分隔成兩個
結果
Line1-abcdef Line2-abc Line4-abcd ['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] ['Line1-abcdef', '\nLine2-abc \nLine4-abcd']
splitlines 參數 keepends – 在輸出結果裡是否保留換行符(’\r’, ‘\r\n’, \n’)，默認為 False，不包含換行符，如果為 True，則保留換行符。 返回值 返回一個包含各行作為元素的列表。
print(str2.strip()) str1 = 'ab c\nde fg\nkl' print(str1) print(str1.splitlines()) print(str1.splitlines(True))
結果
ab c de fg kl ['ab c', 'de fg', 'kl'] ['ab c\n', 'de fg\n', 'kl']
函數 語法 定義 無返回值
def print_123():#定義函數 print("123") print_123()#調用函數 輸出123
一個返回值
def jiachen(A): return A+1,A+2 print(jiachen(1),type(jiachen(1)))#2 <class 'int'> date,date1=jiachen(1) print(date,date1)#2 3
多個返回值
返回時候用逗號隔開
def jiachen1(A): return A+1 print(jiachen1(1),type(jiachen1(1)))#(2, 3) <class 'tuple'>
形參 定義函數時候用到的定義參數
實參 真正運行時候用到的參數
def zzs(arg,arg1=1): print(arg,arg1) zzs(1)#11 zzs(1,2)#11
有默認值的調用時候可以只輸入沒默認值的
如果輸入默認值的默認值會更換
默認值參數需要放後面
因為數要根據位置去匹配
也可以通過調用時候輸入來確定
def zzs(arg,arg1=1,arg2=1): print(arg,arg1,arg2) zzs(arg1=2,arg=1,arg2=5)
會按照輸入參數來確定輸入
特殊參數 *args 一個或者多個參數 aegs 名字可以改 重點是星號
def zzs(arg,args): print(arg,args )#1 2 3 4 5 print(args,type(args))#(2, 3, 4, 5) <class 'tuple'> # print(type(*args)) 會報錯 因為他是多個數 zzs(1,2,3,4,5)
**kwargs 一個或者多個關鍵字參數
一言概之，*主要使用在函數參數中，在定義函數中添加是為了在調用該函數時直接將多個參數轉換成一個元組，而在調用函數時參數添加，是為了將列表/元組轉化成多個參數。
也主要使用在函數參數中，在定義函數中添加是為了在調用該函數時可以添加任意個鍵值對轉出一個字典，而在調用函數時在列表中添加，是為了將字典轉化成多個參數。
如例子：
def func1(a): print(a) def func2(**b): print(b) func1(1,2,3,4,5) #這樣可以將多個參數變成一個元組 func2(name='mr',age='22') #這樣可以將多個鍵值對變成一個字典 def f1(a,b,c): print(a) def f2(name,age,sex): print(name) l = [1,2,3] d = {"name":'mr',"age":22,"sex":'boy'} f1(l) #將列表、元組變成多個參數f2(**d) #將字典轉成賦值參數，name='mr',age=22,sex='boy'`
func1(*l) #先將參數轉成多個參數，在函數參數中又轉成元組
func2(**d) #先將參數轉成多個鍵值對，在函數參數中又轉成字典結果：
(1, 2, 3, 4, 5) {'age': '22', 'name': 'mr'} 1 mr (1, 2, 3) {'age': 22, 'sex': 'boy', 'name': 'mr'}
/ 作用 在它之前的參數只能以位置參數形式傳入
def hunhe(X1,Y1,/,X=None,Y=None): return X1,Y1,X,Y print(hunhe(X1=1,Y1=2,X=3,Y=2)) #報錯因為x1y1不是以位置參數傳入的
* 作用 在它之後的參數只能以關鍵字參數形式傳入
def hunhe(*,X1,Y1,X=None,Y=None): return X1,Y1,X,Y print(hunhe(X1=1,Y1=2,X=3,Y=2))#（1,2,3,4） print(hunhe(1,2,3,4))#報錯
調用 def print_123(): print("123") print_123()#調用函數 輸出123 PPPP=print_123 #獲取函數 PPPP()#調用函數 輸出123
嵌套函數 定義 def outer(): def inner(): print("inner") print("outer") return inner() outer() #outer #inner
遞歸 定義 函數自身調用自身
應用 累加
def num(N): if N==1: return 1 else: return num(N-1)+N print(num(100))#5050 時間函數 類 定義 語法格式 class 類名:
注意 類名 盡量使用駝峰命名 單詞首字符大寫
class Person: name="張三" age=18 gender="男" def test(): print("this is test") pass
初始化變量定義 定義在 初始化類 _ init_ 中
注 外部的是類變量 如果一個修改了 就全修改了需要實例化
class Person: def init(self,name,age,gender): self.name=name self.agr=age self.gender=gender def print(self): return self.name,self.agr,self.gender student1=Person("li",18,"男") student2=Person("si",18,"nv") print(student1.print())#('li', 18, '男') print(student2.print())#('si', 18, 'nv')
類變量實例化 實例化前
class delivery: location="beixin" def init(self, id, from1, to, type): self.id=id self.from1 = from1 self.to=to self.type = type pass kuaiid1=delivery kuaiid2=delivery kuaiid1.location=2 print(kuaiid1.location)#2 print(kuaiid2.location)#2
實例化後
class delivery: location="beixin" def init(self, id, from1, to, type): self.id=id self.from1 = from1 self.to=to self.type = type kuaiid1=delivery(1,1,1,1)#實例化 kuaiid2=delivery kuaiid1.location=2 print(kuaiid1.location)#2 print(kuaiid2.location)#beixin
若實例化後 無對象類變量繼續修改實例化類變量類變量不會改變
但是修改其他的類變量 實例化類變量類變量也會改變
kuaiid1=delivery(1,1,1,1) kuaiid2=delivery kuaiid1.location=2 print(kuaiid1.location)#2 print(kuaiid2.location)#beixin
修改未實例化的類變量
kuaiid1=delivery(1,1,1,1) kuaiid2=delivery kuaiid2.location=2 print(kuaiid1.location)#2 print(kuaiid2.location)#2
繼承 父類默認為object
class delivery(object): pass
suber() 尋找父類方法
suber(A，c)
從A類之後開始尋找
具體百度
_和 _ _ 在類中實現私有和不被繼承
_name 即外部人直接調用時候 用 . . 不出來
但是如果全拼的時候還是可以找到的
_ _funt()
雙下劃線方法 被調用時候 會被改名為類名加_ _funt()
達到不被調用效果 但是全拼還是可以調用的
注：python中沒有私有的概念：這是約定的東西 是希望可以遵守
區快概念 date=1 def txt(): date=2 print(date)#2 print(date)#1 txt() print(date)#1
裝飾器 @ 叫語法糖
def decorate(text): def innter(): print("內部1") text() print("內部2") return innter @decorate def fund(): print("東西")
fund()
下面更無敵 上面的不可傳參數
def decorate(text): def innter(args,**kwargs): print("內部1") text(args,**kwargs) print("內部2") return innter @decorate def fund(i): print(f"東西{i}")
fund(1)
推導式 列表推導式 定義一次存儲 存儲1到10的平方
原方法
list=[] for i in range(1,11): list.append(i**2) print(list)
推導式方法
list=[i**2 for i in range(1,11)] print(list)
結果相同都為
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
循環二次輸出 將兩個列表所有組合方式輸出
原方法
color=['red','blue','black'] size=['S','m','L'] for i in color: for j in size: print(i,j,end=" ")
結果
red S red m red L blue S blue m blue L black S black m black L
推導式
color=['red','blue','black'] size=['S','m','L']
list=[(i,j) for i in color for j in size] print(list)
結果
[('red', 'S'), ('red', 'm'), ('red', 'L'), ('blue', 'S'), ('blue', 'm'), ('blue', 'L'), ('black', 'S'), ('black', 'm'), ('black', 'L')]
判斷輸出 輸出10以內奇數
原方法
list=[] for i in range(1,11): if i%2!=0: list.append(i) print(list)
推導式
list=[i for i in range(1,11) if i%2!=0] print(list)
結果都為
[1, 3, 5, 7, 9]
10以內平方大於10的數
list1=[i for i in range(1,11) if i*i>10] print(list1)#[4, 5, 6, 7, 8, 9, 10]
特殊判斷 獲取10以內數 且偶數變為0
list=[i if i%2 else 0 for i in range(1,11) ] print(list)
結果
[1, 0, 3, 0, 5, 0, 7, 0, 9, 0]
字典推導式 基本一元素推導式 獲取10以內 key對應的 valus為key’平平方
data={i:i*i for i in range(1,11)} print(data)
結果
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}
正則表達式 定義 導入包 re
import re str="abc" str2="abc" bool=re.fullmatch(str,str2)#是否相同 str3="abcssabcabcabcabcabcabcabc" bool2=re.findall(str,str3)##返回所有的str #['abc', 'abc', 'abc', 'abc', 'abc', 'abc', 'abc', 'abc'] str4=".a..."#匹配字符 str5="sasaa" print(re.match(str4,str5))
