當(dāng)前位置：首頁 > 编程语言 > python >内容正文

python

python各种数据类型的常用方法_Python之数据类型的常用方法

發(fā)布時間：2024/7/5 python 28 豆豆

生活随笔收集整理的這篇文章主要介紹了 python各种数据类型的常用方法_Python之数据类型的常用方法小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

常用方法匯總

1. int類

方法匯總：

變量名.to_bytes('數(shù)字'，"little"\"big") # (把數(shù)字轉(zhuǎn)換成bytes)

# 數(shù)字表示轉(zhuǎn)換后幾個字節(jié)表示 little在前面，big在后面(大小端)

int.from_bytes("要轉(zhuǎn)換的東西","little"\"big") # 字節(jié)轉(zhuǎn)換成數(shù)字

bit_length() # 判斷當(dāng)前十進(jìn)制數(shù)字占二進(jìn)制的位數(shù)

# 新加功能：big 和little 在這里是一個大小端，big 在后，little在前

# to_bytes() 從數(shù)字轉(zhuǎn)換字節(jié)

a =5

new_bytes = a.to_bytes(2,"big")

print(new_bytes)

a =5

new_bytes = a.to_bytes(2,"little")

print(new_bytes)

# from_bytes() 從字節(jié)轉(zhuǎn)換成數(shù)字

a =5

new_bytes = a.to_bytes(1,"little")

new_a = int.from_bytes(new_bytes,"big")

print(new_bytes)

print(new_a)

# 結(jié)果：

b'\x00\x05'

b'\x05\x00'

b'\x05'

2. str類

方法匯總：

str.lower() # 只能做英文

str.casefold() # 包含小語種 β-->ss的大寫

str.center('總長度',"前后填充")

str.ljust('總長度',"后面填充")

str.rjust('總長度',"前面填充")

str.count("序列","起始位","結(jié)束位") # 查看序列是否存在

str.expandtabs('總位數(shù)') # xxx\t 一共占多少位，可以做簡單表格形式

# \n 或 \r\n 換行符 \t制表符

str.find("字符") # 找到字符所在第一個位置的索引，沒有時，返回-1

str.index("字符") # 找到字符所在第一個位置的索引，沒有時，報錯

str.format() # 字符串格式化(重點(diǎn))

name = "我叫{name}，年齡{age}-{name}"

1 val= name.format("aaa","dddd")

2 val= name.format(*["aaa","dddd"])

3 val= name.format(name="aaa",dddd)

4 dic = {"name":"aaa","age":"dddd"}

val= name.format(**dic)

# 1 和 4 常用

str.format_map() # 字符串格式化

dic = {"name":"aaa","age":"dddd"}

val= name.format_map(dic) # (只能寫字典)

str.isalnum() # 判斷中文或字母或數(shù)字存在---True

str.isalpha() # 判斷中文和字母

str.isdecimal() # 數(shù)字

str.isdigit() # 數(shù)字

str.isnumeric() # 數(shù)字

str.isidentifier() # 判斷是否為關(guān)鍵字或python內(nèi)置使用，叫做標(biāo)識符(python已經(jīng)賦予意義)

str.islower() # 是否全為小寫

str.isprintable() # 是否可以全部打印

str.isspace() # 是否全為空格

str.title() # 變成標(biāo)題

str.istitle() # 是否為標(biāo)題(首字母變大寫)

str.partition() # 分割并且保留分割符(結(jié)果是元組)

str.splitlines() # 根據(jù)換行符分割

str.swapcase() # 大寫變小寫小寫變大寫

str.maketrans("原內(nèi)容"，"新內(nèi)容") # 依次替換

# str.capitalize() 首字母變大寫

v = "adgdakl13235"

new_v = v.capitalize()

print(new_v)

# str.casefold() 變小寫有英語，還包含小語種

v = "aDGHHdak"

new_v = v.casefold()

print(new_v)

# str.islower() 是否全為小寫

v = "aDGHHdak"

new_v = v.islower()

print(new_v)

# str.isupper() 是否全為大寫

v = "aDGHHdak"

new_v = v.isupper()

print(new_v)

# str.lower() 變小寫

v = "aDGHHdak"

new_v = v.lower()

print(new_v)

# str.uppper() 變小寫

v = "aDGHHdak"

new_v = v.upper()

print(new_v)

# str..swapcase() 大寫變小寫小寫變大寫

v = "aDGHHdak"

new_v = v.swapcase()

print(new_v)

