Python-04-數據結構

来源:https://www.cnblogs.com/lsf123456/archive/2019/07/05/11132809.html
-Advertisement-
Play Games

一、數字 整數 Python可以處理任意大小的整數，當然包括負整數，在程式中的表示方法和數學上的寫法一模一樣，例如：1，100，-8080，0，等等。 電腦由於使用二進位，所以，有時候用十六進位表示整數比較方便，十六進位用0x首碼和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等 ...


一、數字

整數

　　Python可以處理任意大小的整數，當然包括負整數，在程式中的表示方法和數學上的寫法一模一樣，例如：1，100，-8080，0，等等。

　　電腦由於使用二進位，所以，有時候用十六進位表示整數比較方便，十六進位用0x首碼和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

浮點數

　　浮點數也就是小數，之所以稱為浮點數，是因為按照科學記數法表示時，一個浮點數的小數點位置是可變的，比如，1.23x109和12.3x108是完全相等的。浮點數可以用數學寫法，如1.23，3.14，-9.01，等等。但是對於很大或很小的浮點數，就必須用科學計數法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以寫成1.2e-5，等等。

　　整數和浮點數在電腦內部存儲的方式是不同的，整數運算永遠是精確的（除法難道也是精確的？是的！），而浮點數運算則可能會有四捨五入的誤差。

常用方法：

  • int    將字元串轉化為數字
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = '123'
print(type(a), a)
a = int(a)
print(type(a), a)

#輸出
<class 'str'> 123
<class 'int'> 123
  • bit_length   當前數字的二進位至少用幾位表示
#!/usr/bin/env python
# -*- coding:utf-8 -*-
age = 10
r = age.bit_length()
print(r)

#輸出
4

 二、字元串

1. 常用方法

  • capitalize    把字元串的第一個字元大寫

　　　　mystr.capitalize()

  • casefold     lower    轉換 mystr 中所有大寫字元為小寫    casefold可以識別特殊字元

　　　　mystr.lower()

  • upper    轉換 mystr 中的小寫字母為大寫

　　　　mystr.upper()

  • swapcase    大小寫切換

　　　　mystr.swapcase()

test = 'sFHVahKHJss'
v = test.swapcase()
print(v)

#輸出
SfhvAHkhjSS
  • center    返回一個原字元串居中,並使用fillchar填充至長度 width 的新字元串

　　　　mystr.center(width, fillchar=” ”)

  • count    返回str在start和end之間 在 mystr裡面出現的次數

　　　　mystr.count(str, start=0, end=len(mystr))

  • endswith    檢查字元串是否以obj結束，如果是返回True,否則返回 False.

　　　　mystr.endswith(obj)

  • startswith    檢查字元串是否是以 obj 開頭, 是則返回 True，否則返回 False

　　　　mystr.startswith(obj)

  • find    檢測str是否包含在 mystr中，如果包含返回開始的索引值，否則返回-1

　　　　mystr.find(str, start=0, end=len(mystr))

  • index    跟find()方法一樣，只不過如果str不在 mystr中會報一個異常

　　　　mystr.index(str, start=0, end=len(mystr))

  • format    字元串格式化
#!/usr/bin/env python
# -*- coding:utf-8 -*-
test = 'my name is {name},age is {age}'
print(test)
mstr = test.format(name='Tom', age=15)
print(mstr)

#輸出
my name is {name},age is {age}
my name is Tom,age is 15

# format的三種玩法
res1 = '{} {} {}'.format('egon', 18, 'male')
res2 = '{1} {0} {1}'.format('egon', 18, 'male')
res3 = '{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res1)
print(res2)
print(res3)

#輸出
egon 18 male
18 egon 18
egon 18 male
  • format_map    類似於format，但傳入的參數是一個字典
#!/usr/bin/env python
# -*- coding:utf-8 -*-
test = 'my name is {name},age is {age}'
print(test)
mstr = test.format_map({"name":"Tom", "age":"15"})
print(mstr)

