Python全棧之基本數(shù)據(jù)類型

更新時間：2021年12月01日 14:54:56 作者：熬夜泡枸杞

這篇文章主要為大家介紹了Python基本數(shù)據(jù)類型，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助

1. number類型

Number 數(shù)字類型 (int float bool complex)

1.1 int整型

# int 整型 (正整型 0 負(fù)整型)
intvar = 100
print(intvar)
# type 獲取值得類型
res = type(intvar)
print(res)
# id   獲取值得地址
res = id(intvar)
print(res)
# 二進(jìn)制整型
intvar = 0b110
print(intvar)
print( type(intvar) )
print(     id(intvar)    )
# 八進(jìn)制整型
intvar = 0o127
print(intvar)
print(type(intvar))
print(id(intvar))
# 十六進(jìn)制
intvar = 0xff
intvar = 0XFF
print(intvar)
print(type(intvar))
print(id(intvar))
"""
二進(jìn)制 1 + 1 = `10
八進(jìn)制 7 + 1  = 10
十六進(jìn)制 f + 1 = 10
"""

1.2 float浮點型（小數(shù)）

# 表達(dá)方式之一
floatvar = 3.6
print(floatvar , type(floatvar))
# 表達(dá)方式2 科學(xué)計數(shù)法
floatvar = 5.75e5 # 小數(shù)點右移5
floatvar = 5.7e-2 # 小數(shù)點左移2
print(floatvar, type(floatvar))

1.3 bool布爾型

# True 真的, False 假的
boolvar = True
boolvar = False
print(boolvar , type(boolvar))

1.4 復(fù)數(shù)類型

"""
3 + 4j
實數(shù)+虛數(shù)
實數(shù): 3
虛數(shù): 4j
j   : 如果有一個數(shù)他的平方等于-1,那么這個數(shù)就是j , 科學(xué)家認(rèn)為有,表達(dá)一個高精度的類型
"""
# 表達(dá)方式1
complexvar = 3 + 4j
complexvar = -3j
print(complexvar , type(complexvar))
# 表達(dá)方法2 
"""
complex(實數(shù),虛數(shù)) => 復(fù)數(shù)
"""
res = complex(3,4)
print(res , type(res))

2. 字符串類型

# ### 字符串類型 str
"""
用引號引起來的就是字符串，單引號，雙引號，三引號
# 轉(zhuǎn)移字符 \ + 字符串類型	
	(1) 可以將無意義的字符變的有意義
	(2) 可以將有意義的字符變的無意義
\n   : 換行
\r\n : 換行
\t   : 縮進(jìn)（水平制表符）
\r   : 將\r后面的字符串拉到了當(dāng)前行的行首 
"""
# 1. 單引號的字符串
strvar = '生活不知眼前的茍且'
print(strvar , type(strvar))
# 2. 雙引號的字符串
strvar = "還有詩和遠(yuǎn)方的田野"
print(strvar , type(strvar))
# 可以將無意義的字符變得有意義
strvar = "還有詩和\n遠(yuǎn)方的田野"
print(strvar)
strvar = "還有詩和\r\n遠(yuǎn)方的田野"
strvar = "還有詩和\t遠(yuǎn)方的田野"
strvar = "還有詩和\r遠(yuǎn)方的田野"
strvar = "還有詩和\n遠(yuǎn)方的\r田野"
# 可以將有意義的字符變得無意義
strvar = "還有詩和\"遠(yuǎn)\"方的田野"
print(strvar)
strvar = '''
"生活就像醉酒"
表面上'不'要
身體卻很誠實
'''
print(strvar)
# 元字符串 r"字符串" 原型化輸出字符串
strvar = " D:\nython32_python\tay02"
strvar = r" D:\nython32_python\tay02"
print(strvar)
# 5. 字符串的格式化
"""
%d 整型占位符
%f 浮點型占位符
%s 字符串占位符
語法格式：
	"字符串" % （值1，值2）
"""
# %d 整型占位符
strvar = "小明昨天買了%d風(fēng)油精，洗澡" % (2)
print(strvar)
# %2d 占兩位（不夠兩位拿空格來補(bǔ)位）原字符串具右
strvar = "小明昨天買了%2d風(fēng)油精，洗澡" % (2)
print(strvar)
# %-2d 占兩位（不夠兩位拿空格來補(bǔ)位）原字符串具左
strvar = "小明昨天買了%-2d風(fēng)油精，洗澡" % (2)
print(strvar)
# %f 浮點型占位符
strvar = "小明一個月開%f工資" % (9.9)
print(strvar)
# %.2f 保留小數(shù)點后面兩位小數(shù)（存在四舍五入的情況，默認(rèn)保留六位小數(shù)）
strvar = "小明一個月開%.2f工資" % (9.178)
print(strvar)
# %s字符串占位符
strvar = "%s最喜歡在電影院尿尿" % ("小明")
print(strvar)
# 綜合案例
strvar = "%s在水里%s被發(fā)現(xiàn)了，罰款%.2f元，并且做了%d俯臥撐." % ("小明","尿尿",500.129,50000)
print(strvar)
# 如果搞不清楚用什么占位符，可以無腦使用%s
strvar = "%s在水里%s被發(fā)現(xiàn)了，罰款%s元，并且做了%s俯臥撐." % ("小明", "尿尿", 500.129, 50000)
print(strvar)

