python学习笔记2 task2

python学习笔记2 task2

1. 作业

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

# 1，定义一个空列表存储结果，用循环来索引1500到2700之间的数字
#2，用条件判断数字是否能被5整除，也能被7整除，能被整除的输出
#3，返回数字到列表中
def divis(m,n,s,t):
    if m>=n:
        print('参数输入错误')
    else:
        result = []
        for i in range(m,n+1):
            if i%s == 0 and i%t == 0:
                result.append(i)
        return result
res = divis(2700,2000,5,7)
print(res)

# 列表推导式
def divis(m,n,s,t):
    if m>=n:
        print('参数输入错误')
    else:
        return [i for i in range(m,n+1) if i%s == 0 and i%t == 0 ]

2，龟兔赛跑

def guitu(v1,v2,t,s,l):
    count = 0
    d = 0
    while True:
        if d < t:
            d += v1 - v2
            count += 1
        else:
            d -= v2*s
            count = count + s
        if d + count*v2 >= l and d  > 0:
            print('R 兔子赢了，\n耗时', count)
            break
        elif count*v2 >= l and d  < 0:
            print('T 乌龟赢了，\n耗时', l/v2)
            break
        elif count*v2 >= l and d == 0:
            print('D 平局，\n耗时', count)
            break

第二种稍微不一样的写法

# 最终的目的是判断兔子和乌龟谁先到终点，而这个要通过二者之间同时的路程来判断
# 1，利用时间这个变量来进行循环计算兔子和乌龟的路程差，通过路程差>=t来作为第一个条件判断兔子是否需要休息
def H_T_game(v1,v2,t,s,l):
    time = 0
    d = 0
    while True:
# 2，不休息的话，时间每次更新一秒，如果休息的话，时间更新s秒，此时距离减小s*v2,
        if d<t:
            d += v1-v2
            time += 1
        else:
            d -= v2*s
            time += s            
# 3,还要判断一次，是否此时兔子或者乌龟已经到达终点，若有则直接跳出整个循环，        
        if v2*time >= l or v2*time+d >= l:
            break
# 4 ,找出谁先到终点以及到达的时间    
    if d > 0:
        print('R, The rabbit win')
    elif d < 0:
        print('T, The tortoise win')
    else:
        print('D, a dead heat')  
    print('costTime：%d'%time)

2. 条件语句

if后面的条件可以是and、or、not,==,!=,等条件运算语句，也可以是数字，字符 串，列表等。格式及案列如下：

#if 条件1：
   #做的事情1
#elif 条件2：#可以不要
   #做的事情2
#else:#可以不要
   #做的事情3 
 num = int(input('请输入一个数字：（0-9）'))
if num>=4 and num<=7:
# if not(num>=4 and num<=7):
    print('请到办公室领奖')
 
chepiao = 1#1表述有，0表示没有
changdu = 8#刀长度，大于10不能进去
# 条件嵌套
if chepiao == 1:
    print('可以进入候车厅')
    if chengdu<=10:
        print('通过安检，等待上车')
    else:
        print('没有通过案安检')
else:
    print('请先购买车票再检票')
 
 #1.让电脑产生一个数字i
import random#随机数的库
computer = random.randint(0,2)
print('computer--->%d'%computer)
#2.提示用户并获取一个数字
player = int(input('请输入数字：0表示石头，1表示剪刀，2表示布'))
#3比较两个，若相同，则输出‘平局’,不相同，进行判断????
if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
    print('你赢了')
elif player == computer:
    print('平局')
else:
    print('你输了')

注意：1，if通过缩进来判断满足条件的执行语句，在if下面，敲一个Tab键得到缩进，缩进的内容就是满足条件时会执行的语句，如果没有缩进就不在这个条件判断内，另外，！！！if 加条件的后面一定要加一个冒号：，python的条件，循环，定义函数、类，with方法等都需要在末尾加上冒号，这样才会判断语句，不加就报错了，加了冒号后，直接按回车键就可缩进了。
2，python 中同一个缩进级别的语句运行顺序是平行的，因此，if和elif以及else在一个循环结构中一定要对齐。

assert这个关键词我们称之为“断言”，当这个关键词后边的条件为 False 时，程序自动崩溃并抛出AssertionError的异常
#在进行单元测试时，可以用来在程序中置入检查点，只有条件为 True 才能让程序正常工作

3. 四个循环结构

3.1 while 循环