# str.center(總長度,"前后填充")

v = "aDGHHdak"

new_v = v.center(25,"%")

print(new_v)

# str.ljust(總長度,"后面填充")

v = "aDGHHdak"

new_v = v.ljust(25,"%")

print(new_v)

# str.rjust(總長度,"前面填充")

v = "aDGHHdak"

new_v = v.rjust(25,"%")

print(new_v)

# str.zfill() 給定一個總長度，只能從前面填充，只能填充0

name = 'alex'

v = name.zfill(20)

print(v)

# str.count("序列","起始位","結(jié)束位") 查看序列是否存在

v = "aDGHHdaHkFHFGJH"

print(v.count("H",3,7))

# str.encode() 字符串(Unicode編碼)轉(zhuǎn)換成其他編碼形式

v = "海角"

new_v = v.encode("utf-8")

print(new_v)

# str.expandtabs(總位數(shù)) xxx\t 一共占多少位，可以做簡單表格形式

# \n 或 \r\n 換行符 \t制表符

v = "aDG\tHH\tdaH\naDG\tHH\tdaH\naDG\tHH\tdaH"

new_v = v.expandtabs(10)

print(new_v)

# str.find("字符") 找到字符所在第一個位置的索引，沒有時，返回-1

v = "aDGHHdaHkFHFGJH"

new_v = v.find("H")

print(new_v)

v = "aDGHHdaHkFHFGJH"

new_v = v.find("b")

print(new_v)

# str.rfind("字符") 右邊開始找到字符所在第一個位置的索引，沒有時，返回-1

v = "aDGHHdaHkFHFGJH"

new_v = v.rfind("H")

print(new_v)

v = "aDGHHdaHkFHFGJH"

new_v = v.rfind("b")

print(new_v)

# str.index("字符") 找到第一個字符所在位置的索引，沒有時，報錯

v = "aDGHHdaHkFHFGJH"

new_v = v.index("H")

print(new_v)

v = "aDGHHdaHkFHFGJH"

new_v = v.index("b")

print(new_v)

# str.index("字符") 找到第一個字符所在位置的索引，沒有時，報錯

v = "aDGHHdaHkFHFGJH"

new_v = v.rindex("H")

print(new_v)

v = "aDGHHdaHkFHFGJH"

new_v = v.rindex("b")

print(new_v)

# (重點(diǎn))變量名.format() 字符串格式化

v = "我叫{name}，年齡{age}-{name}"

val = v.format("aaa","dddd")

print(val)

val= v.format(*["aaa","dddd"])

print(val)

val= v.format(name="aaa",age = "11")

print(val)

dic = {"name":"aaa","age":"dddd"}

val= v.format(**dic)

print(val)

# 標(biāo)注：1 和 4 常用

# str.format_map() 字符串格式化

v = "我叫{name}，年齡{age}-{name}"

dic = {"name":"aaa","age":"dddd"}

val= v.format_map(dic) #(只能寫字典)

print(val)

# str.isalnum() 判斷中文或字母或數(shù)字存在---True

v = "aagkf243變量"

print(v.isalnum())

.isalpha() # 判斷中文和字母

v = "aagkf243變量"

print(v.isalpha())

# str.isdecimal() 判斷數(shù)字是否存在

name = '123'

print(name.isdecimal()) # 123

# str.isdigit() 數(shù)字

name = '②123'

print(name.isdigit()) # 123 ②

# str.isnumeric() 數(shù)字

name = '二十②123'

print(name.isnumeric()) # 123 ② 二十

# 連接符.join(可迭代對象)

li = ["978","6745","435","24","12"]

new_li = "*".join(li)

print(new_li)

# str.strip() 去空格

name = ' aff '

val = name.strip()

print(name)

print(val)

# str.lstrip() 去左邊空格

name = ' aff '

val = name.lstrip()

print(name)

print(val)

# str.rstrip() 去右邊空格

name = ' aff '

val = name.rstrip()

print(name)

print(val)

# str.replace() 替換

msg = "asdefasdfja"

val = msg.replace("a","##",2)

print(val)

# str.maketrans("原內(nèi)容"，"新內(nèi)容") 依次替換

# str.translate() 轉(zhuǎn)換，把maketrans替換的內(nèi)容轉(zhuǎn)換出來

table = str.maketrans("aeiou",'12345')

msg = "asdefasdfjasdifw[kmnakjudfasdf"

val = msg.translate(table)

print(val)

