每一種計算機語言都有自己的數(shù)據(jù)類型，但大多數(shù)計算機語言的數(shù)據(jù)類型都基本一致，下來我們來看看python中的數(shù)據(jù)類型

int數(shù)字，運算

就是用來計算的，定義方式就是 ：變量名 = 數(shù)值

方法也不多，就記住 bit_length() 當十進制用二進制表示時，最少使用的位數(shù)

v = 9 #定義一種整型的數(shù)據(jù)類型

data = v.bit_length() #判斷該數(shù)值轉化為二進制需要的最小位數(shù)

print(data)

布爾值bool，判斷

布爾值就兩種：True，False。就是判斷條件的正確與否，其實所有的計算機語言都有bool值，基本一致。

真 1 True。

假 0 False。

str字符串，存儲少量的信息數(shù)據(jù)，操作簡單，便于傳輸

在python里，""(雙引號)''(單引號)都是用來標識字符串的， 字符串就是由字母數(shù)字，下劃線，其他字符組成的，用引號引起來的就是字符串，需要注意的是：字符串是有序的，從前往后是0開始，從后往前是從-1開始。

我們：我們來看一下字符串的具體用法：

字符串的索引與切片。

索引即下標，就是字符串組成的元素從第一個開始，初始索引為0以此類推。 字符串是有序的，從前往后是0開始，從后往前是從-1開始， 首個切片從0開始，即0可以省略，如果是想取到整個字符串，則可以寫為s[:]，單 個空格也是一個字符，只要是對字符串進行了操作，就會產生一個新的字符串

步長，步長為一定的數(shù)值，是有規(guī)律的取出

[起始索引: 截至索引 :步長]會有三個參數(shù)，前兩個是你取的字符串，最后一個參數(shù)，就是你每隔幾個字符串再去一個字符串

如果你想要反向取出字符串，即需要添加步長，步長為負值

s = 'Nice to meet you 999!'

print(s[2])

print(s[6])

print(s[7])

切片就是通過索引(索引：索引：步長)截取字符串的一段，形成新的字符串(但是切片的區(qū)間是半開區(qū)間，左閉右開)。

s = 'Nice to meet you 999!'

print(s[3:9])

print(s[0:-1]) #默認到最后

print(s[0:10:2]) # 反向步長

print(s[11:0:-2]) #反向加步長

print(a[0:]) #默認到最后

字符串常用方法：

關于字母的大小寫轉換

s = 'nice* to* meet you 999!'

print(s.capitalize()) #首字母大寫 Nice* to* meet you 999!

print(s.swapcase()) #大小寫翻轉 NICE* TO* MEET YOU 999!

print(s.title()) #每個單詞的首字母大寫 Nice* To* Meet You 999!

print(s.upper()) #NICE* TO* MEET YOU 999! 全部小寫轉大寫

print(s.lower()) #nice* to* meet you 999! 全部大寫轉小寫

內同居中，總長度，空白處填充

s1 = 'aaa'

print(s1.center(20, '*')) #********aaa*********

統(tǒng)計字符串中的元素出現(xiàn)的個數(shù)

s = '*nice* to* meet you 999!*'

print(s.count('e', 0, -1)) #統(tǒng)計字符串中的元素出現(xiàn)的個數(shù)。 3

去掉字符串中的特殊字符，分割

split分割,默認以空格進行分割，分割后的結果是一個列表,也可以規(guī)定以什么進行分割，也可以設置分割幾次

strip默認去除左邊的空格，換行符，tab鍵

s = '*nice* to* meet you 999!*'

print(s.split("*")) #結果變?yōu)榱肆斜?['nice', ' to', ' meet you 999!']

print(s.lstrip("*")) #nice* to* meet you 999!* #去掉左邊

print(s.rstrip("*")) #*nice* to* meet you 999! #去掉右邊

print(s.strip()) #nice to meet you 999! #都去

判斷開頭結尾，返回結果布爾值

s = '*nice* to* meet you 999!*'

print(s.startswith('k', 0, -1)) #False

print(s.endswith('9', 0, -1)) #True

尋找字符串中的元素是否存在

s = '*nice* to* meet you 999!*'

print(s.index('you', 0, -1)) # 返回的找到的元素的索引，找不到報錯。15

