9.26总结

最新推荐文章于 2024-09-13 19:41:31 发布

一株菌子

最新推荐文章于 2024-09-13 19:41:31 发布

阅读量806

点赞数 15

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/kuailededanzhu/article/details/141793074

版权

python 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

9.26总结

9.25作业回顾

# 4.计算并输出1-2+3-4+……+99-100的值
count4 = 0
for s4 in range(1,101):
    if s4 % 2 != 0:
        count4 += s4
    else:
        count4 -= s4
print(count4)

# 方法2：
# 可以利用-1的幂数 控制是加还是减
(-1)^(1+1)  ===> +1
count4 = 0
for d in range(1, 101):
    count4 += (-1)**(d+1) * d
print(count4)

# 7.设N是⼀个4位数，它的9倍恰好是其的反序数（如1234的反序数为4321）,求所有的满足条件的N
for s7 in range(1000,10000):
    num71 = s7 % 10 * 1000
    num72 = s7 // 10 % 10 * 100
    num73 = s7 // 100 % 10 * 10
    num74 = s7 // 1000
    count7 = num71 + num72 + num73 +num74
    if s7 * 9 == count7:
        print(s7)

# 8.2006年培养学员8万人，每年增长25%，请问按此增长速度，到哪一年培训学员人数将达到20万
people = 8
year = 2006
while people < 20:
    people =people*1.25      # people + people * 0.25  
    year += 1
print(year)

if - else

if-else [else是否则的意思当if条件不成立的时候才会执行else]

for - else

for-else [else也是同理的 for-in遍历容器只要容器中有数据就会进入到循环体中

当且仅当容器中没有数据可遍历时才会执行else]

for i in range(1, 6):
    print(i)
else:
    print('容器中没有数据可遍历了')    # 1 2 3 4 5 容器中没有数据可遍历了

break 的应用

break 结束循环[达到某种要求结束的] 强制结束

1. 判断一个字符串中的数据是否是纯数字的

“”"
纯数字这个概念：
从头到尾没有出现过数字之外的符号
验证是否是纯数字
需要从头到尾进行遍历所有的都是数字才能证明这个字符串是纯数字
这种思路是可以的但是实现是比较难的【一般会使用反向思维】
验证字符串是否不是纯数字
只需要遍历的时候验证字符的内容是是数字之外的符号是的话就代表不是纯数字

# 当所有的符号全部都验证完毕  没有数字之外的符号 代表着字符串是纯数字的
什么情况下 每个符号全部验证完毕？？？？  字符串被遍历完成 字符串中没有内容可取了

当不是不成立  就代表着是

s = '15355422'
s1 = '4567as8'
for ch in s1:
    if not('0' <= ch <= '9'):
        # 这个条件成立了  字符串不是纯数字
        print(s1, '不是纯数字')
        break
else:
    print(s1, '是纯数字')
for ch1 in s:
    if not('0' <= ch1 <= '9'):
        # 这个条件成立了  字符串不是纯数字
        print(s, '不是纯数字')
        break
else:
    print(s, '是纯数字')
    
# 4567as8 不是纯数字
# 15355422 是纯数字

质数的判定 break和for结合

# 判断一个整数是否为质数【大于1的自然数中  因数只有1和本身的数称为质数[素数]】
"""
因数只有1和本身 【重点在只有】
那换句话说 如果在1和本身之间出现了其他因数  这个数据就不是质数了
如果这个数据是11  怎么拿到2到本身之间的数据？？？    range(2, 11)
"""
num = int(input('请输入一个整数:'))
if num <= 1:
    print(num, '不是质数')