while与for的区别在于，while是按条件循环，条件满足时就会一直循环，也就是布尔表达式的值为布尔假时跳出循环，布尔值的真假见上个学习内容task1。没有固定的次数，不确定循环多少次的话，可以用while Ture，条件只要是永远为真的都可；而for是按找迭代对象的大小来循环，结构一定是for xxx in xxx，后面的迭代对象可以是字符串，列表，字典，元组等。

例子：

i= 1
res = 0
while i<=100:
    if i%2 == 0:
#        print(i) 
        res += i
    i += 1    
print('1-100的偶数的和为：%d'%res)
# 1-100的偶数的和为：2550

while循环也可用嵌套，例子：

#while循环的嵌套
#每行输出对应行数的*
i= 1
#控制行数
while i<=5:
#    print('*'*i)#法1
#方法2
    #控制一行中*的个数
    j = 1
    while j<=i:
        print('* ',end = '')#加end=空一行继续输出的意思
        j += 1
    print('')#此处目的为换行
    i += 1
 '''
* 
* * 
* * * 
* * * * 
* * * * * 
'''

3.2 while - else 循环

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
# 加了break 后
count = 0
while count < 5:
    print("%d is  less than 5" % count)
    count = 6
    break
else:
    print("%d is not less than 5" % count)

# 0 is  less than 5

3.3 for 循环

for循环跟逻辑结构跟while是类似，但是for是一个迭代循环，有循环次数限制，for可以遍历任何有序序列，for是按找迭代对象的大小来循环，结构一定是for xxx in xxx，后面的迭代对象可以是字符串，列表，字典，元组等，还可以是range迭代器。
for后迭代对象如果是字典的话有三种循环对象：
1，选取的是键值对这一整个对象，key表示键，value表示值，注意要in对象.items(),这两个成对出现

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 

2，只选取键，要in对象.keys()，

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

for key in dic.keys():
    print(key, end=' ')
    
# a b c d 

3，只选取值，要in对象.values()，

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

for value in dic.values():
    print(value, end=' ')
    
# 1 2 3 4

3.4 for - else 循环

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

for num in range(10, 20):  # 迭代 10 到 20 之间的数字
    for i in range(2, num):  # 根据因子迭代
        if num % i == 0:  # 确定第一个因子
            j = num / i  # 计算第二个因子
            print('%d 等于 %d * %d' % (num, i, j))
            break  # 跳出当前循环
    else:  # 循环的 else 部分
        print(num, '是一个质数')

# 10 等于 2 * 5
# 11 是一个质数
# 12 等于 2 * 6
# 13 是一个质数
# 14 等于 2 * 7
# 15 等于 3 * 5
# 16 等于 2 * 8
# 17 是一个质数
# 18 等于 2 * 9
# 19 是一个质数

4. 三个跳出语句

4.1 break语句

break是跳出当前整个循环，这个循环层在break后面的内容都不执行了，下面这个例子很好的说明了：

import random
secret = random.randint(1, 10) #[1,10]之间的随机数

while True:
    temp = input("不妨猜一下小哥哥现在心里想的是那个数字：")
    guess = int(temp)
    if guess > secret:
        print("大了，大了")
    else:
        if guess == secret:
            print("你这样懂小哥哥的心思啊？")
            print("哼，猜对也没有奖励！")
            break
        else:
            print("小了，小了")
print("游戏结束，不玩儿啦！")
#不妨猜一下小哥哥现在心里想的是那个数字：10
#大了，大了
#不妨猜一下小哥哥现在心里想的是那个数字：1
#你这样懂小哥哥的心思啊？
#哼，猜对也没有奖励！
#游戏结束，不玩儿啦！

要注意的是，这里break 虽然是在if 条件语句中，但它跳出的是整个while循环

4.2 continue语句：

与break有点像的是continue**,这里也先介绍continue语句，continue跳出的是本轮循环，并开始下一轮循环。

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

解释一下上面的代码，首先i=0，不满足if，到i=i+2=2，输出，然后继续循环，注意下一个循环i是在range(10)中取的，所以i=1，进入条件语句，输出1，然后跳出当层循环，也就是i=1这个循环，继续i=2循环，以次类推。

4.3 pass语句

此外还有个pass语句，pass 语句的意思是“不做任何事”，如果你在需要有语句的地方不写任何语句，那么解释器会提示出错，而 pass 语句就是用来解决这些问题的。pass是空语句，不做任何操作，只起到占位的作用，其作用是为了保持程序结构的完整性。尽管pass语句不做任何操作，但如果暂时不确定要在一个位置放上什么样的代码，可以先放置一个pass语句，让代码可以正常运行。

