Python中分為六種基本數(shù)據(jù)類型

• 不可變類型（又叫靜態(tài)數(shù)據(jù)類型，沒有增刪改操作）：數(shù)字(number)、字符串(string)、元組(tuple)
• 可變類型（又叫動態(tài)數(shù)據(jù)類型，支持增刪改操作）：列表(list)、字典(dictionary)、集合(set)

1. 數(shù)字類型(numbers)：

數(shù)字類型下還可分為整數(shù)(int)、浮點數(shù)(float)、復(fù)數(shù)(complex)、布爾(bool)

age = 22        # 整數(shù)型，可以通過print(sys.maxsize)查看最大取值范圍
print(age)      # 輸出：22

weight = 116.65 # 浮點型
print(weight)   # 輸出：116.65

c1 = 1 + 2j
c2 = 2 + 3j
print(c1+c2)    # 輸出：(3+5j)，復(fù)數(shù)在實際工作中幾乎用不到，請自行了解
print(complex(2,1)) # 輸出：(2+1j)


print(True == 1)  # 輸出：True
print(False == 0) # 輸出：True
# True==1，F(xiàn)alse==0 ，因此True 和 False 可以和數(shù)字相加
print(True + 1)   # 輸出：2
print(False - 2)  # 輸出：-2

# ↓其實布爾型就是整數(shù)型的子類，可以使用內(nèi)置函數(shù)issubclass()判斷，該函數(shù)是用于判斷一個類型對象是否是另一個類型對象的子類
print(issubclass(bool, int)) # 輸出：True

2. 字符串類型(string)

字符串必須使用''或""括起來，對于特殊字符可以使用反斜杠\進(jìn)行轉(zhuǎn)義，用+拼接多個字符串， 用*復(fù)制字符串，字符串還支持索引截取(又叫切片)

name = "ZhangSan"   # 字符串型，也可以使用單括號
print(name)         # 輸出：ZhangSan
print(name * 2)    # 輸出字符串兩次，也可以寫成 print (2 * name)，輸出：ZhangSanZhangSan
print(name +'-123')# 拼接字符串，輸出：ZhangSan-123
print(name +'\'123\'')# 拼接字符串并將單引號轉(zhuǎn)義，輸出：ZhangSan'123'

print(name[0:-1])  # 輸出第一個至倒數(shù)第二個的字符，截取時顧頭不顧尾，輸出：ZhangSa
print(name[0])     # 輸出第一個字符，輸出：Z
print(name[-1])    # 輸出最后一個字符，輸出：n
print(name[2:])    # 輸出從第三個開始之后的所有字符，輸出：angSan
print(name[0:-1:2]) # 輸出第一個至倒數(shù)第二個的字符，步長為2，輸出：Zaga
print(name[8])		# 若字符不存在，則會拋出IndexError: string index out of range

3. 列表(list)

列表是一組可重復(fù)且有序的數(shù)據(jù)集合，任何類型的數(shù)據(jù)都可以存到列表中，會根據(jù)需要動態(tài)分配和回收內(nèi)存，是Python中使用最頻繁的數(shù)據(jù)類型，列表同樣也支持索引截取(又叫切片)，列表中的元素是可變的，能夠進(jìn)行增刪改操作

• 列表創(chuàng)建

  l0 = []	# 創(chuàng)建空列表
  l1 = ["張三",'lisi',12,["22","lisi","王武"],"趙柳"]  # 直接使用中括號創(chuàng)建列表
  l2 = list(['lisi',12,("22","王武"),"趙柳"])  		# 或者調(diào)用內(nèi)置函數(shù)list()，通常用于轉(zhuǎn)換為列表時使用
  