3. 列表_元組_字符串

3.1 列表類型

"""特征: 可獲取,可修改,有序"""
# 1.定義一個空列表
listvar = []
print( listvar , type(listvar))
# 定義普通列表
listvar = [98,6.9,True,12-90j,"趙萬里"]
# 2.獲取列表中的元素
# 正向索引   0  1   2     3      4
listvar =   [98,6.9,True,12-90j,"趙萬里"]
# 逆向索引  -5  -4  -3     -2      -1
res = listvar[2]
res = listvar[-2]
print(res)
# 通用寫法
# len 獲取容器類型數(shù)據(jù)中元素個數(shù)
length = len(listvar)
res = listvar[length-1]
print(res)
# 簡寫
res = listvar[len(listvar)-1]
print(res)
# python逆向索引的特點,瞬間得到列表中最后一個元素
print(listvar[-1])
# 3.修改列表中的元素
listvar = [98,6.9,True,12-90j,"趙萬里"]
listvar[3] = "大象"
print(listvar)

3.2 元組類型

"""特征：可獲取，不可修改，有序"""
# 定義一個元組
# 正向索引    0      1      2      3
tuplevar = ("小趙","小錢","小孫","小李")
# 逆向索引    -4     -3     -2     -1
print(tuplevar[2])
print(tuplevar[-1])
# 修改元組中的元素：元組中的值不能修改
# tuple[0] = "萌不好心" error
# 注意點
""" 逗號才是區(qū)分是否是元組的標(biāo)識符"""
tuplevar = (8.9,)
tuplevar = 8.1,
print(tuplevar)
print(type(tuplevar))
# 定義空元組
tuplevar = ()
print(type(tuplevar))

3.3 字符串類型

"""特征：可獲取，不可修改，有序"""
# 正向索引
#		  0 1 2 3 4 5 6 7 8
strvar = "看你,我就心跳加速"
#		  -9-8-7-6-5-4-3-2-1
# 逆向索引
# 獲取字符串中的元素
print(strvar[3])
print(strvar[-6])
#不能修改字符串中的元素
#strvar[3] = "你" error
print("<=================>")
strvar = "" # 單純定義一個字符串類型
print(strvar)
print(type(strvar))
strvar = "   " # 字符串中含有3個空格字符
print(strvar[0])
print(type(strvar))

4. 集合_字典

4.1 集合類型