#輸出
my name is {name},age is {age}
my name is Tom,age is 15
  • replace    把 mystr 中的 str1 替換成 str2,如果 count 指定，則替換不超過 count 次

　　　　mystr.replace(str1, str2,  mystr.count(str1))

name = 'alex say :i have one tesla,my name is alex'
print(name.replace('alex', 'SB', 1))

#輸出
SB say :i have one tesla,my name is alex
  • split    以 str 為分隔符切片 mystr，如果 maxsplit有指定值，則僅分隔 maxsplit 個子字元串

　　　　mystr.split(str=" ", maxsplit)

name = 'root:x:0:0::/root:/bin/bash'
print(name.split(':'))  # 預設分隔符為空格
name = 'C:/a/b/c/d.txt'  # 只想拿到頂級目錄
print(name.split('/', 1))

#輸出
['root', 'x', '0', '0', '', '/root', '/bin/bash']
['C:', 'a/b/c/d.txt']
  • rsplit    類似split，但從右邊開始
  • title    把字元串的每個單詞首字母大寫

　　　　mystr.title()

  • ljust    返回一個原字元串左對齊,並使用fillchar填充至長度 width 的新字元串

　　　　mystr.ljust(width, fillchar=” ”)

  • rjust    返回一個原字元串右對齊,並使用fillchar填充至長度 width 的新字元串

　　　　mystr.rjust(width, fillchar=” ”)

  • zfill    返回指定長度的字元串，原字元串右對齊，前面填充0

　　　　mystr.zfill(width)

  • lstrip    刪除 mystr 左邊的空白字元   也可以去除指定的字元

　　　　mystr.lstrip()

#!/usr/bin/env python
# -*- encoding:utf-8 -*-
test = 'asdfghh'
v = test.lstrip('8assdf') # 消除所有匹配到的字元
print(v)

#輸出
ghh
  • rstrip    刪除 mystr 右邊的空白字元   也可以去除指定的字元

　　　　mystr.rstrip()

  • strip    刪除mystr字元串兩端的空白字元   也可以去除指定的字元

　　　　mystr.strip()

  • rfind    類似於 find()函數，不過是從右邊開始查找

　　　　mystr.rfind(str, start=0,end=len(mystr) )

  • rindex   類似於 index()，不過是從右邊開始.

　　　　mystr.rindex( str, start=0,end=len(mystr))

  • partition    把mystr以str分割成三部分,str前，str和str後

　　　　mystr.partition(str)

 

test = 'ahjsyklsuiyska'
v = test.partition('s')
print(v)

#輸出
('ahj', 's', 'yklsuiyska')

 

  • rpartition    類似於 partition()函數,不過是從右邊開始.

　　　　mystr.rpartition(str）

  • splitlines    按照行分隔，返回一個包含各行作為元素的列表

　　　　mystr.splitlines()

 

test = 'ahjsykls\nuiyska\nvjshgk\ndhvgks'
v1 = test.splitlines(True)
print(v1)
v2 = test.splitlines(False)
print(v2)

#輸出
['ahjsykls\n', 'uiyska\n', 'vjshgk\n', 'dhvgks']
['ahjsykls', 'uiyska', 'vjshgk', 'dhvgks']

 

  • isupper    判斷字元串否全是大寫字母

　　　　mystr.isupper()

  • islower    判斷字元串否全是小寫字母

　　　　mystr.islower()

  • isalpha    如果 mystr 所有字元都是字母 則返回 True,否則返回 False

　　　　mystr.isalpha()

  • isdigit    isdecimal    isnumeric    如果 mystr 只包含數字則返回 True 否則返回 False。isdigit可以判斷一些特殊字元例如②。 isnumeric可以判斷中文數字例如二。

　　　　mystr.isdigit()

#!/usr/bin/env python
# -*- encoding:utf-8 -*-
test = '②'
v1 = test.isdecimal()
v2 = test.isdigit()
print(v1, v2)

#輸出
False True
test = '二'
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1, v2, v3)

#輸出
False False True
  • isalnum    如果 mystr 所有字元都是字母或數字則返回 True,否則返回 False

