Python——循环与分支结构

1.循环

在编程中，循环结构是非常常见的一种结构，我们可以使用循环来重复执行某个代码块。Python中提供了两种循环结构：

for循环

while循环

1.1 for循环

for循环适合用于遍历序列或集合中的元素，比如：

#遍历列表中的元素
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(fruit)

上述代码中，我们通过for循环遍历了列表fruits中所有的元素，并将其打印出来。

我们也可以使用range函数来控制循环的次数：

#使用range函数
for i in range(1,6):
    print(i)

上述代码中，我们使用range函数从1到5生成一个序列，然后通过for循环遍历该序列中的所有元素，并将其打印出来。

1.2 while循环

while循环在某些情况下更加方便，比如需要无限循环或者需要根据某些条件来控制循环的次数：

#无限循环
while True:
    print('Hello, world!')

上述代码中，我们使用while循环来无限循环输出Hello, world!。

当然，我们也可以使用条件表达式来控制while循环的次数：

#使用条件表达式
i = 1
while i <= 5:
    print(i)
    i += 1

上述代码中，我们使用while循环遍历从1到5的整数，并将其打印出来。

2.分支结构

分支结构是另外一种常见的编程结构，我们可以使用分支结构来根据不同的条件执行不同的代码块。Python中提供了if语句来实现分支结构。

2.1 if语句

if语句可以根据某个条件来判断执行哪些代码块：

#使用if语句
x = 10
if x > 0:
    print('x is positive')

上述代码中，我们根据x是否大于0来判断是否执行print语句。

我们也可以使用if…else语句来根据不同的条件执行不同的代码块：

#使用if…else语句
x = -10
if x > 0:
    print('x is positive')
else:
    print('x is non-positive')

上述代码中，我们根据x是否大于0来判断执行不同的print语句。

我们还可以使用if…elif…else语句来实现多个条件的判断：

#使用if…elif…else语句
x = 0
if x > 0:
    print('x is positive')
elif x == 0:
    print('x is zero')
else:
    print('x is non-positive')

上述代码中，我们根据x是否大于0、是否等于0来分别判断执行不同的print语句。

3.实例

下面是一个具体的例子，该例子实现了一个生成文本的小程序：

#生成文本的小程序
import tensorflow as tf
import numpy as np
#定义数据集
data = "abcdefghijklmnopqrstuvwxyz"
char_to_ix = { ch:i for i,ch in enumerate(data) }
ix_to_char = { i:ch for i,ch in enumerate(data) }
n_input = n_output = len(data)
n_hidden = 256
learning_rate = 0.001
temperature = 0.6
#定义输入输出
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_output])
#定义网络结构
W1 = tf.Variable(tf.truncated_normal([n_input, n_hidden], stddev=0.1))
b1 = tf.Variable(tf.zeros([n_hidden]))
h1 = tf.nn.relu(tf.matmul(x, W1) + b1)
W_out = tf.Variable(tf.truncated_normal([n_hidden, n_output], stddev=0.1))
b_out = tf.Variable(tf.zeros([n_output]))
y_pred = tf.matmul(h1, W_out) + b_out
#定义损失函数和优化器
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_pred, labels=y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)
#生成文本的函数
def generate_text(sess, seed_ix, n):
    #生成输入
    x_pred = np.zeros((1, n_input))
    x_pred[0][seed_ix] = 1
    #生成输出
    text = []
    for _ in range(n):
        y_pred_val = sess.run(y_pred, feed_dict={x: x_pred})
        p = tf.nn.softmax(tf.multiply(y_pred_val, 1 / temperature)).eval()[0]
        ix = np.random.choice(range(n_output), p=p.ravel())
        x_pred = np.zeros((1, n_input))
        x_pred[0][ix] = 1
        text.append(ix_to_char[ix])
    return ''.join(text)
#训练模型
n_epochs = 10000
batch_size = 128
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for epoch in range(n_epochs):
        #生成批次数据
        batch_input = []
        batch_output = []
        for _ in range(batch_size):
            ix = np.random.choice(range(n_input))
            batch_input.append(np.eye(n_input)[ix])
            ix += 1
            if ix == n_input:
                ix = 0
            batch_output.append(np.eye(n_output)[ix])
        #训练模型
        _, loss_val = sess.run([optimizer, loss], feed_dict={x: batch_input, y: batch_output})
        if epoch % 100 == 0:
            print('Epoch:', epoch, 'Loss:', loss_val)
            #生成文本
            seed_ix = np.random.choice(range(n_input))
            generated_text = generate_text(sess, seed_ix, n=10)
            print('Generated text:', generated_text)

上述代码中，我们在定义数据集和网络结构后，使用循环结构来训练模型，使用条件语句来判断生成文本的温度。

总结

本文主要介绍了Python中的循环和分支结构，以及如何使用它们来实现不同的功能。在实际开发过程中，这些结构是非常常见的，掌握它们对于提高代码的效率和可读性都是非常有帮助的。