L = [95.5, 85, 59, 66, 72]

L.sort(reverse = True)

#重置list排序-倒序

print(L[0:3])

这个赋值语句其实有两个功能：

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

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

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}

需要往里面添加Dodo、Mimi的成绩时，可以使用赋值语句往里面添加元素：

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

d['Mimi'] = 72
d['Dodo'] = 88
print(d)

实际上，value可以是任意类型的元素，可以是list、tuple等:

d['Mimi'] = [72, 73]
d['Dodo'] = [88, 90]
print(d)

此后，如果Mimi、Dodo的第三次成绩也出来了，则可以先通过key把对应的value查询出来，然后再往类型是list的value中添加第三次的成绩:

d['Mimi'].append(75)
d['Dodo'].append(90)
print(d)

有时候，我们会想获取字符串的一部分（子串），这个时候我们采取切片的方式获取，切片需要在中括号[]中填入两个数字，中间用冒号分开，表示子串的开始位置和结束位置，并且这是半闭半开区间，不包括最后的位置。

因此我们可以使用位置的方式取出字符串中特定位置的字符，按照位置取字符串的方式使用中括号[]访问，这个时候可以把字符串看作是一个列表（一种新的数据类型，在后面会继续学习），不过需要注意的是，在程序的世界中，计数是从0开始的，使用0来表示第一个。 s = 'ABC' a = s[0] # 第一个 b = s[1] # 第二个 c = s[2] # 第三个 print(a) # ==> A print(b) # ==> B print(c) # ==> C

因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），0 - 255被用来表示大小写英文字母、数字和一些符号，这种编码方式被称为ASCII编码，比如大写字母 A 的编码是65，小写字母 z 的编码是122。 如果要表示中文，显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。 类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。 Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0就可以。

# 指定顺序 template = 'Hello {0}, Hello {1}, Hello {2}, Hello {3}.' result = template.format('World', 'China', 'Beijing', 'imooc') print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.

通过d[key]的形式，就可以得到对应的value。如：

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49,
    'Gaven': 86
}
print(d['Bob']) # ==> 60
在dict中，也是一样的，当对应的key不存在时，也会引发错误。

print(d['Dodo'])
# 抛出异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Dodo'

dict本身提供get方法，把key当作参数传递给get方法，就可以获取对应的value，当key不存在时，也不会报错，而是返回None。

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

使用dict可以方便的保存“名字”->“成绩”的映射。
在dict中，每一项包含一个key和一个value，key和value是一一对应的，在解决上面的问题中，我们可以使用名字作为key，成绩作为value，那么dict的定义如下：

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

在定义里，我们使用花括号{}表示这是一个dict，然后key和value之间使用冒号:分割，并且每一组key:value的最后，以逗号,表示这一组的结束。

我们也可以使用以下的方式定义一个dict。

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

不过这种定义方式，默认得到的是一个空dict，需要调用函数往里面添加数据，我们后面会继续学习。

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所约束不到的范围。

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

T = () ; print(T) # ==> ()

要定义只有一个元素的tuple，需要在元素后面添加一个逗号","。

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

不加逗号：

T = (1)
print(T) # ==> 1,显示出来的不是元组，而是一个数

count()方法用来统计tuple中某个元素出现的次数。对于不存在的元素，count方法不会报错，而是返回0。

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

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 # 多次出现，返回第一次出现的位置

index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。

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

L = [75, 92, 59, 68, 99]

sum = 0.0

for x in L:

    print(x)

    sum += x

print(sum / 5)

1. 二进制数只使用数字0、1表示，在Python中，二进制整数使用前缀0b表示

    十六进制使用前缀0x

2.  在Python中，把10用e替代，比如：1.23x10^9就是1.23e9

3.  字符串是以''或""括起来的任意文本

4.  and运算是与运算，只有所有都为 True，and运算结果才是 True。
   

   or运算是或运算，只要其中有一个为 True，or 运算结果就是 True。

   not运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。

5.  空值是Python里一个特殊的值，用None表示   None不能理解为0