python 走向编程的第一步

当然，我们可以将 Python 用于更复杂的任务，而不是仅仅两个和两个一起添加。 例如，我们可以编写 斐波那契数列的初始子序列，如下所示:

  1 >>> # Fibonacci series:
  2 ... # the sum of two elements defines the next
  3 ... a, b = 0, 1
  4 >>> while a < 10:
  5 ...     print(a)
  6 ...     a, b = b, a+b
  7 ...
  8 0
  9 1
 10 1
 11 2
 12 3
 13 5
 14 8

这个例子引入了几个新的特点。

• 第一行含有一个 多重赋值: 变量 a 和 b 同时得到了新值 0 和 1. 最后一行又用了一次多重赋值, 这体现出了右手边的表达式，在任何赋值发生之前就被求值了。右手边的表达式是从左到右被求值的。

• while循环只要它的条件(这里指： a < 10)保持为真就会一直执行。Python 和 C 一样，任何非零整数都为真；零为假。这个条件也可以是字符串或是列表的值，事实上任何序列都可以；长度非零就为真，空序列就为假。在这个例子里，判断条件是一个简单的比较。标准的比较操作符的写法和 C 语言里是一样： <(小于)、 > (大于)、 == (等于)、 <= (小于或等于)、 >= (大于或等于)以及 != (不等于)。

• 循环体 是 缩进的 ：缩进是 Python 组织语句的方式。在交互式命令行里，你得给每个缩进的行敲下 Tab 键或者(多个)空格键。实际上用文本编辑器的话，你要准备更复杂的输入方式；所有像样的文本编辑器都有自动缩进的设置。交互式命令行里，当一个组合的语句输入时, 需要在最后敲一个空白行表示完成(因为语法分析器猜不出来你什么时候打的是最后一行)。注意，在同一块语句中的每一行，都要缩进相同的长度。

• print() 函数将所有传进来的参数值打印出来. 它和直接输入你要显示的表达式(比如我们之前在计算器的例子里做的)不一样， print() 能处理多个参数，包括浮点数，字符串。 字符串会打印不带引号的内容, 并且在参数项之间会插入一个空格, 这样你就可以很好的把东西格式化, 像这样:

    1 >>> i = 256*256
    2 >>> print('The value of i is', i)
    3 The value of i is 65536

关键字参数 end 可以用来取消输出后面的换行, 或是用另外一个字符串来结尾:

  1 >>> a, b = 0, 1
  2 >>> while a < 1000:
  3 ...     print(a, end=',')
  4 ...     a, b = b, a+b
  5 ...
  6 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

注意:

1.因为 ** 比 - 有更高的优先级, 所以 -3**2 会被解释成 -(3**2) ，因此结果是 -9. 为了避免这个并且得到结果 9, 你可以用这个式子 (-3)**2. 2.和其他语言不一样的是, 特殊字符比如说 \n 在单引号 ('...') 和双引号 ("...") 里有一样的意义. 这两种引号唯一的区别是，你不需要在单引号里转义双引号 " (但是你必须把单引号转义成 \') ， 反之亦然.

其他流程控制工具

除了刚刚介绍过的 while语句，Python 中也会使用其他语言中常见的流程控制语句，只是稍有变化。

 if 语句

可能最为人所熟知的编程语句就是 if 语句了。例如：

  1 x = int(input("Please enter an integer: "))
  2 Please enter an integer: 42
  3 >>> if x < 0:
  4 ...     x = 0
  5 ...     print('Negative changed to zero')
  6 ... elif x == 0:
  7 ...     print('Zero')
  8 ... elif x == 1:
  9 ...     print('Single')
 10 ... else:
 11 ...     print('More')
 12 ...
 13 More

可以有零个或多个 elif部分，以及一个可选的 else部分。 关键字 'elif' 是 'else if' 的缩写，适合用于避免过多的缩进。 一个 if ... elif ... elif ... 序列可以看作是其他语言中的 switch 或 case 语句的替代。

4.2. for 语句

