for结合range的小案例

文章详细解释了for和while循环、break和continue关键字在Python中的使用,通过实例展示了如何遍历、累加、条件判断以及处理循环次数不明确的情况,如求和、寻找特定数字规律和猜数字游戏。
摘要由CSDN通过智能技术生成

for结合range的小案例

产生一个容器 容器放着1-100的数据

遍历容器的取值 取出来一个累加起来

注意:和随着取值会发生变化 【定义一个变量 用来接受累加加的值】

 total = 0
 for i in range (1, 101):
 total  += i
 # 第一次 in 的时候 i = 1
 total += i == >total = total + i =1
 # 第二次 in 的时候 i = 2
 total += i == >total = total + i = 1 + 2 = 3
 # 第三次 in 的时候 i = 3
 total += i == >total = total + i = 3 + 3 = 6
 print(total)

求1-2+3-4+5-6+…-98+99-100

# 求 1-2+3-4+5-6+...-98+99-100
# a = 0
# for i in range(1,101):
#     if  i % 2 ==1:
#         a += i
#
#     else:
#         a -= i
# print(a)

关键字break和continue

break和continue

都是应用在循环结构语句中,只能对循环起作用

break的作用是中断它所在的循环【退出循环】

continue的作用【循环一次一次执行的是】,结束当前次【循环体中后面的代码不在执行】

跳过循环判断的位置,在决定是否开启下一次【判断成立的时候,开启下一次】

打印1-10 中的偶数
for i range (1,11):
 if i % 2 == 0:
 print(i)
 
 for j in range (1,11):
  if j % 2 == 1 :
    continue
    print(j)

利用continue 写数7 游戏

使用range生成1-100的数列

遍历逐个获取数据

判断 获取的数据 是否为7的倍数或者是带7

带有7 有两种情况
            个位   %10 == 7
            十位  //10%10 == 7
        7的倍数
            %7 == 0
            
for m in range(1, 101):
if m % 10 == 7 or m // 10 % 10 == 7 or m % 7 == 0:
 continue
   print(m)

break 是结束所在的循环

​ 一般循环结束是 循环条件不成立或者容器中没有数据可拿是 结束循环

for n in range (1,11):
   print(n)
   if n== 5:
   break
   

需求:

获取 1-100中 3的倍数且个位数为5 当获取到第二个的时候 结束获取
思路:
获取的时候还需要计数 当计数器为2的时候 结束循环

for k in range(1, 101):
    if k % 3 == 0 and k % 10 == 5:
        count += 1  # 计算器+1
        print(k)

判断计算器是否为2 结束

if count == 2:
    break

whlie循环结构

while 条件判断:

​ 循环体代码块

解读:

只要条件成立,程序就一直再次循环,直到循环条件不成立。

输出1-10之间的数据
for循环的思想:需要一个容器,容器中存放在1-10
for in range1,11):
   print(i)
   print('    ')
 重复做的操作是什么  ==== 打印数据  每次打印的都是一个
 做这件事情的条件  ===只要打印的数据没有到10 就得一直打印
 
 
 根据这两件事情,需要那些数据支持
 打印数据 每打印一次 数据要在原来的基础上加1
 也就是说要打印的数据都是变化的 就得设置标记名给其进行标记【定义一个变量 记录打印的数据值】
 
 num = 1 
 while num <=10:
    print(num)
    num += 1
    print('循环结束时 num的值',num)

1-10中的偶数 使用whlie打印1-10中的偶数

m = 1
while m <= 10:
 if m % 2 ==0:
 print(m)
 m+=1
 

使用while循环 完成 1+2+3+…+100

m = 1
total = 0
whlie m<101:
    total +=m
     m += 1 
print(total)

求1-2+3-4+5-6+…-98+99-100

k=1
toyal = 0
while  k<101:
  if  k% 2 ==0:
   total -= k
else:
total += k
k += 1 
print(total)

p = 1
count = 0
whlie p<101:
   if p% 3 == 0 and p% 10==5:
   count += 1
   p += 1
   print(count)

循环结束的场景:

  1. 明确循环次数 — for- in循环 遍历容器,容器中有几个数据 循环就执行几次

  2. 明确结束状态的 —while循环

    ​ while 循环条件:

    ​ 满足条件执行

    经过上面的代码演示while可以使用与明确循环次数的,只不过使用while书写起来麻烦一些

    所以建议使用for in循环

    案例:有1023个桃子,每天吃桃子的一半多一个,问多少天能吃完

    因为循环次数不明确 就使用while循环而用while循环就要明确

    1.重复做什么

    2,结束做这件事情的状态【只要没有达到这个状态就没有结束】

    需要的数据
    1.需要一个变量名  接受桃子的个数  起始值为1023
    2.计数器 记录吃的天数
    peach_count = 1023
    day = 0
    whlie peach _count > 0 :
           peach_count = peach_count -(peach_count/2+1)
           day += 1
     print('1023个桃子需要',day,'天吃完')
    

    练习

    1.录入一个大于1的整数

    ​ 如果这个数值是偶数 将数据整除2后-1

    ​ 如果这个数是奇数 将这个数据-1 在整除 2

    ​ 重复操作 问多少次之后才能将数据设置为0

    2.一张纸的厚度是0.8mm,假设纸足够长,问对折多少次可以将纸的高度达到千米

    num = int(input('请输入一个大于一的整数:'))
    count = 0
    while num > 0 :
        if num % 2 == 0:
            num = num // 2 -1
        else:
            num = num - 1//2
            count += 1
    print(num)
    
    paper_height = 0.8
    count3 = 0
    while true:
        paper_height *= 2
        count3+= 1
        if paper_height >= 1000*1000
            break
    

    数字炸弹:
    规则: 有一个出题人 随便在1-100之间设定一个数据,然后其他人猜
    猜小了、猜大了 出题人提示新的范围
    猜中了 就一顿暴揍