　　　　mystr.isalnum()

  • isspace    如果 mystr 中只包含空格，則返回 True，否則返回 False

　　　　mystr.isspace()

  • istitle    如果字元串的每個單詞的首字母都是大寫，則返回True，否則返回False

　　　　mystr.istitle()

  • isprintable    判斷字元串是否能夠被列印

　　　　mystr.isprintable()

test = '\n'
v = test.isprintable()
print(v)

#輸出
False
  • join    將字元串、元組、列表中的元素以mystr連接生成一個新的字元串

　　　　mystr.join(str)

mystr = ' '
print(mystr.join(["haha", "hehe", "heihei"]))
mystr = '-'
print(mystr.join(["haha", "hehe", "heihei"]))

# 運行結果：
haha hehe heihei
haha-hehe-heihei
  •  expandtabs 方法把字元串中的 tab 符號('\t')轉為空格，tab 符號('\t')預設的空格數是 8。從頭開始數，數到第一個\t正好為8個空格，不足則補空格，如果還有\t，接著從第一個\t數到第二個\t仍然為8個空格，以此類推直到最後一個\t結束。
　　　　S.expandtabs([tabsize=8]) 
#!/usr/bin/python3
 
S = "this is\tstring example....wow!!!"
print ("原始字元串: " + S)
print ("替換 \\t 符號: " +  S.expandtabs())
print ("使用16個空格替換 \\t 符號: " +  S.expandtabs(16))
"""
以上實例輸出結果如下：
原始字元串: this is     string example....wow!!!
替換 \t 符號: this is string example....wow!!!
使用16個空格替換 \t 符號: this is         string example....wow!!!
"""

#!/usr/bin/env python
#-*- encoding:utf-8 -*-

S = "username\temail\tpassword\nlaiying\[email protected]\t123\nlaiying\[email protected]\t123\nlaiying\[email protected]\t123"
v = S.expandtabs(20)
print(v)

 

  • translate   替換字元串中指定的字元
test = 'ahjsykliuiyjka'
m = str.maketrans('aeiou','12345')
v = test.translate(m)
print(v)

#輸出
1hjsykl353yjk1

 重點：

　　1、strip,lstrip,rstrip

　　2、lower,upper

　　3、startswith,endswith

　　4、format的三種玩法

　　5、split,rsplit

　　6、join

　　7、replace

　　8、isdigit

2. 下標切片

字元串中"下標"的使用

字元串實際上就是字元的數組，所以支持下標索引。

如果有字元串:name = 'abcdef'，在記憶體中的實際存儲如下:

如果想取出部分字元，那麼可以通過下標的方法，（註意python中下標從 0 開始）

name = 'abcdef'
print(name[0])
print(name[1])
print(name[2])

運行結果：
a
b
c

切片

切片是指對操作的對象截取其中一部分的操作。

切片的語法：變數名[起始:結束:步長]

註意：選取的區間屬於左閉右開型，即從"起始"位開始，到"結束"位的前一位結束（包含起始位本身但不包含結束位本身)。結束位可以不寫，那麼預設按照步長一直到末尾。

如果取出一部分，則可以在中括弧[]中

示例1：
name = 'abcdef'
print(name[0:3])  # 取下標0~2 的字元
運行結果：
abc

示例2：
name = 'abcdef'
print(name[2:])  # 取下標為2開始到最後的字元
運行結果：
cdef

示例3：
name = 'abcdef'
print(name[len(name)-1])  # 取下標為字元長度-1的字元
print(name[-1])  # 取下標為倒數第一個的字元
運行結果：
f
f

示例4：
name = 'abcdef'
print(name[1:-1])  # 取第2個到倒數第2個字元切片
print(name[0::2])  # 從第一個字元開始每次步長為2取切片
運行結果：
bcde
ace

示例5：
name = 'abcdef'
print(name[-1:-5:-1])  # 逆向取倒數第一個到倒數第4個字元切片
print(name[-1::-1])  # 逆向取倒數第一個到末尾的字元切片
print(name[::-1])  # 倒序字元的切片
運行結果：
fedc
fedcba
fedcba

 三、列表

