字符串和常用數(shù)據(jù)結(jié)構(gòu)

這個地方得好好看按摘，正常得就是在操作字符串和這些類型的使用

1.字符串一些操作

字符串操作

def main():
    str1 = 'hello world!'
    str2 = 'abc123456'
    str3 = '   testspace   '
    #do demo
if __name__ == '__main__':
    main()

下面有個講的很詳細的 傳送門

上代碼：

import os
import time
def main():

    # 這一片是字符串
    str1 = 'hello, world!'
    # 通過len函數(shù)計算字符串的長度
    print(len(str1))  # 13
    # 獲得字符串首字母大寫的拷貝
    print(str1.capitalize())  # Hello, world!
    # 獲得字符串變大寫后的拷貝
    print(str1.upper())  # HELLO, WORLD!
    # 從字符串中查找子串所在位置
    print(str1.find('or'))  # 8
    print(str1.find('shit'))  # -1
    # 與find類似但找不到子串時會引發(fā)異常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 檢查字符串是否以指定的字符串開頭
    print(str1.startswith('He'))  # False
    print(str1.startswith('hel'))  # True
    # 檢查字符串是否以指定的字符串結(jié)尾
    print(str1.endswith('!'))  # True
    # 將字符串以指定的寬度居中并在兩側(cè)填充指定的字符
    print(str1.center(20, '*'))
    # 將字符串以指定的寬度靠右放置左側(cè)填充指定的字符
    print(str1.rjust(20, '*'))
    print(str1.ljust(20, ' '))
    str2 = 'abc123456'
    # 從字符串中取出指定位置的字符(下標運算)
    print(str2[2])  # c
    # 字符串切片(從指定的開始索引到指定的結(jié)束索引)
    print(str2[2:5])  # c12
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    # 檢查字符串是否由數(shù)字構(gòu)成
    print(str2.isdigit())  # False
    # 檢查字符串是否以字母構(gòu)成
    print(str2.isalpha())  # False
    # 檢查字符串是否以數(shù)字和字母構(gòu)成
    print(str2.isalnum())  # True
    str3 = '  jackfrued@126.com '
    print(str3)
    # 獲得字符串修剪左右兩側(cè)空格的拷貝
    print(str3.strip())

    # content = '北京歡迎你為你開天辟地······'
    # while True:
    #     # 清理屏幕上的輸出
    #     os.system('cls')  # os.system('clear')
    #     print(content)
    #     # 休眠200毫秒
    #     time.sleep(0.2)
    #     content = content[1:] + content[0]


if __name__ == '__main__':
    main()

執(zhí)行結(jié)果：

13
Hello, world!
HELLO, WORLD!
8
-1
False
True
True
***hello, world!****
*******hello, world!
hello, world!       
c
c12
c123456
c246
ac246
654321cba
45
False
False
True
  jackfrued@126.com 
jackfrued@126.com

2.列表

列表是Python中最基本的數(shù)據(jù)結(jié)構(gòu)跃惫。列表中的每個元素都分配一個數(shù)字 - 它的位置应又，或索引，第一個索引是0罕邀，第二個索引是1畅形，依此類推。

格式是這個樣子诉探，塞啥進去都行

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

2.1列表的操作日熬，和上面字符串操作方式基本一致 主要可以分為增刪改查

2.1.1訪問列表的值 通過[] -- 查

實例：

    list1 = ['one', 'two', 1, 2 , 'xxx', 'yyy', 1000, 1234]
    print(type(list1))
    print('list [0]:', list1[0], 'list[-2]:',list1[-2])
    print('list[1:]', list1[1:], 'list[0:2]', list1[0:2], 'list1[::2]', list1[::2], '\n', 'list[::-1]', list1[::-1],
          'list1[7::-1]', list1[7::-1])

結(jié)果:

