set提供了remove()方法允许我们删除set中的元素。

如果remove的元素不在set里面的话，那么将会引发错误。要提前判断要remove()的元素是否在set里面，确保存在后，再进行remove。

任务：

# 针对以下set，给定一个list，对于list里面的每个元素，如果set中包含这个元素，就将其删除，否则添加到set里面去。

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
S = set([1, 3, 5, 7, 9, 11])

# Enter a code
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
S = set([1, 3, 5, 7, 9, 11])
for x in L:
    if x in S:
        S.remove(x)
    else:
        S.add(x)
print(S)

set提供add()方法，往set里面添加元素。

name_set.add('Gina')

批量往set里面添加元素：set提供了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']。

# coding=utf-8
names = ['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl']
nameset = set([])
nameset.update(names)
print(nameset)

# coding=utf-8
names = ['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl']
nameset = set([])
for x in names:
    nameset.add(x)
print(nameset)

set里面的元素是没有顺序的，因此我们不能像list那样通过索引来访问。访问set中的某个元素实际上就是判断一个元素是否在set中，这个时候我们可以使用in来判断某个元素是否在set中。

set元素是区分大小写的，必须大小写完全匹配，才能判断该元素在set里面。

任务:

# 由于name_set不能识别小写的名字，请改进name_set，是小写的名字也能判断在name_set里面。

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)

# Enter a code
names1 = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
names2 = []
for x in names1:
    names2.append(x.lower())
    
name_set = set(names2)
bool1 = 'Alice'.lower() in name_set
print(bool1)

""或''只是一种表达方式，

set里面的元素是不允许重复的，set里面的元素是没有顺序的。

创建set的方式是使用set()，并传入一个list，list的元素将会被转换成set的元素。

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

任务：

# 请使用set表示班里面的五个同学。
'Alice', 'Bob', 'Candy', 'David', 'Ellena'

# Enter a code
set1 = set(['Alice', 'Bob', 'Candy', 'David', 'Ellena'])
print(set1)

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

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

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

任务：

# 已知d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}，请输出d的元素个数。

# Enter a code
d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
L = d.keys()
num = len(L)
print(L)
print(num)

dict提供便捷的pop()方法，允许我们快速删除元素，pop()方法需要指定需要删除的元素的key，并返回对应的value。

alice_score= d.pop('Alice')
pop()方法的参数是dict中的key，当key不存在时，同样会引起错误。比如在上述操作中，已经把Alice的成绩删除了，假如再次pop('Alice')，将会引发错误。KeyError

任务：

# 在dict中，使用keys()方法，可以返回dict的所有key，在删除某个元素时，可以通过这个方法先判断某个元素是否存在，请改造前面的程序，使得即使key不存在时，删除也不会抛异常。

# Enter a code
d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
alice_score= d.pop('Alice')
key = 'Alice'
if key in d.keys():
    d.pop(key)
    
print(d.keys())
print(d)

通过赋值语句就可以把元素添加到dict中去，这个赋值语句其实有两个功能：

1. 当key不存在时，往dict中添加对应的key: value元素。

2. 当key存在时，会更新dict，用新的value替换原来的value。

在使用赋值语句往dict中添加元素时，为了避免不必要的覆盖问题，我们需要先判断key是否存在，然后再做更新。

任务：

# 已有同学们的成绩如下，请更新Alice的成绩为60，并把旧的成绩记录下来。

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

}

解答如下：

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

dict是可变的，我们随时可以往dict中添加新的key-value。value可以是任意类型的元素，可以是list、tuple等。可以使用赋值语句往dict中添加元素。

任务

已有同学的某次成绩dict如下：

d = {
    'Alice': [45],
    'Bob': [60],
    'Candy': [75],
}

Alice、Bob、Candy的最近三次的成绩分别是[50, 61, 66]，[80, 61, 66]，[88, 75, 90]，请更新dict，使得dict可以保存同学多次的成绩。

# Enter a code
d = {
    'Alice': [45],
    'Bob': [60],
    'Candy': [75],
}
print(d)
d['Alice'] = [50, 61, 66]
d['Bob'] = [80, 61, 60]
d['Candy'] = [88, 75, 90]
print(d)

1. dict提供通过key找到对应value的功能，通过d[key]的形式，就可以得到对应的value。

当对应的key不存在时，会引发错误。KeyError

需要通过key找到value时，一定要先判断key存不存在，然后才使用d[key]的方式获取对应的value，以避免错误。

if 'Alice' in d:
    print(d['Alice'])

