取模运算意思就是判断奇偶，取最后余数，余数为0是偶数，余数为1是奇数；用%表示取模

底板除的意思就是抹掉小数点后的数字，取整，用//表示

小数点位数用round（）表示

变量不能用数字开头；

变量名=数据

整数就是数字1，2，3等等整数；

浮点数就是有小数点的数字，比如0.1，0.2，0.44等；

字符串指的就是文本文件一样；

布尔值对应的就只有“对”或“错”；真假

同时注意“与非或”逻辑运算；

1，查找速度快

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

2，有序与无序

在Python3.5之前，dict中的元素是无序的，也就是dict中元素的插入顺序和打印顺序未必一致

在Python3.6、Python3.7版本中，可以得到有序的结果。

3，key不可变

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

key = (1, 2, 3) # 以tuple作为key

d[key] = True

key = [1, 2, 3]

d[key] = True

# 报错

注意：key不能重复——由于dict是按 key 查找，所以，在一个dict中，key不能重复。

4，Python遍历dict

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

遍历dict有两种方法——

①key的for循环，判断value是否满足输出条件：遍历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)

②key和value的for循环，采用items()方法调用：通过dict提供的 items() 方法，items()方法会返回dict中所有的元素，每个元素包含key和value。

d = {

    'Alice': 45,

    'Bob': 60,

    'Candy': 75,

    'David': 86,

    'Ellena': 49

}

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 in d:    #每个key（同学）

    scores=d[key]

    i=1

    for score in scores:    #每个value（三次成绩）

        print(key,i,score)      #每次成绩

        i+=1

运行成功

('Bob', 1, 80)

('Bob', 2, 61)

('Bob', 3, 66)

('Alice', 1, 50)

('Alice', 2, 61)

('Alice', 3, 66)

('Candy', 1, 88)

('Candy', 2, 75)

('Candy', 3, 90)

②

d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}

print(len(d))

运行成功

3

③

#coding=utf-8

d = {

     'Alice': [50, 61, 66],

     'Bob': [80, 61, 66],

     'Candy': [88, 75, 90]

}

template = "{}的第{}次的成绩为{}"

for eachItem in d.items():   #eachItem是以列表形式保存，元素中间是以逗号“,”隔开的，例如['Bob',[80,61,66]]

    print(eachItem)

    for i in range(len(eachItem[1])):    #i自动默认值为0 ——>等同于  for i in range(0,3):

        a=range(len(eachItem[1]))    #计算eachItem列表中的，value值的位数（从0开始计算）

        print(a)

        print(template.format(eachItem[0], i + 1, eachItem[1][i]))

#coding=utf-8

d = {

     'Alice': [50, 61, 66],

     'Bob': [80, 61, 66],

     'Candy': [88, 75, 90]

}

template = "{}的第{}次的成绩为{}"

for eachItem in d.items():

    print(eachItem)

    for i in range(len(eachItem[1])):    #  每一次循环后，i自动递增1

        a=range(len(eachItem[1]))

        print(a)

        print(template.format(eachItem[0], i+1, eachItem[1][i]))    #print中的i+1，对于i的值不构成影响，除了按照print打印出来，其余的无影响，不会保存为i的新值。

        print i

注意：

①for循环中的i默认递增1——在python中，for i in range()语句下，i是自动递增1，不需要使用i=i+1语句即可达到循环一次递增1的效果。

②python中，i自动默认值为0：可以不需要对i进行赋值定义

③len(somethingname)：计算sonethingname这个数据类型的位置个数，从1开始计数 ——>

④Range(len(sonethingname))：定义len()的位置范围，从0开始 ——>

 for i in len(eachItem[1]): 语法错误

for i in range(len(eachItem[1])): 语法正确

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

假设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}

当key不存在时，同样会引起错误

任务

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

d = {    

    'Alice': 45,    

    'Bob': 60,    

    'Candy': 75,    

    'David': 86,    

    'Ellena': 49 }

name = 'Alice'

if name in d.keys():    

    d.pop(name)

    print(d)

else:    

    print('{} not in d'.format(name))

dict的更新方法：使用赋值语句，dictname[keyname]=new value

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

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

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

注意——

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

