1. # d = {
   #     'Alice': 45,
   #     'Bob': 60,
   #     'Candy': 75,
   #     'David': 86,
   #     'Ellena': 49
   # }
   # for key in d:
   #     value = d[key]
   #     if value > 60:
   #         print(key,value)
       
   # for key,value in d.items():
   #     if value > 60:
   #         print(key , value)
       
   d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
   for key,value in d.items():
       for i in value:
           print(key,i)

2. 对于基础数据类型，字符串、数字等，这些都是不可变的，可以作为dict的key，而对于复杂数据类型，经过前面的学习，我们知道tuple是不可变的，list是可变的，因此tuple可以作为dict的key，但是list不可以作为dict的key，否则将会报错。

3. 通过直接print(d)，我们打印出来的是完整的一个dict；有时候，我们需要把dict中m一定条件的元素打印出来，比如成绩超过60的，在这种情况下，我们需要则需要遍历dict（这种时候需要使用for循环），并通过条件判断把满足条件的打印出来。
   遍历dict有两种方法， 第一种是遍历dict的所有key，并通过key获得对应的value。
   

print（"苏美华")

# d = {
#     'Alice': 45,
#     'Bob': 60,
#     'Candy': 75,
#     'David': 86,
#     'Ellena': 49
# }
# name = 'Alice'
# if name in d.keys():
#     d.pop(name)
# else:
#     print('{} not in d'.format(name))

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

2. 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 = {
    '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的缘故。
因此我们发现这个赋值语句其实有两个功能：

1. 当key不存在时，往dict中添加对应的key: value元素。
2. 当key存在时，会更新dict，用新的value替换原来的value。

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

1. dict和list通过下标找到对应位置的元素是类似的。
   回顾一下前面使用下标的方式访问list元素的时候，当下标不存在时，就会引发错误，在dict中，也是一样的，当对应的key不存在时，也会引发错误。

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

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

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

字典是一种数据结构，用于存储数据以键值对的形式。每个键（key）都与一个特定的值（value）相关联。这使得你可以通过键来快速查找和检索相关联的值。字典在各种编程语言中都有不同的实现，通常被称为关联数组、哈希表或映射。

以下是字典的一些基本特征和用途：

1. 键值对：字典包含多个键值对，每个键唯一地标识一个值。这意味着每个键在字典中只能出现一次。

2. 高效查找：字典的设计使得通过键来查找值非常高效，通常在常数时间复杂度内完成，因此适用于大规模数据的快速检索。

3. 无序性：大多数编程语言中的字典是无序的，这意味着键值对的顺序不固定，不像列表或数组那样按照索引顺序排列。

4. 可变性：许多字典是可变的，允许在运行时添加、修改或删除键值对。但也有一些语言提供不可变的字典实现。

5. 用途广泛：字典在编程中非常常见，用于解决各种问题，如配置管理、数据索引、数据缓存等。

不同编程语言中的字典可能有不同的名称和语法，例如：

- 在Python中，字典被称为字典（Dictionary），使用大括号 `{}` 来创建，例如 `my_dict = {"name": "John", "age": 30}`。

- 在JavaScript中，字典被称为对象（Object），使用大括号 `{}` 和键值对来创建，例如 `let person = {name: "John", age: 30}`。

- 在Java中，字典可以使用 `HashMap` 或 `Hashtable` 等数据结构来表示。

总之，字典是一种重要的数据结构，它提供了一种便捷的方式来组织和检索键值对数据。它在编程中广泛用于存储和操作各种类型的信息。

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

1. print后面没有f
2.语句猴面包有用加分号
3.括号内单双引号都可以

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

2. 前面我们学习了，对于tuple，它和list一个最大的不同点就是tuple是不可变的，tuple里面的元素，也是不可替换的。但是这针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束。

3. 虽然tuple中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。

   
   

a  = (100, 69, 29, 100, 72, 99, 98, 100, 75, 100, 100, 42, 88, 100)
a.count(100)

1.  count()方法用来统计tuple中某个元素出现的次数。对于不存在的元素，count方法不会报错，而是返回0，这是合理的，因为元组里面有0个不存在的元素。

2.  index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。注意，index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。

L = (1,2,3,4,5,6,7,8,9)
print(L)
T = list(L)
print(T)

1. 元组(tuple)和list一样，也是一个有序容器，在元组中，同样可以包含0个或者多个元素，并且也支持索引访问、切片等操作。定义元组的方式是使用小括号()将元组内的元素括起来。

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

3. 同样的，对于列表数据类型，也可以把元组转换成列表。
   

L = [[1, 2, 3], [5, 3, 2], [7, 3, 2]]
for i in L:
    length = i[0]
    width = i[1]
    height = i[2]
    r = length*width*2+width*height*2+length*height*2
    print(r)

1. 对于列表，除了可以向列表添加元素，删除列表元素以外，列表已有的元素，也是可以修改的，通过索引指定位置，并赋值新的元素，即可替换列表中原有的元素。

2.  注意，如果替换一个不存在的下标，则同样会引起Python运行错误。
   

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
L.pop(2)
L.pop(2)
print(L)

1. 使用列表的pop()方法，pop()方法默认删除列表的最后一个元素，并返回。

2. pop()方法，除了可以删除最后一个元素以外，pop()还可以接收一个参数，指定需要删除的元素的位置。
   

Python基础数据类型：整数【十进制、二进制（0b）、十六进制（0x）】、浮点数（小数）、字符串、布尔值【and（与运算）、or（或运算）、not（非运算）】、空值（None）