# 數據類型分為可變數據類型和不可變數據類型
    # 可變數據類型：list、set、dict 不可哈希
    # 不可變數據類型：str、int、bool、tuple(元祖) 可哈希

基本類型和數據集

基本類型

int

數字型：int 1,2,3,56
取值範圍為：-2\*\*31~2**31-1
可以進行的運算：+ - * / **(冪次方) %(取余)
type() 查看數據類型

str

字符串：str

python中只要是用引號引起來的全是字符串

字符串轉化成數字的條件: 字符串必須全是數字 int(str)

數字轉化成字符串：str(int)

字符串可以相加：就是字符串的拼接

a = ‘我愛‘
b =  ‘中國‘
print(a+b)

字符串可以相乘：str*int

a = ‘堅強‘
b = 8 
print(a*b)

字符串的換行：‘‘‘內容‘‘‘ 或者 """內容"""

msg = ‘‘‘
 鵝 鵝 鵝
 白毛浮綠水
 紅掌波清波
 曲項向天歌
‘‘‘
print(msg)

字符串的索引和切片

s = ‘jokerORroot‘
s1 = s[0]  # 索引
s2 = s[0:2] # [首:尾] 切片  顧頭不顧尾
s3 = s[0:4:2] # [首:尾:步長] 有規律的去 

# 倒著取
s = ‘jokerORroot‘
s1 = s[::-1]  #倒著取全
print(s1)
s2 = s[:2:-1]
print(s2)
s3 = s[3::-2]
print(s3)
s4 = s[3:1:-2]
print(s4)
s5 = s[3:1:-1]
print(s5)

運行結果為：
toorROrekoj
toorROre
eo 
e
ek
 

常見字符串的操作方法

bool

bool：布爾值 True False
0 空集合 空字典 空列表 空字符串 -->False 非空即為True

float

float：浮點型 1.0 2.12

數據集

list

基本語法格式

Lst = [‘item1‘,‘item2‘,‘item3‘,...,num1,num2..,,[],{}]
list()  # 強制轉化成list類型

list方法

增

• append(追加在最後)

li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
li.append(‘jooker‘)
li.append(‘root‘)
print(li)
運行結果為：
[‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘, ‘taibai‘, ‘jooker‘, ‘root‘]

• insert(插入，在索引的位置加入)

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  li.insert(4,‘jooker‘)
  print(li)
  運行結果為：
  [‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘, ‘jooker‘, ‘taibai‘]

• extend(叠代增加)

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  li.extend(‘jooker‘)
  print(li)
  運行結果為：
  [‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘, ‘taibai‘, ‘j‘, ‘o‘, ‘o‘, ‘k‘, ‘e‘, ‘r‘]

  刪

• pop(按索引去刪，有返回值，默認刪除最後一個元素)

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  li.pop() # 有返回值 默認刪除最後一個
  li.pop(1) # 指定刪除 按照索引
  print(li)
  運行結果為：
  [‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘]
  [‘alex‘, ‘egon‘, ‘女神‘, ‘taibai‘]

• remove(按元素刪)

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  li.remove(‘taibai‘)
  print(li)
  運行結果為：
  [‘alex‘, ‘wusir‘, ‘egon‘, ‘女神‘]

• clear(清空列表)

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  li.clear()
  print(li)
  運行結果為: []

• del(在內存中刪除列表，或者切片刪除列表中的元素)

li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
del li  # 刪除整個列表
print(li)
運行結果為：

li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
del li[1:3] # 切片刪除
print(li)
運行結果為：[‘alex‘, ‘女神‘, ‘taibai‘]

改

• 按照索引改(其實就是先刪除然後再添加)

li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
li[0] = ‘jooker‘
print(li)
運行結果為：[‘jooker‘, ‘wusir‘, ‘egon‘, ‘女神‘, ‘taibai‘]

• 切片改

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  li[0:4] = ‘jooker‘
  print(li)
  運行結果為：[‘j‘, ‘o‘, ‘o‘, ‘k‘, ‘e‘, ‘r‘, ‘taibai‘]

  查

