Python基本數據類型

1. 整型（int）

1.1 其它類型轉換為整型

可以通過 type() 來查看變量到底是什么類型

# 布爾值轉整型
n1 = int(True)  # True轉換為整數 1
n2 = int(False) # False轉換為整數 0

# 字符串轉整型
v1 = int("186", base=10)   # 把字符串看成十進制的值，然后再轉換為 十進制整數，結果：v1 = 186
v2 = int("0b1001", base=2) # 把字符串看成二進制的值，然后再轉換為 十進制整數，結果：v1 = 9 (0b表示二進制)
v3 = int("0o144", base=8)  # 把字符串看成八進制的值，然后轉換為 十進制整數，結果：v1 = 100 (0o表示八進制)
v4 = int("0x59", base=16)  # 把字符串看成十六進制的值，然后轉換為 十進制整數，結果：v1 = 89 （0x表示十六進制）

1.2 Py2和Py3的差異

Python2中有int、long（長整型），長整型都以L結尾 

• int，可表示的范圍：-9223372036854775808～9223372036854775807
• long，整數值超出int范圍之后自動會轉換為long類型（無限制）

Python3中只剩下：int（整型），並且 int 長度不在限制

python2中兩個值相除時，默認進行地板除，只保留整數位（python3中默認會保留小數）

2. 布爾值（bool）

布爾值詳細內容

布爾值True和False的判斷

• 整數0、空字符串、空列表、空元祖、空字典轉換為布爾值時均為False
• 其他均為True

3. 字符串（str）

3.1 可變類型和不可變類型

可變數據類型：在python中定義一個變量，當變量值被修改后，內存地址沒有改變，則該數據定義為可變數據類型。（可以用id來查看）

不可變數據類型：當變量的值被修改后，變量的內存地址發生變更（創建了新對象），則認為該類型為不可變數據類型。

3.2 字符串處理的相關方法

1）大小寫相關，得到的都是一個新的字符串

• swapcase()
• upper()
• lower()
• casefold()
• title()
• capitalize()

2）開頭結尾字符判斷，得到一個布爾值

• endswith()
• startswith()

3）去除字符串兩邊的內容，得到一個新的字符串

• strip()

4）查找統計

• find()
• index()
• count()
• len()

5）替換分割

• replace()
• partition()
• split()，字符串切割，得到的是一個列表
• splitlines()
• join()

6）類型判斷，返回布爾值

• isdigit()
• isalpha()
• isalnum()
• isspace()

7）其他

• expandtabs(15)
• range(0,20,2)

3.3 字符串處理代碼示例代碼

name = "   hgAlexHgzero \n wuzhihao   "

print("大小寫轉換效果：")
print(name.capitalize())                  # 首字母大寫
print(name.swapcase())                    # 將字符串中的大小寫互換
print(name.title())                       # 字符串中的每個單詞首字母大寫
print(name.upper())                       # 全部變大寫
print(name.lower())                       # 全部變小寫,只能轉換26個英文字母
print(name.casefold())                    # 更為牛逼的全部變小寫,不光支持26個英文字母，還支持其他非字母
print("*"*80)

print("判斷開頭結尾：")
print(name.endswith("zero"))              # 判斷是否以zero字符串結尾
print(name.startswith("hg"))              # 判斷是否以hg字符串開頭
print("*"*80)

print("strip效果：")
print(name.strip())                       # 剔除字符串兩端的空白
print(name.rstrip())                      # 剔除字符串右邊的空白
print(name.lstrip())                      #剔除字符串左邊的空白
print("*"*80)

print("查找find和index ：")
print(name.find("A"))                     # 查找A，返回其索引，若找不到，則返回-1
 # index 和 find 都有從左和從右開始找的方法，rfind() lfind()  rindex() lindex()
print("index為：",name.index("A"))        # 返回字符串的索引值，若找不到則返回錯誤

print("統計數量")
name.count("hgzero",3,9)                  # 在3到9的位置計數hgzero出現的次數
print("*"*80)

print("特殊效果：")
print(name.center(50,"*"))                # 將字符串放於50個字符內容的中間，其他空缺內容用*符號補充
print(name.ljust(20,"-"))                 # 占用20個字符串空位，name字符串靠左，未填滿則用-補充
print(name.rjust(20,"-"))                 # 與ljust類似，name字符串靠右
print(name.zfill(20))                     # 占用20個字符串空位，name字符串未占用的空位則在前面補0
print("*"*80)

print("replace效果：")
print(name.replace("zero","Wuzhihao"))    # 用第二個參數來替換第一個參數，但是不會改變原來的字符串，只作為一次結果
# replace()的第三個參數表示要替換的次數,若不指定則表示替換所有
print("*" * 80)                           # 可用變量來接受這一次的結果