<class 'list'>
list [0]: one list[-2]: 1000
list[1:] ['two', 1, 2, 'xxx', 'yyy', 1000, 1234] list[0:2] ['one', 'two'] list1[::2] ['one', 1, 'xxx', 1000] 
 list[::-1] [1234, 1000, 'yyy', 'xxx', 2, 1, 'two', 'one'] list1[7::-1] [1234, 1000, 'yyy', 'xxx', 2, 1, 'two', 'one']

[]這個操作符是左閉右開區(qū)間，要想訪問最右邊的如果是正向肾胯，就最大index加1竖席，如果是反向耘纱，就不寫

2.1.2更新列表，直接賦值 --改

不能超過列表的最大下標毕荐，不然會報列表溢出異常

實列:

   list1 = ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234]
    print(list1)
    list1[1] = 123
    list1[2] = '123'
    list1[0] = 'two'
    list1[4] = 2222
    print(list1)

結(jié)果:

['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234]
['two', 123, '123', 2, 2222, 'yyy', 1000, 1234]

類型啊束析，內(nèi)容都可以改

2.1.3增加列表項，通過append(obj)追加和insert(index,obj)插入 來實現(xiàn) -- 增

看實例：

 list1 = ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234]
    print(list1)
    list1.append('test_append')
    list1.insert(3, 'test_insert')
    print(list1)

執(zhí)行結(jié)果：