# str.partition() 分割并且保留分割符，(結(jié)果是元組)

v = "akl\nalf\nkal\nakl"

val = v.partition("\n") #只有一次

print(val)

# str.rpartition() 從右分割并且保留分割符，(結(jié)果是元組)

v = "akl\nalf\nkal\nakl"

val = v.rpartition("\n") #只有一次

print(val)

# str.split() 分割不保留分割符，結(jié)果是列表

v = "akl\nalf\nkal\nakl"

val = v.split("\n")

print(val)

# str.rsplitl() 從右邊分割，分割不保留分割符，結(jié)果是列表

v = "akl\nalf\nkal\nakl"

val = v.rsplit("\n")

print(val)

# str.splitlines() 根據(jù)換行符分割，結(jié)果是列表

v = "akl\nalf\nkal\nakl"

val = v.splitlines()

print(val)

# str.startswith() 檢測是否以xxx開頭

v = "aklalfkalakl"

val = v.startswith("a")

print(val)

# str.endswith() 檢測是否以xxx結(jié)尾

v = "aklalfkalakl"

val = v.endswith("kl")

print(val)

# str.isidentifier() 判斷是否為關(guān)鍵字或python內(nèi)置使用，叫做標(biāo)識符(python已經(jīng)賦予意義)目前有歧義

# str.isprintable() 是否可以全部打印

name = '二十\n123'

val = name.isprintable()

print(val)

# str.isspace() 是否全為空格

name = '二十\n123' #空字符串也是False

val = name.isspace()

print(val)

# str.title() 變成標(biāo)題，首字母大寫

name = 'afklsdssdf'

val = name.title()

print(val)

3. list類

list.count("元素") # 判斷元素是否存在于列表中，并且返回個數(shù)

list.clear() # 列表.clear()

list.extand("可迭代對象") # 傳遞批量append,批量傳遞，如果是字符串，會把每個字符拆開來放進(jìn)去，所以里面要放可迭代對象

v= list.pop('索引') # 刪除并且獲取到賦值給變量

# v 就是被刪掉的東西

list.remove('值') # 重復(fù)時只能刪第一個

list.sort(reverse=True) # 排序默認(rèn)False從小到大 True從大到小

list.index("值", '起始位置', '終止位置') # 找到字符所在第一個位置的索引，沒有時，報錯

# 深淺拷貝的規(guī)則和基本形式：列表里才會這樣

li = ["11","22","33"]

val = li.append("44")

print(val) # val沒有意義，為none

li1 = ["11","22","33"]

li2 = li1 # 指向同一個內(nèi)存

print(li1,li2)

val = li.append("44") #li2也會發(fā)生變化

print(li1,li2)

li1 = ["11","22","33"]

li2 = ["11","22","33"] #指向兩塊內(nèi)存

# copy 復(fù)制

# 淺拷貝列表.copy() 只拷貝最外層，改變后一樣

li1 = ["11", "22", "33"]

li2 = li.copy()

# 深拷貝 import copy 所有層都拷貝，最后一層補(bǔ)不拷貝，改變后不一樣

import copy

li1 = ["11","22","33"]

li2 = copy.deepcopy()

# ****單個列表時，在只有數(shù)字，字符串的時候，深淺拷貝一樣****

# *****嵌套時才有區(qū)別*****

# 列表'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

append() # 尾部添加，

li = [11,22,11,33,44]

li.append(666)

print(li)

# 淺拷貝的一種形式，列表里才會這樣

li = ["11","22","33"]

val = li.append("44")

print(val) #val沒有意義，為none

li1 = ["11","22","33"]

li2 = li1 #指向同一個內(nèi)存

print(li1,li2)

val = li.append("44") #li2也會發(fā)生變化

print(li1,li2)

li1 = ["11","22","33"]

li2 = ["11","22","33"]#指向兩塊內(nèi)存

#copy 淺拷貝只拷貝最外層，指向同一塊內(nèi)存

# ****單個列表時，在只有數(shù)字，字符串的時候，深淺拷貝一樣****

li1 = ["11","22","33"]

li2 = li1.copy() #這里相當(dāng)于重新創(chuàng)建了一個列表但是列表內(nèi)元素所指向的是同一塊內(nèi)存

print(li2)

li1.append(666)

print(li1)

print(li2)

# 結(jié)果:

['11', '22', '33']

['11', '22', '33', 666]

['11', '22', '33']