print("partition效果：")
print(name.partition("zero"))             # 以zero將整個字符串分成3部分   zero前，zero，zero后   保存為列表
print("*"*80)

print("split效果：")
print(name.split("H"))                    # 按照H字符將整個字符串進行切割，切割后H字符消失，切割后內容保存為列表形式
print(name.splitlines())                  # 按照行分隔，返回一個包含各行作為元素的列表，按換行來切割
print("*"*80)
# 注意，split()不加參數默認以空格切割，加參數不能為空，就是說貌似split不能對asdfadf這樣的字符串進行每個字符的切割

print("join效果：")
b = "-"
print(b.join(name))                       # 將字符串b 插入到字符串變量name中的每個字符之間，形成一個新的字符串
print("*".join(name))
print("*"*80)

print("字符串類型判斷：")
print(name.isdigit())                     # 判斷所有字符是否是字符
print(name.isalpha())                     # 判斷所有字符是否為字母
print(name.isalnum())                     # 判斷所有字符是否為數字和字母的組合
print(name.isspace())                     # 判斷是否為純空格
print("*"*80)

print("expandtabs方法的使用：")
like = "name:wuzhihao\tage:20\taddr:China\t"
print(like.expandtabs(15))               # 每次以15個字符位為一單位，直至出現\t ，每一單位中的除了字符串的空白位用空格填充

print("    7個基本魔法：join() , split() , find() , strip() , lower() , upper() , replace()   ")
print("\n"*3)

love = "I love you forever"
print(len(love))                          # 獲取字符串的長度
print(love[4])                            # 通過下標的方法截取字符串
print(love[2:6])                          # 通過切片的方式截取字符串

print("range方法")
print(range(0, 20, 2))                      # 以2為步長(每隔一個數)，打印在0到20的范圍內(不包括20)的值
# python2中range方法立即創建，而python3中range只在要循環迭代的時候才創建

3.4 字符串的其他內容

1）字符串拼接

2）字符串格式化

4. 列表（list）

4.1 列表類型說明

列表為可變數據類型，且列表是有序的。

• 可變數據類型（mutable）：列表、字典、集合。
• 不可變數據類型（unmutable）：數字、字符串、元組。

可迭代對象：字符串、列表、元組、字典、集合。

4.2 列表的常用方法

1）切片

• name[0:4]，name[0:4:2]，name[:4]，name[1:]，name[:-1]

2）增加

• append()
• insert()

3）擴展

• extend()

4）刪除

• del  name[2]
• remove()
• pop()

5）修改

• name[2]='two'
• name[3:6]=['first','second','third']

6）查找、統計

• index()
• count()

7）排序、翻轉

• sort()
• reverse()

8）深淺copy（要導入copy模塊）

• copy()
• deepcopy()

4.3 深淺copy

1）淺拷貝

對可變對象而言，對象的值一樣可能包含有其他對象的引用；淺拷貝產生新的對象，雖然具有完全不同的id，但是其值若包含可變對象，這些對象和原始對象中的值包含同樣的引用。

也就是說，淺拷貝只拷貝了一層，若子層內還有其他引用，則只拷貝引用的鏈接。

2）深拷貝

深拷貝不僅僅拷貝了原始對象自身，也對其包含的值進行拷貝，它會遞歸的查找對象中包含的其他對象的應用，來完成更深層次拷貝。

深拷貝產生的副本可以隨意修改而不需要擔心引起原始值的改變。

import copy

a = copy.copy(b)      # 對b進行淺copy后賦值給a，淺拷貝
c = copy.deepcopy(d)  # 深拷貝

# copy.copy()  淺拷貝 只拷貝父對象，不會拷貝對象的內部的子對象。
# copy.deepcopy()  深拷貝 拷貝對象及其子對象

v = names.copy()
print(v)

4.4 列表常用方法示例代碼

names = ['hgzero', 'wuzhihao', 'zero', 'wuzhihao', 'hg', 'hao']

print("切片操作")
print(names[0:4])                        # 列表的切片操作不包括最后一個值
print(names[0:4:2])                      # 切片的第三個參數代表 每隔1個數取一個值
print(names[:4])
print(names[1:])
print(names[:-1])                        # 取值不包括最后一個值
print("#" * 50)

print("三種增加的方法：")
print("追加")
names.append("wu")                       # 在列表尾部追加
names.append("zhi")
names.append("hao")
print(names)
print("插入")
names.insert(2, "插入的值")              # 在2索引的位置插入要添加的值
print(names)
print("擴展")
b = [1, 2, 3, 5, 9, 7, 8]
names.extend(b)                         # 將b列表合並到names列表中（尾部添加），形成一個新的列表
print(names)

print("三種刪除的方法")
del names[2]
del names[3:5]
print(names)
names.remove("hgzero")                  # 刪除指定的元素
print(names)
names.pop()                             # 刪除列表的最后一個值並返回刪除的值，也可加上參數表示刪除指定的索引的值並返回刪除的值
print(names)

