Python入门-1

1. Python解释器

2. 调用解释器

The Python interpreter is usually installed as /usr/local/bin/python3.7 on those machines where it is available; putting /usr/local/bin in your Unix shell’s search path makes it possible to start it by typing the command:

python3.7

1. 在主提示符中输入文件结束字符（在 Unix 系统中是 Control-D，Windows 系统中是 Control-Z）就退出解释器并返回退出状态为0。如果这样不管用，你还可以写这个命令退出：quit()。
2. 有些 Python 模块也可以作为脚本使用。可以这样输入：python -m module [arg] ...，这会执行 module 的源文件，就跟你在命令行把路径写全了一样。
3. 在终端（tty）输入并执行指令时，我们说解释器是运行在 交互模式（interactive mode）。在这种模式中，它会显示 主提示符（primary prompt），提示输入下一条指令，通常用三个大于号（>>>）表示；连续输入行的时候，它会显示 次要提示符，默认是三个点（...）

3. 解释器的运行环境

默认情况下，Python 源码文件以 UTF-8 编码方式处理。

如果不使用默认编码，要声明文件所使用的编码，文件的 第一 行要写成特殊的注释。语法如下所示：

# -*- coding: encoding -*-

关于 第一行 规则的一种例外情况是，源码以UNIX “shebang”行开头。这种情况下，编码声明就要写在文件的第二行。例如：

#!/usr/bin/env python3
# -*- coding: cp1252 -*-

4. 字符串

5. 索引

6. 切片

