一、基本數據類型

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的数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。