python數據類型強制轉換和運算符

　# Number 強制類型轉換

　　 (1) int 強制類型轉換整型

　　 將浮點型數據強制轉換成整型，它會默認將小數點後的數值捨去，不存在四捨五入
　　 將布爾值強制轉換成整型，它會默認將True和False的值轉變爲1和0
　　 複數不能強制轉化成整型，它會報錯
　　 字符串可以強制轉化爲整型，但首先字符串必須是全數字，不然不行，會報錯

　　 int只能對   int   float   bool   str(必須是全數字) 進行轉換

　　# (1) float 強制轉換爲浮點型

　　 將整型強制轉化爲浮點型，它會默認在整型以後面加上小數點.0
　　 將布爾值強制轉化爲浮點型，它會默認將Ture和False的值轉化爲1.0和0.0
　　 複數不能轉化爲浮點型，它會報錯
　　 字符串可以強制轉化爲浮點型，但首先字符串必須是全數字，不然不行，會報錯

　　# (3) complex 強制轉化爲複數

　　 將整型強制轉化爲複數，它會默認在整型後面加上 0j
　　 將浮點型強制轉換爲複數，同上
　　 將布爾值強制轉化爲複數，它會將True轉化爲 1+0j，False轉化爲 0j
　　 將字符串強制轉化爲複數，但首先字符串必須是全數字，不然不行，會報錯

　　# (4) bool 強制轉化爲布爾類型 結果只有兩種 要麼True 要麼False

　　# bool 能夠轉換全部的數據類型均爲True

　　# 惟獨有如下十種狀況 會爲False   0   0.0    0j   False   ''空   ()空元祖     []空列表    set()空集合    None

　　# None 系統關鍵字 無特殊意義 表明啥也沒有通常用於初始化變量的時候用

 

 

　# 容器類型強制轉換 (str list tuple set dict) 只能相互轉換，不能轉換Number數據類型

　　    (1) str 全部數據類型均可以強制轉化成字符串str
　　  　　　　規律：   在原有類型基礎上，在外套一層引號便可
　　  　　　　repr 　　打印出字符串類型的那個引號(原型化輸出)

 　　   (2) list 全部數據類型均可以強制轉化爲列表list
   　　　　　　規律：強制轉換：若是是字符串，把字符串當中的每個字符當成列表
 　　　　　　　　　  中的新元素，其它都是在原有數據類型上，在外面套一個[]便可

 　　　　　　將字符串強制轉化爲列表時，它會在外套一層  []  同時裏面的字符也會一一顯示出字符串的引號
 　　　　　　將字典強制轉化爲列表型時，它會在外套一層  []  同時只保留字典裏的鍵，而忽略字典裏的值

　　    (3) tuple 全部數據類型均可以強制轉化爲元組tuple
　　   　　　　規律：強制轉換：若是是字符串，把字符串當中的每個字符當成列表
　　 　　　　             中的新元素，其它都是在原有數據類型上，在外面套一個 () 便可

　　 　　　　  將字典強制轉化爲元組時，它會在外套一層  ()  同時只保留字典裏的鍵，而忽略字典裏的值

           (4) set 全部數據類型均可以強制轉化爲集合set
        　　　　  規律：強制轉換：若是是字符串，把字符串當中的每個字符當成列表
 　　　　　　　　     中的新元素，(列表中的字符串會無序排列，由於集合本是無序排列)
 　　　　　　　　     其它都是在原有數據類型上，在外面套一個  {}  便可

　　　　  # 將字典強制轉化爲集合時，它會在外套一層{}同時只保留字典裏的鍵，而忽略字典裏的值

 

　　　(5) dict 強制轉化爲字典類型

　　　# 多級容器數據: 該類型是容器數據，而且裏面的元素仍是容器類型數據

　　　# ## 二級容器

　　　# 二級列表
　　　　listvar = [1,2,3,4,5[6,7,8,9]]

　　　# 二級元組
　　　　tuplevar = (1,2,3,4,5(6,7,8,9))

　　　# 二級集合 (只能在裏面放元組做爲集合裏面的容器數據,只能放可哈希不可變的數據)
　　　　setvar = {1,2,3,(4,5,6)}

　　　# 二級字典
　　　　dictvar = {'a':{'c':3},'b':2}

　　　# 四級容器

　　　　content = [1,2,3,4,(4,6,{'a':{4,5,6,7,8},'b':2},7),5]

　　　# 等長的二級容器

　　　　'''
　　　　首先容器是兩個，表明二級容器
　　　　每個容器元素個數都是同樣的叫作等長
　　　　'''
　　　　listvar = [(1,2,3,4),(5,6,7,8)]
　　　　tupvar = ([1,2],[3,4],[5,6])

　　　# ## dict 強制轉換成字典: (裏面的元素只能是兩個)

　　　# (1) 外面是列表，裏面是 列表、元組、字符串(元素個數只能是兩個，不然會報錯)
　　　　listvar = [['a',1],('b',2)]

