循环

while

while 布尔表达式:
代码块

如果布尔表达式不带有<、>、==、！=、in、not in等运算符，仅仅给出数值之类的条件，也是可以的。当while后写入一个非零整数时，视为真值，执行循环体；写入0时，视为假值，不执行循环体。也可以写入str、list或任何序列，长度非零则视为真值，执行循环体；否则视为假值，不执行循环体。

while else

当while循环正常执行完的情况下，执行else输出，如果while循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容

count = 0
while count < 5:
    print("%d is  less than 5" % count)
    count = count + 1
else:
    print("%d is not less than 5" % count)

0 is  less than 5
1 is  less than 5
2 is  less than 5
3 is  less than 5
4 is  less than 5
5 is not less than 5

count = 0
while count < 5:
    print("%d is  less than 5" % count)
    count = count + 1
    if count >3:
        break
else:
    print("%d is not less than 5" % count)

0 is  less than 5
1 is  less than 5
2 is  less than 5
3 is  less than 5

for 循环

for 迭代变量 in 可迭代对象:
代码块

dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for key, value in dic.items():
    print(key, value, sep='-', end=' ,')
    

a-1 ,b-2 ,c-3 ,d-4 ,

for - else 循环

当for循环正常执行完的情况下，执行else输出，如果for循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容，与while - else语句一样。

for key, value in dic.items():
    print(key, value, sep='-', end=' ,')
else:
    print('colse')

a-1 ,b-2 ,c-3 ,d-4 ,colse

enumerate()函数

返回一个迭代对象包含元素和新建的索引
使用循坏可以查看

for i in  enumerate('nihaoma'):
    print(i)

(0, 'n')
(1, 'i')
(2, 'h')
(3, 'a')
(4, 'o')
(5, 'm')
(6, 'a')

break 和 continue pass

break语句可以跳出当前所在层的循环。
continue终止本轮循环并开始下一轮循环。
break会跳出整个循坏，continue是不进行本次循坏之后的操作

pass 不做任何操作 

for i in range(10):
    if i % 2 != 0:
        print(i)
        break
    i += 2
    print(i)

2
1

for i in range(10):
    if i % 2 != 0:
        print(i)
        continue
    i += 2
    print(i)

2
1
4
3
6
5
8
7
10
9

推导式

a = []
for i in range(0,3):
    for j in range(0,3):
        a.append([i,j])
b = [[i,j] for i in range(0,3) for j in range(0,3)]
a is b,a == b

(False, True)

('a','b') is ('a','b') ,('a','b') == ('a','b')

(True, True)

['a','b'] is ['a','b'],['a','b'] == ['a','b']

(False, True)



is, is not 对比的是两个变量的内存地址
==, != 对比的是两个变量的值
比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
对比的两个变量，指向的是地址可变的类型（list，dict等），则两者是有区别的。

1.整数、字符串是真正意义上的值，而内存只有一份指的是较小的值

对于（-5~256）之间的整数，会在内存中进行缓存，两个相同的整数只开辟一份内存，当地址引用为0时，内存自动删除

2.对于元组、字典、列表、集合以及range、map等容器类对象，这些的值看起来一样，但内存却不是保存一份

3.同一个列表 或者元组 中，大的整数 在内存中会保存同一个地址

4.对于实数（有理数、无理数）来说（不包括-5~256），地址是不同的

5.整数的话 -5 以下内存另开辟，大于 -5 的正整数内存地址一样，实验到了百亿两个地址一样

{i:i**2 for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

练习

编写一个Python程序来查找那些既可以被7整除又可以被5整除的数字，介于1500和2700之间。

result = [ i for i in range(1500,2701) if i%7 == 0 and i%5 == 0]

话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔 子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以 上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。

然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1 米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找 到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果。

def run(v1,v2,t,s,l):
    time_list,l1_list,l2_list = [],[],[]
    t1 = l/v2
    time,l1,l2 = 0,0,0
    while l1<l and l2<l:
        if l1 - l2 >=t:
            l1 = l1 + 0
            l2 = l2 + s*v2
            time = time + s
        else:
            l1 = l1 + v1 
            l2 = l2 + v2
            time = time +1 
        l1_list.append(l1)
        l2_list.append(l2)
        time_list.append(time)
    else:
        if l1>l2:
            result = 'R'
        elif l1==l2:
            result = 'D'
        else:
            result = 'T'
    return result,l1_list,l2_list,time_list
        

result,l1_list,l2_list,time_list = run(v1=2,v2=1,t=20,s=10,l=200)

import matplotlib.pyplot as plt 
plt.plot(time_list,l1_list,label='R')
plt.plot(time_list,l2_list,c='r',label='T')
plt.title(f'win:{result}')
plt.legend()

<matplotlib.legend.Legend at 0x276d909ee48>