3.3.1 for 循环¶

n = int(input())             # 将输入的字符转成整型,例如输入 100
sum_of_i = 0                 # 设累加容器初值为0
for i in range(1, n+1):      # 遍历1,2,...n的数列 
    sum_of_i = sum_of_i + i  # 将当前项加到累加容器上，注意此处要缩进，表示循环执行
print(sum_of_i)              # 输出累加总和，5050

n =  int(input())            # 将输入的字符转成整型,例如输入 100
print(sum(range(1, n + 1)))  # sum()函数可返回序列参数的元素的和,输出 5050

print(sum(range(1, int(input()) + 1)))  # sum()函数可返回序列参数的元素的和,输出 5050

print(sum(range(1, 100, 2)))  # 100以内奇数的和2500
print(sum(range(0, 101, 2)))  # 不超过100的偶数的和2550
print(sum(range(0, 101, 5)))  # 不超过100的偶数5的整数倍的数的和1050
print(sum(range(50, 80, 5)))  # 序列50 55 60 65 70 75的和为375

n = int(input())           # 将输入的字符转成整型,例如输入6
fact = 1                   # 设阶乘初值为1，n为0时不进入循环，0的阶乘为1
for i in range(1, n + 1):  # 遍历1,2,...n的数列
    fact = fact * i        # 将当前项加到累加容器上
print(fact)                # 输出累加总和，720

import math

print(math.factorial(6))    # factorial() 为计算阶乘的函数,720

total = 0              # 米粒总数初值
for i in range(64):    # 迭代获取整数序列中的值
    t = 2 ** i         # 当前格中米粒数为2的i次幂
    total = total + t  # 累加各格中米粒数
print(total)           # 输出米粒总数，18446744073709551615

x = 50/600             # 每粒米的质量，单位为克
total_weight = total * x  * 1e-3 * 1e-3 * 1e-8  # 每粒米的质量从克转为千克再转为吨再转为亿吨
print(f'总质量为{total_weight:.2f}亿吨')

# 变量t只用一次，可不定义，直接将当前格米粒数量加上即可，减少不必要的变量定义可使程序更清晰
total = 0              # 米粒总数初值
for i in range(64):    # 迭代获取整数序列中的值
    total = total + 2 ** i  # 当前格中米粒数为2的i次幂加到当前总数上
print(total)           # 输出米粒总数，18446744073709551615

# 列表推导式方法，第6章学习
print(sum([2 ** i for i in range(64)]))

from math import factorial  # 导入math库中的factorial函数 用于计算阶乘

n = int(input())    # 输入正整数表示累加项数，例如输出3
result = 0          # 累加初值为0
for k in range(n):  # 重复执行n次累加
    result = result + factorial(4 * k) * (1103 + 26390 * k) / (factorial(k) ** 4 * 396 ** (4 * k))
pi = 1 / (result*2 * 2 ** 0.5 / 9801)     # 累加结果取倒数为圆周率值
print(pi)           # 输出圆周率值，输出3.141592653589793

import random  # 导入随机数模块

keys = random.randint(100, 999)  # 随机产生一个三位整数
print(keys)  # 查看当前生成的随机数，每次结果不同，此处若密码为651

for i in range(10):          # 猜测百位上的数字
    for j in range(10):      # 猜测十位上的数字
        for k in range(10):  # 猜测个位上的数字
            # 三个数字拼接为一个三位整数，若此三位数与随机产生的相同，则找到密码
            if i * 100 + j * 10 + k == keys:  
                print(f'密码是{i}{j}{k}')      # 密码是651

%%timeit

for cock in range(1, 101):              # 公鸡数量不为0且小于或等于100
    for hen in range(1, 101):           # 母鸡数量不为0且小于或等于100
        for chicken in range(1, 101):   # 小鸡数量大于0小于等于100且是3的倍数
            # 鸡的总数为100，钱的总数为100
            if cock + hen + chicken == 100 and 5 * cock + 3 * hen + chicken // 3 == 100 and chicken % 3 ==0 :
                print(f'公鸡{cock}只，母鸡{hen}只，小鸡{chicken}只')  # 遇到满足条件的数字组合就输出

# 57.4 ms ± 3 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%%timeit

# 100 * 100 * 33 = 33万次
for cock in range(1, 101):                 # 公鸡数量不为0且小于或等于100
    for hen in range(1, 101):              # 母鸡数量不为0且小于或等于100
        for chicken in range(3, 101, 3):   # 小鸡数量大于0小于等于100且是3的倍数
            # 鸡的总数为100，钱的总数为100
            if cock + hen + chicken == 100 and 5 * cock + 3 * hen + chicken // 3 == 100:
                print(f'公鸡{cock}只，母鸡{hen}只，小鸡{chicken}只')  # 遇到满足条件的数字组合就输出

# 20.7 ms ± 626 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

# %%timeit

# 100 * 100 = 1万次
for cock in range(1, 101):          # 公鸡数量不为0且小于或等于100
    for hen in range(1, 101):       # 母鸡数量不为0且小于或等于100
        chicken = 100 - cock - hen  # 小鸡数量可由公鸡和母鸡数量计算得到
        if chicken % 3 == 0 and 5 * cock + 3 * hen + chicken // 3 == 100:
            print(f'公鸡{cock}只，母鸡{hen}只，小鸡{chicken}只')  # 遇到满足条件的数字组合就输出
            
# 1.35 ms ± 41.5 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

%%timeit