• for循環遍歷查

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  for i in li:
  print(i)

• 切片查

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  print(li[1:4])

• 公共方法

  li = [‘alex‘,‘wusir‘,‘egon‘,‘女神‘,‘taibai‘]
  l = len(li)  # 獲取列表的長度
  num = li.count(‘taibai‘)  # 就算列表中指定元素出現的次數(即指定元素的個數)
  ret = li.index(‘女神‘)  # 查看元素的的索引(即列表中元素的下標) 列表只能用index 而不能用find
  li.sort()  # 正向排序 默認是按照ascii碼表順序排
  li.sort(reverse=True)  # 反向排序
  li.reverse()  # 反轉

  set

  語法格式

set1 = {‘value1‘,‘value2‘}
set() # 強制轉化成集合
# 集合的特性
    # 集合是可變的數據類型
    # 集合裏面的元素必須是不可變的數據類型
    # 集合是無序的 
    # 集合裏面的元素是不能重復的

set方法

增

• add

  set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
  set1.add(‘女神‘)
  print(set1)  # {‘alex‘, ‘女神‘, ‘egon‘, ‘ritian‘, ‘barry‘, ‘wusir‘}

• update 叠代增加(即先打散在增加)

  set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
  set1.update(‘abc‘)
  print(set1)  # {‘c‘, ‘wusir‘, ‘barry‘, ‘a‘, ‘b‘, ‘ritian‘, ‘alex‘, ‘egon‘}

  刪

• pop 隨機刪除，有返回值

set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.pop()
print(set1) # {‘egon‘, ‘barry‘, ‘alex‘, ‘wusir‘}

• remove 按元素刪

set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.remove(‘alex‘)
print(set1)  # {‘wusir‘, ‘barry‘, ‘egon‘, ‘ritian‘}

• clear 清空集合

set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.clear()
print(set1)  #set()

• del 刪除整個集合

  set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
  del set1

  查

• 只能用for循環進行遍歷查詢

set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
for i in set1:
    print(i)

交集

• &
• intersetion()

  set1 = {1,2,3,4,5}
  set2 = {2,4,6,8,10}
  set3 = set1 & set2
  print(set3)  #  {2, 4}
  set4 = set1.intersection(set2)
  print(set4)  #  {2, 4}

並集

• |
• union()

  set1 = {1,2,3,4,5}
  set2 = {2,4,6,8,10}
  set3 = set1 | set2
  print(set3)  # {1, 2, 3, 4, 5, 6, 8, 10}
  set4 = set1.union(set2)
  print(set4)  # {1, 2, 3, 4, 5, 6, 8, 10}

  反交集

• ^
• symmetric_difference()

set1 = {1,2,3,4,5}
set2 = {2,4,6,8,10}
set3 = set1 ^ set2
print(set3)  # {1, 3, 5, 6, 8, 10}
set4 = set1.symmetric_difference(set2)
print(set4)  #  {1, 3, 5, 6, 8, 10}

差集

• -
• difference()

set1 = {1,2,3,4,5}
set2 = {2,4,6,8,10}
set3 = set1 - set2
print(set3)  # {1, 3, 5}
set4 = set1.difference(set2)
print(set4)  # {1, 3, 5}

子集

註意：返回的結果為True 或 False

• <
• issubset

set1 = {1,2,3}
set2 = {1,2,3,4,5}
set3 = set1 < set2
print(set3)  # True
set4 = set1.issubset(set2)
print(set4) # True

超集

• \>
• issuperset

  set1 = {1,2,3}
  set2 = {1,2,3,4,5}
  set3 = set2 > set1
  print(set3)   # True
  set4 = set2.issuperset(set1)
  print(set4)  # True

  去重

  li = [1,2,33,33,2,1,4,5,6,6]
  set1 = set(li)
  print(set1)   #  {1, 2, 33, 4, 5, 6}
  li = list(set1)
  print(li)  # [1, 2, 33, 4, 5, 6]

  frozenset

  將結合轉變成不可變的數據類型 無序的 只能查詢