# 深拷貝所有層都拷貝，最后一層補(bǔ)不拷貝，改變后不一樣。單個列表時，在只有數(shù)字，字符串的時候，深淺拷貝一樣

import copy

li1 = ["11","22","33"]

li2 = copy.deepcopy(li1)

print(li2)

li1.append(666)

print(li1)

print(li2)

# 結(jié)果：

['11', '22', '33']

['11', '22', '33', 666]

['11', '22', '33']

# *****嵌套時才有區(qū)別*****

# 淺拷貝

li1 = ["11","22","33",[11,22,33]]

li2 = li1.copy() #這里相當(dāng)于重新創(chuàng)建了一個列表但是列表內(nèi)元素所指向的是同一塊內(nèi)存

print(li2)

li1[3].append(666) #因?yàn)橹赶蛲粔K內(nèi)存，所以li2也會改變

print(li1)

print(li2)

# 結(jié)果：

['11', '22', '33', [11, 22, 33]]

['11', '22', '33', [11, 22, 33, 666]]

# 深拷貝

import copy

li1 = ["11","22","33",[11, 22, 33]]

li2 = copy.deepcopy(li1)# 這里是把li1里所有的東西都重新創(chuàng)建了一份，li1 li2指向不同的內(nèi)存，

print(li2)

li1.append(666) #因?yàn)橹赶虿煌膬?nèi)存，所以li1改變 li2不會改變

print(li1)

print(li2)

# 結(jié)果：

['11', '22', '33', [11, 22, 33]]

['11', '22', '33', [11, 22, 33], 666]

['11', '22', '33', [11, 22, 33]]

# .clear 全部清空列表.clear()

li = [11, 22, 11, 33, 44]

li.clear()

print(li)

# 判斷元素是否存在于列表中，并且返回個數(shù)

.count("元素")

li = [11,22,11,33,44]

v = li.count(11)

print(v)

# .extand("可迭代對象") 傳遞批量append

# 如果是字符串，會把每個字符拆開來放進(jìn)去，所以里面要放可迭代對象

li = [11,22,33,44]

li.extend("aaa")

print(li)

li = [11,22,33,44]

li2 = ["aaa","bbb"]

li.extend(li2)

print(li)

# pop 刪除 v= li.pop(索引) 刪除并且獲取到賦值給變量 v 就是被刪掉的東西

li = [11,22,33,44]

li.pop(1) #默認(rèn)刪除最后一個，也可以指定

print(li)

# .remove(值) 重復(fù)時只能刪第一個

li = [11,22,33,44,33]

li.remove(33)

print(li)

.sort(reverse=True) # 排序默認(rèn)False從小到大 True從大到小

li = [11,22,33,44,33]

li.sort()

print(li)

li = [11,22,33,44,33]

li.sort(reverse=True)

print(li)

# .index("值",起始位置，終止位置) 找到字符所在第一個位置的索引，沒有時，報錯

li = [11,22,33,44,33]

v = li.index(33)

print(v)

li = [11,22,33,44,33]

v = li.index(666)

print(v)

# .insert() 在指定位置插入

li = [11,22,33,44,33]

li.insert(2,"8888")

print(li)

# .reverse() 反轉(zhuǎn)

li = [11,22,33,44,]

li.reverse()

print(li)

4. tuple類

方法匯總：

index("值", '起始位置', '終止位置') # 找到字符所在第一個位置的索引，沒有時，報錯

count() # 判斷元素是否存在于列表中，并且返回個數(shù)

count() # 判斷元素是否存在列表中，并返回個數(shù)

tu = (11,22,11,33,44)

v = tu.count(22)

print(v)

tuple.index("值",'起始位置', '終止位置') # 找到字符所在第一個位置的索引，沒有時，報錯

tu = (11,22,33,44,33)

v = tu.index(33)

print(v)

5. dict類　　方法匯總：

# 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'

dict.clear() # 清空

dict.copy() # 和列表一樣

dict.pop("key","默認(rèn)值") # 刪掉key值對應(yīng)的值，并取出來，，，key不存在時報錯，加了默認(rèn)值，就不會報錯，打印默認(rèn)值

dict.popitem() # 隨機(jī)刪掉鍵值對操作完位為元組類型

dict.setdefalut("key","value") # 設(shè)置：只添加不修改，有key時，不改變

dict.update({"key":"value"}) # 更新不存在加進(jìn)去，存在時更新

dict.fromkeys() # 生成一個字典

val = dict.fromkeys(["k1","k2","k3"],value)