d = {

    'Alice': 45,

    'Bob': 60,

    'Candy': 75,

    'David': 86,

    'Ellena': 49

}

if 'Alice' in d:

    ori_marks = d['Alice']

    print('ori_marks:{}'.format(ori_marks))

    d['Alice'] = 60

    print('new_marks:{}'.format(d['Alice']))

else:

    print('nothing to do')

dict和tuple不一样，dict是可变的，我们随时可以往dict中添加新的key-value。

①使用赋值语句往里面添加key元素：d['new key']=new value

注意——value可以是任意类型的元素，可以是list、tuple等。d['new key']=[new value1,new value2] （list 类型），或者d['new key']=（new v1，new v2）（tuple类型）

比如对于上节课的成绩dict：

d = {

    'Alice': 45,

    'Bob': 60,

    'Candy': 75,

    'David': 86,

    'Ellena': 49

}

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

d['Mimi'] = 72

d['Dodo'] = 88

print(d)

假如Mimi近两次成绩分别是72，73，Dodo近两次的成绩分别是88，90，则可以使用赋值语句往dict中添加list元素。

d['Mimi'] = [72, 73]

d['Dodo'] = [88, 90]

print(d)

②使用append()语句往里面添加value元素：dictname[keyname].append('new value')

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

d['Mimi'].append(75)

d['Dodo'].append(90)

print(d)

任务

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

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

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

代码如下：

d = {

    'Alice': [45],

    'Bob': [60],

    'Candy': [75]

}          #原始dict数据组的数据

A=[[50, 61, 66],[80, 61, 66],[88, 75, 90]]    #要新增加的数据，分别对应Alice、Bob、Candy

i=0

for key in d.keys():    #追踪到每个同学上，通过for循环进行by同学录入成绩

    B=A[i]

    for grade in B:     #通过for循环，将每个同学的三次成绩，分次录入增加，而不是三次一起录入增加，可以避免输出出现双重[[]]

        d[key].append(grade)

    i+=1

print(d)

输出结果：{'Bob': [60, 50, 61, 66], 'Alice': [45, 80, 61, 66], 'Candy': [75, 88, 75, 90]}

双重[[]]——没有将成绩分次录入

创建dict数据组：可以创建一个dict，保存key和value的对应关系（名字和成绩）。

读取dict元素：

①下标[ ]读取——dictname['key1']：直接读取dictname数据组里面的key1，会返回所对应的value1

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

在dict中，当对应的key不存在时，也会引发错误。——>  在需要通过key找到value时，一定要先判断key存不存在。

②get函数调用读取：dictname.get('key')，返回key所对应的value值。dict本身提供get方法，把key当作参数传递给get方法，就可以获取对应的value。

当搜索的key不存在时，自动返回none，不会引发错误。

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

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

字典的名Key和值value可以自动从字典中获取——

①key：调用keys()函数

for key in dictname.keys()

②value：调用value()函数

for key in dictname.keys()

d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}

for i in d.keys():

    print(i)    #逐次打印出key名

for j in d.values():

    print(j)    #逐次打印出value值

任务

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

# coding=utf-8

d = {

    'Alice': 45,

    'Bob': 60,

    'Candy': 75,

    'David': 86,

    'Ellena': 49

}

for i in d.keys():

    j=d.get(i)

    print('{}同学的成绩是{}'.format(i,j))

List 和 tuple 可以用来表示顺序集合，例如，班里同学的名字，或者考试的成绩。

名字：

['Alice', 'Bob', 'Candy', 'David', 'Ellena'] # List
('Alice', 'Bob', 'Candy', 'David', 'Ellena') # tuple

成绩:

[45, 60, 75, 86, 49] # list
(45, 60, 75, 86, 49) # tuple

①两个列表之间的映射——如果同学名字的列表和同学成绩的列表是一一对应的，那么通过下标，我们也可以找到每个同学的成绩。

#coding=utf-8

names=['Alice', 'Bob', 'Candy', 'David', 'Ellena']

grades=[45, 60, 75, 86, 49]

i=0

for name in names:

    grade=grades[i]

    i+=1

    print('name={},grade={}'.format(name,grade))

映射的弊端：使用两个list，始终有些麻烦的，尤其是需要变换一个列表的顺序后，另外一个列表也需要做同样的变换，否则就可能出现对应不上的问题。