# 19 * 32 = 608次
for cock in range(1, 20):           # 公鸡数量不超过20
    for hen in range(1, 33):        # 母鸡数量不超过33
        chicken = 100 - cock - hen  # 小鸡数量可由公鸡和母鸡数量计算得到
        if chicken % 3 == 0 and 5 * cock + 3 * hen + chicken // 3 == 100:
            print(f'公鸡{cock}只，母鸡{hen}只，小鸡{chicken}只')  # 遇到满足条件的数字组合就输出
            
            
# 88.7 µs ± 5.1 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%%timeit

for cock in range(4, 16, 4):    # cock 初值为4，小于16，步长为4
    hen = 25 - cock // 4 * 7    # 整除“//”符号保证运算结果仍为整数
    chicken = 75 + cock // 4 * 3
    print(f'公鸡{cock}只，母鸡{hen}只，小鸡{chicken}只')  # 遇到满足条件的数字组合就输出

# 15.9 µs ± 518 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

n = int(input())       # int()将input()接收的字符串转整数,例如输入12
a, b = 1, 1            # 设定数列前两项的初值
for i in range(n):     # i 只用于控制循环次数,n值为12
    print(a, end=' ')  # 每次循环输出一个值，不换行
    a, b = b, a + b    # 迭代，b的值赋给a，把a，b的和赋值给b
# 1 1 2 3 5 8 13 21 34 55 89 144

import math


x = int(input())             # 输入整数
x0 = x / 2                   # 初值
x1 = (x0 + x / x0) / 2       # 迭代公式
while True:   # 迭代精度
    x0 = x1
    x1 = (x0 + x / x0) / 2
    if abs(x0 - x1) < 1e-5:
        break
print(x1)            # 2.23606797749979
print(math.sqrt(x))  # 2.23606797749979

# 定义初始值和参数
x0 = 0.2
max_iter = 50
tol = 1e-5

# 开始迭代
for i in range(max_iter):
    # 计算f(x)和f'(x)
    fx = x0 ** 4 - 3 * x0 ** 3 + 1.5 * x0 ** 2 + -4
    fx_first_order = 4 * x0 ** 3 - 9 * x0 ** 2 + 3 * x0

    # 计算新的x值
    x = x0 - fx / fx_first_order

    # 检查是否满足精度要求
    if abs(x - x0) < tol:
        print(f'经{i}次迭代，估计参数值是{x}')
        break

    # 更新x0
    x0 = x
else:
    print('达到最大迭代次数，无法收敛')

def f(x):
    """f的方程"""
    return x ** 4 - 3 * x ** 3 + 1.5 * x ** 2 + -4


def f_first_order(x):
    """f的一阶导数"""
    return 4 * x ** 3 - 9 * x ** 2 + 3 * x


def get_root(x0, max_iter=50, tol=1e-5):
    """将初始值浮点化"""
    p0 = 0.2  # 初始化迭代值
    for i in range(max_iter):
        p = p0 - f(p0) / f_first_order(p0)  # f的一阶导数不能为0
        if abs(p - p0) < tol:  # 如果小于精度值则退出迭代
            return f'经{i}次迭代，估计参数值是{p}'
        p0 = p
    print('达到最大迭代次数，无法收敛')


if __name__ == '__main__':
    print(get_root(0))  # 经12次迭代，估计参数值是2.648936536182061

import random


# 输入正整数，表示产生点数量
times = int(input())

# 计数器，落在圆内的点数，初值为0
hits = 0
for i in range(times):
    x, y = random.uniform(-1, 1), random.uniform(-1, 1)
    # 计算坐标（x,y）到原点的距离，小于半径则在圆内
    if x**2 + y**2 < 1:
        hits += 1
# 计算并输出圆周率值，浮点数
pi = (hits / times) * 4
print(pi)

import random


def monte_carlo_cock(num):
    answer = []
    for i in range(num):
        hen = random.randint(1, 20)
        cock = random.randint(1, 33)
        chicken = 100 - cock - hen
        if chicken % 3 == 0 and 5 * cock + 3 * hen + chicken // 3 == 100 :
            group = [cock, hen, chicken]
            if group not in answer:
                answer.append(group)
    return answer


if __name__ == '__main__':
    result = monte_carlo_cock(10000)
    for x in result:
        print('公鸡{}只，母鸡{}只，小鸡{}只'.format(*x))

birthdate = input()  # 输入自己的生日或其他字符串
n = len(birthdate)   # 获取输入的字符串的位数
pi = open('/data/bigfiles/3200wpi.txt').read()  # 读取文件中的圆周率为字符串
# print(len(pi))                                # 去掉注释可输出文件中圆周率位数
for i in range(len(pi)):                       # 逐个遍历圆周率中的字符序号
    if birthdate == pi[i: i + n]:              # 如果从当前字符向后的n个字符构成的字符串与输入的字符串相同
        print(i, i + n)                        # 输出这个字符串的起止位置序号
        # print(pi[:i + n])                    # 输出到匹配字符串为止的圆周率，此语句在本地运行，不要在平台上运行
        # break                                # 若去掉注释，匹配到一个就终止循环

输入：
5201314
输出：
2823258 2823265
25808025 25808032
26170648 26170655

输入
13297966265
输出：
22822747 22822758

a, b, c, d, e = 0, 0, 0, 0, 0  # 累加器清0
pi = open('/data/bigfiles/3200wpi.txt').read()  # 读取文件中的圆周率为字符串
for i in pi:  # 逐个遍历圆周率中的字符序号
    if i == '0':
        a = a + 1
    elif i == '1':
        b = b + 1
    elif i == '2':
        c = c + 1
    elif i == '3':
        d = d + 1
    elif i == '4':
        e = e + 1
        
# 分别统计输出0，1，2，3，4的数量
print(a, b, c, d, e)
# 3355091 3355566 3356627 3355076 3357258