1. 添加元素("增"append, extend, insert)

append：通過append可以向列表添加元素，並且預設添加在列表末尾。

示例：

namesList = ['tom', 'jerry', 'jhon']
print("----添加之前，列表中的元素----")
print(namesList)
print("----添加之後，列表中的元素----")
namesList.append("james")
print(namesList)

運行結果：
----添加之前，列表中的元素----
['tom', 'jerry', 'jhon']
----添加之後，列表中的元素----
['tom', 'jerry', 'jhon', 'james']

extend：通過extend可以將另一個集合中的元素逐一添加到列表中

示例：

print("----使用append添加----")
a = ['a', 'b', 'c']
b = ['1', '2', '3']
a.append(b)
print(a)
print("----使用extend添加----")
a = ['a', 'b', 'c']
b = ['1', '2', '3']
a.extend(b)
print(a)

運行結果：
----使用append添加----
['a', 'b', 'c', ['1', '2', '3']]
----使用extend添加----
['a', 'b', 'c', '1', '2', '3']

insert：insert(index, object) 在指定位置index前插入元素object

示例：

a = ['a', 'b', 'c']
a.insert(1, "haha")
print(a)

運行結果：
['a', 'haha', 'b', 'c']

2. 刪除元素("刪"del, pop, remove,clear)

del：根據下標進行刪除

示例：

movieName = ['綠巨人', '鋼鐵俠', '超人', '雷神', '洛基']
print('------刪除之前------')
print(movieName)
print('------刪除之後------')
del movieName[2]
print(movieName)

運行結果：
------刪除之前------
['綠巨人', '鋼鐵俠', '超人', '雷神', '洛基']
------刪除之後------
['綠巨人', '鋼鐵俠', '雷神', '洛基']

pop：刪除最後一個元素

示例：

movieName = ['綠巨人', '鋼鐵俠', '超人', '雷神', '洛基']
print('------刪除之前------')
print(movieName)
print('------刪除之後------')
movieName.pop()  # 也可以傳入下標作為參數，刪除該下標的元素
print(movieName)

運行結果：
------刪除之前------
['綠巨人', '鋼鐵俠', '超人', '雷神', '洛基']
------刪除之後------
['綠巨人', '鋼鐵俠', '超人', '雷神']

remove：根據元素的值進行刪除

示例：

movieName = ['綠巨人', '鋼鐵俠', '超人', '雷神', '洛基']
print('------刪除之前------')
print(movieName)
print('------刪除之後------')
movieName.remove('超人')
print(movieName)

運行結果：
------刪除之前------
['綠巨人', '鋼鐵俠', '超人', '雷神', '洛基']
------刪除之後------
['綠巨人', '鋼鐵俠', '雷神', '洛基']

clear:清空所有元素

mlist = [1, 2, 3, 4, 5, 6, 7]
mlist.clear()
print(mlist)

運行結果：
[]

3. 修改元素("改")

修改元素的時候，要通過下標來確定要修改的是哪個元素，然後對其重新賦值

示例：

movieName = ['綠巨人', '鋼鐵俠', '超人', '雷神', '洛基']
print('------修改之前------')
print(movieName)
print('------修改之後------')
movieName[2] = '美國隊長'
print(movieName)

運行結果：
------修改之前------
['綠巨人', '鋼鐵俠', '超人', '雷神', '洛基']
------修改之後------
['綠巨人', '鋼鐵俠', '美國隊長', '雷神', '洛基']

4. 查找元素("查"in, not in, index, count)

in, not in

示例：

name_list = ['tom', 'jerry', 'alice', 'james']
print('tom' in name_list)
print('tom' not in name_list)

運行結果：
True
False

index, count

示例：

name_list = ['tom', 'jerry', 'alice', 'james', 'jerry']
print(name_list.index('jerry', 1, 3))
print(name_list.index('jerry', 4, 6))
print(name_list.count('jerry'))

運行結果：
1
4
2