　　　# (2) 外面是元組，裏面是列表、元組、字符串
　　　　tupvar = (['c',3],('d',33))

　　　# (3) 外面是集合，裏面是元組、字符串

　　　　setvar ={('a',1),('b',2)}

 

　　　# 總結:
　　　　'''
　　　　容器類型數據強轉：
　　　　str()   tuple()   list()   set()   dict() 都能轉換成對應的數據類型
　　　　Number數據類型強轉：
　　　　int()   float()   bool()    complex() 都能轉換成對應的數據類型

　　　　能夠強轉函數值進行初始化
　　　　'''

 

 

 

　# 變量存儲的緩存機制 (爲了節省空間)

　　# (1)Number (int float bool complex)

　　# int (整型類取值在-5~正無窮範圍內，取兩個相同的值，
　　# 這兩個值得地址就相同，若超過這個取值範圍，地址就不一樣)

　　# float (浮點型取值只要是非負數，值得地址就相同)

　　# bool (在布爾值相同的狀況下，值得地址相同)

　　# complex (在實數加虛數的狀況下，永遠不同，只有虛數的狀況下，就會同樣)

 

　　# (2)容器類型數據 (str list tuple set dict)

　　# str (字符串值相同狀況下，值得地址是同樣的)
　　# list   tuple   set   dict (不管啥狀況，值得地址都不同)
　　# 例外： (空元祖的值得地址是同樣的)

 

　　# # python 運算符

　　# (1) 算數運算符： + - * / //地板除 %取餘 **冪運算

　　#    /  (除法,結果必定是小數)
　　#   //  地板除(整除) (若是相除的兩個含有小數，那麼就在結果上加上.0)

　　var1 = -7
　　var2 = 4
　　res = var1 % var2
　　print(res) => 1
　　# 把-7的負號拿走，而後7 - 4 = 3
　　# 算出結果，再把負號拿回來變成-3
　　# 這時在與4相加，-3 + 4 = 1
　　# 就可求得整除的結果

　　var1 = 7
　　varl = -4
　　res = var1 % var2
　　print(res) => -1

　　# 跟上述同理，先7 - 4 = 3
　　# 而後再用3 + (-4)
　　# 就可求得整除的結果

 

 

 

　# ## 比較運算符   >    <    >=    <=    ==等於    !=不等於

　　# 比較運算符就只有兩種結果，要麼是True 要麼是False

　　'''
　　是兩個等號，不是一個等號，1個等號是在作變量的賦值，兩個是比較是否相同
　　'''

 

 

　　# ### 身份運算符 is 和 is not (檢測兩個數據在內存中是不是同一個值)

　　var1 = 5
　　varl = 6
　　print(id(var1),id(var2))

　　# is 用來判斷兩個變量的地址是否一致
　　res = var1 is var2
　　print(res) => True

　　res = var1 is not var2
　　print(res) => False

　　# var1 == var2 與 var1 is var2 的區別
　　'''
　　一個是比較兩個值是否相同
　　一個是比較兩個值的地址是否相同
　　'''

 

　# ### 邏輯運算符 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 = True or False => True
　　res = False or True => True
　　res = False or False => False
　　print(res)

 

　　# not 非
　　'''真變假,假變真'''
　　res = not False => True
　　res = not True => False

　# (1)邏輯短路 (後面代碼不走了)
　　'''
　　# 兩種狀況
　　res = False and 布爾值 => False
　　res = True or 布爾值 => False
　　'''
　# print 默認返回一個 None 而None的布爾值是假

　　res = False and print(1) => False
　　print(res)
　　res = True and print(1) => 1 None
　　res = True or print(3) => True
　　res = False or print(4) => 4 None

 

　# 邏輯運算符優先級
　　'''()  >  not  >  and  >  or'''

　　res = 5 or 6 and 7
　　# 5 or 7 => 5
　　print(res)

　　res = (5 or 6) and 7
　　# 5 and 7 => 7

　　res = not (5 or 6) and 7

　　# (5 or 6) => 5
　　# not 5 => False
　　# False and 7 => False

　　res = 5>6 or 7<8 and 9>10 or 11<12
　　print(res) => True

　　'''
　　有一種狀況不用考慮and和or優先級問題,
　　就是or短路 好比 True or ...... => 結果必定爲 True
　　'''

 

　　# ## 數據類型的判斷 isinstance
　　'''
　　isinstance(要判斷的數據,判斷的類型) 要麼返回真，要麼返回假
　　ininstance(要判斷的數據,(元組，放上各類數據類型,知足一個條件即爲真))
　　'''

　　# 5 是 int 類型的嗎？
　　res = isinstance(5,int) => True
　　res = isinstance('123',list) => False
　　print(res)

　　# 有一個類型知足 反爲真,一個都不知足,反爲假　　res = isinstance(5,(list,tuple,str,int))　　print(res) => True　　res = isinstance(5,(list,tuple,str,))　　print(res) => False