一、基礎資料型別
1.數字型別（int float bool complex）
(1)int 整數（正整數 0 負整數）
type 獲取值的型別
res = =type(invar) print(res)
id 獲取值的地址
res = id(intvar) print(res)
二進制整形
intvar = 0b110 print(intvar) print(type(intvar)) print(id(intvar))
八進制整形
intvar = 0o127 print(intvar) print(type(intvar)) print(id(intvar))
十六進制
intvar = 0xff promt(intvar) print(type(intvar)) print(id(intvar))
小結：
二進制1+1=10
八進制7+1=10
十六進制f+1=10
(2) float 浮點型（小數）
浮點型簡單來說就是表示帶有小數的資料,而恰恰小數點可以在相應的二進制的不同位置浮動,可能是這樣就被定義成浮點型了，
# 表達方式1
floatvar = 3.6 print(floatvar,type(floatvar))
# 表達方式2 科學計數法
floatvar = 5.7e5 # 小數點右移5位
floatvar = 5.7e-5 # 小數點左移5位
print(floatvar,type(floatvar))
（3）bool 布爾型（True 真的 ，False 假的）
boolvar = Ture
print(boolvar,type(boolvar))
(4) complex 復數型別
''' 3 + 4j 實數+虛數 實數：3 虛數4j j ： 如果有一個數他都平方等于-1，那么這個數就是j，科學家認為有，表達一個高精度的型別 ''' 表達方式1 complexvar1 = 3 + 4j complexvar2 = -3j #虛數部分可以是負數 是復數型別 print(complexvar1,type(complexvar1)) print(complexvar2,type(complexvar2))
表達方式2
'''
complex(實數，敘述) ==> 復數
'''
res = complex(3,4)
print(res,type(res))
2.字串（str）型別
'''
有引號的就是字串，單引號，雙引號，三引號
# 轉義字符\ +字符
（1）可以將無意義的字符變得有意義
（2）可以有意義的字符變得無意義
\n： 換行
\r\n：換行
\t ： 縮進（水平制表符） 默認四個空格距離
\r ： 將\r 后面的字串拉到了當選行的行首
'''
（1）單引號的字串
strvar = '生活不止眼前的茍且' print(savar,type(strvar))
（2）雙引號的字串
strvar = ''還有詩和遠方的田野'' print(savar,type(strvar)) strvar = ''還有詩和\n遠方的田野'' print(strvar)
#可以將無意義的字符變得有意義
strvar = ''還有詩和\r\n遠方的田野''
print(strvar)
strvar = ''還有詩和\t遠方的田野''
print(strvar)
strvar = ''還有詩和\r遠方的田野''
print(strvar)
strvar = ''還有詩和\n遠方的\r田野''
print(strvar)
#可以將有意義的字符變得無意義
strvar = ''還有詩\"遠\"方的田野''
print(strvar)
（3）三引號的字串(可以支持跨行效果)strvar = '''
strvar = '''
生活就像醉酒 表面上說不要 身體卻很誠實 '''
print(strvar)
#下面這么寫也是可以的
stavar = '''
生活就像"醉"酒
表面上說'不'要
身體卻很誠實
'''
print(strvar)
python中單引號雙引號沒有區別 但是在其他語言中有區別
比如說php
$a = "123" "{$a} => "123" '{$a}' => '($a)' 單引號當做普通字串
（4）元字串 r"字串" 原型化輸出字串
strvar = 'D:\python32_python\tar02' #這是個路徑很明顯這個 字串前面沒加r 很亂輸出不對
print(stavar)
r"字串" 原型化輸出字串
strvar = r'D:\python32_python\tar02'
print(strvar)
#這回就對了
（5）字串的格式化
比如說小張買了三個藥水 李四買了 四個藥水 張三買了五個藥水 你會發現 這些話整體來說除了數量在改變 字串并沒有改變
''' %d 整型占位符 %f 浮點型占位符 %s 字串占位符 ''' strvar = '張三昨天買了%d個風油精，洗澡' %（2） print(strvar)
接下倆看這個
%2d 占兩位（不夠兩位拿空格來部位）原字串在右面
strvar = '張三昨天買了%2d箱風油精，洗澡' %（2）
print(strvar)
# %-2d占兩位（不夠兩位拿空格來部位）原字串在左面
strvar = '張三昨天買了%-2d'箱風油精，洗澡' %（2）
print(strvar)
# %f 浮點型占位符 （存在四舍五入的情況，默認保留6位小數）
strvar = '閻王爺一個月開%f工資'%(9.9)
print（strvar）
# 我么會發現 列印出來的結果是這樣的 閻王爺一個月9.900000工資 小數點后保留了6位小數
# 下面有一種方法可以保留小數點后兩位小數
# %.2f 保留小數點后兩位小數
strvar = '閻王爺一個月開%.2f工資'%(9.9178)
print（strvar）
%.xf x = 任意數字 是幾小數點后面就保留幾位小數
# %s 字串占位符
strvar = "%s最喜歡在電影院尿尿" %（"李白"）
print（strvar）
#綜合案例
strvar = "%s在水里%s被發現了，罰了%.2f元，并且做了%d個俯臥撐" （"張三"，"拉屎"，500.129,50000）
print(strvar)
# 如果忘記用什么占位符，可以無腦用%s，
strvar = "%s在水里%s被發現了，罰了%s元，并且做了%s個俯臥撐" （"張三"，"拉屎"，500.129,50000）
print(strvar)
3.串列型別 （list）
定義一個空串列
listvar = [] print(listvar,type(liatvar))
定義普通串列
listvar = [98,6.9,Tyre,12-90,"張三"]
獲取串列中的元素
在python分為 正向索引和逆向索引
正向索引 （從0開始） 0 1 2 3 4 ......
0 1 2 3 4
listvar = [98,6.9,Tyre,12-90,"張三"]
-5 -4 -3 -2 -1
逆向索引 （只有python可以）（從-1開始） -1 -2 -3 -4 -5
len() 獲取容器型別資料中元素的個數
listvar = [98,6.9,True,12-90j,"張三"] print(len(listvar))
# python逆向索引的特點，瞬間得到串列最后一個索引
listvar = [98,6.9,True,12-90j,"張三"]
print(listvar[-1])
# 修改串列中的元素
listvar = [98,6.9,True,12-90j,"張三"] l1= listvar[3] = "大象" print(l1)
4.元組型別（tuple）
特征：只能獲取，不可以修改，有序
定義一個元組
tuplevar = ('張三','李四','熊大') print(tuplevar,type(tuplevar))
獲取元組中的元素
正向索引
#下面要獲取熊大 tuplevar = ('張三','李四','熊大') print(tuplevar[2])
逆向索引
逆向獲取熊大 tuplevar = ('張三','李四','熊大') print(tuplevar[-1])
修改元組中的元素 ：元組中的值不能修改
注意點
我們發現下面列印結果并不是元組型別
tuplevar = (1)
print(tuplevar)
print(type(tuplevar))
#列印結果
1
<class 'int'>
接下來我們看下一個
tuplevar = (1,) print(tuplevar) print(type(tuplevar)) #列印結果 (1,) <class 'tuple'>
我們發現添加個逗號 列印結果是元組型別
總結： 逗號才是區分是否是元組的識別符號
定義空元組
tuplevar = () print(type(tuplevar))
這個列印結果也是元組 但是沒加逗號 這是為什么呢 ？
因為里面沒有值 是一個空元組
字串型別 （補充）
'''
特征：可獲取，不可修改，有序
'''
正向索引
strvar = "大妹子，我 一看 你，我就心跳加速，喘不上氣兒" print(stavar[3])
#列印結果：，
我們發現 空格和符號都占有一個索引位置
5.集合型別 set（交差并補）
setvar = {"Amy","Sam","謠","帥"}
print(setvat,type(setvar))
我們列印發現每次的結果都不一樣，所以說集合是無序的
獲取集合中的元素
setvar = {"Amy","Sam","謠","帥"}
setvar[1]
獲取我們發現報錯 那是為什么呢？
剛剛說過集合是無序的所以說 沒有辦法按照索引來獲取集合中的元素
接下來再看幾行代碼
setvar = {"Amy","Sam","謠","帥","Sam"}
print(setvar)
我們列印完發現 原本集合中有兩個Sam 卻只輸出了一個Sam 這說明集合具有自動去重功能
我們再看看下面的代碼 看看可不可以定義空集合
setvar = {} print(setvar,type(setvar))
列印結果報錯 顯然這樣是不可以定義空集合的 ，接下來讓我們看看如何定義一個空集合？
setvar = set() print(setvar,type(setvar))
列印回傳集合型別 定義空集合只需要set+（）只有這一種方法可以創建空集合
總結：
6.字典型別 （dict）
'''
鍵值對存盤的資料
dictvar = {鍵1：值1,鍵2：值2,......}
3.6版本之前，完全無序
3.6版本之后，存盤的時候，保留了字典定義的字面順序，在獲取記憶體中的資料時重新按照字面順序做了排序，所以看起來有序，實際上存盤時還是無序，
'''
接下來我們創建一個字典
dictvar = {"top":"the shy","middle":"肉雞","bottom":"jacklove","support":"吃飽飽_嘴里種水稻"}
print(dictvar,type(dictvar))
獲取字典中的值
dictvar = {"top":"the shy","middle":"肉雞","bottom":"jacklove","support":"吃飽飽_嘴里種水稻"}
res = dictvar["middle"]
print(res)
修改字典中的值
dictvar["top"] = "the boy" print(dictvar)
定義空字典
dictvar = {} print(dictvar,type(dictvar))
重要：set和dict 的注意點
'''
字典的鍵和 集合的值 有資料型別上面的要求：
（允許的型別范圍）不可變的資料型別：Number str tuple
（不允許的型別）可變的資料型別 ：list set dict
字典的鍵有要求值沒有要求
字典的值可以任意換掉，但是鍵不可以，鍵就相當于一個人的身份證號
哈希演算法的提出目的是讓資料盡量均勻的在記憶體當中分配，以減少哈希碰撞，提升儲存分配的效率;哈希演算法一定是無序的散列，所以集合 和 字典都是無序的
'''
字典允許的型別范圍
dictvar = {1:"abc",4.89:111,3+90j:666,False:333,"王文":"你好帥啊，我好喜歡哦,沒毛病",(1,2,3,4,5,6):9999}
print(dictvar)
集合允許的內容
setvar = {1,"a",4.56,9+3j,False,(1,2,3)}
print(setvar)
二.哈希演算法
定義:
把不可變的任意長度值計算成固定長度的唯一值,這個值可正可負,可大可小,但長度固定
該演算法叫哈希演算法(散列演算法)，這個固定長度值叫哈希值(散列值)
特點:
1.計算出來的值長度固定且該值唯一
2.該字串是密文，且加密程序不可逆
用哈希計算得到一個字串的用意？
例如：比對兩個檔案的內容是否一致？
例如：比對輸入的密碼和資料庫存盤的密碼是否一致
字典的鍵和集合中的值都是唯一值,不可重復:
為了保證資料的唯一性，
用哈希演算法加密字典的鍵得到一個字串，
用哈希演算法加密集合的值得到一個字串，
如果重復，他們都是后面的替換前面的，自動去重
版本:
3.6版本之前都是 字典和集合都是無序的
3.6版本之后,把字典的字面順序記錄下來，當從記憶體拿資料的時候，
根據字面順序重新排序，所以看起來像有序,但本質上無序
可哈希的資料 (不可變的資料)：Number(int float bool complex) str tuple
不可哈希的資料 (可變的資料)： list set dict
三.快取機制
在同一檔案中，變數的快取機制（僅針對3.6版本）
-->Number 部分
1.對于整型而言，-5~正無窮范圍內的相同值 id一致
2.對于浮點數而言，非負數范圍內的相同值 id一致
3.布林值而言,值相同情況下，id一致
4.復數在 實數+虛數 這樣的結構中永不相同(只有正虛數的情況例外)
-->容器類型部分
5.字串 和 空元組 相同的情況下，地址相同
6.串列，元組，字典，集合無論什么情況 id標識都不同 [空元組例外]
四.強制型別的轉換
Number 型別的強制轉換（int float complex bool）
（1）int 強制把資料變成整型
可以轉換的資料型別： int float bool 純數字字串
var1 = 13 var2 = 5.67 var3 = True var4 = "123456" var5 = "123abc" var6 = 3+5j res = int(var2) res = int(var3) # True => 1 res = int(False)# False => 0 res = int(var4) # res = int(var5) error # res = int(var6) error print(res , type(res))
（2）float 強制把資料變成浮點型
可以轉換的資料型別： int float bool 純數字字串
res = float(var1) res = float(var3) # True => 1.0 res = float(False)# False => 0.0 res = float(var4) # 123456.0 print(res , type(res))
（3）complex 強制把資料變成復數
可以轉換的資料型別：int float bool 純數字字串 complex
res = complex(var1) # 添加0j 表達復數 res = complex(var2) res = complex(var3) # True => 1+0j res = complex(False) # False => 0j res = complex(var4) # 123456+0j print(res , type(res))
（4）bool 強制把資料型別變成布爾型
可以轉換的型別： 布爾可以強轉一切資料型別
布爾型為假的十種情況：0 , 0.0 , False , 0j '' [] () set() {} None
res = bool(None) print(res , type(res))
初始化變數時,不清楚用什么值,無腦寫上None
a =None
b =None
默認轉換成當前資料型別的一個值 int() float() complex() bool()
res = bool() print(res , type(res))
額外的擴展
strvar = "123" strvar = "3.134" strvar = "5+3j" # res = int(strvar) # print(res,type(res)) # res = float(strvar) # print(res,type(res)) # res = complex(strvar) # print( res,type(res) )
Number 自動型別轉換（int float complex bool）
注意:低精度默認向高精度進行轉換
bool--> int --> float --> complex
# bool + int res = True + 100 print(res ,type(res)) # 1 + 100 => 101 # bool + float res = True + 344.565 # 1.0 + 344.565 => 345.565 print(res ,type(res)) # bool + complex res = True + 7 - 90j # 1 + 0j + 7 - 90j => 8 - 90j print(res ,type(res)) # int + float res = 5 + 7.88 # 5.0 + 7.88 => 12.88 print(res ,type(res)) # int + complex res = 5 + 6 + 8j # 5 + 0j 6 + 8j => 11 + 8j print(res ,type(res)) # float + complex res = 5.66 + 9.1 -90j # 5.66 + 0j + 9.1 -90j => 14.76-90j print(res ,type(res))
'''
小數的精度損耗 (小數后面一般有時截取15~18位,但是不完全,存在精度損耗)
"""不要用小數作比較,咬不準"""
print(0.1 + 0.2 == 0.3)
print(5.1 + 5.9 == 11.0)
0.0999999999999999
'''
容器型別的強制轉換(str list tuple set dict)
var1 = "我愛你,文哥哥" var2 = [1,2,3] var3 = (4,4,5) var4 = {"陳璐","上朝氣","劉子濤","合理"} var5 = {"cl":"文質彬彬,斯文敗類","szq":"學霸","lzt":"籃球少年","hl":"武大高手"} var6 = 90 var7 = True
str 強制轉換成字串
可以轉換的型別: 所有的資料型別都可以轉換, 在當前的資料型別兩邊套上引號
res = str(var2) res = str(var3) res = str(var4) res = str(var5) res = str(var6) res = str(var7) print(res ,type(res)) # repr 不轉移字符原型化輸出字串 print(repr(res))
list 強制轉換成串列
如果是字串：把字串中的每個元素單獨拿出來，作為串列中的新元素
如果是字典：只保留字典中的鍵
如果是其他容器資料：就是單純的在元資料型別的兩年換上[ ] 括號
res = list(var1) res = list(var3) res = list(var4) # 字典: 只獲取字典得鍵,忽略掉值 res = list(var5) # res = list(var6) error 只能是容器間的互轉 print(res ,type(res))
tuple 強制轉換成元組
如果是字串：把字串中的每個元素單獨拿出來，作為元組中的新元素
如果是字典： 只保留字典中的鍵
如果是其他容器資料：就是單純的在原資料型別的兩邊換上( ) 括號
res = tuple(var1) res = tuple(var2) res = tuple(var4) res = tuple(var5) print(res ,type(res))
set 強制轉換成集合
如果是字串：把字串中的每個元素單獨拿出來，作為集合中的新元素
如果是字典 ：只保留字典中的鍵
如果是其他容器資料：就是單純的在元資料型別的兩邊換上{}括號
res = set(var1) res = set(var2) res = set(var5) print(res ,type(res))
dict 字典型別的強制轉換
要求：必須是等長的二級容器,并且里面的元素個數是2個;外層是串列,元組,集合 , 里層是串列或者元組的等長二級容器 => 字典;
1.外層是串列,里層是串列或者元組
lst = [ ["a",1] , ("b",2) ] dic = dict(lst) print(dic , type(dic)) # {'a': 1, 'b': 2} <class 'dict'>
2.外層是元組,里層是串列或者元組
tup = ( ["a",1] , ("b",2) ) dic = dict(lst) print(dic , type(dic))
3.外層是集合,里層是元組
setvar = { ("a",1) , ("b",2) }
dic = dict(setvar)
print(dic , type(dic))
例外1:外層是串列/元組,里層放集合
可以實作,不推薦使用,因為達不到想要的目的,集合無序,不推薦使用
lst = [ ["a",1] , {"b","250"} ] dic = dict(lst) print(dic)
例外2:外層是串列/元組,里層放字串
字串長度只能是2位,有極大的局限性,不推薦使用
lst = ["a1","b2"] # lst = ["a11","b22"] error # dic = dict(lst) # print(dic)
過濾掉串列中所有重復元素的方法
講串列轉換成集合的資料型別，在轉換回字典，因為集合有去重功能
lst = [1,222,3,3,3,44,88,999,77,88,1] res = set(lst) print(res) # 在把當前的集合轉換成原來的串列 res2 = list(res) print(res2)
默認不加任何值,轉換成該資料型別的空值 str() list() tuple() set() dict()
res = dict() print(res ) print(type(res))
五.二級容器 ( list tuple set dict )
二級串列
lst = [1,2,3,[4,5,6]]
二級元組
tup = (1,2,(10,11))
二級集合
setvar = {1,2,("a","b")}
二級字典
dic = {"a":1,"b":{"c":10}}
print(dic["b"]["c"])
四級容器
如何獲取bingo？
container = [1,2,3,(4,5,6,{"a":1,"b":[11,"bingo"]})]
# (4,5,6,{"a":1,"b":[11,"bingo"]})
res1 = container[-1]
print(res1)
# {'a': 1, 'b': [11, 'bingo']}
res2 = res1[-1]
print(res2)
# [11, 'bingo']
res3 = res2["b"]
print(res3)
# bingo
res4 = res3[-1]
print(res4)
# 一步簡寫
res = container[-1][-1]["b"][-1]
print(res)
等長的二級容器
外面是容器,里面的元素也是容器,且元素個數相同
六.判斷型別 isinstance
使用方法一：isinstance(資料，型別)
該資料是這個型別，回傳True 反之，回傳False
型別：int float complex bool str list tuple set dict
使用方法二： isinstance (資料，(型別1，型別2，型別3...))
如果該資料在所對應的型別元組當做，回傳True，反之，回傳False
使用方法一：
n = 123 res = isinstance(n,int) prinr(res) n = [1,2,3] res = isinstance(n,list) res = isinstance(n,tuple) print(res)
使用方法二：
使用方法二 n = "1233" res = isinstance(n,(list,tuple,str,set)) print(res) n = {"a":1} res = isinstance(n,(list,tuple,str,set)) print(res)
七.算數 比較
（1）算數運算子：+ - * / // % **
+
var1 = 7 var2 = 90 res = var1 + var2 print(res)
-
var1 = 7 var2 = 90 res = var1 - var2 print(res)
*
var1 = 7 var2 = 10 res = var1 * var2 print(res)
/ （結果永遠都為小數）
var1 = 10 var2 = 5 res = var1 / var2 print(res , type(res))
// 地板除
被除數 ÷ 除數 = 商
注意點：如果被除數或者除數是小數，那么得到正常結果之后，數值后面帶上.0變成小數
var1 = 10.0 var2 = 3.0 # var2 = 3.0 res = var1 // var2 print(res)
% 取余
var1 = 7 var2 = 4 res = var1 % var2 res = -7 % 4 # -3 + 4 = 1 res = 7 % -4 # 3 + (-4) = -1 res = -7 % -4 # -3 (被除數和除數都是負的,正常結果加負號) res = 81 % 7 # 4 res = 81 % -7 # -3 res = -81 % 7 # 3 res = -81 % -7 # -4 print(res)
**冪運算
res = 2 ** 3
print(res)
（2）比較運算子：> , < , >= , >= , == , !=
比較運算子的結果要么是True，要么是False 只有兩個值
res = 10 > 5 res = 10 >= 10 # ==這個符號是在做比較,比較==兩邊的數值是否一樣 res = 5 == 9 res = 5 != 9 print(res)
（3）賦值運算子： = += -= *= /= //= %= **=
= 賦值運算子 將右側的值賦值給左側變數
a = 5 <= 3 print(a) var1 = 10 var2 = 5
+=
"""var1 = var1 + var2""" # var1 += var2 # print(var1)
-=
"""var1 = var1 - var2""" # var1 -= var2 # print(var1)
%=
"""var1 = var1 % var2""" var1 %= var2 print(var1)
（4）成員運算子：in 和 not in （針對于容器型資料）
①字串判斷時，必須是連續的片段
strvar = "今天天氣要下雨,趕緊回家收衣服" res = "今" in strvar res = "天氣" in strvar res = "趕回" in strvar print(res)
②針對于串列，元組，集合
container = ["趙沈陽","趙萬里","趙世超"] container = ("趙沈陽","趙萬里","趙世超") container = {"趙沈陽","趙萬里","趙世超"} # res = "趙沈陽" in container # res = "趙萬里" not in container res = "趙世超1223232" not in container print(res)
③針對于字典（判斷的是字典的鍵，不是值）
container = {"zsy":"趙沈陽","zwl":"趙萬里","zsc":"趙世超"}
res = "趙沈陽" in container # False
res = "zsy" in container
print(res)
（5）身份運算子 is 和 is not （檢測兩個資料在記憶體當中是否是同一個值）
①整型 - 5 ~ 正無窮
var1 = 100 var2 = 100 print(var1 is var2)
②浮點型 非負數
var1 = -9.1 var2 = -9.1 print(var1 is var2)
③ bool 相同即可
var1 = True var2 = True print(var1 is var2)
④complex 在實數+虛數不相同（只有虛數的情況下例外）
var1 = 6-8j var2 = 6-8j var1 = -10j var2 = -10j print(var1 is var2)
⑥容器：相同字串，空元組相同即可 剩下的所有容器都不相同
container1 = () container2 = () print(container1 is not container2) container1 = "你" container2 = "你" print(container1 is not container2) container1 = [1,23,3] container2 = [1,23,3] print(container1 is not container2)
（6）邏輯運算子：and or not
① and 邏輯與
一真則真，一假則假
res = True and True # True res = True and False # False res = False and True # False res = False and False # False print(res)
② or 邏輯或
一真則真，全假則假
res = True or True # True res = False or True # True res = True or False # True res = False or False # False print(res)
③ not 邏輯非
res = not True res = not False print(res)
④邏輯短路
無論后面的運算式是True 還是False 都已經無法改變最后的結果，那么直接短路，后面的代碼不執行；
(1) True or print("程式執行了~ 1111")
(2) False ande print("程式執行了~2222")
True or print("程式執行了 ~ 1111") True or True => True True or False => True False and print("程式執行了 ~ 2222") False and True => False False and False => False
計算規律：
先腦補計算當前運算式的布林值是True還是False，如果出現了True or 運算式 或者False and 運算式的情況，直接回傳牽著，后面代碼不執行，如果沒有出現短路效果，直接回傳后者
res = 5 and 6 # 6
'''
True and True => True
True and False => False
'''
接下來看一段代碼
res = 5 or 6 # 5 res = 0 and 999 res = 0 or "abc" print(res)
邏輯運算子的優先級：
優先級從高到低：() > not > and > or
小練習：
res = 5 or 6 and 7 # 5 or 7 => 5 res = (5 or 6) and 7 # 5 and 7 res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
not (False or False) => True res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1) res = True or False and True or True and True res = True or False or True res = True or True => True print(res)
（7）位運算子：& | ^ << >> ~
① & 按位與
var1 = 19 var2 = 15 res = var1 & var2 print(res)
#結果是這么來的： """ 000 ... 10011 000 ... 01111 000 ... 00011 => 3 """
② | 按位或
var1 = 19 var2 = 15 res = var1 |var2 print(res)
結果是這么來的：
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""
③ ^ 按位異或
量遏制不相同 => True 反之回傳False
var1 = 19 var2 = 15 res = var1 ^ var2 print(res)
結果是這么來的：
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""
④ << 左移（想當于乘法）
這個數乘以2的n次冪
res = 5 << 1 # 10 res = 5 << 2 # 20 res = 5 << 3 # 40 print(res)
結果是這么來的：
"""
000 ... 101 => 5
000 .. 1010 => 10
000 ..10100 => 20
000 .101000 => 40
"""
⑤ >> 右移 （相當于除法）
這個數地板除2的n次冪
res = 5 >> 1 # 2 res = 5 >> 2 # 1 res = 5 >> 3 # 0
print(res)
結果是這么來的:
"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""
⑥ ~ 按位非（針對于補碼進行操作，按位取反，包含每一位）
-（n+1）
練習1：
# res = ~22 res = ~19 print(res)
結果是這么來的："""
原碼:000 ... 10011
反碼:000 ... 10011
補碼:000 ... 10011
補碼: 000 ... 10011
按位非: 111 ... 01100
給你補碼->原碼
補碼:111 ... 01100
反碼:100 ... 10011
原碼:100 ... 10100 => -20
"""
練習2
res = ~-19
print(res)
結果是這么來的:
"""
原碼:100 ... 10011
反碼:111 ... 01100
補碼:111 ... 01101
補碼: 111 ... 01101
按位非: 000 ... 10010
給你補碼->原碼 (因為是整數 ,原反補相同)
000 ... 10010 => 19
"""
總結：
個別運算子：
運算子優縣級最高的：**
運算子優先級最低的：=
（） 可以提升優先級
一元運算子 > 二元運算子（優先級）
一元運算子：同一時間，操作一個值 ~ -
二元運算子：同一時間，操作一個值 + - * / ……
同一種類運算子：
算數運算子：乘除 > 加減
邏輯運算子：() > not > and > or
位運算子： (<< >>) > & > ^ > |
整體排序：
算數運算子 > 位運算子 > 比較運算子 > 身份運算子 > 成員運算子 > 邏輯運算子、
賦值運算子用來做收尾
小練習
res = 5+5 << 6 // 3 is 40 and False """ res = 10 << 2 is 40 and False res = 40 is 40 and False res = True and False res = False """ print(res) # 用括號提升下優先級 res = (5+5) << (6//3) is 40 and False
八.代碼塊（以冒號作為開始，用縮進來劃分相同的作用于，這個整體是代碼塊）
作用域：作用的范圍
if 10 == 11: print(1) print(2) print(3) print(4)
# 縮進：要么全都使用/t Tab 要么全都是使用4個空格 來表達相同的作用域，不能混在一起；
if 10 == 10: print(1) print(2)
其他語言的寫法（了解）
if(10 == 10){ print(1) print(2) print(3) }
九.流程控制
流程：代碼執行的程序
控制：對代碼執行程序中的把控
三大結構：
（1）順序結構：默認代碼從上到下，依次執行
（2）分支結構：單項分支 雙向分支 多項分支 巢狀分支
（3）回圈結構：while / for
單項分支
if 條件運算式：
code1
code2
當條件運算式成立，回傳True，執行對應的代碼塊
zhiye = "程式員" if zhiye == "程式員": print("拿高薪") print("錢多,話少,死的早") print("發量日漸稀少")
雙向分支（二選一）
if條件運算式：
code1 ...
else：
code2...
如果條件運算式成立，回傳True，執行if這個區間的代碼塊
如果條件運算式不成立，回傳False，執行else這個區間的代碼塊
if 分支的代碼快啊也叫做鎮區間
else 分支的代碼塊也叫做假區間
zhiye = "美團外賣騎手" zhiye = "律師" if zhiye == "美團外賣騎手": print("打他") print("罵他") print("喂他辣椒水") else: print("給你一朵紅花")
input 等待用戶輸入字串（注意：結果一定是字串）
name = input("你好~ 你媽貴姓：") print(name,type(name))
模擬網站登陸
如果admin = Sam 密碼：password = 111 顯示登陸成，否者顯示登陸失敗
admin = input("請輸入您的賬號：") password = input("請輸入您的密碼：") if admin == "Sam" and password == "111": promt("登陸成功") else： print("登陸失敗")
多項分支(多選一)
"""
if 條件運算式1:
code1
elif 條件運算式2:
code2
elif 條件運算式3:
code3
else:
code4
如果條件運算式1成立,執行對應的分支code1,反之判斷條件運算式2是否成立
如果條件運算式2成立,執行對應的分支code2,反之判斷條件運算式3是否成立
如果條件運算式3成立,執行對應的分支code3,如果不成立,直接走ekse分支,到此程式執行完畢
elif 可以是0個 或者 多個
else 可以是0個 或者 一個
"""
youqian = False youfang = False youche = False if youqian == True: print("說明這個人很有實力") elif youfang == True: print("能交給朋友么") elif youche == True: print("開了雅迪艾瑪調動車,我們碰一碰吧") else: print("你還是去做美團騎手吧") print("<=======================>")
巢狀分支
"""單項分支,雙向分支,多項分支的互相嵌套組合"""
youqian = True youfang = True youche = True youyanzhi = True youtili = False if youqian == True: if youfang == True: if youche == True: if youyanzhi == True: if youtili == True: print("我要嫁給你~") else: print("你去吃點大腰子再來~") else: print("你去一下泰國+韓國,整整容") else: print("你是個好人吶~")
小練習
#height
#女生找物件
# 男生在1米~1.5米之間 小強 你在哪里?
# 男生在1.5~1.7米之間 沒有安全感~
# 男生 1.7~ 1.8米之間 帥哥 留個電話
# 男生 1.8~2米之間 帥哥 你建議多一個女朋友嗎
# 通用寫法 height = float(input("請輸入您的身高:")) if 1 <= height and height < 1.5: print("小強 你在哪里?") elif 1.5 <= height and height < 1.7: print("沒有安全感~") elif 1.7 <= height and height < 1.8: print("帥哥 留個電話") elif 1.8 <= height and height < 2: print("你建議多一個女朋友嗎") else: print("抱歉,沒有合適的選項")
快捷鍵用法:
tab 向右縮進
shift + tab 向左縮進
回圈結構
特點:減少冗余代碼,提升執行效率
語法:
while 條件運算式:
code1
(1)初始化一個變數
(2)寫上回圈的條件
(3)自增自減的值
列印1~100
# (1) 初始化一個變數 i = 1 # (2) 寫上回圈的條件 while i <= 100: # (4) 寫上回圈的邏輯 print(i) # (3) 自增自減的值 i += 1 # i = i + 1
"""
代碼決議:
第一次回圈
i = 1 i<=100 判斷為真,執行回圈體 print(1)
i += 1 i => 2
第二次回圈
代碼回到17行,重新進行條件判定
i = 2 i<=100 判斷為真,執行回圈體 print(2)
i += 1 i => 3
第三次回圈
代碼回到17行,重新進行條件判定
i = 3 i<=100 判斷為真,執行回圈體 print(3)
i += 1 i => 4
....
以此類推
直到i = 101 i <= 100 判斷為假,不執行回圈體,到此回圈結束...
1 ~ 100
"""
1~100的累加和
# (1) 初始化一個變數 i = 1 total = 0 # (2) 寫上回圈的條件 while i <= 100 : # (4) 寫上自定義的邏輯 total += i # (3) 自增自減的值 i += 1 print(total) """ 代碼決議: 第一次回圈 i = 1 i <= 100 判定為真True 執行回圈體 total += i => total = total + i => 0 + 1 i += 1 => i = 2 第二次回圈 i = 2 i <= 100 判定為真True 執行回圈體 total += i => total = total + i => 0 + 1 + 2 i += 1 => i = 3 第三次回圈 i = 3 i <= 100 判定為真True 執行回圈體 total += i => total = total + i => 0 + 1 + 2 + 3 i += 1 => i = 4 ... 依次類推 當i = 101 101 <= 100 判定為假False 不執行回圈體,到此,回圈結束.. total += i => total + i => 0 + 1 + 2 + 3 + 4 + .... + 100 => 5050 """
死回圈
"""
while True:
print(1)
"""
用死回圈的方法實作1~100的累加和
i = 1 total = 0 sign = True while sign: total += i i+=1 # 判斷i是否加到了101 , 不參與回圈 if i == 101: # 終止回圈 sign = False print(total) #1 ~ 100 = 5050
單向回圈的練習
(1)列印 一行是個小星星* help(print)
# help 查看某個方法的檔案
help(print)
""" # print("*",end='') # print("*",end='') # print("*",end='') # print("*",end='') # print("*",end='') # print("*",end='') # print("*",end='') # print("*",end='') # print("*",end='') # print("*",end='') """
如果用上面的方法不僅代碼量多 而且太蠢了 接下來我們用while 回圈
i = 0 while i<10: # end='' 列印時,尾部默認不加換行 print("*",end='') i += 1 # 默認換行 # print()
(2)通過列印一個變數的形式,展現一行十個小星星
print("<======>") i = 0 strvar = "" while i < 10: # 寫上回圈的邏輯 strvar += "*" # strvar = strvar + "*" i +=1 print(strvar) 程序: """ strvar += "*" => strvar = "*" strvar += "*" => strvar = "*" + "*" = "**" strvar += "*" => strvar = "**" + "*" = "***" ... strvar += "*" => strvar = "********" + "*" = "*********" """
(3)一行十個換色的星星★☆★☆★☆★☆★☆
方法一:
i = 0 while i < 5: print("★☆",end="") i+=1
方法二:
i = 0 while i < 10: if i % 2 == 0 : print("★",end="") else: print("☆",end="") i+=1
方法三:
i = 0 strvar = "" while i < 10: if i % 2 == 0 : strvar += "★" else: strvar += "☆" i+=1 print(strvar)
***公式: 任意數 和 n 進行取余,余數的范圍: 0 ~ (n-1)***
0 % 2 = 0
1 % 2 = 1
2 % 2 = 0
3 % 2 = 1
被除數 % 2 => 0 或者 1
0 % 5 = 0
1 % 5 = 1
2 % 5 = 2
3 % 5 = 3
4 % 5 = 4
5 % 5 = 0
6 % 5 = 1
7 % 5 = 2
被除數 % 5 => 0 或者 1,2,3,4
(4)用一個回圈,列印十行十列小星星
"""
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
"""
方法一:
i = 0 while i < 100: # 邏輯寫在這里 print("*" , end="") # 列印換行 (在9 19 29 .. 99 ) if i % 10 == 9: print() i += 1
"""
0123456789
**********
10111213141516171819
**********
20212223242526272829
**********
...
90919293949596979899
**********
9 19 29 39 49 59 69 79 89 99
9 % 10 = 9
19 % 10 = 9
29 % 10 = 9
...
99 % 10 = 9
"""
方法二:
i = 1 while i <= 100: # 邏輯寫在這里 print("*" , end="") # 列印換行 (在9 19 29 .. 99 ) if i % 10 == 0: print() i += 1
"""
12345678910
**********
11121314151617181920
**********
21222324252627282930
**********
...
919293949596979899100
**********
10 20 30 ... 100
"""
(5)一個回圈實作一十行十列,格列換色的小星星
"""
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
"""
i = 0 while i < 100: # (1)列印星星 if i % 2 == 0 : print("★",end="") else: print("☆",end="") # (2)列印換行 (在9 19 29 .. 99 ) if i % 10 == 9: print() i += 1
(6)一個回圈實作十行十列,隔行換色的小星星
"""
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
"""
公式:任意數和n進行底板處,會出現n個相同的數
0 // 10 = 0 1 // 10 = 0 2 // 10 = 0 .. 9 // 10 = 0 0 ~ 9 // 10 => 0 (10個相同的0) 10 // 10 = 1 11 // 10 = 1 12 // 10 = 1 ... 19 // 10 = 1 10 ~ 19 // 10 => 1 (10個相同的1) .... 以此類推 20 ~ 29 // 10 => 2 (10個相同的2) 30 ~ 39 // 10 => 3 (10個相同的3) 40 ~ 49 // 10 => 4 (10個相同的4) ... 90 ~ 99 // 10 => 9 (10個相同的9) 0~ 100 會出現10個相同的0,1,2 , 3 ... 9 0 // 3 0 1 // 3 0 2 // 3 0 3 // 3 1 4 // 3 1 5 // 3 1 """
方法一:
i = 0 while i < 100: # (1)列印星星 if i // 10 % 2 == 0: print("★",end="") else: print("☆",end="") # (2)列印換行 (在9 19 29 .. 99 ) if i % 10 == 9: print() i += 1
方法二:
print("<=================>") i = 10 while i < 110: # 列印星星 num = int(str(i)[-2]) if num % 2 == 0 : print("★",end="") else: print("☆",end="") # 列印換行 if i % 10 == 9: print() i+=1 #決議: """ 10 ~ 100 101 102 103 110... 10 ~ 19 => 1 20 ~ 29 => 2 30 ~ 39 => 3 90 ~ 99 => 9 100 ~ 109 => 0 """
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/423373.html
標籤：其他