python固定数据类型_Python的数据类型
一、基本數據類型
1、整型：int
（1）整型的作用：用來記錄人的年齡，出生年份，學生人數等整數相關的狀態。
（2）整型的定義：
age=18 # 本質 age=int(18)birthday=1990
2、浮點型：（floating point numbers，或者簡稱為 floats ）
（1）浮點型的作用：用來記錄人的身高，體重，薪資等小數相關的狀態。
（2）浮點型的定義：
#float 浮點型(小數)#表達方式一
floatvar = 3.14 # 本質是floatvar=float(3.14)
print(floatvar)
res=type(floatvar)print(res)#表達方式二 (科學計數法)
floatvar = 3.98e3 #3.98乘以10的3次方（小數點向右移動3位） 結果：3980
floatvar = 3.98e-3 #3.98乘以10的-3次方（小數點向左移動3位） 結果：0.00398
print(floatvar)
res=type(floatvar)print(res)
注意：名字+括號的意思就是調用某個功能，比如
# print(...)調用打印功能
#int(...)調用創建整型數據的功能
#float(...)調用創建浮點型數據的功能
數字類型的使用：
（1）算數運算：
a = 1b= 2
print(a +b)
輸出3
（2）比較大小：
a = 1b= 2
print(a >b)
輸出
False
3、布爾型：bool
（1）布爾型的作用：用來記錄真假這兩種狀態。
（2）布爾型的定義：
>>> is_ok =True>>> is_ok = False
（3）布爾型的使用：通常用來當作判斷的條件，我們將在if判斷中用到它。
4、復數：complex
（1）復數的作用：
（2）復數的定義：
complex_num = 3 + 4j # j：科學家定義一個數的平方是-1就說這個數是j
print(complex_num)
5、字符串類型：str
（1）字符串的作用：用來記錄人的名字，家庭住址，性別等描述性質的狀態。
（2）字符創的定義：
name = "lsj" # 本質：name = str("lsj")sex= '男' # 本質：sex = str('男')
hobbies = """女""" # 本質：hobbies = str("""女""")
（3）用單引號、雙引號、多引號，都可以定義字符串，本質上引號里面存放任意形式的內容這三種形式沒有區別的，但是要注意引號的使用。
#1、需要考慮引號嵌套的配對問題
msg = "My name is lsj , I'm 18 years old!" #內層有單引號，外層就需要用雙引號#2、多引號可以寫多行字符串
msg = '''\'念奴嬌。赤壁懷古\'
大江東去，浪淘盡，千古風流人物。
故壘西邊，人道是，三國周郎赤壁。
亂石穿空，驚濤拍岸，卷起千堆雪。
江山如畫，一時多少豪杰。
遙想公瑾當年，小喬初嫁了，雄姿英發。
羽扇綸巾，談笑間，檣櫓灰飛煙滅。
故國神游，多情應笑我，早生華發'''
（4）字符串的簡單使用
#字符串也可以進行"相加"和"相乘"運算。
a = "a"b= "b"
print(a +b) # ab字符串的拼接
c= a * 3
print(c) # 字符串重復
（5）字符串的數據類型轉換：str()可以將任意數據類型轉換成字符串類型
#列表轉換成字符串：list->str
l = [1,2,3]print(l,type(l)) #[1, 2, 3]
l_s = str(l) #list->str
print(l_s,type(l_s)) #[1, 2, 3]
#字典轉換成字符串：dict->str
d = {"name":"jason","age":18}print(d,type(d)) #{'name': 'jason', 'age': 18}
d_s =str(d)print(d_s,type(d_s)) #{'name': 'jason', 'age': 18}
#元組轉換成字符串；tuple->str
t = (1,2,3)print(t,type(t)) #(1, 2, 3)
t_s =str(t)print(t_s,type(t_s)) #(1, 2, 3)
（6）字符串的騷操作
#字符串的一些操作#0123456789101112#str1 = 'hello python!'#-12 -1#1.按索引取值(正向取，反向取)：#1.1 正向取值(從左往右)#z = str1[6]#print(z,id(z)) # p 34200464
#1.2 反向取(負號表示從右往左)#f = str1[-4]#print(f,id(f)) # h 36862920
#1.3 對于str來說，只能按照索引取值，不能改其值#u = str1[0] = 'H' # 我意思是把h改稱H#print(u)#u = str1[0] = 'H' # 報錯TypeError#TypeError: 'str' object does not support item assignment
#2.切片(顧頭不顧尾，步長)#2.1 顧頭不顧尾：取出索引為0到8的所有字符#print(str1[0:9]) # hello pyt
#2.2 步長：0:9:2,第三個參數2代表步長，會從0開始，每次累加一個2即可，所以會取出索引0、2、4、6、8的字符#print(str1[0:9:2]) # hlopt
#2.3 反向切片,-1表示從右往左依次取值#print(str1[::-1]) # !nohtyp olleh
#3.長度len#3.1 獲取字符串的長度，即字符的個數，但凡存在于引號內的都算作字符)#print(len(str1)) # 空格也算字符 13
#4.成員運算 in 和 not in#4.1 int:判斷hello 是否在 str1里面#print('hello' in str1) # True#print('hl' in str1) # False 雖然h和l都在str1里面，不是連續的片段
#4.2 not in:判斷lsj 是否不在 str1里面#print('lsj' not in str1) # True
#5.strip移除字符串首尾指定的字符(默認移除空格)#5.1 括號內不指定字符，默認移除首尾空格#str2 = ' life is short! '#print(str2.strip()) # life is short!
#5.2 括號內指定字符，移除首尾指定的字符#str3 = '**tony**'#print(str3.strip('*')) # tony
#6.切分split#6.1 括號內不指定字符，默認以空格作為切分符號#str4='hello world'#print(str4.split()) # ['hello', 'world']
#6.2 括號內指定分隔字符，則按照括號內指定的字符切割字符串#str5 = '127.0.0.1'#print(str5.split('.'))#['127', '0', '0', '1'] # 注意:split切割得到的結果是列表數據類型
#7.循環#str7 = '今天你好嗎？'#print(str7)#for line in str7: # 依次取出字符串中每一個字符#print(line)
"""今
天
你
好
嗎
？"""
（7）重點掌握的字符串的操作
#1、字符串中關鍵字strip, lstrip, rstrip操作
str1 = '**lsj***'
print(str1.strip('*')) #移除左右兩邊的指定字符#lsj
print(str1.lstrip('*')) #只移除左邊的指定字符#lsj***
print(str1.rstrip('*')) #只移除右邊的指定字符#**lsj
#2、字符串中關鍵字lower(),upper()
str2 = 'My nAme is Lsj！'
print(str2.lower()) #將英文字符串全部變小寫#my name is lsj！
print(str2.upper()) #將英文字符串全部變大寫#MY NAME IS LSJ！
#3、字符串中關鍵字startswith(),endswith()
str3 = 'lsj study python !'
#startswith()判斷字符串是否以括號內指定的字符開頭，結果為布爾值True或False
print(str3.startswith('l')) #True
print(str3.startswith('j')) #False
#endswith()判斷字符串是否以括號內指定的字符結尾，結果為布爾值True或False
print(str3.endswith('on')) #False
print(str3.endswith('!')) #True
## 4、字符串中關鍵字split,rsplit，執行后類型由字符串類型轉換到列表類型。## split會按照從左到右的順序對字符串進行切分，可以指定切割次數#str4 = 'C:/a/b/c/d.txt'#f_g_4 = str4.split('/',1)#print(type(str4),type(f_g_4),f_g_4) # ['C:', 'a/b/c/d.txt']#
## rsplit剛好與split相反，從右往左切割，可以指定切割次數#str5 = 'a|b|c'#f_g_5 = str5.rsplit('|',1)#print(type(str5),type(f_g_5),f_g_5) # ['a|b', 'c']
## 5.join # 從可迭代對象中取出多個字符串，然后按照指定的分隔符進行拼接，拼接的結果為字符串#print('%'.join('hello')) # 從字符串'hello'中取出多個字符串，然后按照%作為分隔符號進行拼接## h%e%l%l%o#print('|'.join(['lsj','18','read'])) # 從列表中取出多個字符串，然后按照|作為分隔符號進行拼接## lsj|18|read
#7.replace# 用新的字符替換字符串中舊的字符#str7 = 'my name is lsj, my age is 18!' # 將lsj的年齡由18歲改成73歲#str7 = str7.replace('18', '73') # 語法:replace('舊內容', '新內容')#print(str7) # my name is lsj, my age is 73!
#可以指定修改的個數#str7 = 'my name is lsj, my age is 18!'#str7 = str7.replace('my', 'MY',1) # 只把一個my改為MY#print(str7) # 'MY name is lsj, my age is 18!'
#8.isdigit # 判斷字符串是否是純數字組成，返回結果為True或False#str8 = '5201314'#print(str8.isdigit()) # True#str8 = '123g123'#print(str8.isdigit()) # False
（8）了解字字符串的操作
#1.find,rfind,index,rindex,count#msg = 'lsj say hello'#1.1 find：從指定范圍內查找子字符串的起始索引，找得到則返回數字1，找不到則返回-1#print(msg.find('s',1,3)) # 1 在索引為1和2(顧頭不顧尾)的字符中查找字符o的索引#print(msg.find('a',1,3)) # -1## 1.2 index:同find,但在找不到時會報錯#msg.index('e',2,4) # 報錯ValueError#msg.index('e',2,4) # 報錯ValueError#ValueError: substring not found
## 1.3 rfind與rindex：略
## 1.4 count:統計字符串在大字符串中出現的次數#msg = "hello everyone"#print(msg.count('e')) # 統計字符串e出現的次數#4#print(msg.count('e',1,6)) # 字符串e在索引1~5范圍內出現的次數#1
## 2.center,ljust,rjust,zfill
name='lsj'
#print(name.center(30,'-')) # 總寬度為30，字符串居中顯示，不夠用-填充#-------------lsj-------------#print(name.ljust(30,'*')) # 總寬度為30，字符串左對齊顯示，不夠用*填充#lsj**************************#print(name.rjust(30,'*')) # 總寬度為30，字符串右對齊顯示，不夠用*填充#**************************lsj#print(name.zfill(50)) # 總寬度為50，字符串右對齊顯示，不夠用0填充#0000000000000000000000000000000000000000000000lsj
## 3.expandtabs#name = 'lsj\thello' # \t表示制表符(tab鍵)#print(name)#lsj hello#print(name.expandtabs(1)) # 修改\t制表符代表的空格數#lsj hello
## 4.captalize,swapcase,title## 4.1 captalize：首字母大寫#message = 'hello everyone nice to meet you!'#print(message.capitalize())#Hello everyone nice to meet you!#4.2 swapcase：大小寫翻轉#message1 = 'Hi girl, I want make friends with you!'#print(message1.swapcase())#hI GIRL, i WANT MAKE FRIENDS WITH YOU!#4.3 title：每個單詞的首字母大寫#msg = 'dear my friend i miss you very much'#print(msg.title())#Dear My Friend I Miss You Very Much
## 5.is數字系列##在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中無需加u就是unicode
num3 = '四' #中文數字
num4 = 'Ⅳ' #羅馬數字#
##isdigt:bytes,unicode # 判斷是否都為數字#print(num1.isdigit())## True#print(num2.isdigit())## True#print(num3.isdigit())## False#print(num4.isdigit())#False
##isdecimal:uncicode(bytes類型無isdecimal方法)
print(num2.isdecimal())#True
print(num3.isdecimal())#False
print(num4.isdecimal())#False#
##isnumberic:unicode,中文數字,羅馬數字(bytes類型無isnumberic方法)
print(num2.isnumeric())#True
print(num3.isnumeric())#True
print(num4.isnumeric())#True#
## 三者不能判斷浮點數
num5 = '4.3'
print(num5.isdigit())#False
print(num5.isdecimal())#False
print(num5.isnumeric())#False
#'''#總結:#最常用的是isdigit,可以判斷bytes和unicode類型,這也是最常見的數字應用場景#如果要判斷中文數字或羅馬數字,則需要用到isnumeric。#'''#
## 6.is其他#name = 'tony123'
print(name.isalnum()) #字符串中既可以包含數字也可以包含字母#True
print(name.isalpha()) #字符串中只包含字母#False
print(name.isidentifier())#True
print(name.islower()) #字符串是否是純小寫#True
print(name.isupper()) #字符串是否是純大寫#False
print(name.isspace()) #字符串是否全是空格#False
print(name.istitle()) #字符串中的單詞首字母是否都是大寫#False
6、列表類型：list[]
（1）列表的作用：按位置可以存放多個值，列表類型是用索引來對應值，索引代表的是數據的位置，從0開始計數
（2）列表的定義：
# 定義：在[]內,用逗號分隔開多個任意數據類型的值
l=[1,1.2,'a'] # l=list([1,1.2,'a'])
print(type(l)) #
#定義一個空列表
listvar =[]print(listvar, type(listvar)) # [] #(1) 定義一個普通的列表#正向索引下標 0 1 2 3 4
listvar = [1,3.14,False,3+4j,"你好帥哥"]#逆向索引下標 -5 -4 -3 -2 -1
（3）類型轉換:但凡能夠被for循環遍歷的類型都可以當做參數傳給list()轉成列表，list()會跟for循環一樣遍歷出數據類型中包含的每一個元素然后放到列表中
# 使用for循環將字符串轉轉成列表
l = 'hello'r=[]for i inl:print(r.append(i))print(r)#使用list()將字符串轉轉成列表
res=list('hello')print(res,type(res))
# 使用list()將字典轉成列表
# res=list({'k1':111,'k2':222,'k3':3333})
# print(res) # ['k1', 'k2', 'k3']
（4）列表的使用：
"""特點: 可獲取,可修改,有序"""
#(2) 獲取列表當中的元素
res = listvar[3]#python特點,用下標-1
res = listvar[-1]#獲取列表中最后一個元素(通用寫法)#len 獲取容器類型數據的總長度(元素總個數)
res =len(listvar)
max_len= res - 1
print(max_len) #4
val=listvar[max_len]print(val)#(3) 修改列表當中的元素
listvar[-4] = "太帥了"
print(listvar)
# 列表可以嵌套，嵌套取值如下
students_info=[['tony',18,['jack',]],['jason',18,['play','sleep']]]
students_info[0][2][0] #取出第一個學生的第一個愛好 'play
（5）列表的內置方法：
#1、按索引存取值(正向存取+反向存取)：即可以取也可以改#l=[111,'egon','hello']#正向取#print(l[0]) # 111#反向取#print(l[-1]) # hello
#2、 可以取也可以改：索引存在則修改對應的值
l[0]=222
print(l) #[222, 'egon', 'hello']#無論是取值操作還是賦值操作：索引不存在則報錯
l[3]=333
#l[3]=333#IndexError: list assignment index out of range
#2、切片(顧頭不顧尾，步長)
l = [111, 'lsj', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]print(l[0:3])print(l[0:5:2]) #0 2 4 開始值，結束值，步長
print(l[0:len(l)]) #從頭到尾取值
print(l[:]) #從頭到尾取值#[111, 'lsj', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
new_l=l[:] # 切片等同于拷貝行為，而且相當于淺copy
print(id(l)) # 34933248
print(id(new_l)) # 34955200
# 淺copy
l = [111, 'lsj', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
l[-1][0]=1111111
print(l)
new_l=l[:]
print(new_l)
# 反向取值
print(l[::-1])
# 賦值操作
msg1='hello:lsj:<>:18[]==123'
print(msg1,id(msg1),type(msg1))
msg2=msg1[:]
print(msg2,id(msg2),type(msg2))
#3、列表長度#print(len([1, 2, 3])) # 3
#4、成員運算in和not in#print('aaa' in ['aaa', 1, 2]) # True#print(1 in ['aaa', 1, 2]) # True
#5、往列表中添加值#5.1 追加
l=[111,'lsj','hello']
l.append(3333)print(l) #[111, 'lsj', 'hello', 3333]
l.append(4444)print(l) #[111, 'lsj', 'hello', 3333, 4444]
#5.2、插入值
l=[111,'lsj','hello']
l.insert(0,'alex') #對索引是0的位置插入一個值
print(l) #['alex', 111, 'lsj', 'hello']
#5.3、extend添加值
new_l=[1,2,3]
l=[111,'lsj','hello']
l.append(new_l)#列表后添加一個新的列表
print(l) #[111, 'lsj', 'hello', [1, 2, 3]]
# for循環代碼實現
for item in new_l:
l.append(item)
print(l) # [111, 'lsj', 'hello', 1, 2, 3]
# extend實現了上述代碼
l.extend(new_l)
l.extend('abc')
print(l) # [111, 'lsj', 'hello', 1, 2, 3, 'a', 'b', 'c']
#7、刪除#方式一：通用的刪除方法，只是單純的刪除、沒有返回值#l = [111, 'lsj', 'hello']#del l[1] # [111, 'hello']#x =del l[1] # 拋出異常，不支持賦值語法。SyntaxError: invalid syntax#print(l)
#方式二：l.pop()根據索引刪除，會返回刪除的值#l = [111, 'lsj', 'hello']#l.pop() # 不指定索引默認刪除最后一個#l.pop()#print(l)
#返回刪除的值#res=l.pop(1)#print(l)## 返回刪除的值#print(res)
#方式三：l.remove()根據元素刪除，返回None#l = [111, 'lsj', [1,2,3],'hello']#l.remove([1,2,3])#print(l)#res=l.remove('lsj')#print(res) # None#res=l.remove('l')#print(res) # 如果所刪除的值不存在報錯：ValueError: list.remove(x): x not in list
#8、循環#l=[1,'aaa','bbb']#for x in l:#l.pop(1)#print(x)
#需要掌握操作#l = [1, 'aaa', 'bbb','aaa','aaa']#1、l.count() # 根據括號里的參數統計出現的次數#print(l.count('aaa')) # 3
#2、l.index() # 根據括號里的參數查找索引值#print(l.index('aaa')) # 索引位置1#print(l.index('aaaaaaaaa')) # 找不到報錯
#3、l.clear() # 清空列表,返回[]空列表#l.clear()#print(l) # []
#4、l.reverse():列表倒過來#l = [1, 'lsj','alex','lxx']#l.reverse()#print(l)
#5、l.sort(): 列表內元素必須是同種類型才可以排序#l=[11,-3,9,2,3.1]#l.sort() # 默認從小到大排，稱之為升序#print(l) # [-3, 2, 3.1, 9, 11]#l.sort(reverse=True) # 從大到小排，設置為降序#print(l) # [11, 9, 3.1, 2, -3]
#l=[11,'a',12]#l.sort()
#l=['c','e','a']#l.sort()#print(l)
#了解：字符串可以比大小，按照對應的位置的字符依次pk#字符串的大小是按照ASCI碼表的先后順序加以區別，表中排在后面的字符大于前面的#print('a'>'b') # False#print('abz'>'abcdefg') # True
#了解：列表也可以比大小,原理同字符串一樣,但是對應位置的元素必須是同種類型#l1=[1,'abc','zaa']#l2=[1,'abc','zb']#print(l1 < l2) # True
#補充#1、隊列：FIFO,先進先出#l=[]#入隊操作，向列表中追加原始#l.append('first')#l.append('second')#l.append('third')#print(l) # ['first', 'second', 'third']
## 出隊操作，從列表中刪除元素，從索引為0開始#print(l.pop(0))#print(l.pop(0))#print(l.pop(0))
#2、堆棧：LIFO,后進先出#l=[]## 入棧操作#l.append('first')#l.append('second')#l.append('third')#print(l) # ['first', 'second', 'third']## 出隊操作，默認從最后開始刪除#print(l.pop())#print(l.pop())#print(l.pop())
7、字典類型:dict{}
（1）字典的作用：（大前提：計算機存取數據是為了能取出來）字典類型是用key：value形式來存儲數據，其中key可以對value有描述性的功能
（2）字典的定義：
{}內用逗號分隔開多個key：value，其中value可以使任意類型。key必須是不可變類型,且不能重復，多用字符串可描述性表示
#1.定義一個字典
dictvar = {"top":"夏侯淳","middle":"安其拉","bottom":"程咬金","jungle":"李白","support":"蔡文姬"}print(dictvar , type(dictvar))
# 造字典的方式一：
# d={'k1':111,(1,2,3):222} # d=dict(...)
# print(d['k1']) # 111
# print(d[(1,2,3)]) # 222
# print(type(d)) #
# d={} # 默認定義出來的是空字典
# print(d,type(d)) # {}
# 造字典的方式二：
# d=dict(x=1,y=2,z=3)
# print(d,type(d)) # {'x': 1, 'y': 2, 'z': 3}
#3、造字典的方式三：數據類型轉換：列表轉換成字典
info=[
['name','egon'],
('age',18),
['gender','male']
]
res=dict(info) #一行代碼搞定上述for循環的工作
print(res) #{'name': 'egon', 'age': 18, 'gender': 'male'}
#使用for循環制造字典#d={}#for k,v in info: # k,v=['name','egon'],#d[k]=v#print(d) # {'name': 'egon', 'age': 18, 'gender': 'male'}
#造字典的方式四:快速初始化一個字典
keys=['name','age','gender']#使用for循環造字典
d={}for k inkeys:
d[k]=Noneprint(d) #{'name': None, 'age': None, 'gender': None}#d={}.fromkeys(keys,None) # 一行代碼搞定上述for循環的工作#print(d) # {'name': None, 'age': None, 'gender': None}
#4、內置方法#優先掌握的操作：#1、按key存取值：可存可取#d={'k1':111}#print(d) # {'k1': 111}#針對賦值操作：key存在，則修改#d['k1']=222#print(d) # {'k1': 222}#針對賦值操作：key不存在，則創建新值#d['k2']=3333#print(d) #{'k1': 111, 'k2': 3333}
#2、長度len#d={'k1':111,'k2':2222,'k1':3333,'k1':4444}#print(d) # {'k1': 4444, 'k2': 2222}#print(len(d)) 2
#3、成員運算in和not in:根據key#d={'k1':111,'k2':2222}#print('k1' in d) # True#print('k1' not in d) # False#print(111 in d) # False#print(121 not in d) # True
#4、刪除#d={'k1':111,'k2':2222}#4.1 通用刪除#del d['k1']#print(del d['k1']) # 語法無效：SyntaxError: invalid syntax#print(d) # {'k2': 2222}
#4.2 pop刪除：根據key刪除元素，返回刪除key對應的那個value值#res=d.pop('k2')#print(d) # {'k1': 111}#print(res) # 2222
#4.3 popitem刪除：隨機刪除，返回元組(刪除的key,刪除的value)#res=d.popitem()#print(d) # {'k1': 111}#print(res) # 返回值是元組('k2', 2222)
#5、鍵keys()，值values()，鍵值對items() =>在python3中得到的是老母雞#d={'k1':111,'k2':2222}
#在python2中,所有的key,占用更多空間#d={'k1':111,'k2':2222}#print(d.keys()) # dict_keys(['k1', 'k2'])
#6、循環#k = ['k2', 'k1']#d.values()#print(d.values()) # dict_values([111, 2222])#d.items()#print(d.items()) # dict_items([('k1', 111), ('k2', 2222)])
#dict(d.items())#print(dict(d.items())) # {'k2': 2222, 'k1': 111}
#7、for循環
d={'k1':111,'k2':2222}#for k in d.keys():#print(k) # k1 k2#
#for k in d:#print(k) # k1 k2
#for v in d.values():#print(v) # 111 2222
#for k,v in d.items():#print(k,v) # k1 111 k2 2222
#轉換成列表#print(list(d.keys())) # ['k1', 'k2']#print(list(d.values())) # [111, 2222]#print(list(d.items())) # [('k1', 111), ('k2', 2222)]
#需要掌握的內置方法#d={'k1':111}#1、d.clear() # 清空，有返回值#print(d.clear()) # None## 上面一行代碼可以轉換為下面的#c = d.clear()#print(c)
#2、d.update() # 更新操作，有則改之，無則加入#d={'k1':111}#d.update({'k2':222,'k3':333,'k1':111111111111111})#print(d)
#3、d.get() ：根據key取值，容錯性好#d={'k1':111}## print(d['k2']) # key不存在則報錯，KeyError: 'k2'#
#print(d.get('k1')) # 111#print(d.get('k2')) # key不存在不報錯，返回None
#4、d.setdefault()#info={}#if 'name' in info:#... # 等同于pass#else:#info['name']='lsj'#print(info) # {'name': 'lsj'}
#4.1 如果key有則不添加,返回字典中key對應的值#info={'name':'lsj'}#res=info.setdefault('name','lsj')#print(info) # {'name': 'lsj'}#
#print(res) # lsj
## 4.2 如果key沒有則添加，返回字典中key對應的值#info={}#res=info.setdefault('name','lsj')#print(info) # {'name': 'lsj'}#print(res) # lsj
（3）字典的使用：
#字典dict
"""特點:鍵值對存儲的數據,表面上有序,實際上無序
語法: dictvar = {鍵1:值1,鍵2:值2,鍵3:值3 ... }"""#2.獲取字典當中值
res = dictvar["middle"]print(res)#3.修改字典當中的值
dictvar["bottom"] = "后裔"
print(dictvar)
8、集合類型：set()
（1）集合的作用：（1）去重（有一定的局現性）。（2）關系運算。所謂關系是：交、差、并、補。
（2）集合的定義：在{}內用逗號分隔開多個元素，多個元素滿足以下三個條件
1. 集合內元素必須為不可變類型
2. 集合內元素無序
3. 集合內元素沒有重復
#定義一個集合#s={1,2} # 本質是s=set({1,2})#print(s)#注意1：列表類型是索引對應值，字典是key對應值，均可以取得單個指定的值，#而集合類型既沒有索引也沒有key與值對應，所以無法取得單個的值，#而且對于集合來說，主要用于去重與關系元素，根本沒有取出單個指定值這種需求。
#注意2:{}既可以用于定義dict，也可以用于定義集合，但是字典內的元素必須是key:value的格式，#現在我們想定義一個空字典和空集合，該如何準確去定義兩者?#定義空字典
d = {} #默認是空字典
print(d,type(d)) #{} #定義空集合
s = set() #這才是定義空集合
print(s,type(s)) #set()
#集合的幾個特點：#1、集合內元素必須為不可變類型#2、集合內元素無序#3、集合內元素不能重復，輸出的結果會在自動去重#s={1,[1,2]} # 集合內元素必須為不可變類型，否則報錯：TypeError: unhashable type: 'list'#s={1,'a','z','b',4,7} # 集合內元素無序#print(s) # {1, 4, 7, 'a', 'z', 'b'}#s={1,1,1,1,1,1,'a','b'} # 集合內元素沒有重復#print(s) # 得到結果自動去重{1, 'a', 'b'}
#3、類型轉換:但凡能被for循環的遍歷的數據類型
#強調：遍歷出的每一個值都必須為不可變類型,都可以傳給set()轉換成集合類型
#s = set({1,2,3})
#print(s) # {1, 2, 3}
#set():字符串轉換成集合
#res=set('hellolllll')
#print(res) # {'o', 'e', 'h', 'l'}
#集合中的每一個值都必須為不可變類型，否則報錯
#print(set([1,1,1,1,1,1])) # {1}
#print(set([1,1,1,1,1,1,[11,222]])) # 報錯 TypeError: unhashable type: 'list'
#使用set()字典轉換成集合，得出的結果是字典key的集合
#print(set({'k1':1,'k2':2})) # {'k1', 'k2'}
#4、內置方法
#=========================關系運算符=========================
#friends1 = {"zero","kevin","jason","egon","lsj"}
#friends2 = {"Jy","ricky","jason","egon","lsj"}
#4.1 取交集&和intersection()效果同：兩者共同的好友
#res = friends1 & friends2
#print(res) # {'jason', 'egon', 'lsj'}
#print(friends1.intersection(friends2)) #{'jason', 'egon', 'lsj'}
#4.2 取并集/合集,|和union()功能同：兩者所有的好友
#print(friends1 | friends2)
#print(friends1.union(friends2))
#{'zero', 'kevin', 'lsj', 'ricky', 'Jy', 'jason', 'egon'}
#4.3 取差集，-和difference()功能同，但是前后有順序：取friends1獨有的好友
#print(friends1 - friends2) # {'zero', 'kevin'}
#print(friends1.difference(friends2)) # {'zero', 'kevin'}
#取差集有順序區分，取friends2獨有的好友
#print(friends2 - friends1) # {'Jy', 'ricky'}
#print(friends2.difference(friends1)) # {'Jy', 'ricky'}
#4.4 對稱差集^和symmetric_difference()功能同: 求兩個用戶獨有的好友們（即去掉共有的好友）
#print(friends1 ^ friends2) # {'kevin', 'ricky', 'Jy', 'zero'}
#print(friends1.symmetric_difference(friends2)) # {'kevin', 'ricky', 'Jy', 'zero'}
#4.5 父子集 > ,<：包含的關系
#s1={1,2,3}
#s2={1,2,4}
#不存在包含關系，下面比較均為False
#print(s1 > s2) # False
#print(s1 < s2) # False
#s1={1,2,3}
#s2={1,2}
#print(s1 > s2) # True 當s1大于或等于s2時，才能說是s1是s2他爹
#總結>和issuperset()功能同，<和issubset()功能同
#print(s1.issuperset(s2)) # True
#print(s2.issubset(s1)) # s2 < s1 =>True
#== 互為父子
#s1={1,2,3}
#s2={1,2,3}
#print(s1 == s2) # True s1與s2互為父子
#print(s1.issuperset(s2)) # True
#print(s2.issuperset(s1)) # True
#=========================去重=========================
#1、只能針對不可變類型去重
#print(set([1,1,1,1,2])) # {1, 2}
#2、無法保證原來的順序
#l=[1,'a','b','z',1,1,1,2]
#l=list(set(l))
#print(l) # [1, 2, 'z', 'a', 'b']
#使用for循環創建一個新的列表，要求不能有重復數據#l=[#{'name':'lili','age':18,'sex':'male'},#{'name':'jack','age':73,'sex':'male'},#{'name':'tom','age':20,'sex':'female'},#{'name':'lili','age':18,'sex':'male'},#{'name':'lili','age':18,'sex':'male'},#]#new_l=[]#for dic in l:#if dic not in new_l:#new_l.append(dic)#print(new_l)
"""[{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'jack', 'age': 73, 'sex': 'male'},
{'name': 'tom', 'age': 20, 'sex': 'female'}]"""
#其他操作#'''## 1.集合的長度len()#s={'a','b','c'}#print(len(s)) # 3#
## 2.成員運算#print('c' in s) # True#
## 3.循環#for item in s:#print(item)#"""#b#a#c#"""
#其他內置方法#s={1,2,3}#需要掌握的內置方法1：discard#s.discard(4) # 刪除元素不存在do nothing#print(s.discard(4)) # 返回None#s.remove(4) # 刪除元素不存在則報錯 KeyError: 4
## 需要掌握的內置方法2：update#s.update({1,3,5})#print(s) # {1, 2, 3, 5}
#需要掌握的內置方法3：pop()隨機刪除#res=s.pop()#print(res) # 1
#需要掌握的內置方法4：add()無則加之#s.add(4)#print(s) # {1, 2, 3, 4}#s.add(3) # 有則不報錯#print(s) # {1, 2, 3}
#s={1,2,3}#判斷兩個集合是否完全獨立（這里完全指的是沒有共同元素）#res=s.isdisjoint({3,4,5,6}) # 兩個集合完全獨立、沒有共同部分，返回True#print(res) # 有一個相同元素則返回False#差集并跟新原集合#res = s.difference_update({3,4,5}) # s=s.difference({3,4,5})#print(res)#s=s.difference({3,4,5})#print(s) # {1, 2}
9、元組類型：tuple()
（1）元組的作用：按照索引/位置存放多個值，只用于讀不用于改
（2）元組的定義：（）內用逗號分隔開多個任意類型的元素
#t=(1,1.3,'aa') # t=tuple((1,1.3,'aa'))#print(t,type(t)) # (1, 1.3, 'aa')
（3）元組的使用：
#x=(10) # 單獨一個括號代表包含的意思#print(x,type(x)) # 10
#t=(10,) # 如果元組中只有一個元素，必須加逗號#print(t,type(t)) # (10,)
#t=(1,1.3,'aa') # t=(0->值1的內存地址,1->值1.3的內存地址,2->值'aaa'的內存地址，)## t[0]=11111 # TypeError: 'tuple' object does not support item assignment#print(t) # (1, 1.3, 'aa')
#t=(1,[11,22]) # t=(0->值1的內存地址,1->值[1,2]的內存地址，)#print(id(t[0]),id(t[1])) # 8791464990368 6880704#t[0]=111111111 # 不能改，報錯#t[1]=222222222 # 不能改，報錯#
#t[1][0]=11111111111111111#print(t) # (1, [11111111111111111, 22])#print(id(t[0]),id(t[1])) # 8791464990368 31391424
#3、類型轉換#print(tuple('hello')) #字符串轉換成元組 ('h', 'e', 'l', 'l', 'o')#print(tuple([1,2,3])) #列表轉換成元組(1, 2, 3)#print(tuple({'a1':111,'a2':333})) # 字典轉換成元組('a1', 'a2')
#4、內置方法#優先掌握的操作：#1、按索引取值(正向取+反向取)：只能取，不能改#t=('aa','bbb','cc')#print(t[0]) # aa#print(t[-1]) # cc#
##2、切片(顧頭不顧尾，步長)#t=('aa','bbb','cc','dd','eee')#print(t[0:3]) # ('aa', 'bbb', 'cc')#print(t[::-1]) # ('eee', 'dd', 'cc', 'bbb', 'aa')
#3、長度len()#t=('aa','bbb','cc','dd','eee')#print(len(t)) # 5#4、成員運算in和not in#t=('aa','bbb','cc','dd','eee')#print('aa' in t) # True#print('ee' in t) # False#print('f' not in t) # True#print('eee'not in t) # False
#5、循環#t=('aa','bbb','cc','dd','eee')#for x in t:#print(x)#"""#aa#bbb#cc#dd#eee#"""#6、index()，按值取出索引#t=(2,3,111,111,111,111)## print(t.index(111)) # 2#print(t.index(1111111111)) # 按參數去出索引，不存在則報錯，ValueError: tuple.index(x): x not in tuple
#7、count() # 按參數統計個數#t=(2,3,111,111,111,111)#print(t.count(111)) # 4
二、數據類型轉換
1、數據類型轉換
（1）int可以將由純整數構成的字符串直接轉換成整型，若包含其他任意非整數符號，則會報錯
i_num = "123"
print(i_num,type(i_num)) #123
res =int(i_num)print(res,type(res)) #123
i_num = "123.4adf" # 錯誤演示：字符串內包含了非整數符號.
print(i_num,type(i_num)) #123.4adf
res =int(i_num)print(res,type(res))
輸出
res=int(i_num)
ValueError: invalid literalfor int() with base 10: '123.4adf'
（2）進制轉換
#進制轉換#十進制轉換成其他進制
x = 20
print(x,type(x)) #20 #十進制轉換成二進制
print(bin(20),type(bin(20))) #0b10100
#十進制轉換成八進制
print(oct(20),type(oct(20))) #0o24 #十進制轉換成十六進制
print(hex(20),type(hex(20))) #0x14
#其他進制轉換成十進制#二進制轉換成十進制
print(int("0b10100",2)) #20#八進制轉換成十進制
print(int("0o24",8)) #20#十六進制轉換成十進制
print(int("0x14",16)) #20
（3）float同樣可以用來做數據類型的轉換
f = '12.34'
print(f,type(f)) #12.34
res =float(f)print(res,type(res)) #12.34
數據類型的總結
總結
以上是生活随笔為你收集整理的python固定数据类型_Python的数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： bat修改文件内容_在win10系统中一
- 下一篇： 在将varchar值id转换为int时失