['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234]
['one', 'two', 1, 'test_insert', 2, 'xxx', 'yyy', 1000, 1234, 'test_append']

這個append和insert都是國際慣例

2.1.4 刪除憎亚，可以用del员寇，remove，pop第美，clear 這些來實現(xiàn)蝶锋，具體看實例 -- 刪

實例：

       list1 = ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']
    print(list1)
    del list1[0]  # 刪除制定的元素
    print(list1)
    list1.remove(1234)  # 清除元素，你得知道你是啥 或者 改成 list1.remove(list1[6]) 這樣
    print(list1)
    list1.pop()  # 出棧的操作什往，竟然不支持push扳缕，奇怪，pop（index = -1）
    print(list1)
    list1.pop(1)  # 同上
    print(list1)
    list1.clear()  # 一了百了了
    print(list1)

['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']
['two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']
['two', 1, 2, 'xxx', 'yyy', 1000, 'test_del']
['two', 1, 2, 'xxx', 'yyy', 1000]
['two', 2, 'xxx', 'yyy', 1000]
[]

怎刪改查就這樣了别威，也就這么多操作了躯舔，這部分基本都是對列表元素的操作，下面一部分是對列表的操作

2.2對列表的一些操作兔港，腳本操作符庸毫，截取與拼接，嵌套列表

2.2.1 操作符

2.2.2 截取與拼接

L=['Google', 'Runoob', 'Taobao']

拼接使用加號

實例：

    list1 = ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']
    print(list1)
    list1 += list1
    print(list1)

結(jié)果：

['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']
['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 'one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']

2.2.3 嵌套列表 就是可以列表里套列表衫樊，俄羅斯套娃

直接上實例：

    list1 = ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']
    print(list1)
    list2 = [list1,list1]
    print(list2)

執(zhí)行結(jié)果：

['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']
[['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del'], ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']]

2.3 對列表有用的一些函數(shù)和列表的方法

• python包含以下函數(shù):
  點鏈接可以跳轉(zhuǎn)

實例

    list1 = ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del']
    print(len(list1))
    # print(max(list1)) # 不能既包含數(shù)字又包含字母
    list_max_min = ['a', 'b', 'c', 'd']
    print(max(list_max_min))
    print(min(list_max_min))
    list_max_min = ['1', '2', '3', '4']
    print(max(list_max_min))
    print(min(list_max_min))
    list_max_min = [1, 2, 3, 4]
    print(max(list_max_min))
    print(min(list_max_min))
    seq = (1, '1', 'test_seq')
    print(seq)
    print(list(seq))

結(jié)果：

9
d
a
4
1
4
1
(1, '1', 'test_seq')
[1, '1', 'test_seq']

• Python包含以下方法:

實例：

list1 = ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 1234]
    list1.append('test_append')
    print('list1.append(\'test_append\')', list1)
    print('list1.count(1234)', list1.count(1234))
    print('list1.count(list1[7]', list1.count(list1[7]))
    list1.extend((1, 2, 3, 4))
    print('list1.extend((1, 2, 3, 4))', list1)
    print('list1.index(1)', list1.index(1))
    # print(list1.index(-1)) 不能這么玩
    list1.insert(1,'test_insert')
    print('list1.insert(1,\'test_insert\')',list1)
    list1.pop()
    print('list1.pop()', list1)
    list1.pop(-3)
    print('list1.pop(-3)', list1)
    list1.remove('one')
    print('list1.remove(\'one\')', list1)
    list1.remove(list1[1])
    print('list1.remove(list1[1])', list1)
    list1.reverse()
    print('list1.reverse()', list1)
    list_sort = [1, 3, 7, 2, 10, 6]
    list_sort.sort(reverse=True)
    print('list_sort.sort(reverse=True)', list_sort)
    list2 = list1.copy()
    print('list2 = list1.copy()', list2)
    list2.clear()
    print('list2.clear()', list1)

結(jié)果：

list1.append('test_append') ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 1234, 'test_append']
list1.count(1234) 2
list1.count(list1[7] 2
list1.extend((1, 2, 3, 4)) ['one', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 1234, 'test_append', 1, 2, 3, 4]
list1.index(1) 2
list1.insert(1,'test_insert') ['one', 'test_insert', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 1234, 'test_append', 1, 2, 3, 4]
list1.pop() ['one', 'test_insert', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 1234, 'test_append', 1, 2, 3]
list1.pop(-3) ['one', 'test_insert', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 1234, 'test_append', 2, 3]
list1.remove('one') ['test_insert', 'two', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 1234, 'test_append', 2, 3]
list1.remove(list1[1]) ['test_insert', 1, 2, 'xxx', 'yyy', 1000, 1234, 'test_del', 1234, 'test_append', 2, 3]
list1.reverse() [3, 2, 'test_append', 1234, 'test_del', 1234, 1000, 'yyy', 'xxx', 2, 1, 'test_insert']
list_sort.sort(reverse=True) [10, 7, 6, 3, 2, 1]
list2 = list1.copy() [3, 2, 'test_append', 1234, 'test_del', 1234, 1000, 'yyy', 'xxx', 2, 1, 'test_insert']
list2.clear() [3, 2, 'test_append', 1234, 'test_del', 1234, 1000, 'yyy', 'xxx', 2, 1, 'test_insert']

列表大概就這么些

3.元組類型

Python 的元組與列表類似，不同之處在于元組的元素不能修改炒事。
元組使用小括號臀栈，列表使用方括號。
元組創(chuàng)建很簡單挠乳，只需要在括號中添加元素权薯，并使用逗號隔開即可。

格式就是這個樣子的

    tup1 = ('Google', 'Runoob', 1997, 2000);
    print(tup1)
    tup2 = (1, 2, 3, 4, 5);
    tup3 = "a", "b", "c", "d";  # 不需要括號也可以
    print(type(tup3))
    tup4 = (50)
    print(tup4)
    print(type(tup4))
    tup5 = (50,)
    print(tup5)
    print(type(tup5))

結(jié)果：

('Google', 'Runoob', 1997, 2000)
<class 'tuple'>
50
<class 'int'>
(50,)
<class 'tuple'>

3.1訪問元祖

通過[]來訪問下標訪問元組中的值

實例：

    tup1 = ('Google', 'Runoob', 1997, 2000);
    print(tup1)
    print('tupl[0]', tup1[0])
    print('tup1[1:3]', tup1[1:3])
    print('tupl[:]', tup1[:])
    print('tup1[::]', tup1[::])
    print('tup1[::2]', tup1[::2])
    print('tup1[::-1]', tup1[::-1])
    print('tup1[::-2]', tup1[::-2])

結(jié)果：

('Google', 'Runoob', 1997, 2000)
tupl[0] Google
tup1[1:3] ('Runoob', 1997)
tupl[:] ('Google', 'Runoob', 1997, 2000)
tup1[::] ('Google', 'Runoob', 1997, 2000)
tup1[::2] ('Google', 1997)
tup1[::-1] (2000, 1997, 'Runoob', 'Google')
tup1[::-2] (2000, 'Runoob')

3.2修改元組

元組張的元素沒法修改的睡扬，可以連接增加元組

實例：

    tup1 = ('Google', 'Runoob', 1997, 2000);
    print(tup1)
    tup6 = tup1+tup1
    print(tup6)

('Google', 'Runoob', 1997, 2000)
('Google', 'Runoob', 1997, 2000, 'Google', 'Runoob', 1997, 2000)

3.3刪除元組

刪除不了元素盟蚣，只能刪除了，刪除就直接釋放掉了卖怜，也不用打印了屎开，打印出錯

實例：

    tup1 = ('Google', 'Runoob', 1997, 2000);
    print(tup1)
    del tup1
    print(tup1)

結(jié)果:

('Google', 'Runoob', 1997, 2000)
Traceback (most recent call last):
  File "day007.py", line 180, in <module>
    main()
  File "day007.py", line 176, in main
    print(tup1)
UnboundLocalError: local variable 'tup1' referenced before assignment

3.4 元組的一些操作，包括運算符马靠，索引奄抽，截取蔼两，內(nèi)置函數(shù)

3.4.1元組運算符

與字符串一樣，元組之間可以使用 + 號和 * 號進行運算逞度。這就意味著他們可以組合和復(fù)制额划，運算后會生成一個新的元組。

3.4.2 元組索引档泽，截取

就是通過[]來實現(xiàn)

L = ('Google', 'Taobao', 'Runoob')

3.4.3元組的內(nèi)置函數(shù)

就下面這幾個

• len(tuple)
  計算元組元素個數(shù)。

實例：

    tuple1 = ('Google', 'Runoob', 'Taobao')
    print(len(tuple1))

結(jié)果:

3

• max(tuple)
  返回元組中元素最大值甜熔。不能有str和int 混合圆恤，不然會報錯

實例：

    tuple2 = ('5', '4', '8')
    print(max(tuple2))

結(jié)果：

8

• min(tuple)
  返回元組中元素最小值。不能有str和int 混合腔稀，不然會報錯

實例：

    tuple2 = ('5', '4', '8')
    min(tuple2)

結(jié)果：

4

• tuple(seq)
  將列表轉(zhuǎn)換為元組盆昙。這個和那個list是個你過程

實例：

    list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] 
    tuple1=tuple(list1)
    print(tuple1)

結(jié)果:

('Google', 'Taobao', 'Runoob', 'Baidu')

4.字典

字典是另一種可變?nèi)萜髂Ｐ停铱纱鎯θ我忸愋蛯ο蟆?/p>