②dict类型：专门保存两者的映射——每一项包含一个key和一个value，key和value是一一对应的。

Eg. 用dict可以方便的保存“名字”->“成绩”的映射。

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

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

③空dict：先设置空dict，需要调用函数往里面添加数据

d = dict()

print(d) # ==> {}

注意：dict有序无序问题——

在Python3.5之前，dict中的元素是无序的，也就是dict中元素的插入顺序和打印顺序未必一致。

在Python3.6的版本以后，dict是有序的，但是一般而言，为了避免不必要的误解，一般在需要有序的dict时，我们会使用一种叫做Ordereddict的字典，来确保有序。

dict的增加元素方法——d{'key1'}=value1

任务

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

d = {

    'Alice': 45,

    'Bob': 60,

    'Candy': 75,

    'David': 86,

    'Ellena': 49

}

d['Gaven']=86

print(d)

针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据——对于tuple，它和list一个最大的不同点就是tuple是不可变的，tuple里面的元素，也是不可替换的。

对于组合数据类型——不受这个约束。

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])

元组T中的第三个元素已经成功被改变了

指向性：T--T[2]--L--L[1]——因为虽然tuple中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。

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

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

L2 = [3, 40]

# 尝试替换tuple中的list

T[2] = L2

# 报错

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not support item assignment

总结：

1，tuple只能够管理到自己的元素不被改变，但是元素内的列表内的值变化不是受控制的。

2，对于组合数据类型数据，tuple依然可变

3，元组、列表的元素是复合数据类型的，将该元素对外复制时实际是将指向该数据的指针付给别的变量，当对别的变量做出修改时，原数据也会改变

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

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

T = ()

print(T) # ==> ()

②创建包含一个元素的tuple：在单元素之后要加个逗号“，”

T = (1,)

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

如果单元素之后没有加逗号“，”，则会导致输出内容没有tuple的()括号符号——

原因：改变优先级我们是通过 () 来实现的，这和元组的定义有冲突。这就解释了只有一个元素的元组，在不加逗号情况下，被默认为是四则运算优先符号()，运算后结果是1，打印出来得到一个数字的结果了

T = (1)

print(T) # ==> 1

③对于多个元素的tuple：则加和不加这个逗号，效果是一样的

任务

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

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

程序：

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

for i in T:

    print(i)

根据输出结果可以判断有几个tuple。（最后在加上整个的tuple，也就是T）

解释：

(1+2)：相当于(3)，输出是3，不是tuple。——>应该是(3,),反推也就是(1+2,)，是tuple

 ((1+2),)：相当于(3,)，输出(3,)

“a” + “b” = “ab”：("ab")不是元组，所以（"a"+"b"）不是元组，而（“ab”,）这个是元组

Python的发展历史

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

因此在使用上，tuple提供了便捷的方法可以访问tuple中的数据。

①统计某元素个数——count()方法： tuplename.count(data number)

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

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

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

print(T.count(10)) # ==> 0

②统计指定元素下标——index()方法：tuplename.index(data number)

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

对于不存在的元素，使用index()方法Python会报错。

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

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

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

用法：

①定义：tuplename=(a,b,c,d)

②索引访问：T[ num ]

③切片访问：T[num1 : num2]

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
# 通过下标的方式访问元素
print(T[0]) # ==> Alice
print(T[4]) # ==> Ellena
# 切片
print(T[1:3]) # ==> ('Bob', 'Candy')

非元组容器转换为元组——元组数据类型可以把不是元组的容器转换为元组，比如将列表转换成元组。如：T=tuple(listname)

元组转换为非元组——对于列表数据类型，也可以把元组转换成列表。如：L=list(tuplename)

T=(0,1,2,3,4,5,6,7,8,9)

print(T)

L=list(T)    #把tuple类型的T数据，转换为list类型的数据

print(L)

【非常重要！】元组(tuple)的特性：tuple是固定不变的，在运行上tuple的性能是list的数倍。

tuple和list的差异——tuple是固定不变的，一旦变成tuple，tuple中的每一个元素都不可被改变，同时也不能再往tuple中添加数据，而list是可以增/减/替换。