5. 排序(sort, reverse)

  • sort方法是將list按特定順序重新排列，預設為由小到大，參數reverse=True可改為倒序，由大到小。
  • reverse方法是將list逆置。

示例：

a = [1, 4, 2, 3, 6, 5, 9, 8, 7]
print('----原列表----')
print(a)
print('----reverse----')
a.reverse()
print(a)
print('----sort----')
a.sort()
print(a)
print('----sort(reverse=True)----')
a.sort(reverse=True)
print(a)

運行結果：
----原列表----
[1, 4, 2, 3, 6, 5, 9, 8, 7]
----reverse----
[7, 8, 9, 5, 6, 3, 2, 4, 1]
----sort----
[1, 2, 3, 4, 5, 6, 7, 8, 9]
----sort(reverse=True)----
[9, 8, 7, 6, 5, 4, 3, 2, 1]

 四、元組

python的元組與列表類似，不同之處在於元組的元素不能修改。元組使用小括弧，列表使用方括弧。

tuple = (1, 2, 3, 4)

1. 訪問元組

tuple = (1, 2, 3, 4)
print(tuple[0])
print(tuple[2])

運行結果：
1
3

2. 元組的內置函數count, index

tuple = ('tom', 'jerry', 'alice', 'james')
print(tuple.index('alice', 1, 3))
print(tuple.count('jerry'))

運行結果：
2
1

 五、字典

字典的創建
person = {"name": "sb", 'age': 18}
或
person = dict(name='sb', age=18)
person = dict({"name": "sb", 'age': 18})
person = dict((['name','sb'],['age',18]))

{}.fromkeys(seq,100) #不指定100預設為None
註意：

>>> dic={}.fromkeys(['k1','k2'],[])
>>> dic
{'k1': [], 'k2': []}
>>> dic['k1'].append(1)
>>> dic
{'k1': [1], 'k2': [1]}

變數info為字典類型：

info = {'name':'孫悟空', 'id':100, 'sex':'男', 'address':'花果山'}

說明：

  • 字典和列表一樣，也能夠存儲多個數據
  • 列表中找某個元素時，是根據下標進行的。字典中找某個元素時，是根據'名字'（就是冒號:前面的那個值，例如上面代碼中的'name'、'id'、'sex'）
  • 字典的每個元素由2部分組成，鍵:值。例如 'name':'孫悟空' ,'name'為鍵，'孫悟空'為值

1. 根據鍵訪問值

info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print(info['name'])
print(info['address'])

運行結果：
孫悟空
花果山

若訪問不存在的鍵，則會報錯：
info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print(info['haha'])

運行結果：
Traceback (most recent call last):
  File "X:/xxx/xxx/xxx.py", line 2, in <module>
    print(info['haha'])
KeyError: 'haha'

在我們不確定字典中是否存在某個鍵而又想獲取其值時，可以使用get方法，還可以設置預設值：
info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print(info.get('name'))
print(info.get('haha'))
print(info.get('haha', 'haha'))

運行結果：
孫悟空
None
haha

2. 修改元素

字典的每個元素中的數據是可以修改的，只要通過key找到，即可修改

info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print('----修改前----')
print(info)
print('----修改後----')
info['name'] = "齊天大聖"
print(info)