"""特點：無序，自動去重"""
# 1. 集合無序
setvar = {"巨石強(qiáng)森","史泰龍","施瓦辛格","小明"}
print(setvar,type(setvar))
# 獲取集合中的元素，不可以
# setvar[0] error
# 修改集合中的元素，不可以
# setvar[2] = 111
# 2. 集合自動去重
setvar = {"巨石強(qiáng)森","史泰龍","史泰龍","施瓦辛格","小明"}
print(setvar , type(setvar))
# 3. 定義一個空集合
setvar = set()
print(setvar , type(setvar))

4.2 字典類型

"""
鍵值對存儲的數(shù)據(jù)，表面上有序，本質(zhì)上無序
dicvar = {鍵1:值1，鍵2:值2，...}
3.6版本之前，完全無序
3.6版本之后，存儲的時候，保留了字典的字面順序，在獲取內(nèi)存中數(shù)據(jù)時
重新按照字面順序做了排序，所以看起來有序，實際上存儲時還是無序
"""
# 1. 定義一個字段
dictvar = {"top":"the shy","middle":"肉雞","bottom":"jacklove","jungle":"臭鞋","support":"水稻"}
print(dictvar, type(dictvar))
# 2. 獲取字典中的值
res = dictvar["middle"]
print(res)
res = dictvar["jungle"]
print(res)
# 3. 修改字典中的值
dictvar["top"] = "the xboy"
print(dictvar)
# 4. 定義空字典
dicvar = {}
print(dicvar,type(dictvar))
"""
字典的鍵 和 集合的值，有數(shù)據(jù)類型上的要求：
(允許的類型范圍)不可變的類型：Number(int float complex bool) str tuple
(不允許的類型)可變的類型：list set dict
哈希算法的提出目的是讓數(shù)據(jù)盡量均勻的咋i內(nèi)存當(dāng)中分配，以減少哈希碰撞，提升存儲分配的效率；
哈希算法一定是無序的散列，所以集合和字典都是無序
字典的鍵有要求，值沒要求
字典的值可以任意換掉，但是鍵不可以
"""
# 允許的類型范圍
dictvar = {1:"abc",4.89:111,False:333,3+90j:666,"小明":"你好帥",(1,2,3,4,5,6):9999}
print(dictvar)
print(dictvar[(1,2,3,4,5,6)])
# dictvar = {[1,2,3]:123} error
# 允許的類型范圍
setvar = {1,"a",4.56,9+3j,False,(1,2,3)}
print(setvar , type(setvar))
# 總結(jié)：
"""
無論是變量緩存機(jī)制還是小數(shù)據(jù)池的駐留機(jī)制，
都是為了節(jié)省內(nèi)存空間
"""

5. 變量的緩存機(jī)制

# ### 在同一文件中,變量的緩存機(jī)制 (僅僅針對python3.6版本負(fù)責(zé))
# 1.對于整型而言，-5~正無窮范圍內(nèi)的相同值 id一致
var1 = 5
var2 = 5
var1 = -100
var2 = -100
print(id(var1) , id(var2) )

# 2.對于浮點數(shù)而言，非負(fù)數(shù)范圍內(nèi)的相同值 id一致
var1 = 4.67
var2 = 4.67
var1 = -4.67
var2 = -4.67
print(id(var1) , id(var2) )
# 3.布爾值而言,值相同情況下，id一致
var1 = True
var2 = True
print(id(var1) , id(var2) )
# 4.復(fù)數(shù)在 實數(shù)+虛數(shù) 這樣的結(jié)構(gòu)中永不相同(只有虛數(shù)的情況例外)
var1 = 4 +5j
var2 = 4 +5j
# 5j 情況下例外
var1 = 5j
var2 = 5j
var1 = -5j
var2 = -5j
print(id(var1) ,id(var2))
# -->容器類型部分
# 5.字符串 和 空元組 相同的情況下，地址相同
var1 = "你"
var2 = "你"
var1 = ()
var2 = ()
print(id(var1) ,id(var2))
# 6.列表，元組，字典，集合無論什么情況 id標(biāo)識都不同 [空元組例外]
var1 = (1,2)
var2 = (1,2)
var1 = [1,2,3]
var2 = [1,2,3]
print(id(var1) ,id(var2))
# 不同文件（模塊）里，部分?jǐn)?shù)據(jù)駐留小數(shù)據(jù)池中（僅對python3.6負(fù)責(zé)，了解）