• 獲取列表中的元素

  print(l1[1])        # 獲取列表l1中第二個元素，輸出：lisi
  print(l1[0:2])      # 獲取列表l1中第一個和第二個元素，輸出：['張三', 'lisi']
  print(l1[-5:-2])    # 獲取列表l1中第一個至倒數(shù)第三個數(shù)據(jù)，反向索引，輸出：['張三', 'lisi', 12]
  print(l1[2:-1])     # 獲取列表l1中第三個至倒數(shù)第二個元素，輸出：[12, ['22', 'lisi', '王武']]
  print(l1[1::2])     # 獲取列表l1中第二個至最后一個元素，步長為2，輸出：['lisi', ['22', 'lisi', '王武']]
  print(l1[:1:-2])    # 反向獲取列表l1中元素，步長為-2，輸出：['趙柳', 12]
  print(l1[::-1])     # 步長為-1時表示倒序排列元素，輸出：['趙柳', ['22', 'lisi', '王武'], 12, 'lisi', '張三']
  print(l1[3][0])     # 獲取l1嵌套列表(即第四個元素)中的第一個元素，輸出：22
  print(l1[3][-1])    # 獲取l1嵌套列表(即第四個元素)中的最后一個元素，輸出：王武
  print(l1[5])		# 若元素不存在，則會拋出IndexError: list index out of range
  
  for i in l1:		# 使用for循環(huán)遍歷列表中的元素
      print(i)		# 遍歷元素后的操作，比如輸出結(jié)果
  

• 判斷元素是否在列表中

  print("lisi" in l1)     # 判斷l(xiāng)1列表中包含“l(fā)isi”，輸出：True
  print("趙柳" not in l1)  # 判斷l(xiāng)1列表中不包含“趙柳”，輸出：False
  print("22" in l1[3])    # 判斷l(xiāng)1嵌套列表中包含“22”，輸出：True
  print("王武" not in l1)  # 判斷l(xiāng)1列表中不包含“王武”，輸出：True
  

• 列表排序

  li = [22,18,9,-2,0,6]	# 對于需要排序的列表，元素類型必須一致，比如：元素統(tǒng)一為數(shù)字類型或字符串類型
  li.sort()				# 調(diào)用sort()方法，默認(rèn)從小到大排序
  li.sort(reverse=True)	# 指定reverse=True后列表會進(jìn)行降序排列
  # ↓還可以調(diào)用內(nèi)置函數(shù)sorted()進(jìn)行排序，此方式不會改變原列表
  sorted(li)				# 從小到大排序
  sorted(li,reverse=True)	# 同樣指定reverse=True后列表會進(jìn)行降序排列
  

• 修改列表中的元素

  l1[1]="李思"			   # 將l1列表中第二個元素改為李思
  l1[3][0] = 22			# l1嵌套列表中的第一個元素改為22
  l1[1:3]= ["張珊","李思"]  # 將l1列表中第二個和第三個值改為張珊和李思
  

• 列表中添加元素

  l3 = [1,2]
  l4 = ["壹","er"]
  l3.append(3)		# 在l3列表末尾添加元素3，輸出：[1, 2, 3]
  l3.append(l4)		# 將l4列表添加到l3列表末尾，輸出：[1, 2, ['壹', 'er']]
  l3.extend("3L")		# 在l3列表末尾至少添加兩個元素，輸出：[1, 2, '3', 'L']
  l3.extend(l4)		# 將l4列表添加到l3列表末尾，等同于l3+l4，輸出：[1, 2, '壹', 'er']
  l3.insert(1,"張珊")  # 在l3列表中索引為1的位置插入元素，輸出：[1, '張珊', 2]
  l3.insert(0,l4)		# 將l4列表添加到l3列表頭部，輸出：[['壹', 'er'], 1, 2]
  

  注意三者的區(qū)別：

  • append()：指在列表的末尾添加一個元素，新元素會視為一個整體追加到列表末尾
  • extend()：指在列表的末尾至少添加一個元素，新元素會將整體中的每個元素一個一個地追加列表末尾
  • insert()：指在列表的指定索引位置添加元素