2. 还有一种方法可以通过通过key来获取对应的value，这种方法不会引起错误，dict本身提供get方法，把key当作参数传递给get方法，就可以获取对应的value，当key不存在时，也不会报错，而是返回None。

通过get方法在代码实现上更加简单，且不会引起错误，因此更加推荐使用get方法来获取dict的元素。

任务

根据如下dict，打印出Alice, Bob, Candy, Mimi, David的成绩，当同学不存在时，打印None。

# Enter a code
d = {
        'Alice': 45,    
    'Bob': 60,    
    'Candy': 75,    
    'David': 86,    
    'Ellena': 49
    }
L = ['Alice', 'Bob', 'Candy', 'Mimi', 'David']
for key in L:
    print(d.get(key))

python的dict就是专门保存这种映射的，使用dict可以方便的保存“名字”->“成绩”的映射。dict中，每一项包含一个key和一个value，key和value是一一对应的。

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

我们使用花括号{}表示这是一个dict，然后key和value之间使用冒号:分割，并且每一组key:value的最后，以逗号,表示这一组的结束。
我们也可以使用以下的方式定义一个dict，默认得到的是一个空dict，需要调用函数往里面添加数据。

d = dict()
print(d) # ==> {}

任务：

# 新来的Gaven同学成绩是86，请编写一个dict，把Gaven同学的成绩也加进去。

# Enter a code

d = {

    'Alice': 45,

    'Bob': 60,

    'Candy': 75,

    'David': 86,

    'Ellena': 49,

    'Gaven':86

}

print(d)

tuple是不可变的，tuple里面的元素，也是不可替换的，针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束。

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中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。

如果我们直接替换list，这也是不行的。

任务：

# T = (1, 'CH', [3, 4])
tuple里面包含list，导致tuple是可变的，请修改T的定义，不改变基本数据类型的数据，使T是不可变的。

# Enter a code

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

print(T)

listtemp = list(T)

listtemp[2] = tuple(listtemp[2])

T = tuple(listtemp)

print(T)

# 先将T转变为list，然后更改里面的list为tuple，最后将该list转变为tuple。

tuple和list一样，可以包含 0 个、1个和任意多个元素。

1. 包含 0 个元素的 tuple，也就是空tuple，直接用()表示：T = ()

2. 改变优先级我们是通过()来实现的，这和元组的定义有冲突。要定义只有一个元素的tuple，需要在元素后面添加一个逗号,：T = (1, )

3. 对于多个元素的tuple，则加和不加这个逗号，效果是一样的：T = (1, 2, 3,)

任务：

# tuple的元素也可以是tuple，请判断以下定义T的元素中，有多少个tuple。

T = ((1+2),  ((1+2),), ('a'+'b'), (1, ), (1,2,3,4,5))

答：T的元素中，有5个tuple，分别是：(1+2)    ((1+2),)    ('a'+'b')    (1,)   (1,2,3,4,5)   

tuple一旦定义之后便不可修改，所以在实际编程中，tuple经常用于存放固定不变的数据。

tuple提供了便捷的方法可以访问tuple中的数据。

1. count()方法用来统计tuple中某个元素出现的次数。

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

对于不存在的元素，count方法不会报错，而是返回0，这是合理的，因为元组里面有0个不存在的元素。

2. index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。ValueError: tuple.index(x): x not in tuple.

任务：

# 在某次考试中，班上的成绩如下：(100, 69, 29, 100, 72, 99, 98, 100, 75, 100, 100, 42, 88, 100)，请统计满分（100分）同学的数量。

# Enter a code

tuple1 = (100, 69, 29, 100, 72, 99, 98, 100, 75, 100, 100, 42, 88, 100)

x = tuple1.count(100)

print(x)

元组(tuple)和list一样，也是一个有序容器，在元组中，同样可以包含0个或者多个元素，并且也支持索引访问、切片等操作。

定义元组的方式是使用小括号()将元组内的元素括起来。

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

元组数据类型可以把不是元组的容器转换为元组，比如将列表转换成元组。

T = tuple(L)

对于列表数据类型，也可以把元组转换成列表。

L = list(T)

tuple和list不一样的是，tuple是固定不变的，一旦变成tuple，tuple中的每一个元素都不可被改变，同时也不能再往tuple中添加数据，而list是可以的。

注意：元组(tuple)的这个特性是非常重要的，在运行上tuple的性能是list的数倍。

任务：

# 请创建一个tuple，顺序包含0~9的十个数，并尝试将其转换为列表list。
# Enter a code
list1 = []
for i in range(10):
    list1.append(i)
tuple1 = tuple(list1)
list1 = list(tuple1)
print(tuple1)
print(list1)