​ 69

​ 你: 85 出题人 1-85
​ 他: 70 出题人 1-70
​ 她: 55 出题人 55-70
​ 我: 69 挨揍了

import random

print(random.randint(1, 101))

完成这个游戏 是需要循环的
循环次数是不明确的,使用while循环
循环结束状态: 猜中了
数据准备
1. 准备一个1-100中的随机数
2. 猜数的范围的起始值和结束值

random_num = random.randint(1, 100)  # 唯一一个包含结束位置的
# 猜数的范围
start = 1
stop = 100
# 开始猜
while True:
    # 猜的动作是重复的  所以放在循环中
    # 字符串数据可以使用+将数据拼接在一起 【只能是字符串与字符串拼接】
    # 把数据转化成字符串的操作 str(数据)  int() float()
    guess = int(input('请输入' + str(start) + '-' + str(stop) + '之间的数据,进行竞猜:'))
    # 将输入的数据与随机的数据进行对比
    if guess > random_num:
        # pass
        print('猜大了')
        stop = guess
    elif guess < random_num:
        print('猜小了')
        start = guess
    else:
        print('猜中了  暴揍中.....')
        break
print('游戏结束')
这里是一个使用栈自编码器结合LSTM来预测时间序列的PyTorch案例代码。 首先,我们需要导入必要的库和定义一些超参数: ```python import torch import torch.nn as nn import torch.optim as optim import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler # 超参数 input_size = 1 hidden_size = 64 num_layers = 2 stack_size = 3 output_size = 1 batch_size = 64 num_epochs = 100 learning_rate = 0.001 ``` 然后,我们需要加载数据并对其进行归一化: ```python # 加载数据 data = pd.read_csv('data.csv', index_col=0) data = data.values.astype('float32') # 归一化 scaler = MinMaxScaler(feature_range=(-1, 1)) data = scaler.fit_transform(data) ``` 接下来,我们需要定义模型。我们将使用一个栈自编码器和一个LSTM来构建模型。在栈自编码器中,我们将把输入数据压缩成一个更小的向量,然后再解压缩回原始形式。这个过程可以帮助我们提取更有用的特征。然后,我们将使用LSTM来学习时间序列的模式。 ```python class StackedAutoEncoder(nn.Module): def __init__(self, input_size, hidden_size, stack_size): super(StackedAutoEncoder, self).__init__() self.input_size = input_size self.hidden_size = hidden_size self.stack_size = stack_size self.encoder = nn.ModuleList([ nn.Linear(input_size, hidden_size) for i in range(stack_size)]) self.decoder = nn.ModuleList([ nn.Linear(hidden_size, input_size) for i in range(stack_size)]) def forward(self, x): for i in range(self.stack_size): x = self.encoder[i](x) x = torch.relu(x) for i in range(self.stack_size - 1, -1, -1): x = self.decoder[i](x) x = torch.relu(x) return x class LSTM(nn.Module): def __init__(self, input_size, hidden_size, num_layers, output_size): super(LSTM, self).__init__() self.input_size = input_size self.hidden_size = hidden_size self.num_layers = num_layers self.output_size = output_size self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device) c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device) out, _ = self.lstm(x, (h0, c0)) out = self.fc(out[:, -1, :]) return out ``` 然后,我们需要定义训练函数: ```python # 初始化模型和优化器 sae = StackedAutoEncoder(input_size, hidden_size, stack_size).to(device) lstm = LSTM(hidden_size, hidden_size, num_layers, output_size).to(device) params = list(sae.parameters()) + list(lstm.parameters()) optimizer = optim.Adam(params, lr=learning_rate) # 定义损失函数 criterion = nn.MSELoss() def train(data): # 将数据转换成序列 data = torch.from_numpy(data).float() dataset = [] for i in range(len(data) - stack_size): dataset.append((data[i:i+stack_size], data[i+stack_size])) dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True) # 训练模型 for epoch in range(num_epochs): for seq, label in dataloader: seq = seq.to(device) label = label.to(device) # 前向传播 encoded_seq = sae(seq.view(-1, input_size)) encoded_seq = encoded_seq.view(batch_size, stack_size, hidden_size) output = lstm(encoded_seq) loss = criterion(output, label) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() # 打印损失 if (epoch+1) % 10 == 0: print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item())) return sae, lstm ``` 最后,我们可以使用训练好的模型来进行预测: ```python # 加载模型并预测 sae, lstm = train(data) sae.eval() lstm.eval() test_data = np.array([0.5, 0.6, 0.7, 0.8, 0.9]) test_data = scaler.transform(test_data.reshape(-1, 1)).reshape(1, -1) test_data = torch.from_numpy(test_data).float().to(device) with torch.no_grad(): encoded_seq = sae(test_data.view(-1, input_size)) encoded_seq = encoded_seq.view(1, stack_size, hidden_size) output = lstm(encoded_seq) output = scaler.inverse_transform(output.cpu().numpy()) print(output) ``` 这就是使用栈自编码器结合LSTM来预测时间序列的PyTorch案例代码。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值