字典的每個鍵值(key=>value)對用冒號(:)分割焊虏，每個對之間用逗號(,)分割淡喜，整個字典包括在花括號({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

聯(lián)想下map

4.1這里主要了解下操作，跟上面一樣诵闭，增刪改查

4.1.1訪問字典里的值--查

通過[]里面加key的方式訪問

實例：

    dict1 = {'name': 'jinxx', 123: 345, 444: 'xxx'}
    print(dict1)
    print('dict1[list(dict1.keys())[0]] :', dict1[list(dict1.keys())[0]])  # 這個地方很好玩炼团，拿到dict1的所有key轉(zhuǎn)換為list的第一個元素做為key的dict1的value
    print('name:', dict1['name'])

結(jié)果:

{'name': 'jinxx', 123: 345, 444: 'xxx'}
dict1[list(dict1.keys())[0]] : jinxx
name: jinxx

就這么玩的，操作不存在的key會拋異常疏尿，慎重瘟芝，但是可以賦值，賦值的話就是新增了

4.1.2 修改字典-- 增和改

向字典添加新內(nèi)容的方法是增加新的鍵/值對褥琐，修改或刪除已有鍵/值對

如下實例:

   dict1 = {'name': 'jinxx', 123: 345, 444: 'xxx'}
    print(dict1)
    dict1['name'] = 'liuxxx'
    print(dict1)
    dict1['age'] = 26
    print(dict1)

結(jié)果：

{'name': 'jinxx', 123: 345, 444: 'xxx'}
{'name': 'liuxxx', 123: 345, 444: 'xxx'}
{'name': 'liuxxx', 123: 345, 444: 'xxx', 'age': 26}

就這么簡單

4.1.3 刪除字典元素 --刪

可以用del锌俱，clear，pop敌呈，popitem

直接看實例：

    dict1 = {'name': 'jinxx', 123: 345, 444: 'xxx', 555: 5555, 'xxx': 444}
    print(dict1)
    del dict1[444]
    print('del dict1[444]:', dict1)
    dict1.pop('xxx')
    print('dict1.pop(\'xxx\')', dict1)
    dict1.popitem()
    print('dict1.popitem():', dict1)
    dict1.clear()
    print('dict1.clear()', dict1)

結(jié)果：

{'name': 'jinxx', 123: 345, 444: 'xxx', 555: 5555, 'xxx': 444}
del dict1[444]: {'name': 'jinxx', 123: 345, 555: 5555, 'xxx': 444}
dict1.pop('xxx') {'name': 'jinxx', 123: 345, 555: 5555}
dict1.popitem(): {'name': 'jinxx', 123: 345}
dict1.clear() {}

4.2字典的2個特征

4.2.1不允許同一個鍵出現(xiàn)兩次贸宏。創(chuàng)建時如果同一個鍵被賦值兩次，后一個值會被記住磕洪，

實例：

dic1 = {111: 222, '0000': '1111', 111: 3333}
print(dic1[111])

結(jié)果：

3333

4.2.2鍵(key)必須不可變吭练，所以可以用數(shù)字，字符串或元組充當褐鸥，而用列表就不行线脚，用了就給你拋異常

實例：

dict2 = {(123, 456): 'abc'}
print('dict2 :', dict2)
dict3 = {[123, 456]: 'abc'}
print('dict3', dict3)

結(jié)果:

dict2 : {(123, 456): 'abc'}
    dict3 = {[123, 456]: 'abc'}
TypeError: unhashable type: 'list'

就是這個list是可變的算不出來hash值

4.3 字典內(nèi)置函數(shù)&方法

4.3.1內(nèi)置函數(shù)主要包括一下三個

• len(dict) 計算字典元素個數(shù)，即鍵的總數(shù)。
• str(dict) 輸出字典浑侥，以可打印的字符串表示姊舵。
• type(variable) 返回輸入的變量類型，如果變量是字典就返回字典類型寓落。

實例：

dic1 = {111: 222, '0000': '1111', 111: 3333}
print('len(dic1)', len(dic1))
print('str(dic1)', str(dic1))
print('type(dic1)', type(dic1))

結(jié)果:

len(dic1) 2
str(dic1) {111: 3333, '0000': '1111'}
type(dic1) <class 'dict'>

str()函數(shù)還排了個小序

4.3.2 Python字典包含了以下內(nèi)置方法：

實例操作一波

dic1 = {111: 222, '0000': '1111', 111: 3333}
dict2 = dic1.copy()
print('copy:', dict2)

tup1 = (1, 2, 3, 4, 5)
dict3 = {}
dict3 = dict3.fromkeys(tup1, 'tup')
print('fromkeys(tup1, \'tup\'):',dict3)
list1 = [4, 3, 2, 1,5,6,8]
dict4 = {}
dict4 = dict4.fromkeys(list1, 'list')
print('fromkeys(list1, \'list\'):', dict4)

print('dict4.get(4):', dict4.get(4))
print('dict4.get(100):', dict4.get(100))
print('dict4.get(100, \'nop\'):', dict4.get(100, 'nop'))

if 100 not in dict4:
    print('100  not in dict4')
if 1 in dict4:
    print('1 in dict4')

print('dict4.items():', dict4.items())

print('dict4.keys():', dict4.keys())
print('lsit(dict4.keys()):', list(dict4.keys()))

print('dict4.setdefault(3,\'default\'):', dict4.setdefault(3, 'default'))
print('dict4.setdefault(100,\'default\'):', dict4.setdefault(100, 'default'))

dict4.update(dict3)
print('dict4.update(dict3)', dict4)

print('dict4.values():', dict4.values())
print('list(dict4.values())', list(dict4.values()))

dict4.pop(100)
print('dict4.pop():', dict4)

dict4.popitem()
print('dict4.popitem()', dict4)

dict4.clear()
print('dict4.clear()', dict4)

**結(jié)果: **

copy: {111: 3333, '0000': '1111'}
fromkeys(tup1, 'tup'): {1: 'tup', 2: 'tup', 3: 'tup', 4: 'tup', 5: 'tup'}
fromkeys(list1, 'list'): {4: 'list', 3: 'list', 2: 'list', 1: 'list', 5: 'list', 6: 'list', 8: 'list'}
dict4.get(4): list
dict4.get(100): None
dict4.get(100, 'nop'): nop
100  not in dict4
1 in dict4
dict4.items(): dict_items([(4, 'list'), (3, 'list'), (2, 'list'), (1, 'list'), (5, 'list'), (6, 'list'), (8, 'list')])
dict4.keys(): dict_keys([4, 3, 2, 1, 5, 6, 8])
lsit(dict4.keys()): [4, 3, 2, 1, 5, 6, 8]
dict4.setdefault(3,'default'): list
dict4.setdefault(100,'default'): default
dict4.update(dict3) {4: 'tup', 3: 'tup', 2: 'tup', 1: 'tup', 5: 'tup', 6: 'list', 8: 'list', 100: 'default'}
dict4.values(): dict_values(['tup', 'tup', 'tup', 'tup', 'tup', 'list', 'list', 'default'])
list(dict4.values()) ['tup', 'tup', 'tup', 'tup', 'tup', 'list', 'list', 'default']
dict4.pop(): {4: 'tup', 3: 'tup', 2: 'tup', 1: 'tup', 5: 'tup', 6: 'list', 8: 'list'}
dict4.popitem() {4: 'tup', 3: 'tup', 2: 'tup', 1: 'tup', 5: 'tup', 6: 'list'}
dict4.clear() {}

有點多，哈啊哈

5 集合

集合（set）是一個無序的不重復(fù)元素序列耙饰。

可以使用大括號{ } 或者 set() 函數(shù)創(chuàng)建集合纹笼，注意：創(chuàng)建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創(chuàng)建一個空字典苟跪。

創(chuàng)建格式：

parame = {value01,value02,...}
# 或者
set(value)

集合支持數(shù)學運算
而且可以進行交集 &廷痘、并集 |、差集 -對稱差 ^運算。

實例：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print('type(basket):', type(basket))
print('basket:', basket)
print('\'orange\' in basket:', 'orange' in basket)
print('\'abc\' in basket:', 'abc' in basket)

a = {1, 2, 3, 4}
b = {4, 5, 6, 7}
print('a-b:', a-b)
print('a|b:', a|b)
print('a&b:', a&b)
print('a^b:', a^b)

**結(jié)果: **

type(basket): <class 'set'>
basket: {'banana', 'pear', 'orange', 'apple'}
'orange' in basket: True
'abc' in basket: False
a-b: {1, 2, 3}
a|b: {1, 2, 3, 4, 5, 6, 7}
a&b: {4}
a^b: {1, 2, 3, 5, 6, 7}

自動去重去掉一個orange，用in可以判斷是否包含

5.1集合的一些基操

5.1.1添加元素

添加元素可以使用add和update

• add() 除了list都可以菩收，使用list會報錯驰贷，unhashable的錯誤
• update() 必須得是迭代器iterable才行，int昨寞，float都不行

看實例吧：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print('basket:', basket)
basket.add((1, 2))
print(basket)
basket.add(123)
print(basket)
# basket.add([123, 456])
# print(basket) # TypeError: unhashable type: 'list'
basket.update('333', (123, 456), ['list1', 'list2'])
print(basket)

結(jié)果：

basket: {'pear', 'orange', 'banana', 'apple'}
{(1, 2), 'orange', 'banana', 'pear', 'apple'}
{(1, 2), 'orange', 'banana', 'pear', 123, 'apple'}
{(1, 2), 'orange', 'banana', 456, '3', 'list2', 'pear', 123, 'list1', 'apple'}

5.1.2刪除元素

主要有3種方式

• remove() 這個刪除指定元素瞻惋，沒有得話會報錯，慎用
• discard() 這個隨意援岩，不會報錯
• pop() 這個不管啥歼狼，出第一個，然鵝并不能出空的享怀，會報錯KeyError: 'pop from an empty set

看實例吧：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)
basket.remove('pear')
print(basket)
basket.discard('apple')
print(basket)
basket.pop()
print(basket)
basket.pop()
print(basket)
basket.pop()
print(basket)

結(jié)果:

{'apple', 'pear', 'banana', 'orange'}
{'apple', 'banana', 'orange'}
{'banana', 'orange'}
{'orange'}
set()
Traceback (most recent call last):
  File "day007_home.py", line 95, in <module>
    basket.pop()
KeyError: 'pop from an empty set'

加個len()判斷就不會撲空

5.1.3 len()判斷長度羽峰，就這么簡單

實例:

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(len(basket))

結(jié)果：

4

5.1.4 x in set 判斷元素是否在集合中

實例：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print('basket:', basket)
print('\'orange\' in basket:', 'orange' in basket)
print('\'abc\' in basket:', 'abc' in basket)

結(jié)果:

basket: {'orange', 'banana', 'apple', 'pear'}
'orange' in basket: True
'abc' in basket: False

5.1.5 內(nèi)置的一些函數(shù)

直接上實例就是咯：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print('basket:', basket)
basket.add(123)
print(basket)
basket1 = basket.copy()
print(basket1)
a = {1, 2, 3, 4, 'a'}
b = {3, 4, 6, 7 , 'a'}
print(a.difference(b,basket))
a.difference_update(b)
print(a)
a = {1, 2, 3, 4}
a.discard(3)
print(a)
print(a.intersection(b))
a.intersection_update(b)
print(a)
a = {1, 2, 3, 4}
b = {1, 2, 3, 4, 5, 7}
x = a.isdisjoint(b)
print(x)  # 奇怪
print(a.issubset(b))
print(a.issuperset(b))
a.pop()
print(a)
b.remove(1)
print(b)
print(a.symmetric_difference(b))
a.symmetric_difference_update(b)
print(a)
a = {1, 2, 3, 4}
print(a.union(b))
a.update('123', (8, 9), ['lsit1','list2'])
print(a)
a = {1, 2, 3, 4}
a.update({'123'}, (8, 9), ['lsit1','list2'])
print(a)
a.clear()
print(a)

結(jié)果：

basket: {'banana', 'pear', 'apple', 'orange'}
{'pear', 'banana', 123, 'apple', 'orange'}
{'banana', 123, 'pear', 'apple', 'orange'}
{1, 2}
{1, 2}
{1, 2, 4}
{4}
{4}
False
True
False
{2, 3, 4}
{2, 3, 4, 5, 7}
{5, 7}
{5, 7}
{1, 2, 3, 4, 5, 7}
{'3', 1, 2, 3, 4, '2', 'lsit1', 8, 9, '1', 'list2'}
{1, 2, 3, 4, 8, 9, '123', 'lsit1', 'list2'}
set()

這篇寫了好多行。搓幌。杆故。。打完收工溉愁，睡大覺

文集傳送門 學習python100天

---

整個學習python100天的目錄傳送門

---

無敵分割線

---

再最后面附上大神的鏈接傳送門