# value 是一個可變數(shù)據(jù)類型時，對val做操作后，所有的key對應(yīng)的value都變化

# value 是一個不可變類型時，更改其中一個時不會全部改變，只改變其中一個

# 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'

# clear 清空

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.clear()

print(d)

# copy 淺拷貝只拷貝最外層，指向同一塊內(nèi)存

# ****單個字典時，在只有數(shù)字，字符串的時候，深淺拷貝一樣****

d1 = {"k1":"v1","k2":"v2","k3":"v3"}

d2 = d1.copy() # 這里是重新創(chuàng)建了一個字典，但是字典內(nèi)的元素指向同一個內(nèi)存

print(d2)

d1["k1"] = 666

print(d1)

print(d2)

# 深拷貝,所有層都拷貝，最后一層補(bǔ)不拷貝，改變后不一樣

# ****單個字典時，在只有數(shù)字，字符串的時候，深淺拷貝一樣****

import copy

d1 = {"k1":"v1","k2":"v2","k3":"v3"}

d2 = copy.deepcopy(d1) # 這里是重新創(chuàng)建了一個字典，

print(d2)

d1["k1"] = 666

print(d1)

print(d2)

# *****嵌套時才有區(qū)別*****

# 淺拷貝

d1 = {"k1":[11,22,33],"k2":"v2","k3":"v3"}

d2 = d1.copy() # 這里是重新創(chuàng)建了一個字典，但是字典內(nèi)的元素指向同一個內(nèi)存

print(d2)

d1["k1"].append(666) #因?yàn)橹赶蛲粋€內(nèi)存，所以d1改變d2也會改變

print(d1)

print(d2)

# 深拷貝

import copy

d1 = {"k1":[11,22,33],"k2":"v2","k3":"v3"}

d2 = copy.deepcopy(d1) # 這里是重新創(chuàng)建了一個字典，d1 d2 指向不同的內(nèi)存

print(d2)

d1["k1"] = 666 # 因?yàn)橹赶虿煌膬?nèi)存，所以d2不會改變

print(d1)

print(d2)

# 重點(diǎn) 類.fromkeys() dict.fromkeys() 生成一個字典

# value 是一個可變數(shù)據(jù)類型時，對val做操作后，所有的key對應(yīng)的value都變化

# value 是一個不可變類型時，更改其中一個時不會全部改變，只改變其中一個

val = dict.fromkeys(["k1","k2","k3"],6666)

print(val)

val["k1"] = "aaa"

print(val)

val = dict.fromkeys(["k1","k2","k3"],[11,22,33])

print(val)

val["k1"].append("qqqq")

print(val)

# get() 取到key，沒有時返回None

d = {"k1":"v1","k2":"v2","k3":"v3"}

print(d.get("k2"))

# keys() 取到所有key 常和for循環(huán)一起用

d = {"k1":"v1","k2":"v2","k3":"v3"}

for v in d.keys():

print(v)

# values() 取到所有value 常和for循環(huán)一起用

d = {"k1":"v1","k2":"v2","k3":"v3"}

for v in d.values():

print(v)

# items() 取到所有鍵值對常和for循環(huán)一起用

d = {"k1":"v1","k2":"v2","k3":"v3"}

for v in d.items():

print(v)

# pop("key","默認(rèn)值") 刪掉key值對應(yīng)的值，并取出來，，，key不存在時報錯，加了默認(rèn)值，就不會報錯，打印默認(rèn)值

d = {"k1":"v1","k2":"v2","k3":"v3"}

v = d.pop("k2")

print(v)

print(d)

d = {"k1":"v1","k2":"v2","k3":"v3"}

v = d.pop("k12",888)

print(v)

print(d)

# popitem() 隨機(jī)刪掉鍵值對操作完為元組類型

d = {"k1":"v1","k2":"v2","k3":"v3"}

v1,v2 = d.popitem()

print(v1,v2)

print(d)

# setdefalut("key","value") 設(shè)置：只添加不修改，有key時，不改變

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.setdefault("k5","v5")

print(d)

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.setdefault("k2","v5")

print(d)

# update({"key":"value"}) 更新不存在加進(jìn)去，存在時更新

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.update({"k2":"v5"})

print(d)

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.update({"k5":"v5"})

print(d)

6. set類

方法匯總：

add() # 添加，如果存在不添加

copy() # 拷貝

update() # 更新，沒有返回值

# 差集(后面的元素一般是可迭代對象)

