一、運算
1.1、算數運算
1.2、比較運算：
1.3、賦值運算：
1.4、邏輯運算：
1.5、成員運算：
針對邏輯運算的進一步研究：
1、在沒有()的情況下not 優先級高於 and，and優先級高於or，即優先級關系為( )>not>and>or，同一優先級從左往右計算。
2、 x or y , x為真，值就是x，x為假，值是y；
x and y, x為真，值是y,x為假，值是x。
3、Python運算符優先級，以下表格列出了從最高到最低優先級的所有運算符：
| 運算符 | 描述 |
|---|---|
| ** | 指數 (最高優先級) |
| ~ + - | 按位翻轉, 一元加號和減號 (最后兩個的方法名為 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法減法 |
| >> << | 右移，左移運算符 |
| & | 位 'AND' |
| ^ | | 位運算符 |
| <= < > >= | 比較運算符 |
| <> == != | 等於運算符 |
| = %= /= //= -= += *= **= | 賦值運算符 |
| is is not | 身份運算符 |
| in not in | 成員運算符 |
| not and or | 邏輯運算符 |
二、基本數據類型
2.1、數字，int（整型）
在32位機器上，整數的位數為32位，取值范圍為-2**31～2**31-1，即-2147483648～2147483647
在64位系統上，整數的位數為64位，取值范圍為-2**63～2**63-1，即-9223372036854775808～9223372036854775807
在64位系統上，整數的位數為64位，取值范圍為-2**63～2**63-1，即-9223372036854775808～9223372036854775807
2.2、布爾值（bool）
True、False
1、0
真、假
2.3、字符串（str）
"hello world"
在Python中,加了引號的字符都被認為是字符串
2.3.1、索引:
a = 'ABCDEFGHIJK' print(a[1]) print(a[3]) print(a[5]) print(a[7])
執行結果：
2.3.2、切片，切片就是通過索引（索引：索引：步長）截取字符串的一段，形成新的字符串
a = 'ABCDEFGHIJK' print(a[1:3]) print(a[0:5]) print(a[0:]) #默認從開始到最后 print(a[0:-1]) # -1 是列表中最后一個元素的索引，但是取不到 print(a[0:5:2]) #加步長 print(a[5:0:-2]) #反向加步長
執行結果：
2.3.3、字符串常用方法：
最常用的為：join（字符串拼接）\spilt（切割）\find（查找）\strip（去空格）\upper、lower（大小寫轉換）\encode、decode（編碼、解碼）
a="abcABC"
#公共方法len(a),type(a)
a.capitalize() #首字母大寫
a.upper() #轉換大寫
a.lower() #轉換小寫
a.swapcase() #大小寫轉換
a.casefold() #轉換小寫
a.title() #轉換成標題
a.center(20,"*"）#設置寬度，並居中，20為總長度，*為空白處填充
a.ljust(20,"*") #左邊
a.rjust(20,"*") #右邊
a.zfill(20) #默認使用0填充，長度20
a.expandtabs() #補tab鍵
a.count("xx"，star，end) #計數出現次數，star開始位置，end結束位置
a.strip() #去全部空格、換行
a.lstrip("xx") #去除左邊 xx
a.lstrip() #去左邊空格
a.rstrip() #去右邊空格
a.partition("s") #字符串按照第一個s進行分割，分三份 (包含分割元素s)
a.split("s") #a.split("s"，2) 按照s進行分割 ，2為分割次數 (不包含分割元素s）
a.splitlens() #按換行符分割
a.find("ex",start=None, end=None) #找到第一個對應字符串的索引,默認是找整體，也可單獨指定判斷位置 （找不到返回-1）
(a.index()與find相同，但找不到報錯 )
a.endswith("x") #以判斷x結尾
a.startswith("x",start=None, end=None)#判斷以x開頭，默認是找整體，也可單獨指定判斷位置
a.isalnum() #判斷字符串中包含數字或字符
a.isalpha()#判斷是否是字符
a.isdeciml() #判斷是否是數字 （10進制數字）
a.isdigit()#判斷是否是數字，支持特殊形式
a.isdentifier() #判斷字母、數字、下划線
a.islower()#判斷是否小寫
a.isupper()#判斷是否是大寫
a.isnumeric()#判斷是否是數字 支持特殊字符（中文）
a.isprintable() #判斷是否包含不可顯示的字符如：\t \n
a.isspace() #判斷是否全部 是空格
a.istitle() #判斷是否是標題
a.replace("xx","oo") #xx替換oo
a.join(xxx) #字符串拼接，a作為拼接符，重新拼接xxx (" ".join(xx） "xx".join(dd))
a.format(name="xxxx") #替換name
a.format_map
a.encode() #編碼 str轉換bytes
a.decode() #解碼 獲得字符串類型對象
2.4、列表 （list）
列表是python中的基礎數據類型之一，列表是有序的，有索引值，可切片，方便取值。其基本操作有：索引、切片、追加、刪除、長度、切片、循環、包含
2.4.1、創建列表：
a=["name","age","job","addr"]
2.4.2、增加
li = ["a","b","c"]
li.append("d") #增加到末尾
print(li)
li.insert(0,"aa") #按索引位置增加
print(li)
li.extend(['q,w,e']) #迭代增加
print(li)
li.extend('w')
li.extend('p,l,m')
print(li)
執行結果：
2.4.3、刪除
li = ["a","b","c"]
l1 = li.pop(1) #按照位置去刪除，有返回值，默認刪除最后一個值
print(l1)
print(li)
del li[1:3] #按照位置去刪除，也可切片刪除沒有返回值。
print(li)
li.remove('a') #按照元素去刪除
print(li)
執行結果：
2.4.4、改
li = ["a","b","c","d"] li[1] = 'dfasdfas' print(li) li[1:3] = ['b1','c1'] print(li)
執行結果：
2.4.5、查
切片去查，或者循環去查，與str的切片、索引相同
2.4.6 其他補充：
li = [] li.reverse() #將當前列表反轉 li.sort() #排序 默認從小到大 li.sort(reverse=True) #從大到小 li.copy() #淺拷貝 li.count(xxx) #計算元素xxx出現的次數 li.index(xx) #根據元素值獲取其索引位置 li.clear() #清空列表
2.5、字典 （dict） 無序
字典是python中唯一的映射類型，采用鍵值對（key-value）的形式存儲數據。python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字、字符串、元組。
創建字典：
dict = {"k1":"v1","k2":"v2"}
2.5.1、增加
dic = {"k1":"v1","k2":"v2"}
dic['li'] = ["a","b","c"]
dic.setdefault('k','v') #在字典中添加鍵值對，如果只有鍵那對應的值是none,但是如果原字典中存在設置的鍵值對，則他不會更改或者覆蓋。
print(dic)
執行結果：
2.5.2 、刪除
dic = {"name":"crazyjump","age":18,"job":"民工"}
dic_pop = dic.pop("a",'無key默認返回值') # pop根據key刪除鍵值對，並返回對應的值，如果沒有key則返回默認返回值
print(dic_pop)
print(dic)
del dic["name"] # 沒有返回值。
print(dic)
dic_pop1 = dic.popitem() # 隨機刪除字典中的某個鍵值對，將刪除的鍵值對以元祖的形式返回
print(dic_pop1)
print(dic)
dic_clear = dic.clear() # 清空字典
print(dic,dic_clear) # {} None
執行結果：
2.5.3、改
dic = {"name":"crazyjump","age":18,"job":"民工"}
dic1 = {"age":20,"k":"v"}
dic.update(dic1) # 將dic1所有的鍵值對覆蓋添加（相同的覆蓋，沒有的添加）到dic中
print(dic)
執行結果：
2.5.4、查
dic = {"name":"crazyjump","age":18,"job":"民工"}
value = dic["name"]
print(value)
print(dic.get("n")) #key值不存在返回None
print(dic.get("s",12 )) #值不存在，返回定義的12
dic.setdefault("x","z") #不存在就新增，存在獲取當前值
print(dic.setdefault("name","z"))
print(dic)
執行結果：
2.5.5、字典的循環
dic = {"name": "crazyjump", "age": 18, "job": "民工"}
for k, v in dic.items():
print(k, v)
for k in dic.items():
print(k)
for k in dic.keys():
print(k)
for v in dic.values():
print(v)
for k in dic:
print(k)
執行結果：
2.5.6、補充（可迭代對象）
dic = {"name":"crazyjump","age":18,"job":"民工"}
l = dic.items()
print(l)
k = dic.keys()
print(k)
v = dic.values()
print(v)
執行結果：
2.6、元組 （tuple）
元組不可被修改，不能被增加或者刪除。但可以被查詢，字符串的切片操作同樣適用於元組
新建元組：
tu=(11,22,33,"aaa")
2.7、集合 （set）
集合是無序的，不重復的數據集合，它里面的元素是可哈希的(不可變類型)，但是集合本身是不可哈希（所以集合做不了字典的鍵）的。以下是集合最重要的兩點：
去重，把一個列表變成集合，就自動去重了。
關系測試，測試兩組數據之前的交集、差集、並集等關系。
2.7.1、創建集合：
set1 = set({1,2,'xxx'})
set2 = {1,2,'xxx'}
2.7.2、增加
set1={"a","b",12,"c"}
set1.add("d") #增加
set1.update('A') #迭代增加
print(set1)
set1.update('哈哈')
print(set1)
set1.update([1,2,3])
print(set1)
執行結果：
2.7.3、刪
set1={"a","b",12,"c"}
set1.pop() #刪除任意一個
set1.remove(12) #刪除指定xx，指定的元素不存在會報錯
set1.discard("xx") #刪除指定xx ，指定的元素不存在不會報錯
print(set1)
set1.clear() #清空集合
print(set1)
執行結果：
補充：集合查詢使用循環即可
2.7.4、集合的其他操作
2.7.4.1、交集 （& 或者 intersection）
set1 = {1,7,8,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)
print(set1.intersection(set2))
執行結果：
2.7.4.2、並集（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)
print(set2.union(set1))
執行結果：
2.7.4.3、差集。（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)
print(set1.difference(set2)) #set獨有的
執行結果：
2.7.4.4、反交集。 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)
print(set1.symmetric_difference(set2))
執行結果：
2.7.4.5、子集與超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 這兩個相同，都是說明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 這兩個相同，都是說明set2是set1超集。
2.7.4.6、frozenset不可變集合，讓集合變成不可變類型。
s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
三、數據類型總結
3.1、數字：不可變，直接訪問
3.2、字符串：不可變，順序訪問
3.3、列表：可變、有序、順序訪問
3.4、字典：可變、無序、key值訪問
3.5、元組：不可變、有序、順序訪問
3.6、布爾值：不可變
3.7、集合：無序、不重復
補充
一、格式化輸出：
1.1、%s
name = input('你的姓名：')
age = input('你的年齡：')
job = input('你的工作：')
info = "歡迎 %s，你的年齡是：%s ，你的工作是：%s "%(name,age,job)
print(info)
執行結果：
%s就是代表字符串占位符，除此之外，還有%d是數字占位符，%f是浮點數， 如果把上面的age后面的換成%d，就代表你必須只能輸入數字，否則就會報錯 (另%3==3%%)
1.2、srt.format()
a = "{},{}".format("hello","world")
# 默認順序
b = "{1},{0},{1}".format("hello","world")
#指定順序
c = "{name},{age}".format(name="crazyjump",age=12)
print("a:",a)
print("b:",b)
print("c:",c)
執行結果：
二、for 循環（用戶按照順序循環可迭代對象的內容）：
msg = "crazyjump"
for item in msg:
print(item)
data = [1,2,3,4]
for item in msg:
print(iterm)
三、enumrate為可迭代的對象添加序號
li = ['a','b','c','d','e']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1): #索引默認從0開始，可改成1開始
print(index,name)
執行結果：
四、range 指定范圍，生成指定數字。
for i in range(1,10):
print(i)
for i in range(1,10,2): # 步長
print(i)
for i in range(10,1,-2): # 反向步長
print(i)
五、深淺拷貝
5.1、淺拷貝 （id() 對象的內存地址）
li = ["a", "b", ['crazy', 'jump']] l1 = li.copy() print(li, id(li)) print(l1, id(l1)) li[1] = "c" print(l1, id(l1)) print(li, id(li)) li[2][0] = 'DB' print(l1, id(l1[2])) print(li, id(li[2]))
執行結果:
對於淺copy來說，第一層創建的是新的內存地址，而從第二層開始，指向的都是同一個內存地址，所以，對於第二層以及更深的層數來說，保持一致性。
5.2、深拷貝
import copy l1 = ["a",['crazy','jump']] l2 = copy.deepcopy(l1) print(l1,id(l1)) print(l2,id(l2)) l1[0] = 222 print(l1,id(l1)) print(l2,id(l2)) l1[1][0]="db" print(l1,id(l1[1])) print(l2,id(l2[1]))
執行結果：
對於深copy來說，兩個是完全獨立的，改變任意一個的任何元素（無論多少層），另一個絕對不改變