5. 两个迭代对象函数（迭代器）

5.1 range() 函数

range的形式是range([start,] stop[, step=1])，其中中括号里的内容可要可不要。这三个参数意思为：start值指的是迭代对象初始值， stop指是迭代对象末尾值+1，也就是只能取到stop-1，step表示start取到stop-1的步长。不输入start，默认其值为0，不输入step 的话默认其值为1。

for i in range(1, 10, 2):
    print(i)

# 1
# 3
# 5
# 7
# 9

5.2 enumerate()函数

enumerate()函数的形式为enumerate(sequence, [start=0])，这个sequence内容可以是一个序列、迭代器或其他支持迭代对象，如列表，字典，元组等，这个会对应两个值，一个是迭代的序号，一个是sequence中的内容，而start是序号开始位置。不输入start，默认其值为0

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
lst = list(enumerate(seasons))
print(lst)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
lst = list(enumerate(seasons, start=1))  # 下标从 1 开始
print(lst)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

enumerate()与 for 循环的结合使用，形式为

for i, a in enumerate(A)
    do something with a  

用 enumerate(A) 不仅返回了 A 中的元素，还顺便给该元素一个索引值i (默认从 0 开始)。此外，用 enumerate(A, j) 还可以确定索引起始值为 j。

languages = ['Python', 'R', 'Matlab', 'C++']
for language in languages:
    print('I love', language)
print('Done!')

'''
I love Python
I love R
I love Matlab
I love C++
Done!
'''

for i, language in enumerate(languages, 2):
    print(i, 'I love', language)
print('Done!')

'''
2 I love Python
3 I love R
4 I love Matlab
5 I love C++
Done!
'''

6. 几个循环推导式

循环推导式的目的在于简洁代码，直接在定义中迭代该对象的取值范围。

6.1 列表推导式

即得到的迭代对象为列表，列表的形式为a[]，类似matllab中的元包，列表中的元素可以是，数组、元组、字典、列表，格式为
[ expr for value in collection [if condition] ]，这个if 是在for循环中的条件判断。即一个表达式或者数据+for +循环变化变量(i等)+in+变化范围（+if或者其他循环），for 后面的内容都是在第一个for 这个循环层的。

x = [-4, -2, 0, 2, 4]
y = [a * 2 for a in x]
print(y)
# [-8, -4, 0, 4, 8]

x = [i ** 2 for i in range(1, 10)]
print(x)
# [1, 4, 9, 16, 25, 36, 49, 64, 81]

列表内容为元组，结果的索引形式为x[3][2] =0

x = [(i, i ** 2) for i in range(6)]
print(x)
# [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x)
# [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]

下面这个程序有两个循环，应该是嵌套循环，先取i=0，再j的值取满

a = [(i, j) for i in range(0, 3) for j in range(0, 3)]
print(a)
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

x = [[i, j] for i in range(0, 3) for j in range(0, 3)]
print(x)
# [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

x[0][0] = 10##改变第一个列表内容的第一个值
print(x)
# [[10, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

下面这个例子说明了推导式中有多个for和if的层级关系，后面的都在前面的嵌套中。

a = [(i, j) for i in range(0, 3) if i < 1 for j in range(0, 3) if j > 1]
print(a)

# [(0, 2)]

6.2 元组推导式

表达式与列表的一致

a = (x for x in range(10))
print(a)
# <generator object <genexpr> at 0x0000025BE511CC48>，为a存储的地址，a为迭代器，输出不出来
print(tuple(a))
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

6.3 字典推导式

格式为：
{ key_expr: value_expr for value in collection [if condition] }
字典的键值对要成对赋值出现，

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
# {0: True, 3: False, 6: True, 9: False}

这里的值是布尔形式，也就是i 是否整除2这一判断值

6.4 集合推导式

集合推导式结果是去重

c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)
# {1, 2, 3, 4, 5, 6}

有一个综合例子，很好的表述了上述内容结合的运用
这个代码的目的是：用户有输入三次密码的机会，输入对了直接跳出程序，输入错了则继续输入，但是只剩两次机会了，直到三次机会用完。

passwdList = ['123', '345', '890']
valid = False
count = 3
while count > 0:
    password = input('enter password:')
    for item in passwdList:
        if password == item:
            valid = True
            break
            
    if not valid:
        print('invalid input')
        count -= 1
        continue
    else:
        break