亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

和list、dict一樣，有時候我們也需要考慮刪除set的元素。
set提供了remove()方法允許我們刪除set中的元素。

name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
name_set.remove('Jenny')
print(name_set) # ==> set(['Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])

需要注意的是，如果remove的元素不在set里面的話，那么將會引發錯誤。

name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
name_set.remove('Jenny')
print(name_set) # ==> set(['Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
name_set.remove('Jenny') # ==> 重復remove 'Jenny'
# 引起錯誤
Traceback (most recent call last):
?File "<stdin>", line 1, in <module>
KeyError: 'Jenny'

比如，班里面來了新的同學，名字叫Gina。

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)
name_set.add('Gina')
print(name_set) # ==> set(['Gina', 'Alice', 'Candy', 'David', 'Ellena', 'Bob'])

可以看到，'Gina'已經添加到name_set里面去了。對于set，如果添加一個已經存在的元素，不會報錯，也不會改變什么。

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)
name_set.add('Alice')
print(name_set) # ==> set(['Bob', 'Ellena', 'Alice', 'Candy', 'David'])

有些時候需要批量往set里面添加元素，如果一個一個add是比較麻煩的，有沒有批量往set里面添加元素的方法呢？
set提供了update()方法，可以一次性給set添加多個元素。
比如，新來了一批同學，名字分別是['Hally',? 'Isen',? 'Jenny',? 'Karl']，則可以使用update()方法，批量往set中添加。

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
new_names = ['Hally', 'Isen', 'Jenny', 'Karl']
name_set = set(names)
name_set.update(new_names) # ==> set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
print(name_set)

有的時候，我們只想要 dict 的 key，不關心 key 對應的 value，目的就是保證這個集合的元素不會重復，這時，set就派上用場了。
set和list類似，擁有一系列元素，但是set和list不一樣，set里面的元素是不允許重復的，而list里面可以包含相同的元素；set與list的另一個區別是，set里面的元素是沒有順序的。
創建set的方式是使用set()，并傳入一個list，list的元素將會被轉換成set的元素。

s = set([1, 4, 3, 2, 5])
print(s) # ==> set([1, 2, 3, 4, 5])

需要注意的是，上述打印的形式類似 list， 但它不是 list，仔細看還可以發現，打印的順序和原始 list 的順序有可能是不同的，因為set內部存儲的元素是無序的。
另外，set不能包含重復的元素，我們傳入重復的元素看看會發生什么。

s = set([1, 4, 3, 2, 5, 4, 2, 3, 1])
print(s) # ==> set([1, 2, 3, 4, 5])

可以看到，在傳入set()的list中，包含了重復的元素，但是打印的時候，相同的元素只保留了一個，重復的元素都被去掉了，這是set的一個重要特點。

dict提供keys()函數，可以返回dict中所有的key。

d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
for key in d.keys():
? ?print(key)
# ==> Alice
# ==> Bob
# ==> Candy

ict提供values()函數，可以返回dict中所有的value。

d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
for key in d.values():
? ?print(key)
# ==> [50, 61, 66]
# ==> [80, 61, 66]
# ==> [88, 75, 90]

清除所有元素

dict提供clear()函數，可以直接清除dict中所有的元素。

d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
print(d) # ==> {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
d.clear()
print(d) # ==> {}

通過直接print(d)，我們打印出來的是完整的一個dict；有時候，我們需要把dict中m一定條件的元素打印出來，比如成績超過60的，在這種情況下，我們需要則需要遍歷dict（這種時候需要使用for循環），并通過條件判斷把滿足條件的打印出來。
遍歷dict有兩種方法， 第一種是遍歷dict的所有key，并通過key獲得對應的value。

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49
}
for key in d: # 遍歷d的key
? ?value = d[key]
? ?if value > 60:
? ? ? ?print(key, value)
# ==> Candy 75
# ==> David 86

第二種方法是通過dict提供的items()方法，items()方法會返回dict中所有的元素，每個元素包含key和value。

for key, value in d.items():
? ?if value > 60:
? ? ? ?print(key, value)
# ==> Candy 75
# ==> David 86

dict提供便捷的pop()方法，允許我們快速刪除元素，pop()方法需要指定需要刪除的元素的key，并返回對應的value。
假設Alice轉校了，需要把Alice的成績刪除，可以這樣寫：

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49
}
print(d) # ==> {'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}
alice_score= d.pop('Alice')
print(alice_score) # ==> 45
print(d) # ==> {'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}

需要注意的是，pop()方法的參數是dict中的key，當key不存在時，同樣會引起錯誤。比如在上述操作中，已經把Alice的成績刪除了，假如再次pop('Alice')，將會引發錯誤。