print(s.find('you', 0, -1)) # 15 返回的找到的元素的索引，如果找不到返回-1

replace替換

從頭開始進行替換，(字符串原有的字符串，新的替換的字符串，替換的次數(shù))

s = '*nice* to* meet you 999!*'

print(s.replace("999", "too")) #nice* to* meet you too!

is系列

s = '*nice* to* meet you 999!*'

print(s.isdigit()) #False

print(s.isalpha()) #False

print(s.isalnum()) #False

默認將一個tab鍵變成8個空格，如果tab前面的字符長度不足8個，則補全8個，

# 如果tab鍵前面的字符長度超過8個不足16個則補全16個，以此類推每次補全8個。

s = '*nice* to* meet you 999!*'

print(s.expandtabs())

join加入，形成新的字符串

print('*'.join('meet')) #m*e*e*t

tuple元組，只讀列表，不能更改數(shù)據(jù)

元組被稱為只讀列表，即數(shù)據(jù)可以被查詢，但不能被修改，所以，字符串的切片操作同樣適用于元組。以()進行定義

list列表，存放大量數(shù)據(jù)，存儲不同類型的數(shù)據(jù)，大量數(shù)據(jù)放在列表中便于操作

列表相比于字符串，不僅可以儲存不同的數(shù)據(jù)類型，而且可以儲存大量數(shù)據(jù)，32位python的限制是 536870912 個元素,64位python的限制是 1152921504606846975 個元素。而且列表是有序的，有索引值，可切片，方便取值。

列表是可變數(shù)據(jù)類型，所以可以進行增刪改查

l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]

l.append('too') #增加到最后

print(l) #['I', 'like', 'you', '*', 999, ['dear', 'love'], 'too']

l.insert(5, 'me') #按照索引去增加

print(l) #['I', 'like', 'you', '*', 999, 'me', ['dear', 'love'], 'too']

l.extend('abc') #迭代的去增，將里面的元素分開(里面的元素是以逗號進行分割，列表，是#將列表的每一個元素分別以一個元素進行添加)

print(l) #['I', 'like', 'you', '*', 999, 'me', ['dear', 'love'], 'too', 'a', 'b', 'c']

增

#改 按照索引修改,即只是把該索引的位置重新賦值，覆蓋之前的數(shù)據(jù)

l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]

l[1] = 'love'

print(l) #['I', 'love', 'you', '*', 999, ['dear', 'love']]#按照切片修改

l[:3] = 'w'#但是這個方式，只是把第一個索引的位置修改

print(l) #['w', '*', 999, ['dear', 'love']]

l[:3] = ['I','very', 'love', 'you']#這樣就可以把這些索引的位置可以修改了

print(l) #['I', 'very', 'love', 'you', ['dear', 'love']]

改

l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]#循環(huán)去查。

for i inl :print(i)#切片去查

print(l[0])print(l[2:3])print(l[1:9:2]) #['like', '*', ['dear', 'love']]

print(l[9:0:-2]) #[['dear', 'love'], '*', 'like']

查

l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]#刪 li.pop() 按照索引刪除,默認刪除最后一個，返回的刪除的內容

l.pop(2)print(l) #['I', 'like', '*', 999, ['dear', 'love']]#remove 刪除某部分內容,默認刪除一個相對應的元素

l.remove('*')print(l) #['I', 'like', 999, ['dear', 'love']]#del也可以進行切片刪除

del l[1:3]print(l)#['I', ['dear', 'love']]#clear清空內容，但是列表還是存在的

l.clear()print(l)#[]#del刪除列表，即把列表全部刪除，列表也將不存在

dellprint(l) #NameError: name 'l' is not defined

刪

其他操作

count(數(shù))(方法統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù))

l = ['I', 'like', 'you', '*']

print(l.count('you'))

index(方法用于從列表中找出某個值第一個匹配項的索引位置)

l = ['I', 'like', 'you', '*']

print(l.index('like'))

sort (方法用于在原位置對列表進行排序)，這個只是字符串類型，里面不能有列表或整形。

l = ['I', 'like', 'you', '*']

l.sort()

print(l)

reverse (方法將列表中的元素反向存放)，這個只是字符串類型，里面不能有列表或整形。

l = ['I', 'like', 'you', '*']

l.reverse()

print(l)