• 刪除列表中的元素

  l1.remove("張珊")		# 刪除指定元素，一次只能刪除一個元素，若出現(xiàn)重復(fù)元素則只刪除第一個
  l1.remove("菡菡")		# 若元素不存在，則拋出ValueError: list.remove(x): x not in list
  l1.pop(1)			# 刪除指定索引位置上的元素，若不指定索引則默認(rèn)刪除最后一個元素
  l1.pop(8)			# 若索引不存在，則拋出IndexError: pop index out of range
  l1.clear()			# 清空l1列表
  del l1				# 刪除l1列表
  

4. 元組(tuple)

元組也是一組可重復(fù)且有序的對象集合，任何類型的數(shù)據(jù)都可以存到元組中，但是元組中的元素是不可變的，元組同樣也支持索引截取(又叫切片)

• 創(chuàng)建元組

  t0 = ()		# 創(chuàng)建空元組
  t1 = ("張珊","lisi",["李思",12,"Python"],("王武","22"))	# 直接使用小括號創(chuàng)建元組
  t2 = (1,)						# 當(dāng)元組只有一個元素時需要在后面加上逗號
  t3 = tuple(("依兒",22,"Java"))   # 或者調(diào)用內(nèi)置函數(shù)tuple()，通常用于轉(zhuǎn)換為元組時使用
  

• 獲取元組中的元素

  print(t1[1])        # 獲取元組t1中第二個元素，輸出：lisi
  print(t1[0:2])      # 獲取元組t1中第一個和第二個元素，輸出：('張珊', 'lisi')
  print(t1[2:-1])     # 獲取元組t1中第三個至倒數(shù)第二個元素，輸出：(['李思', 12, 'Python'],)
  print(t1[1::2])     # 獲取元組t1中第二個至最后一個元素，步長為2，輸出：('lisi', ('王武', '22'))
  print(t1[::-1])     # 步長為-1時表示倒序排列，輸出：(('王武', '22'), ['李思', 12, 'Python'], 'lisi', '張珊')
  print(t1[2][0:-1]) 	# 獲取元組t1中第三個元素中的第一個至倒數(shù)第二個元素，輸出：['李思', 12]
  
  for i in t1:		# 使用for循環(huán)遍歷元組中的元素
      print(i)		# 遍歷元素后的操作，比如輸出結(jié)果
  

• 修改元組中的可變對象

  # 修改元組t1中列表中的元素
  t1[2][1] = "十"		   # 將12改為10
  t1[2].remove("Python")  # 刪除Python元素
  t1[2].pop()				# 刪除最后一個元素
  t1[2].clear()			# 清空列表
  t1[2].append("啊哈")	   # 添加一個元素
  # 拼接元組
  print(t2+t3)			# 輸出：('1', '依兒', 22, 'Java')
  

  注意：元組中存儲的是對象的引用，若對象本身不可變則不可再引用其它對象（比如元組t2和t3，元素都是不可修改的），若對象本身可變則可變對象的引用不可改變，但是對象中的數(shù)據(jù)可以改變（比如t1中的列表，該列表不可刪除，但可以修改列表中的元素）

5. 字典(dictionary)

字典是一組可變的無序的對象集合，字典中的元素是通過鍵(Key) : 值(Value)來保存的，一組鍵值對稱為一個元素，其中鍵(Key)不可重復(fù)，必須唯一，而值(Value)是可重復(fù)的，字典會浪費較大內(nèi)存，是一種使用空間換時間的數(shù)據(jù)類型

• 創(chuàng)建字典

  d0 = {}		# 創(chuàng)建空字典
  d1 = {"張珊":100,"李思":120,"王武":110}	# 使用花括號創(chuàng)建字典
  d2 = dict(name="李爾",weight=116)		   # 調(diào)用內(nèi)置函數(shù)dict()創(chuàng)建，通常用于轉(zhuǎn)換為字典時使用
  