d.pop('Alice')
# 報錯
Traceback (most recent call last):
?File "<stdin>", line 1, in <module>
KeyError: 'Alice'

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49
}
d['Bob'] = 75
print(d)
# ==> {'Alice': 45, 'Bob': 75, 'Candy': 75, 'David': 86, 'Ellena': 49}

這個時候我們發現，原來Bob的成績是60，現在變成75了，因為d['Bob'] = 75的緣故。
因此我們發現這個賦值語句其實有兩個功能：

當key不存在時，往dict中添加對應的key: value元素。

當key存在時，會更新dict，用新的value替換原來的value。

因此，在使用賦值語句往dict中添加元素時，為了避免不必要的覆蓋問題，我們需要先判斷key是否存在，然后再做更新。

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49,
? ?'Gaven': 86
}

此時，如果想通過名字來查詢某個同學的成績，也就是通過key來查詢value，這個時候怎么辦呢？
dict提供通過key找到對應value的功能，通過d[key]的形式，就可以得到對應的value。

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49,
? ?'Gaven': 86
}
print(d['Bob']) # ==> 60
print(d['Alice']) # ==> 45

這和list通過下標找到對應位置的元素是類似的。
回顧一下前面使用下標的方式訪問list元素的時候，當下標不存在時，就會引發錯誤，在dict中，也是一樣的，當對應的key不存在時，也會引發錯誤。

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49,
? ?'Gaven': 86
}
print(d['Dodo'])
# 拋出異常
Traceback (most recent call last):
?File "<stdin>", line 1, in <module>
KeyError: 'Dodo'

它的意思是key不存在，因此我們在需要通過key找到value時，一定要先判斷key存不存在，然后才使用上面的方式獲取對應的value，以避免錯誤。

if 'Alice' in d:
? ?print(d['Alice']) # ==> 45
if 'Dodo' in d: # Dodo不存在，所以不會走下面的邏輯
? ?print(d['Dodo'])

除了使用這種方法，還有一種方法可以通過key來獲取對應的value，這種方法不會引起錯誤，dict本身提供get方法，把key當作參數傳遞給get方法，就可以獲取對應的value，當key不存在時，也不會報錯，而是返回None。

print(d.get('Alice')) # ==> 45
print(d.get('Dodo')) # ==> None

d = {

? ? 'Alice': 45,

? ? 'Bob': 60,

? ? 'Candy': 75,

? ? 'David': 86,

? ? 'Ellena': 49

}

dg=['Alice', 'Bob', 'Candy', 'Mimi', 'David']

for g in dg:

? ? print(d.get(g))

python的dict就是專門保存這種映射的，使用dict可以方便的保存“名字”->“成績”的映射。
在dict中，每一項包含一個key和一個value，key和value是一一對應的，在解決上面的問題中，我們可以使用名字作為key，成績作為value，那么dict的定義如下：

d = {
? ?'Alice': 45,
? ?'Bob': 60,
? ?'Candy': 75,
? ?'David': 86,
? ?'Ellena': 49
}

T = (1, 'CH', [3, 4])

這里T有三個元素，第一個元素是數字類型，第二個元素是字符串類型，第三個元素是列表類型的，我們嘗試修改第三個元素的數據。

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 嘗試替換L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

接著，我們創建包含一個元素的tuple。

T = (1)
print(T) # ==> 1

可以看到，改變優先級我們是通過()來實現的，這和元組的定義有沖突，這就解釋了前面只有一個元素的元組，為什么打印出來卻得到一個數字的結果了。
因為()既可以表示tuple，又可以作為括號表示運算時的優先級，結果(1)被Python解釋器計算出結果 1，導致我們得到的不是tuple，而是整數 1。
因此，要定義只有一個元素的tuple，需要在元素后面添加一個逗號,。

T = (1, )
print(T) # ==> (1, )

而對于多個元素的tuple，則加和不加這個逗號，效果是一樣的。

>>> T = (1, 2, 3,)
>>> print(T) # ==> (1, 2, 3)

count()方法用來統計tuple中某個元素出現的次數。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1

index()方法可以返回指定元素的下標，當一個元素多次重復出現時，則返回第一次出現的下標位置。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 # 多次出現，返回第一次出現的位置

#ch是在for循環中定義的，意思是把字符串s中的每一個元素依次賦值給ch，然后再把ch打印出來，直到打印出字符串s的最后一個字符為止。

s = 'ABCD'
for ch in s:

print(ch) # 注意縮進

定義元組的方式是使用小括號()將元組內的元素括起來。

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
# 通過下標的方式訪問元素
print(T[0]) # ==> Alice
print(T[4]) # ==> Ellena
# 切片
print(T[1:3]) # ==> ('Bob', 'Candy')