print("修改")
names[2] = "修改的值"
names[3:6] = ["first", "second", "thrid"]    # 批量修改
print(names)

print("獲取下標")
print(names.index("wuzhihao"))          # 只返回找到的第一個下標

print("統計")
print(names.count("wuzhihao"))

print("排序和翻轉")
b.sort()     # 排序
print(b)
b.reverse()  # 反轉
print(b)print("清空")
names.clear()
print(names)

5. 元組（tuple）

5.1 元組類型說明

元組和列表差不多，但是元組一旦創建，就不能再修改（增加、修改、刪除），所以元組又叫只讀列表。

元組不能修改的只是元組的一級元素，但是一級元素中的內容可以修改。

• 元組的末尾最好加上一個逗號。
• 元組為可迭代對象，所以可以被迭代方法進行迭代處理。
• 元組是有序的。

5.2 元組的處理

1）元組和列表的轉換

ls = list(names)   # 轉換為列表
print(ls)
tu = tuple(ls)     # 轉換為元組
print(tu)

2）切片：和列表一樣

3）方法：

• len()
• count()
• index()

5.3 元組常用方法示例代碼

# 元組和列表差不多，但是元組一旦創建，便不能再修改(增加、修改、刪除)，所以又叫只讀列表
# 元組和列表可以互換   list()   tuple()

# 元組的末尾最好加上一個逗號
names = ("hgzero","wuzhihao","zero","wuzhihao",)
(hgzero,)

print("元組的切片")
print(names[1:3])

print("元組和列表的轉換")
ls = list(names)
print(ls)
tu = tuple(ls)
print(tu)

print("元組只有2個查的方法，一個是count，另一個是index")
print(names.count("wuzhihao"))
print(names.index("zero"))

print("元組為可迭代對象")
print("*".join(names))         # 當元組中全部為字符串時，可以用join方法來轉換

print("元組是有序的")
tu = (111,"alex",(11,22),[(33,44)],True,33,55)
print(tu[3][0][0])

print("元組的不能修改只是針對元組的一級元素,但一級元素中的內容可用修改")
tu[3][0]="wuzhihao"
print(tu)

6. 字典（dict）

 6.1 字典類型說明

字典存儲為鍵值對形式，且字典是無序的。

字典的鍵（key）必須是唯一的

• key必須可哈希，且key必須為不可變數據類型；
• 布爾值可以作為字典的key；

6.2 字典的處理方法

1）獲取所有的鍵&值

• xx_dick.keys()       返回為一個高仿列表；
• xx_dick.values()    返回為一個高仿列表；
• xx_dick.items()      獲取字典中所有的鍵、值，返回為一個個元組，包含在一個高仿列表中；

2）增加&修改&更新

• info['stu4'] = 'hgzero'
• info['stu4']='Tom'
• update({"name": "hgzero", "age": 18})

3）刪除

• del info['stu4']
• pop('stu4')

4）查找

• 'stu1' in info
• get()
• info['stu1']

5）其他

• setdefault()

6.3 字典使用示例代碼

# 字典存儲為 鍵值對 形式
# 字典dick  是無序的
info = {
    "stu1": "hg zero",
    "stu2": "wu zhihao",
    "stu3": "hao wu",
}

print("增加：")
info['stu4'] = "wuzhihao"
print(info)

print("字典的擴展：")
b = {"A": 1, "B": 2, "C": 3}
info.update(b)                         # 將b字典中的內容擴展到info中
print(info)
info.update(k1=123, k2=456, k3=789)    # update() 也支持在括號中直接使用=進行鍵值對賦值，其會自動轉換成字典的形式，類似**kwargs
print(info)

print("刪除(兩種)：")
info.pop("stu4")                       # pop() 可傳入第二個參數(默認值)，表示若沒有指定的key，則返回默認值
print(info)
del info["stu3"]
print(info)

print("修改：")
info['stu4'] = "Tom"
print(info)

print("查找(三種)：")
print("stu1" in info)                  # 判斷名為stu1的鍵是否在info字典中
print(info.get("stu2"))                # 獲取字典中鍵為stu2的值
print(info.get("stu9"))                # 若要獲取的鍵在字典中不存在，則返回None
print(info["stu2"])                    # 這樣獲取對應鍵的值，若字典中不存在則會報錯


print("字典中的其他方法：")
print(info.values())                   # 獲取字典中的所有的值
print(info.keys())                     # 獲取字典中的所有的鍵  鍵和值都可用用for循環來打印出來
print(info.items())                    # 獲取字典中的所有的鍵和值

info.setdefault("stu7", "Alex")        # 設置默認的鍵值對
print(info)