Python 中的 for语句与你在 C 或 Pascal 中可能用到的有所不同。 Python 中的 for 语句并不总是对算术递增的数值进行迭代(如同 Pascal)，或是给予用户定义迭代步骤和暂停条件的能力(如同 C)，而是对任意序列进行迭代(例如列表或字符串)，条目的迭代顺序与它们在序列中出现的顺序一致。 例如(此处英文为双关语):

  1 >>> # Measure some strings:
  2 ... words = ['cat', 'window', 'defenestrate']
  3 >>> for w in words:
  4 ...     print(w, len(w))
  5 ...
  6 cat 3
  7 window 6
  8 defenestrate 12

在遍历同一个集合时修改该集合的代码可能很难获得正确的结果。通常，更直接的做法是循环遍历该集合的副本或创建新集合：

  1 # Strategy:  Iterate over a copy
  2 for user, status in users.copy().items():
  3     if status == 'inactive':
  4         del users[user]
  5 
  6 # Strategy:  Create a new collection
  7 active_users = {}
  8 for user, status in users.items():
  9     if status == 'active':
 10         active_users[user] = status

range()函数

类型表示不可变的数字序列，通常用于在 for循环中循环指定的次数。

class range(stop) class range(start, stop[, step])

range 构造器的参数必须为整数(可以是内置的 int或任何实现了 __index__ 特殊方法的对象)。 如果省略 step 参数，其默认值为 1。 如果省略 start 参数，其默认值为 0，如果 step 为零则会引发 valueerror。

如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。

如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i，但限制条件改为 i >= 0 且 r[i]> stop.

如果 r[0] 不符合值的限制条件，则该 range 对象为空。 range 对象确实支持负索引，但是会将其解读为从正索引所确定的序列的末尾开始索引。

一些 range 对象的例子:

  1 >>> list(range(10))
  2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  3 >>> list(range(1, 11))
  4 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  5 >>> list(range(0, 30, 5))
  6 [0, 5, 10, 15, 20, 25]
  7 >>> list(range(0, 10, 3))
  8 [0, 3, 6, 9]
  9 >>> list(range(0, -10, -1))
 10 [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
 11 >>> list(range(0))
 12 []
 13 >>> list(range(1, 0))
 14 []

range 对象实现了 一般 序列的所有操作，但拼接和重复除外(这是由于 range 对象只能表示符合严格模式的序列，而重复和拼接通常都会违反这样的模式)。

start

start 形参的值 (如果该形参未提供则为 0)

stop

stop 形参的值

step

step 形参的值 (如果该形参未提供则为 1)

range类型相比常规list或 tuple 的优势在于一个range对象总是占用固定数量的(较小)内存，不论其所表示的范围有多大(因为它只保存了 start, stop 和 step 值，并会根据需要计算具体单项或子范围的值)。

break 和 continue 语句，以及循环中的 else 子句

break语句，和 C 中的类似，用于跳出最近的 for或 while循环.

  1 >>> for n in range(2, 10):
  2 ...     for x in range(2, n):
  3 ...         if n % x == 0:
  4 ...             print(n, 'equals', x, '*', n//x)
  5 ...             break
  6 ...     else:
  7 ...         # loop fell through without finding a factor
  8 ...         print(n, 'is a prime number')
  9 ...
 10 2 is a prime number
 11 3 is a prime number
 12 4 equals 2 * 2
 13 5 is a prime number
 14 6 equals 2 * 3
 15 7 is a prime number
 16 8 equals 2 * 4
 17 9 equals 3 * 3

continue 语句也是借鉴自 C 语言，表示继续循环中的下一次迭代:

  1 >>> for num in range(2, 10):
  2 ...     if num % 2 == 0:
  3 ...         print("Found an even number", num)
  4 ...         continue
  5 ...     print("Found a number", num)
  6 Found an even number 2
  7 Found a number 3
  8 Found an even number 4
  9 Found a number 5
 10 Found an even number 6
 11 Found a number 7
 12 Found an even number 8
 13 Found a number 9

pass 语句

pass 语句什么也不做。当语法上需要一个语句，但程序需要什么动作也不做时，可以使用它。例如:

  1 >>> while True:
  2 ...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
  3 ...

这通常用于创建最小的类:

  1 >>> class MyEmptyClass:
  2 ...     pass
  3 ...

pass 的另一个可以使用的场合是在你编写新的代码时作为一个函数或条件子句体的占位符，允许你保持在更抽象的层次上进行思考。 pass 会被静默地忽略:

  1 >>> def initlog(*args):
  2 ...     pass   # Remember to implement this!
  3 ...

归类 : python3.8