運行結果：
----修改前----
{'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
----修改後----
{'name': '齊天大聖', 'id': 100, 'sex': '男', 'address': '花果山'}

3. 添加元素

如果在使用變數名['鍵'] = 數據時，這個“鍵”在字典中，不存在，那麼就會新增這個元素

info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print('----修改前----')
print(info)
print('----修改後----')
info['age'] = 500
print(info)

運行結果：
----修改前----
{'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
----修改後----
{'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山', 'age': 500}

4. 刪除元素

del刪除指定的元素

info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print('----刪除前----')
print(info)
print('----刪除後----')
del info['sex']
print(info)

運行結果：
----刪除前----
{'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
----刪除後----
{'name': '孫悟空', 'id': 100, 'address': '花果山'}

clear清空整個字典

info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print('----清空前----')
print(info)
print('----清空後----')
info.clear()
print(info)

運行結果：
----清空前----
{'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
----清空後----
{}

pop刪除指定元素，若刪除的元素不存在，可以指定返回值

dic = {
    'k1': 'v1',
    'k2': 'v2'
}
v = dic.pop('k1')
print(dic, v)
# 運行結果
{'k2': 'v2'} v1

dic = {
    'k1': 'v1',
    'k2': 'v2'
}
v = dic.pop('k111', 1)
print(dic, v)
# 運行結果
{'k1': 'v1', 'k2': 'v2'} 1

5. keys

返回一個包含字典所有KEY的列表

>>> info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}

>>> info.keys()

dict_keys(['name', 'id', 'sex', 'address'])

>>> 

6. values

返回一個包含字典所有value的列表

>>> info = {'name': '孫悟空', 'id': 100, 'sex': '男', 'address': '花果山'}

>>> info.values()

dict_values(['孫悟空', 100, '男', '花果山'])

>>> 

7. items

返回一個包含所有（鍵，值）元組的列表

>>> info = {'name': '孫悟空', 'address': '花果山'}

>>> info.items()

dict_items([('name', '孫悟空'), ('address', '花果山')])

>>> 

8. has_key和in

python3去除了has _key替換為in

如果key在字典中，返回True，否則返回False

>>> info = {'name': '孫悟空', 'address': '花果山'}

>>> 'name' in info

True

>>> 'age' in info

False

>>> 

看看python2中的has_key，當然python2中in也可以使用

>>> info = {'name': '孫悟空', 'address': '花果山'}

>>> 'name' in info

True

>>> info.has_key('name')

True

>>> info.has_key('age')

False

>>> 

9. update

dic = {
    'k1': 'v1',
    'k2': 'v2'
}
dic.update({'k1': 123, 'k3': 456})
print(dic)

# 運行結果
{'k1': 123, 'k2': 'v2', 'k3': 456}

10. 字典遍歷

info = {'name': '孫悟空', 'address': '花果山'}
print('----遍歷字典的key（鍵）----')
for key in info.keys():
    print(key, end='\t')
print()
print('----遍歷字典的value（值）----')
for value in info.values():
    print(value, end='\t')
print()
print('----遍歷字典的項（元素）----')
for item in info.items():
    print(item, end='\t')

運行結果：
----遍歷字典的key（鍵）----
name    address
----遍歷字典的value（值）----
孫悟空   花果山  
----遍歷字典的項（元素）----
('name', '孫悟空')  ('address', '花果山')

六、集合

 1. 定義

　　定義：由不同元素組成的集合，集合中是一組無序排列的可hash值，可以作為字典的key

　　特點：

    • 不同元素組成
    • 無序
    • 每個元素必須是不可變類型

2. 集合的創建

 　　{1,2,3,1}
　　或
　　定義可變集合set
　　>>> set_test=set('hello')
　　>>> set_test
　　{'l', 'o', 'e', 'h'}
　　改為不可變集合frozenset
　　>>> f_set_test=frozenset(set_test)
　　>>> f_set_test
　　frozenset({'l', 'e', 'h', 'o'})

3.  常用操作

add    添加元素

s = {1, 2, 3}
s.add(4)
print(s)

運行結果
{1，2，3，4}

pop    隨機刪除一個元素

s = {'b', 123, 2, 3, 'a'}
s.pop()
print(s)

#運行結果
{3, 'b', 'a', 123}
 

remove    刪除指定元素，刪除不存在的元素時會報錯

s = {'b', 123, 2, 3, 'a'}
s.remove('a')
print(s)

# 運行結果
{2, 3, 'b', 123}

discard    刪除指定元素，刪除不存在的元素時不會報錯

 

intersection  或  &     交集

s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
sb = s.intersection(b)
print(sb)
print(s & b)
# 運行結果
{2, 123, 'a'}
{2, 123, 'a'}

union  或  |    並集 

s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
sb = s.union(b)
print(sb)
print(s | b)

# 運行結果
{2, 3, 'a', 5, 'b', 123}
{2, 3, 'a', 5, 'b', 123}

difference  或  -    差集

s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
sb = s - b
bs = b - s
print(sb, bs)

# 運行結果
{3, 'b'} {5}

symmetric_difference   或  ^     交叉補集（兩個集合不共有的部分）

s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
sb = s.symmetric_difference(b)
print(sb)

# 運行結果
{3, 5, 'b'}

difference_update     返回兩集合的差集

s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
s.difference_update(b) # 將兩集合的差集返回給s
print(s)

# 運行結果
{3, 'b'}

isdisjoint     如果兩集合的交集為空集，返回True

s = {'b', 2, 3, }
b = {'a', 5, 123}
v = s.isdisjoint(b)
print(v)

# 運行結果
True

issubset    如果s1是s2的子集，返回True

s1 = {1, 2}
s2 = {1, 2, 3}
v = s1.issubset(s2)
print(v)

#運行結果
True

 issuperset    如果s1包含s2父集，返回True

s1 = {1, 2}
s2 = {1, 2, 3}
v = s1.issuperset(s2)
print(v)

# 運行結果 
False

update    更新

s1 = {1, 2}
s2 = {1, 2, 3}
s1.update(s2)
print(s1)

# 運行結果
{1，2，3}

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Go基礎編程實踐（五）—— 錯誤和日誌
    自定義錯誤類型 Go中可以使用 創建錯誤信息，也可以通過創建自定義錯誤類型來滿足需求。 是一個介面類型，所有實現該介面的類型都可以當作一個錯誤類型。 記錄日誌 捕獲異常 ...
  • Win10下安裝Hadoop3.1.2詳解
    Win10下安裝Hadoop3.1.2詳解 嘗試在本地win10上安裝hadoop，在官網選擇了最新的hadoop版本，就是這裡開始給自己挖了坑，對著網上的博客一頓操作，發現節點一直啟動不成功。本著不放棄的原則，在不停的配置過程中繼續折騰，終於解決問題。 安裝環境 JDK 1.8 Windows10 ...
  • Java連載2-Java特性
    一、JDK 1.含義：Java開發工具包。 2.做Java開發之前必須安裝的一個工具包，​下載地址：https://www.oracle.com/index.html 3.Java包括三大塊內容： （1）JavaSE(Java標準版)，這是基礎必知必會 （2）JavaEE(Java企業版) （3）J ...
  • Redis基礎命令
    1.Redis單進程: 單進程模型來處理客戶端的請求。對讀寫等事件的響應是通過對epoll函數的包裝來做到的。Redis的實際處理速度完全依靠主進程的執行效率。epoll是Linux內核為處理大批量文件描述符而作了改進的epoll，是Linux下多路復用IO介面select/poll的增強版本，它能 ...
  • 學習第二天：總結
    [TOC] 1.while迴圈 死迴圈 打斷死迴圈： 關鍵字： 2.字元串格式化： 3.運算符 4.編碼 四種（重要） 單位轉換 ...
  • 網易Java研發麵試官眼中的Java併發——安全性、活躍性、性能
    一. 安全性問題 線程安全的本質是正確性，而正確性的含義是程式按照預期執行 理論上線程安全的程式，應該要避免出現可見性問題（CPU緩存）、原子性問題（線程切換）和有序性問題（編譯優化） 需要分析是否存線上程安全問題的場景：存在共用數據且數據會發生變化，即有多個線程會同時讀寫同一個數據 針對該理論的解 ...
  • 一天不學java,渾身難受!
    this 註意 public class ThisDemo { public static void main(String[] args) { } } class Person{ public String name; public int age; public boolean gender; ...
  • ThinkPHP框架
    1.TP框架基礎 1.1目錄結構 1.2配置文件 1.框架主配置文件（慣例配置文件） thinkphp/convention.php 2. 應用公共配置文件 application/config.php， application/database.php 對整個應用生效 3.模塊配置文件 appli ...
一周排行
    -Advertisement-
    Play Games
  • WPF 已知問題 監聽 WMI 事件導致觸摸失效
    示例項目結構 在 Visual Studio 中創建一個 WinForms 應用程式後，項目結構如下所示： MyWinFormsApp/ │ ├───Properties/ │ └───Settings.settings │ ├───bin/ │ ├───Debug/ │ └───Release/ ...
  • [STAThread]特性
    [STAThread] 特性用於需要與 COM 組件交互的應用程式，尤其是依賴單線程模型（如 Windows Forms 應用程式）的組件。在 STA 模式下，線程擁有自己的消息迴圈，這對於處理用戶界面和某些 COM 組件是必要的。 [STAThread] static void Main(stri ...
  • UWP WinUI3 傳入 AddHandler 的 RoutedEventHandler 類型與事件所需不匹配將拋出參數異常
    在WinForm中使用全局異常捕獲處理 在WinForm應用程式中，全局異常捕獲是確保程式穩定性的關鍵。通過在Program類的Main方法中設置全局異常處理，可以有效地捕獲並處理未預見的異常，從而避免程式崩潰。 註冊全局異常事件 [STAThread] static void Main() { / ...
  • .NET 多版本 WinForm 開源控制項庫 SunnyUI
    前言 給大家推薦一款開源的 Winform 控制項庫，可以幫助我們開發更加美觀、漂亮的 WinForm 界面。 項目介紹 SunnyUI.NET 是一個基於 .NET Framework 4.0+、.NET 6、.NET 7 和 .NET 8 的 WinForm 開源控制項庫，同時也提供了工具類庫、擴展 ...
  • .net core8 使用Swagger（附當前源碼）
    說明 該文章是屬於OverallAuth2.0系列文章，每周更新一篇該系列文章（從0到1完成系統開發）。 該系統文章，我會儘量說的非常詳細，做到不管新手、老手都能看懂。 說明：OverallAuth2.0 是一個簡單、易懂、功能強大的許可權+可視化流程管理系統。 有興趣的朋友，請關註我吧(*^▽^*) ...
  • WPF 什麼時候 VisualTreeHelper.GetDescendantBounds 將返回無窮大
    一、下載安裝 1.下載git 必須先下載並安裝git，再TortoiseGit下載安裝 git安裝參考教程：https://blog.csdn.net/mukes/article/details/115693833 2.TortoiseGit下載與安裝 TortoiseGit，Git客戶端，32/6 ...
  • C# 開源教程帶你輕鬆掌握數據結構與演算法
    前言 在項目開發過程中，理解數據結構和演算法如同掌握蓋房子的秘訣。演算法不僅能幫助我們編寫高效、優質的代碼，還能解決項目中遇到的各種難題。 給大家推薦一個支持C#的開源免費、新手友好的數據結構與演算法入門教程：Hello演算法。 項目介紹 《Hello Algo》是一本開源免費、新手友好的數據結構與演算法入門 ...
  • 第22篇 生成proto文件bat腳本
    1.生成單個Proto.bat內容 @rem Copyright 2016, Google Inc. @rem All rights reserved. @rem @rem Redistribution and use in source and binary forms, with or with ...
  • 記一次 .NET某上位機視覺程式 卡死分析
    一：背景 1. 講故事 前段時間有位朋友找到我，說他的窗體程式在客戶這邊出現了卡死，讓我幫忙看下怎麼回事？dump也生成了，既然有dump了那就上 windbg 分析吧。 二：WinDbg 分析 1. 為什麼會卡死 窗體程式的卡死，入口門檻很低，後續往下分析就不一定了，不管怎麼說先用 !clrsta ...
  • 醫學DICOM文件與PACS系統進行數據傳輸
    前言 人工智慧時代，人臉識別技術已成為安全驗證、身份識別和用戶交互的關鍵工具。 給大家推薦一款.NET 開源提供了強大的人臉識別 API，工具不僅易於集成，還具備高效處理能力。 本文將介紹一款如何利用這些API，為我們的項目添加智能識別的亮點。 項目介紹 GitHub 上擁有 1.2k 星標的 C# ...
所有分類