• 獲取字典中的元素

  print(d1["李思"])			# 使用中括號根據(jù)Key獲取Value值，輸出：120
  print(d1["張三"])			# 若Key不存在，則拋出KeyError: '張三'
  
  # ↓還可以使用get()方法取值，此方式若Key不存在則返回None，不會拋出KeyError異常，還可以設(shè)置默認(rèn)Value
  print(d1.get("張珊"))		# 使用get()方法取值，輸出：100
  print(d1.get("王武",98))	# 若對應(yīng)Key不存在則輸出默認(rèn)值，否則輸出對應(yīng)的Value值，此處輸出：110
  
  # ↓使用keys()方法獲取所有Key
  print(d1.keys())		 # 獲取字典中所有的Key，輸出：dict_keys(['張珊', '李思', '王武'])
  print(list(d1.keys()))	 # 獲取字典中所有的Key并轉(zhuǎn)為列表，輸出：['張珊', '李思', '王武']
  print(tuple(d1.keys()))	 # 獲取字典中所有的Key并轉(zhuǎn)為元組，輸出：('張珊', '李思', '王武')
  
  # ↓使用values()方法獲取所有Value值
  print(d1.values())		 # 獲取字典中所有的Value值，輸出：dict_values([100, 120, 110])
  print(list(d1.values())) # 獲取字典中所有的Value值并轉(zhuǎn)為列表，輸出：[100, 120, 110]
  print(tuple(d1.values()))# 獲取字典中所有的Value值并轉(zhuǎn)為元組，輸出：(100, 120, 110)
  
  # ↓使用items()方法獲取所有的鍵值對
  print(d1.items())		 # 獲取字典中所有的Key:Value，輸出：dict_items([('張珊', 100), ('李思', 120), ('王武', 110)])
  print(list(d1.items()))	 # 獲取字典中所有的Key:Value并轉(zhuǎn)為列表，輸出：[('張珊', 100), ('李思', 120), ('王武', 110)]
  print(tuple(d1.items())) # 獲取字典中所有的Key:Value并轉(zhuǎn)為元組，輸出：(('張珊', 100), ('李思', 120), ('王武', 110))
  
  for item in d1:			 # 使用for循環(huán)遍歷字典中的元素
      print(item)			 # 返回字典中所有的Key
  

• 判斷字典中是否存在指定的Key

  print("李思" in d1)		# 判斷d1字典中存在Key"李思"，輸出：True
  print("王武" not in d1)	# 判斷d1字典中不存在Key"王武"，輸出：False
  

• 字典中元素的增刪改

  d1["李思"] = 118		# 若Key存在，則修改對應(yīng)的Value值，原李思對應(yīng)的value值變?yōu)?18
  d1["張三"] = 106		# 若Key不存在，則新增鍵值對，字典中新增'張三': 106
  d1.pop("張三")		# 刪除Key為“張三”的鍵值對
  d1.pop("張鳳")		# 必須傳入一個Key，若Key不存在，則拋出KeyError: '張鳳'
  del d1["張三"]		# 同樣也是刪除Key為“張三”的鍵值對
  d1.clear()			 # 清空字典
  del d1				 # 刪除字典
  

6. 集合(set)

集合是一組可變的、無序的且不可重復(fù)的元素序列，可以理解為是沒有Value值得字典，基本功能是測試元素之間的關(guān)系和刪除重復(fù)元素，比如：共同好友、你可能認(rèn)識的人、關(guān)注TA的人還關(guān)注了…等

• 創(chuàng)建集合

  s0 = set()						 # 創(chuàng)建空集合，不能直接使用花括號，花括號默認(rèn)是創(chuàng)建字典
  s1 = {"李思","張珊","李思","王武"}	# 花括號中元素非鍵值對時，創(chuàng)建的是集合
  s2 = set("李爾")					# 調(diào)用內(nèi)部函數(shù)set()創(chuàng)建，通常用于轉(zhuǎn)換為集合時使用
  