s = frozenset(‘jooker‘)
print(s,type(s))  # frozenset({‘j‘, ‘o‘, ‘e‘, ‘k‘, ‘r‘}) <class ‘frozenset‘>

dict

語法格式

dic = {‘key1‘:‘value1‘,‘key2‘:‘value2‘}
# 特性
    # dict的key必須是不可變數據類型 即是可哈希的
    # dict的value可以是任意數據類型
# 優點 
    # 用二分法去查找數據，查詢的速度快
    # 存儲大量的關系型數據

dict方法

增

• 直接賦值

dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic1[‘height‘] = 185  # 若不存在 則會直接添加

dic1[‘age‘] = 16  # 若存在該建 則會將value覆蓋

• setdefault(有鍵值對的不做任何改變，沒有才添加)

dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic1.setdefault(‘height‘,185) # 沒有的鍵值對 進行增加

dic1.setdefault(‘age‘,16)  # 存在有鍵值對 則不做任何改變

刪

• pop(刪除有返回值，並且可以設置返回值)

dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
print(dic1.pop(‘age‘))  # 有返回值
dic1.pop(‘age‘)

dic.pop(‘name1‘,‘沒有此鍵值‘)  # 設置返回值

• popiten(刪除有返回值，且是隨機刪除的，返回值是元祖)

dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic1.popitem() # 隨機刪除
print(dic1)

print(dic1.popitem())  # 返回值是元祖

• del(從內存中刪除)

  dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
  del dic1

• clear(清空字典)

dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic1.clear()  # 運行結果為：{}

改

• 直接改(即覆蓋)

  dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
  dic1[‘age‘] = 16

• update

dic1 = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic2 = {‘name‘:‘alex‘,‘weight‘:185}
dic2.update(dic1)  #將dic2中的數據進行更新
print(dic1)
print(dic2)

運行結果為：
{‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘}
{‘age‘: 18, ‘weight‘: 185, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘}

# get方法(設置找不到值的返回值)
print(v2) #打印會報錯

# 使用get方法，查找key，找不到返回一個自定義的值
print(dic.get(‘name1‘,‘沒有這個鍵‘))

查

dic = {‘age‘:18, ‘name‘:‘jin‘, ‘sex‘:‘male‘}
dic.keys()  # 輸出字典中的key
dic.values # 輸出字典中的value
dic.items # 輸出字典中的鍵值對

for i in dic:
    print(i)  # 默認打印key

for i in dic.keys():
    print(i)  # 打印key

for i in dic.values():
    print(i)  # 打印value

for i in dic.items
    print(i) # 打印鍵值對 打印的結果默認是元祖的形式

for i,k in dic.items():
    print(i)  # 不以元祖的形式打印

tuple

註意：若元祖中只有一個元素，且不加逗號，則改元素是什麽類型就是什麽類型

tu = (1)
tu1 = (1,)
print(tu,type(tu)) # 運行結果為：1 <class ‘int‘>
print(tu,type(tu1)) # 運行結果為：1 <class ‘tuple‘>
1 <class ‘int‘>

語法格式

tu = = (value1,value2,value3)
tuple()  # 強制轉化成元祖

• 元祖是只讀列表，可以循環查詢，可以切片
• 元祖中有可變數據類型，該元素可以改變

tuple方法

查

• for循環遍歷查

  tu = (1,2,3,‘alex‘,[2,3,4,‘taibai‘],‘egon‘)
  for i in tu:
  print(i)

• 切片查

  tu = (1,2,3,‘alex‘,[2,3,4,‘taibai‘],‘egon‘)
  print(tu[0:5])

• 按照索引查

  tu = (1,2,3,‘alex‘,[2,3,4,‘taibai‘],‘egon‘)
  print(tu[3])

  改

  註意：元祖的改變只能是在元祖有可變的數據類型時才能改變

  tu = (1,2,3,‘alex‘,[2,3,4,‘taibai‘],‘egon‘)
  tu[4][3] = ‘jooker‘

2 Python基礎數據類型