v.difference(n) # v中存在n中不存在的數(shù)據(jù)，并取出

v.difference_update(n) # 找到v中存在n中不存在的數(shù)據(jù)，并更新v中的值，

# 對稱差集

v.symmetric_difference(n) # 去掉v,n中相同的元素，并取出

v.symmetric_difference——update(n) # 去掉v,n中相同的元素，并更新v中的值

# 交集

intersection()

intersection_update()

# 并集

union()

isdisjoint() # 有交集False，沒有True

v.issubset(n) # 判斷v是否是n的子集

v.issuperset() # 判斷v是否是n的父集

# 刪除集合元素

pop() # 隨機(jī)刪除

remove() # 沒有時報錯

discard() # 沒有時不報錯

# add() 添加，如果存在不添加

s = {"a1","a2"}

s.add("a3")

print(s)

# copy 淺拷貝只拷貝最外層，指向同一塊內(nèi)存

# ****單個集合時，在只有數(shù)字，字符串的時候，深淺拷貝一樣****

s = {"a1","a2"}

s1 = s.copy() # 重新創(chuàng)建了一個集合，

print(s1)

s.add("a3") # 所以s改變，s1不改變

print(s)

print(s1)

# 深拷貝所有層都拷貝，最后一層補(bǔ)不拷貝，改變后不一樣

# ****單個集合時，在只有數(shù)字，字符串的時候，深淺拷貝一樣****

import copy

s = {"a1","a2"}

s1 = copy.deepcopy(s) # 重新創(chuàng)建了一個集合，

print(s1)

s.add("a3") # 所以s改變，s1不改變

print(s)

print(s1)

# *****嵌套時才有區(qū)別*****

# 淺拷貝只拷貝最外層，指向同一塊內(nèi)存，重新創(chuàng)建了一個集合，但是集合中的元素指向一個內(nèi)存,,所以會都改變

# 深拷貝除最后一層全部拷貝，拷貝后指向兩個內(nèi)存，所以不會一起改變

# clear()清空

s = {"a1","a2"}

s.clear()

print(s)

# 刪除集合元素

# pop() 隨機(jī)刪除

v = {"11", "22", "33", "44", "55"}

v.pop()

print(v)

# remove() 在集合中刪除指定值沒有時報錯

v = {"11", "22", "33", "44", "55"}

v.remove("22")

print(v)

v = {"11", "22", "33", "44", "55"}

v.remove("77")

print(v)

# discard() 在集合中刪除指定值沒有時不報錯

v = {"11", "22", "33", "44", "55"}

v.discard("22")

print(v)

v = {"11", "22", "33", "44", "55"}

v.discard("77")

print(v)

# update() 更新不用接收

v = {"11", "22", "33", "44", "55"}

n = {"aaa","sss"}

v.update(n)

print(v)

# 差集(后面的元素一般是可迭代對象)

# v.difference(n) v中存在n中不存在的數(shù)據(jù)，并取出

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.difference(n)

print(a)

# v.difference_update(n) 找到v中存在n中不存在的數(shù)據(jù)，并更新v中的值，

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

v.difference_update(n)

print(v)

# 對稱差集

# v.symmetric_difference(n) 去掉v,n中相同的元素，并取出

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.symmetric_difference(n)

print(a)

# v.symmetric_difference_update(n) 去掉v,n中相同的元素，并更新v中的值

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

v.symmetric_difference_update(n)

print(v)

# 交集

# intersection() 找到v,n中相同的元素，并取出

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.intersection(n)

print(a)

# intersection_update() 找到v,n中相同的元素，并更新v中的值

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

v.intersection_update(n)

print(v)

# isdisjoint() 判斷是否無交集有交集False，沒有True

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.isdisjoint(n)

print(a)

# union() 并集

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.union(n)

print(a)

# v.issubset(n) 判斷v是否是n的子集

v = {"44","55"}

n = {"44","55","66","77","88"}

a = v.issubset(n)

print(a)

# v.issuperset(n) 判斷v是否是n的父集

v = {"44","55","66","77","88"}

n = {"44","55"}

a = v.issuperset(n)

print(a)

# 去重相當(dāng)于變成集合類型的數(shù)

li = ["44","55","66","77","88","44","44"]

v = set(li)

print(v)

總結(jié)

以上是生活随笔為你收集整理的python各种数据类型的常用方法_Python之数据类型的常用方法的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

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

上一篇：【Pytorch神经网络理论篇】 21
下一篇： OSError: [Errno 22]