• 獲取集合中的元素

  # ↓若集合中存在相同的元素，只會出現(xiàn)輸出一個，因為集合是無序的，所以每次輸出結(jié)果順序可能不一致
  print(s1)		# 獲取集合s1中所有的元素，輸出：{'李思', '王武', '張珊'} 
  for i in s1:	# 通過for循環(huán)獲取集合中的元素
      print(i)	# 同樣重復(fù)元素只返回一個
  # ↓集合中的某一個元素是不能直接獲取的，可以先轉(zhuǎn)換為列表，然后使用列表方式獲取元素
  ls = list(s1)	# 將集合s1轉(zhuǎn)換為列表
  print(ls[1])    # 獲取列表l1中第二個元素，輸出：李思
  print(ls[0:2])  # 獲取列表l1中第一個和第二個元素，輸出：['王武', '李思']
  ……
  

• 判斷元素是否存在

  print("李思" in s1)		# 判斷s1集合中存在"李思"，輸出：True
  print("王武" not in s1)	# 判斷s1集合中不存在"王武"，輸出：False
  

• 集合中添加、更新元素

  s1.add("趙柳")		# 添加一個元素，因為集合是無序的，所以元素位置隨機
  # update也可以理解為新增，當(dāng)存在相同元素時，相同元素會被覆蓋，不同元素會新增到集合中
  s1.update("張三")		# 集合中會添加兩個元素，‘張’、‘三’
  s1.update("張三豐")   # 集合中會更新兩個元素，‘張’和‘三’，新增一個元素‘豐’
  

• 刪除集合中的元素

  s1.remove("李思")		# 刪除s1集合中的元素“李思”，若元素不存在，則拋出KeyError: '李思'
  s1.discard("張三")	# 刪除s1集合中的元素“張三”，若元素不存在，不會拋出任何異常
  s1.pop()			# 隨機刪除任意一個元素
  s1.clear()			# 清空集合中的元素
  del s1				# 刪除集合
  

• 判斷兩個集合是否相等

  print(s1 == s2)		# 輸出：False
  print(s1 != s2)		# 輸出：True
  

• 判斷兩個集合的關(guān)系文章來源地址http://www.zghlxwxcb.cn/news/detail-444631.html

  s3 = {"李思","張珊","李思","王武","Andy"}
  s4 = {"李四","張珊","張三","王武"}
  s5 = {"Andy"}
  
  # ↓當(dāng)s5中所有的元素s3里都有，但s5中的元素s3中未必有，則s3就是s5的超級，反之s5就是s3子集
  print(s3.issuperset(s5))	# 判斷s3是否是s5的超集，輸出：True，因為s3中有s5所有的元素
  print(s5.issubset(s3))		# 判斷s5是否是s3的子集，輸出：True，因為s5中的所有元素s3中都有
  print(s3.isdisjoint(s4))	# 判斷s3和s4兩個集合是否沒有交集，輸出：False，因為兩個集合中都有"張珊"和"王武"，存在交集
  
  print(s3.intersection(s4))	# 輸出s3和s4交集(即二者都有)的元素，輸出：{'張珊', '王武'}
  print(s3 & s4)				# 與intersection()等價，交集的一種符號表示法
  
  print(s3.union(s4))			# 輸出s3和s4并集(即去掉二者都有)的元素，輸出：{'李思', '張三', '王武', '李四', '張珊', 'Andy'}
  print(s3 | s4)				# 與union()等價，并集的一種符號表示法
  
  print(s3.difference(s4))	# 輸出s3和s4差集(即所有屬于s3但不屬于s4)的元素，輸出：{'Andy', '李思'}
  print(s3 - s4)				# 與union()等價，差集的一種符號表示法
  
  print(s3.symmetric_difference(s4))	# 輸出s3和s4對稱差集(即s3中不屬于s4和s4中不屬于s3)的元素，輸出：{'Andy', '李思', '李四', '張三'}
  print(s3 ^ s4)				# 與symmetric_difference()等價，對稱差集的一種符號表示法
  

到了這里，關(guān)于Python中的六種基本數(shù)據(jù)類型的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！