v = dict.fromkeys([1, 2, 3, 4], "hgzero")  # 構建一個字典，將第一個參數迭代為key ， 第二個參數為每個key的value
print(v)


print("字典的循環：")
for key in info:
    print(key, info[key])

for k, v in info.items():              # 會先把dict字典轉換為list列表，數據量大時不用
    print(k, v)

7. 集合

7.1 集合類型說明

1）集合的特點

• 子元素不重復：具有天生去重性（將一個列表轉換成集合，就自動去重了）；
• 子元素必須可哈希：集合是可變類型，但是不能修改，只能增加或者刪除；
• 集合是無序的；

2）注意

• 集合中沒有提供 索引、切片、步長 這些功能，且無法使用索引操作；
• 集合可以通過 len() 函數獲取長度，也可以通過for循環來取值；

7.2 集合的三種定義方式

a = {3, 6, 4, 7, 8}          

s = set([3, 5, 9, 10, 2])      # 可用set()方法來生成集合, 生成了集合 {3,5,9,10,2}
s2 = set("Hello")              # 這樣會生成包含這個字符串中每個字母的集合

f = frozenset({2, 3, 5, 6, 7}) # 此處定義了一個不可變類型的集合，不可增加或者刪除其中的值

7.3 集合的處理方法

1）添加

• add()
• update()

2）刪除

• pop()
• remove()
• discard()

3）拷貝&清空

• copy()
• clear()

4）存在判斷

• in
• not in

5）集合中的交、並、差、對稱差 集

• |，&，-，^

6）集合關系的判斷

• isdisjoint()
• issubset()
• issuperset()

7.4 集合的轉換

其他類型如果想要轉換為集合類型，可以通過set進行轉換，並且如果數據有重復會自動剔除（自動去重）。

int、str、tuple、dict 都可以轉換為集合。

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) 
# 結果為：{11,22,33,3,99}

v1 = "傻XCCP"
v2 = set(v1)
print(v2) 
# 結果為：{"傻","X","C","C","P"}

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) 
# 結果為：{11,22,3}

v1 = {"age":12, "status":True,"name":"傻X"}
print( set(v1.keys()) )    # 輸出：{'status', 'name', 'age'}
print( set(v1.values()) )  # 輸出：{'status', 'name', 'age'}
print( set(v1.items()) )   # 輸出：{('age', 12), ('status', True), ('name', '傻X')}

7.5 集合常用方法示例代碼

# 集合：去重性 ，  將一個列表轉換成集合，就自動去重了
# 集合是無序的
# 集合是可變類型，但是不能修改，只能增加或者刪除

a = {3, 6, 4, 7, 8}          # 定義集合的方式
s = set([3, 5, 9, 10, 2])    # 可用set()方法來生成集合, 生成了集合 {3,5,9,10,2}
s2 = set("Hello")      # 這樣會生成包含這個字符串中每個字母的集合


print("定義一個不可變類型的集合:")
f = frozenset({2, 3, 5, 6, 7})    # 此處定義了一個不可變類型的集合，不可增加或者刪除其中的值
print(f)
for i in f:
    print(i)

print("添加(兩種)：")
s.add("x")                   # 添加一項，且一次只能添加一個值
s.update([12, 45, 77])       # 添加多項，可以傳進各種可迭代對象，統一迭代添加到集合中
s.update(s2)                 # 更新
print(s)

print("刪除(三種)：")
s.pop()                      # 因為集合是無序的，所以pop()是隨機刪除
s.remove("H")                # 刪除一項，若不存在會報錯
s.discard("e")               # 若不存在不會報錯
print(s)

print("拷貝：")
b = a.copy()
print(b)

print("清空：")
a.clear()
print(a)

print("判斷:")
print(2 in s)                # 判斷2是否在s集合中
print(2 not in s)

print("獲取集合的長度：")
print(len(s))                # 獲取集合的長度


print("集合中的交、並、差、對稱差  集：")
# a = s | s2                 # 兩者之間的並集
x = a.union(s2)

# b = s & s2                 # 兩者之間的交集
y = s.intersection(s2)

# c = s - s2                 # 差集 （在s中，但不在s2中）
z = s.difference(s2)

# d = s ^ s2                 # 對稱差集 （在s或s2中，但不會同時出現在二者中）
w = s.symmetric_difference(s2)


print("兩個集合之間關系的判斷：")
a1 = {1, 2, 3, 4, 5}
a2 = {1, 2, 3, 4, 5, 6, 7, 8}
print(a1.isdisjoint(a2))     # 判斷兩個集合中是否有交集，如果沒有則為True，如果有則為False
print(a1.issubset(a2))       # 判斷a1是否為a2的子集，若是則為真，否則為假
print(a1.issuperset(a2))     # 判斷a1是否為a2的父集，若是則為真，否則為假