#1
>>> print('C:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\name

#2
>>> 'Py' 'thon'
'Python' # 把很长的字符串拆开分别输入的时候尤其有用

#3 索引
>>> word[-1]  # last character
'n' # 注意 -0 和 0 是一样的，所以负数索引从 -1 开始

#4 切片
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
# 切片的索引有默认值；省略开始索引时默认为0，省略结束索引时默认为到字符串的结束
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

# 切片操作基本表达式：object[start_index:end_index:step]
# step：正负数均可，其绝对值大小决定了切取数据时的‘‘步长”，而正负号决定了“切取方向”，正表示“从左往右”取    值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以增量1取值。
# 输出为空列表（[]），说明没取到数据
# 理论上可无限切片

• 对于使用非负索引的切片，如果索引不越界，那么得到的切片长度就是起止索引之差。例如， word[1:3] 的长度为2.
• 使用过大的索引会产生一个错误，切片中的越界索引会被自动处理

>>> word[4:42]
'on'
>>> word[42:]
''

• immutable – 不可变、不可修改

  具有固定值的对象。不可变对象包括数字、字符串和元组

7. 引号

单引号与双引号：这两种引号唯一的区别是，你不需要在单引号里转义双引号" (但是你必须把单引号转义成 \') ， 反之亦然.

8. 列表

1. All slice operations return a new list containing the requested elements.

   >>> squares[:]
   [1, 4, 9, 16, 25]

2. 列表同样支持拼接操作:

   >>> squares + [36, 49, 64, 81, 100]
   [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

3. , 列表是一个mutable类型

   >>> cubes = [1, 8, 27, 65, 125]  
   >>> cubes[3] = 64  
   >>> cubes
   [1, 8, 27, 64, 125]

4. 清空

   >>> letters[:] = []
   >>> letters
   []

5. 嵌套

9. print

字符串会打印不带引号的内容, 并且在参数项之间会插入一个空格, 这样你就可以很好的把东西格式化, 像这样:

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

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

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

10. 乘方

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

11. 流程控制

12. for

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

   注：类似c中的 for(auto x : Array)

2. If you need to modify the sequence you are iterating over while inside the loop (for example to duplicate selected items), it is recommended that you first make a copy. Iterating over a sequence does not implicitly make a copy. The slice notation makes this especially convenient:

   >>> for w in words[:]:  # Loop over a slice copy of the entire list.
   ...     if len(w) > 6:
   ...         words.insert(0, w)
   ...
   >>> words
   ['defenestrate', 'cat', 'window', 'defenestrate']
   # With 'for w in words':, the example would attempt to create an infinite list, inserting 'defenestrate' over and over again.

   关于深浅拷贝可以参照这里

13. range

1. range可以以另一个数字开头，或者以指定的幅度增加（甚至是负数；有时这也被叫做 ‘步进’）

   range(5, 10)
      5, 6, 7, 8, 9
   
   range(0, 10, 3)
      0, 3, 6, 9
   
   range(-10, -100, -30)
     -10, -40, -70

2. range()+len()用enumrate()代替

3. 只打印 range，会出现奇怪的结果

   >>> print(range(10))
   range(0, 10)

14. break和else

1. Loop statements may have an else clause; it is executed when the loop terminates through exhaustion of the list (with for) or when the condition becomes false (with while), but not when the loop is terminated by a break statement. This is exemplified by the following loop, which searches for prime numbers:

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

   When used with a loop, the else clause has more in common with the else clause of a try statement than it does that of if statements: a try statement’s else clause runs when no exception occurs, and a loop’s else clause runs when no break occurs.

15. 函数定义

关键字 def 引入一个函数 定义。它必须后跟函数名称和带括号的形式参数列表。

1. 函数体的第一个语句可以（可选的）是字符串文字；这个字符串文字是函数的文档字符串或 docstring. 在你编写的代码中包含文档字符串是一种很好的做法，所以要养成习惯。

15.1. 文档字符串

第一行应该是对象目的的简要概述。为简洁起见，它不应显式声明对象的名称或类型，因为这些可通过其他方式获得（除非名称恰好是描述函数操作的动词）。这一行应以大写字母开头，以句点结尾。

如果文档字符串中有更多行，则第二行应为空白，从而在视觉上将摘要与其余描述分开。后面几行应该是一个或多个段落，描述对象的调用约定，它的副作用等。

1. 单行文档：
   1. 不要重复函数的声明语句，例如：function(a, b) -> list
   2. 指明做什么和返回什么，例如Do X and return a list.
   3. 使用三引号，方便换行
2. 多行文档：
   1. 如果模块是一个脚本，也就是单文件程序，模块的文档应该写明脚本的使用方法
   2. 模块的文档需要写明包含的类，异常，函数
   3. 如果是包，在__init__.py中，写明包里面包含的模块，子包
   4. 如果是函数或类方法，应该写明函数或方法的作用，参数，返回，副作用，异常和调用的限制等
   5. 如果是类，写明类的行为，和实例参数，构造方法写在__init__中
   6. 使用三引号，而且两个三引号都应该单独成行

def function(a, b):
    """Do X and return a list."""

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword arguments:
    real -- the real part (default 0.0)
    imag -- the imaginary part (default 0.0)
    """

15.2. 局部符号表与返回值

函数的 执行 会引入一个用于函数局部变量的新符号表。 更确切地说，函数中所有的变量赋值都将存储在局部符号表中；而变量引用会首先在局部符号表中查找，然后是外层函数的局部符号表，最后是内置名称表。 因此，全局变量和外层函数的变量不能在函数内部直接赋值（除非是在global语句中定义的全局变量，或者是在 nonlocal语句中定义的外层函数的变量），尽管它们可以被引用。

在函数被调用时，实际参数（实参）会被引入被调用函数的本地符号表中；因此，实参是通过 按值调用 传递的（其中 值 始终是对象 引用 而不是对象的值）

事实上，即使没有return语句的函数也会返回一个值，尽管它是一个相当无聊的值。这个值称为 None （它是内置名称）。一般来说解释器不会打印出单独的返回值 None ，如果你真想看到它，你可以使用print

15.3. 参数

• 位置参数
  • 调用函数时根据函数定义的参数位置来传递参数
• 关键字参数
  • 于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。
• 默认参数
• 可变参数
• 解包参数

15.4. 参数默认值

python允许设置参数默认值

1. 默认值是在 定义过程 中在函数定义处计算的

   i = 5
   
   def f(arg=i):
       print(arg)
   
   i = 6
   f()

2. 重要警告： 默认值只会执行一次。这条规则在默认值为可变对象（列表、字典以及大多数类实例）时很重要。比如，下面的函数会存储在后续调用中传递给它的参数（相当于会共享）:

   def f(a, L=[]):
       L.append(a)
       return L
   
   print(f(1))
   print(f(2))
   
   [1]
   [1, 2]
   
   # 如果不想共享的话
   def f(a, L=None):
       if L is None:
           L = []
       L.append(a)
       return L

15.5. 关键字参数

顺序不重要

当存在一个形式为 **name 的正式形参时，它会接收一个字典，其中包含除了与正式形参相对应的关键字参数以外的所有关键字参数。 这可以与一个形式为 *name，接收一个包含除了正式形参列表以外的位置参数的元组的正式形参 组合使用 (*name 必须出现在 **name 之前。)

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
    print("-" * 40)
    for kw in keywords:
        print(kw, ":", keywords[kw])

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

15.6. 任意的参数列表

一般来说， 可变参数 将在形式参数列表的末尾，因为它们收集传递给函数的所有剩余输入参数。出现在 *args 参数之后的任何形式参数都是 ‘仅关键字参数’，也就是说它们只能作为关键字参数而不能是位置参数。

>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

15.7. 解包参数列表

The reverse situation occurs when the arguments are already in a list or tuple but need to be unpacked for a function call requiring separate positional arguments. For instance, the built-in range() function expects separate start and stop arguments. If they are not available separately, write the function call with the * operator to unpack the arguments out of a list or tuple

>>> list(range(3, 6))            # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))            # call with arguments unpacked from a list
[3, 4, 5]

In the same fashion, dictionaries can deliver keyword arguments with the ** operator

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

15.8. 函数标注

以字典的形式存放在函数的 __annotations__ 属性中，并且不会影响函数的任何其他部分。 形参标注的定义方式是在形参名称后加上冒号，后面跟一个表达式，该表达式会被求值为标注的值。 返回值标注的定义方式是加上一个组合符号 ->，后面跟一个表达式，该标注位于形参列表和表示 def 语句结束的冒号之间。 下面的示例有一个位置参数，一个关键字参数以及返回值带有相应标注

>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     print("Annotations:", f.__annotations__)
...     print("Arguments:", ham, eggs)
...     return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

16. lambda

传递一个小函数作为参数

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

四个用法

由于lambda语法是固定的，其本质上只有一种用法，那就是定义一个lambda函数。在实际中，根据这个lambda函数应用场景的不同，可以将lambda函数的用法扩展为以下几种：

1. 将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。
   例如，为了把标准库time中的函数sleep的功能屏蔽(Mock)，我们可以在程序初始化时调用：time.sleep=lambda x:None。这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。例如，执行time.sleep(3)时，程序不会休眠3秒钟，而是什么都不做。
2. 将lambda函数作为其他函数的返回值，返回给调用者。
   函数的返回值也可以是函数。例如return lambda x, y: x+y返回一个加法函数。这时，lambda函数实际上是定义在某个函数内部的函数，称之为嵌套函数，或者内部函数。对应的，将包含嵌套函数的函数称之为外部函数。内部函数能够访问外部函数的局部变量，这个特性是闭包(Closure)编程的基础，在这里我们不展开。
3. 将lambda函数作为参数传递给其他函数。

部分Python内置函数接收函数作为参数。典型的此类内置函数有这些。

• • filter函数。此时lambda函数用于指定过滤列表元素的条件。例如filter(lambda x: x % 3 == 0, [1, 2, 3])指定将列表[1,2,3]中能够被3整除的元素过滤出来，其结果是[3]。
  • sorted函数。此时lambda函数用于指定对列表中所有元素进行排序的准则。例如sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]按照元素与5距离从小到大进行排序，其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]。
  • map函数。此时lambda函数用于指定对列表中每一个元素的共同操作。例如map(lambda x: x+1, [1, 2,3])将列表[1, 2, 3]中的元素分别加1，其结果[2, 3, 4]。
  • reduce函数。此时lambda函数用于指定列表中两两相邻元素的结合条件。例如reduce(lambda a, b: ‘{}, {}’.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])将列表 [1, 2, 3, 4, 5, 6, 7, 8, 9]中的元素从左往右两两以逗号分隔的字符的形式依次结合起来，其结果是’1, 2, 3, 4, 5, 6, 7, 8, 9’。

另外，部分Python库函数也接收函数作为参数，例如gevent的spawn函数。此时，lambda函数也能够作为参数传入。

17. 编码风格

1. 换行，使一行不超过79个字符。

   这有助于使用小型显示器的用户，并且可以在较大的显示器上并排放置多个代码文件。

2. 使用空行分隔函数和类，以及函数内的较大的代码块。

3. 使用文档字符串。

4. 以一致的规则为你的类和函数命名；按照惯例应使用 UpperCamelCase 来命名类，而以 lowercase_with_underscores 来命名函数和方法。 始终应使用 self 来命名第一个方法参数

5. 如果你的代码旨在用于国际环境，请不要使用花哨的编码。Python 默认的 UTF-8 或者纯 ASCII 在任何情况下都能有最好的表现。

6. 同样，哪怕只有很小的可能，遇到说不同语言的人阅读或维护代码，也不要在标识符中使用非ASCII字符。

18. 数据结构

19. 列表

• list.append(x)

  • 在列表的末尾添加一个元素。相当于 a[len(a):] = [x] 。

• list.extend(iterable)

  • 使用可迭代对象中的所有元素来扩展列表。相当于 a[len(a):] = iterable 。

• list.remove(x)

  移除列表中第一个值为 x 的元素。如果没有这样的元素，则抛出 ValueError 异常。

• list.pop([i])

  删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop() 将会删除并返回列表中的最后一个元素。（ 方法签名中 i 两边的方括号表示这个参数是可选的，而不是要你输入方括号。你会在 Python 参考库中经常看到这种表示方法)。

• list.clear()

  删除列表中所有的元素。相当于 del a[:] 。

• list.index(x[, start[, end]])

  返回列表中第一个值为 x 的元素的从零开始的索引。如果没有这样的元素将会抛出ValueError异常。

  可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。

• list.count(x)

  返回元素 x 在列表中出现的次数。

• list.insert(i,x)

• list.sort(key=None, reverse=False)

• list.copy()

像 insert ，remove 或者 sort 方法，只修改列表，没有打印出返回值——它们返回默认值 None 。

• 实现堆栈：append() + pop()

• 列表作为队列使用：列表也可以用作队列，其中先添加的元素被最先取出 (“先进先出”)；然而列表用作这个目的相当低效。因为在列表的末尾添加和弹出元素非常快，但是在列表的开头插入或弹出元素却很慢 (因为所有的其他元素都必须移动一位)。 （所以应该用collections。deque）

• 列表推导式

  >>> squares = []
  >>> for x in range(10):
  ...     squares.append(x**2)
  
  # 注意这里创建（或被重写）的名为 x 的变量在for循环后仍然存在。我们可以计算平方列表的值而不会产生任何副作用
  # 1
  squares = list(map(lambda x: x**2, range(10)))
  # 2
  squares = [x**2 for x in range(10)]

  列表推导式的结构是由一对方括号所包含的以下内容：一个表达式，后面跟一个 for 子句，然后是零个或多个 for 或 if 子句。 其结果将是一个新列表，由对表达式依据后面的 for 和 if 子句的内容进行求值计算而得出。

  >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
  [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
  
  # 等价于
  
  >>> combs = []
  >>> for x in [1,2,3]:
  ...     for y in [3,1,4]:
  ...         if x != y:
  ...             combs.append((x, y))
  ...
  >>> combs
  [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

在隐式嵌套作用域内禁止使用 yield 和 yield from 表达式

• 嵌套的列表推导式

  # 矩阵翻转
  >>> matrix = [
  ...     [1, 2, 3, 4],
  ...     [5, 6, 7, 8],
  ...     [9, 10, 11, 12],
  ... ]
  >>> [[row[i] for row in matrix] for i in range(4)]
  [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
  
  >>> list(zip(*matrix))
  [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

列表和字符串有很多共同特性，例如索引和切片操作。他们是 序列 数据类型

20. del

有一种方式可以从列表按照给定的索引而不是值来移除一个元素: 那就是del语句。 它不同于会返回一个值的 pop() 方法。 del 语句也可以用来从列表中移除切片或者清空整个列表。

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

21. 元组

如你所见，元组在输出时总是被圆括号包围的，以便正确表示嵌套元组。输入时圆括号可有可无，不过经常会是必须的（如果这个元组是一个更大的表达式的一部分）

一个特殊的问题是构造包含0个或1个元素的元组：为了适应这种情况，语法有一些额外的改变。空元组可以直接被一对空圆括号创建，含有一个元素的元组可以通过在这个元素后添加一个逗号来构建（圆括号里只有一个值的话不够明确）。丑陋，但是有效。

语句 t = 12345, 54321, 'hello!' 是 元组打包 的一个例子：值 12345, 54321 和 'hello!' 被打包进元组。其逆操作也是允许的：x, y, z = t 。这被称为 序列解包 也是很恰当的，因为解包操作的等号右侧可以是任何序列。序列解包要求等号左侧的变量数与右侧序列里所含的元素数相同。

22. 集合

花括号或 set 函数可以用来创建集合。注意：要创建一个空集合你只能用 set() 而不能用 {}，因为后者是创建一个空字典

集合也支持推导式形式

23. 字典

如果一个元组只包含字符串、数字或元组，那么这个元组也可以用作关键字。但如果元组直接或间接地包含了可变对象，那么它就不能用作关键字。

对一个字典执行 list(d) 将返回包含该字典中所有键的列表，按插入次序排列 (如需其他排序，则要使用 sorted(d))。要检查字典中是否存在一个特定键，可使用 in 关键字。

#1
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
#2
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

当关键字是简单字符串时，有时直接通过关键字参数来指定键值对更方便

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}

24. 循环的技巧

1. item():

   >>> for k, v in knights.items():
   ...     print(k, v)

2. enumrate():

   >>> for i, v in enumerate(['tic', 'tac', 'toe']):
   ...     print(i, v)
   ...
   0 tic
   1 tac
   2 toe

3. 当同时在两个或更多序列中循环时，可以用·zip()函数将其内元素一一匹配。

   >>> questions = ['name', 'quest', 'favorite color']
   >>> answers = ['lancelot', 'the holy grail', 'blue']
   >>> for q, a in zip(questions, answers):
   ...     print('What is your {0}?  It is {1}.'.format(q, a))
   ...
   What is your name?  It is lancelot.
   What is your quest?  It is the holy grail.
   What is your favorite color?  It is blue.

25. 条件控制

1. 操作符 is 和 is not 比较两个对象是不是同一个对象，这只跟像列表这样的可变对象有关。

2. 比较操作可以传递。例如 a < b == c 会校验是否 a 小于 b 并且 b 等于 c。

3. 比较操作可以通过布尔运算符 and 和 or 来组合，并且比较操作（或其他任何布尔运算）的结果都可以用 not 来取反。这些操作符的优先级低于比较操作符；在它们之中，not 优先级最高， or 优先级最低，因此 A and not B or C 等价于 (A and (not B)) or C。和之前一样，你也可以在这种式子里使用圆括号。

   布尔运算符 and 和 or 也被称为 短路 运算符：它们的参数从左至右解析，一旦可以确定结果解析就会停止。例如，如果 A 和 C 为真而 B 为假，那么 A and B and C 不会解析 C。当作用于普通值而非布尔值时，短路操作符的返回值通常是最后一个变量。

   >>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
   >>> non_null = string1 or string2 or string3
   >>> non_null
   'Trondheim'

   注意 Python 与 C 不同，赋值操作不能发生在表达式内部。

26. 序列和其它类型的比较

1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

注意对不同类型对象来说，只要待比较对象提供了合适的比较方法，就可以使用 < 和 > 来比较。例如，混合数值类型是通过他们的数值进行比较的，所以 0 等于 0.0，等等。