6. 小練習(xí)

題目如下：

1. 什么是原碼反碼補(bǔ)碼
2. 計算9 + (-3) 以及 -9 + (3)
3. 什么是注釋
4. 注釋種類
5. 如何用注釋排錯
6. 如何定義變量
7. 變量命名
8. 如何交換變量
9. Python6大標(biāo)準(zhǔn)數(shù)據(jù)類型
10. 浮點型和復(fù)數(shù)的兩種表達(dá)方法
11. 寫出三個轉(zhuǎn)義字符，含義
12. 簡述如何使用字符串的格式化占位符
13. 簡述容器類型各個特征
14. 以下各是什么類型：() , (1) , （"abc"） , (False,)
15. 字典的鍵和集合的值有什么要求
16. 用幾種方式獲取列表中的最后一個元素
17. 3.6版本中，變量的緩存機(jī)制有哪些

解答如下：

1.二進(jìn)制表現(xiàn)的三種形式
原碼:用來顯示 補(bǔ)碼:用來存儲計算 反碼:用來轉(zhuǎn)換原碼反碼
正數(shù) : 原碼 = 反碼 = 補(bǔ)碼
負(fù)數(shù) : 原碼和補(bǔ)碼 互為取反 + 1
2.
9
原碼: 000 ... 1001 
反碼: 000 ... 1001 
補(bǔ)碼: 000 ... 1001 
-3
原碼 100 ... 011
反碼 111 ... 100
補(bǔ)碼 111 ... 101
000 ... 1001 
111 ... 1101
000 ... 0110  => 6

-9
原碼:100 ... 1001 
反碼:111 ... 0110
補(bǔ)碼:111 ... 0111
3
原碼 000 ... 011
反碼 000 ... 011
補(bǔ)碼 000 ... 011
111 ... 0111
000 ... 0011
111 ... 1010 補(bǔ)碼
給你補(bǔ)碼求原碼
補(bǔ)碼:111 ... 1010
反碼:100 ... 0101
原碼:100 ... 0110  -6
3. 注釋就是對代碼的解釋,用來方便大家閱讀代碼的
4. 注釋種類:單行注釋 多行注釋
5. 包裹代碼劃分范圍,依次縮小范圍找單行錯誤
6. a =1 ,b = 2,a,b = 3,4 a=b=100 
7. 字母數(shù)字下劃線,首字符不能為數(shù)字,嚴(yán)格區(qū)分大小寫,不能使用關(guān)鍵字,變量命名有意義,且不能使用中文哦
8.
(1) a,b = b,a  
(2)tmp = a a = bb = tmp
9. int float complex bool str list tuple set dict
10.
f = 3.56  f = 3e4 f = 3e-4
c = 3+4j  c = complex(3,4)
11.\n \t \r
12."字符串" % (值1,值2 ... ) %d %f %s
13.list : 可獲取可修改有序 tuple/str:可獲取,不可修改,有序 set:無序,自動去重 dict:鍵值對存儲的數(shù)據(jù),表面上有序,本質(zhì)上無序
14.空元祖 整型 字符串 元組
15.可哈希不可修改的類型 Number str tuple
16.lst[-1] lst[len(lst) - 1]
17.int:-5~正無窮  float: 非負(fù)數(shù) bool:值相同 complex:只有虛數(shù)例外,剩下都不一樣
   str:值相同即可 tuple:空元組即可 其他容器都不相同;