len長度，這個列表的長度

l = ['I', 'like', 'you', '*']

print(len(l))

dict字典，存儲關系型數(shù)據(jù)，以鍵值對的方式存在，查詢數(shù)據(jù)非常快，以二分法進行查找以{}進行定義，

字典是python中唯一的映射類型，采用鍵值對(key-value)的形式存儲數(shù)據(jù)。python對key進行哈希函數(shù)運算，根據(jù)計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數(shù)字、字符串、元組。

字典的值可以是任意數(shù)據(jù)類型，哈希：每一個數(shù)據(jù)都有唯一的對應的哈希值。

數(shù)據(jù)類型分類：

可變數(shù)據(jù)：list dict set

不可變數(shù)據(jù)：int bool str tuple

字典(dictionary)是除列表意外python之中最靈活的內置數(shù)據(jù)結構類型。列表是有序的對象結合，字典是無序的對象集合。兩者之間的區(qū)別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

字典的順序：

3.5之前，字典是無序的

3.6開始，字典在創(chuàng)建的時候是有序的，按照一定的順序創(chuàng)建，看起來是有序的

dic = {'name': 'cat', 'age': 2, 'hobby': 'fish'}

dic['dream'] = 'haapy'

print(dic) #以覆蓋的形式，有則覆蓋 ，無則添加#setdefault,但默認添加的鍵所對應的值是none,無則添加，有則不變

dic.setdefault('like', 'mmd')print(dic)

dic.setdefault('like', 'dear')print(dic)

增

dic = {'name': 'cat', 'age': 2, 'hobby': 'fish'}

dic1= {'addr': '海邊'}

dic.update(dic1)#{'hobby': 'fish', 'age': 2, 'name': 'cat', 'addr': '海邊'}

改

dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}print(dic['name']) #如果沒有該鍵，則會報錯

print(dic.get('name'))#如果沒有該鍵的話，就會返回none

for key indic:print(key +dic[key])for k, v indic.items():print(k, v)print(dic.items())

查

dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}

dic.pop('hobby') #pop根據(jù)key刪除鍵值對，并返回對應的值，如果沒有key則返回默認返回值

print(dic)

dic.popitem()#隨機刪除字典中的某個鍵值對，將刪除的鍵值對以元祖的形式返回

print(dic)

dic.clear()#清空字典

print(dic)del dic

刪

其他操作：

dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}

item=dic.items()print(item,type(item))#這個類型就是dict_items類型，可迭代的，#dict_items([('name', 'cat'), ('age', '2'), ('hobby', 'fish')])

keys=dic.keys()print(keys, type(keys))#dict_keys(['name', 'age', 'hobby'])

values=dic.values()print(values, type(values))#dict_values(['cat', '2', 'fish'])

set集合

按有序無序分類

數(shù)字

字符串

集合：無序，即無序存索引相關信息

元組：有序，需要存索引相關信息，不可變

列表：有序，需要存索引相關信息，可變，需要處理數(shù)據(jù)的增刪改

字典：無序，需要存key與value映射的相關信息，可變，需要處理數(shù)據(jù)的增刪改

其他(for，enumerate，range)

for循環(huán)：用戶按照順序循環(huán)可迭代對象的內容。for循環(huán)就是來迭代那些可迭代的對象的。

msg = '老男孩python是全國范圍內最好的python培訓機構'

for item in msg:

print(item)

li = ['alex','銀角','女神','egon','太白']

for i in li:

print(i)

dic = {'name':'太白','age':18,'sex':'man'}

for k,v in dic.items():

print(k,v)

enumerate：枚舉，對于一個可迭代的(iterable)/可遍歷的對象(如列表、字符串)，enumerate將其組成一個索引序列，利用它可以同時獲得索引和值。

li = ['alex','銀角','女神','egon','太白']

for i in enumerate(li):

print(i)

for index,name in enumerate(li,1):

print(index,name)

for index, name in enumerate(li, 100): # 起始位置默認是0，可更改

print(index, name)

range：指定范圍，生成指定數(shù)字。

for i in range(1,10):

print(i)

for i in range(1,10,2): # 步長

print(i)

for i in range(10,1,-2): # 反向步長

print(i)

總結

以上是生活随笔為你收集整理的在python中print表示的数据类型是_python之数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。

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