else:
    for m in range(2, num // 2 + 1):
        if num % m == 0:
            print(num, '不是质数')
            break
    else:
        print(num, '是质数')

# 质数判定 方法二：
"""
6   2*3
8   2*4
9   3*3
25  5*5
36  2*18   3*12  4*9  6*6
64  2*32   4*16  8*8

观察一下  拆解的因数 
     36 因数拆解
        左边的数据  <= 6   左边是小于开方的
        右边的数据  >= 6   右边是大于开方的
    当左边的数据有成立的 右边的不需要判定了 
    数据再缩小范围   只验证<=6的即可
    6是36的开平方的值  所以范围可以设置为 2到数据开方+1
"""

num = int(input('请输入一个整数:'))
if num <= 1:
    print(num, '不是质数')
else:
    for m in range(2, int(num ** (1/2)) + 1):  # 开方的结果是浮点型的 因此这里需要转成整型
        if num % m == 0:
            print(num, '不是质数')
            break
    else:
        print(num, '是质数')

range（）只支持整形

循环嵌套

场景：重复的操作被重复的执行

# 需求: 横向打印6颗星  一次只打印一个
print('*', end='')
print('*', end='')
print('*', end='')
print('*', end='')
print('*', end='')
print('*', end='')
# ******         
# 默认情况下，print函数在每次输出后会自动添加一个换行符。但是，如果你想在多次print输出后在同一行显示结果，你可以使用end=''来改变这个行为。
# end=''告诉print`函数在输出后不要添加换行符，因此，所有的输出都会在同一行。

# 不加end=''，原本会有个默认换行符，会换行，加了end=''表示后面什么都不加，也就是换行都不需要

print()代表一个换行符

for i in range(6):
    print('*', end='')
print()  # 什么都不打印 就代表的是一个换行符 【end='\n'来的】
# 换行 再次打印6颗星
for i in range(6):
    print('*', end='')
print()

# """
目的是打印3行6列
    有行列概念的时候 就需要使用的循环嵌套
    外层控制的是行
    内层循环控制的是列
"""
for i in range(6):
    print('*', end='')
print()

#   ******
#   ******
#   ******

控制打印情况

"""
有些情景：列的个数 需要和行找规律

打印形状
*
**
***
****
*****

5行 --- 外层循环循环5次
有几列？？？  不固定
   需要找列和行的关系
规律
  行   列
   1    1 --- 序列中一个数据
   2    2 --- 序列中2个数据
   3    3
   4    4
   5    5

可总结为： 每一行的列数 = 当前行号
"""
for r in range(1, 6):  # 行号 1 2 3 4 5
    # 内层：每一行的列数  容器中有几个数据
    for c in range(r):
        print('*', end='')
    # 这一行的列打印完 才换行
    print()

反三角打印

"""
*****
****
***
**
*

行  列
1   5
2   4
3   3
4   2
5   1

当前的列数 = 6 - 当前行号
"""
for r1 in range(1, 6):
    # 列
    for c1 in range(6 - r1):
        print('*', end='')
    print()

# 另外一种写法  行号是倒序的 按照列数来走的
for r2 in range(5, 0, -1):
    for c2 in range(r2):
        print('*', end='')
    print()

九九乘法表

"""
99乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9

数字呈现出来 因为遍历的时候 遍历有几行 有几列
数字要呈现出来使用行号和列号来代替
外层循环中 容器的数据代表的是行号
内层循环中 容器中的数据代表的列号
"""
for r3 in range(1, 10):  # [1, 2,3 ,4, 5, 6, 7, 8,9] 行号
    # 列的容器
    for c3 in range(1, r3+1):
        print(c3, '*', r3, '=', c3*r3, end='\t')
    print()

百马百鸡问题

看代码流程时候, 按debug显示到了位置后，再按一下，才会到达该位置，到时候输入或者查看都可以

"""
百元百鸡问题 、百马百担问题
    公鸡5元一只，母鸡3元一只，小鸡3只一元
涉及到一种计算方式：穷举法【把每种组合列举一下  查找满足需求的】

假设 100元全部买鸡
公鸡  最多买20只    range(1, 20)
母鸡  最多买33只     range(1, 34)
小鸡  最多买100只     range(3, 100, 3)
                          3  6  9  12 15 18 21  24  27 30 ....                         
公鸡  母鸡  小鸡
 1      1     3
 1      1     6
 ...
 1      2    3
 1      2    6
 ....
"""
# 公鸡的购买只数
for g in range(1, 20):
    # 母鸡的购买只数
    for m in range(1, 34):
        # 小鸡的购买只数
        for x in range(3, 100, 3):
            # print(g, m, x)
            # 进行判断: 总只数是100只 并且总金额是100元
            if g + m + x == 100 and 5*g + 3*m + x//3 == 100:
                print(g, m, x)  
                #   4 18 78
				#   8 11 81
				#   12 4 84
# print(20 * 34 * 33)  # 

# 方式二：
# 提高运算效率 简化的方法？？？ --- 可以简化
# 改成2层循环
# 公鸡的购买只数
for g in range(1, 20):
    # 母鸡的购买只数
    for m in range(1, 34):
        # 小鸡的购买只数 [这个数据必须是3的倍数]
        x = 100 - g - m
        # 条件判断
        if x % 3 == 0 and 5*g + 3*m + x//3 == 100:
            print(g, m, x)

百马百担问题：（与百鸡问题类似）

# 百马百担问题：有100匹马，驮100担货，大马驮3担，中马驮2担，两匹小马驮1担，问大，中，小马各有多少？
"""
100担货  最多需要大马 33匹
  最多需要中马50匹
  最多需要小马 100匹
"""
print('=========')
for i in range(1, 34):
    for m in range(1, 50):   # 要求三种都有
        l = 100 - i - m
        if l% 2 == 0 and i*3+m*2+l//2 == 100:
            print(i,m,l)

斐波拉契数列

“”"
F(1) = 1
F(2) = 1
F(n) = F(n-1) + F(n-2) (n>=3)

公式是由一堆兔子推出来的
需求：
第一个月有一对兔子，这对兔子从第三个月开始每个月都会生一对小兔子，
小兔子从出生开始第三个月每个月都会生一对小兔子
假设兔子不死，问N个月后兔子的对数是多少
“”"

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

键盘录入一个月份求这个月份对应的兔子的对数

“”"
规律中是有两个已知项的【1月和2月兔子的对数】
这个已知项就是数据计算的起始值
“”"

记录上个月的兔子数

last_month = 1

记录上上个月

before_last_month = 1

当前月份的兔子数

current = 1

输入月份

month = int(input(‘请输入月份：’))

遍历

if month == 1 or month == 2:
print(‘兔子的对数为’, current)
else:
for m in range(3, month + 1):

# 当前月份兔子数

current = last_month + before_last_month

# 相求下个月的上个月的兔子数与上上个月的兔子数的记录者发生变化

# 上个月的赋值为当前月的数据上上个月的为上个月的数据

last_month, before_last_month = current, last_month
print(‘兔子的对数为’, current)

简洁版：只把1月份当做已知项

F(n) = F(n-1) + F(n-2)

本月的数据 = 上个月的数据+上上个月的数据

现在是1月份

last = 0 # 上个月的数据信息【已知项是1月份上个月0月份没有数据将值设置为0】
current1 = 1 # 1月份

现在到了2月份了上个月就变成1月份

current1, last = last + current1, current1

current1记录的2月数据 last记录的是1月的数据

现在是3月份了上个月得是2月

current1, last = last + current1, current1

current1记录的3月数据 last记录的是2月的数据

按照上面的规律代码编写为

last0 = 0 # 现在是0月份的数据
count = 1 # 现在是1月份的数据
if month == 1:
print(‘兔子的对数’, count)
else:
for m0 in range(2, month + 1):
count, last0 = count + last0, count
print(‘兔子的对数’, count)

2.7 函数

2.7.1函数定义

对一段功能独立并且重复使用的代码进行封装，当我们需要使用的时候，在进行调用，目的是为了减少代码的重复性，提高代码的复用率

语法格式：

def 函数名(形式参数名, 形式参数名1,...,形式参数名n):
    函数功能体
    return 返回值

解读：

def 关键字，用来定义函数的
函数名，根据功能自定义的名字，需要遵守标识符规则
() 存放函数的形式参数的，如果没有形式参数，()内为空

形式参数: 函数运算的时候有些数据的未知[动态]的, 将这些未知的数据使用变量名来进行表示，这个变量名就是形式参数，简称形参。未知的数据有几个，就定义几个形式参数
return,也是一个关键字，结束函数，并把结果返回到函数调用的位置

如果功能需求中不需要返回值，可以写成return None或者省略

注意：return和print不一样
1. print把数据输出到程序外的控制台
2. return把数据传递到函数调用的位置，数据还是在程序中运转的

定义函数的规则：

明确是否有未知项参与功能的运算【用来定义形式参数有什么】
明确是否需要将结果返回到调用的位置【决定return的情况】

函数的调用:

# 有返回值的函数调用
变量名 = 函数名(实际参数, 实际参数1, 实际参数2,..,实际参数n)
# 没有返回值的函数调用
函数名(实际参数, 实际参数1, 实际参数2,..,实际参数n)

"""
实际参数：实际参与函数功能运算的数据 称为实际参数，简称实参
实际参数的个数要和形式参数的个数一致，并且位置是一一对应的

定义函数的时候 函数内部的功能并未被执行，当调用的时候才会执行内部的功能
"""

需求：求圆的面积 S = π * r ** 2

公式中半径r是可以变化的

页面1. 求半径为3的圆的面积圆周率定位3.14

area = 3.141592 * 3 ** 2
print(area)

页面2. 求半径为1.5的圆的面积圆周率定位3.14

area1 = 3.141592 * 1.5 ** 2
print(area1)

页面3. 求半径为5的圆的面积圆周率定位3.14

area2 = 3.141592 * 5 ** 2
print(area2)

需求：精确圆周率到小数点后6位

把功能封装成函数

def get_circle_area(radius):
“”"
求圆的面积
:param radius: 代表半径参与功能体的运算称为形式参数
:return: 返回圆的面积
“”"
S = 3.141592 * radius ** 2
return S

调用函数

res = get_circle_area(10)
print(‘圆的面积是’, res)

调用函数

res1 = get_circle_area(17)
print(‘圆的面积是’, res1)

“”"
练习：

求两个数中的最大值
未知项：有2个
是否返回结果: 需要
对比两个数据的大小，前者大于后者返回1 前者等于后者返回0 前者小于后者返回-1
未知项：有2个
是否返回结果：需要
封装一个功能打印NN乘法表
N为几就打印几行乘法表
比如N为3 控制台打印为
11=1
12=2 22=4
13=3 23=6 33=9

未知项：有1个
是否需要返回结果：不需要
“”"

def get_max(a, b):
# if a > b:
# return a
# else:
# return b
return a if a > b else b

max_value = get_max(17, 20)
print(max_value)

def compare(a, b):
# if a > b:
# return 1
# elif a == b:
# return 0
# else:
# return -1
return (a > b) - (a < b) # 应用的True被当做1 False被当做0

调用函数

res = compare(17, 15)
if res == 1:
print(‘前者大于后者’)
elif res == 0:
print(‘两者相等’)
else:
print(‘前者小于后者’)

def compare1(a, b):
    if a > b:
        print(1)
    elif a == b:
        print(0)
    else:
        print(-1)
res1 = compare1(19, 18)
print(res1)  # None

# 九九乘法表
def n_table(n):
    for r3 in range(1, n+1):  # 行号
        # 列的容器
        for c3 in range(1, r3 + 1): # 列号
            print(c3, '*', r3, '=', c3 * r3, end='\t')
        print()

return 0
# else:
# return -1
return (a > b) - (a < b) # 应用的True被当做1 False被当做0

调用函数

res = compare(17, 15)
if res == 1:
print(‘前者大于后者’)
elif res == 0:
print(‘两者相等’)
else:
print(‘前者小于后者’)

def compare1(a, b):
    if a > b:
        print(1)
    elif a == b:
        print(0)
    else:
        print(-1)
res1 = compare1(19, 18)
print(res1)  # None

# 九九乘法表
def n_table(n):
    for r3 in range(1, n+1):  # 行号
        # 列的容器
        for c3 in range(1, r3 + 1): # 列号
            print(c3, '*', r3, '=', c3 * r3, end='\t')
        print()