算法工程师修仙之路：python3官方文档笔记（三）

本笔记来自于python手册的中文版

Python 简介

---

• Python 中的注释以 # 字符起始，直至实际的行尾。

• 注释可以从行首开始，也可以在空白或代码之后，但是不出现在字符串中。

• 文本字符串中的 # 字符仅仅表示 # 。

• 代码中的注释不会被 Python 解释，可以忽略它们。

  # 这是第一行
  spam = 1  # 这是第二行
            # ... 现在是第三行了!
  text = "# This is not a comment because it's inside quotes."
  

将 Python 当做计算器

数字

• 解释器表现得就像一个简单的计算器：可以向其录入一些表达式，它会给出返回值。

• 表达式语法很直白：运算符 +，-，* 和 / 与其它语言一样，括号 (()) 用于分组。

• 整数(例如，2， 4， 20 )的类型是int，带有小数部分的数字(例如，5.0， 1.6)的类型是float。

• 除法(/)永远返回一个浮点数。如要使用 floor 除法并且得到整数结果（丢掉任何小数部分），你可以使用 // 运算符，要计算余数你可以使用%。

  >>> 17 / 3  # 经典除法返回一个浮点数
  5.666666666666667
  >>>
  >>> 17 // 3  # 丢弃了分数部分
  5
  >>> 17 % 3  # %运算符返回除法的余数部分
  2
  

• 通过 Python，还可以使用 ** 运算符计算幂乘方：

  >>> 5 ** 2  # 5的平方
  25
  >>> 2 ** 7  # 2的7次方
  128
  

• 等号( ‘=’ )用于给变量赋值。赋值之后，在下一个提示符之前不会有任何结果显示。

• 变量在使用前必须 “定义”(赋值)，否则会出错。

• 浮点数有完整的支持，整数和浮点数的混合计算中，整数会被转换为浮点数。

• 交互模式中，最近一个表达式的值赋给变量 _。

  • 这样我们就可以把它当作一个桌面计算器，很方便的用于连续计算：

    >>> tax = 12.5 / 100
    >>> price = 100.50
    >>> price * tax
    12.5625
    >>> price + _		# _代表price*tax
    113.0625
    >>> round(_, 2)	# _代表price+price*tax
    113.06
    

  • 此变量对于用户是只读的。不要尝试给它赋值 —— 你只会创建一个独立的同名局部变量，它屏蔽了系统内置变量的魔术效果。

  • 除了 int 和 float，Python 还支持其它数字类型，例如 Decimal 和 Fraction 。

  • Python 还内建支持复数 ，使用后缀 j 或 J 表示虚数部分（例如，3+5j）。

字符串

• Python 用单引号 (’…’) 或双引号 ("…") 标识表示字符串。

• \ 可以用来转义引号。

  >>> 'spam eggs'  # 单引号
  'spam eggs'
  >>> 'doesn\'t'  # 使用\'来转义单引号
  "doesn't"
  >>> "doesn't"  # 或者使用双引号
  "doesn't"
  >>> '"Yes," he said.'
  '"Yes," he said.'
  >>> "\"Yes,\" he said."
  '"Yes," he said.'
  >>> '"Isn\'t," she said.'
  '"Isn\'t," she said.'
  

• 在交互式解释器中，输出的字符串会用引号引起来，特殊字符会用反斜杠转义。如果字符串中只有单引号而没有双引号，就用双引号引用，否则用单引号引用。

• print() 函数生成可读性更好的输出, 它会省去引号并且打印出转义后的特殊字符：

  >>> '"Isn\'t," she said.'
  '"Isn\'t," she said.'
  >>> print('"Isn\'t," she said.')
  "Isn't," she said.
  >>> s = 'First line.\nSecond line.' 	 # \n表示换行符
  >>> s  	# 没有print()，\n包含在输出中
  'First line.\nSecond line.'
  >>> print(s)  	# 使用print()，\n生成一个新行
  First line.
  Second line.
  

• 如果你前面带有 \ 的字符被当作特殊字符，你可以使用原始字符串，方法是在第一个引号前面加上一个r：

  >>> print('C:\some\name')  	# 这里\n的意思是换行!
  C:\some
  ame
  >>> print(r'C:\some\name')  	# 注意引号前的r
  C:\some\name
  

• 字符串文本能够分成多行。

  • 一种方法是使用三引号："""…""" 或者 ‘’’…’’’。

  • 行尾换行符会被自动包含到字符串中，但是可以在行尾加上 \ 来避免这个行为。

  • 可以使用反斜杠为行结尾的连续字符串，它表示下一行在逻辑上是本行的后续内容：

    print("""\
    Usage: thingy [OPTIONS]
         -h                        显示此使用消息
         -H hostname             要连接的主机名
    """)
    
    # 将生成以下输出（注意，没有开始的第一行）:
    Usage: thingy [OPTIONS]
         -h                       显示此使用消息
         -H hostname             要连接的主机名
    

• 字符串可以由 + 操作符连接(粘到一起)，可以由 * 表示重复：

  >>> # 3 times 'un', followed by 'ium'
  >>> 3 * 'un' + 'ium'
  'unununium'
  

• 相邻的两个字符串文本自动连接在一起。它只用于两个字符串文本，不能用于字符串表达式，如果你想连接多个变量或者连接一个变量和一个字符串文本，使用 + 。

  >>> 'Py' 'thon'
  'Python'
  >>> prefix = 'Py'
  >>> prefix 'thon'  	# 不能连接一个变量和一个字符串文字
  ...
  SyntaxError: invalid syntax
  >>> ('un' * 3) 'ium'
   ...
  SyntaxError: invalid syntax
  

• 字符串也可以被截取(检索)。

  • 类似于 C ，字符串的第一个字符索引为 0 。
  • Python没有单独的字符类型；一个字符就是一个简单的长度为1的字符串。
  • 索引也可以是负数，这将导致从右边开始计算。
  • 请注意 -0 实际上就是 0，所以它不会导致从右边开始计算。

• 除了索引，还支持切片。

  • 索引用于获得单个字符，切片让你获得一个子字符串。

  • 注意，包含起始的字符，不包含末尾的字符。这使得 s[:i] + s[i:] 永远等于 s。

    >>> word[0:2] 	 # 从位置0(包括)到位置2(不包括)的字符
    'Py'
    >>> word[2:5]  	# 从位置2(包括)到位置5(不包括)的字符
    'tho'
    >>> word[:2] + word[2:]
    'Python'
    >>> word[:4] + word[4:]
    'Python'
    

  • 切片的索引有非常有用的默认值，省略的第一个索引默认为零，省略的第二个索引默认为切片的字符串的大小。

    >>> word[:2]  	# 从开始到位置2的字符(不包括)
    'Py'
    >>> word[4:]  	# 从位置4(包括)到结尾的字符
    'on'
    >>> word[-2:] 	# 字符从倒数第二(包括)到最后
    'on'
    

  • 切片时的索引是在两个字符之间 。

    • 左边第一个字符的索引为 0，而长度为 n 的字符串其最后一个字符的右界索引为 n。
    • 文本中的第一行数字给出字符串中的索引点 0…6。
    • 第二行给出相应的负索引。
    • 切片是从 i 到 j 两个数值标示的边界之间的所有字符。
    • 对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。
      

• 试图使用太大的索引会导致错误，Python 能够优雅地处理那些没有意义的切片索引。

  • 一个过大的索引值(即下标值大于字符串实际长度)将被字符串实际长度所代替。

  • 当上边界比下边界大时(即切片左值大于右值)就返回空字符串。

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

• Python字符串不可以被更改 ， 它们是不可变的。

  • 赋值给字符串索引的位置会导致错误。

  • 如果你需要一个不同的字符串，你应该创建一个新的。

  • 内置函数 len() 返回字符串长度。

    >>> word[0] = 'J'
      ...
    TypeError: 'str' object does not support item assignment
    >>> word[2:] = 'py'
      ...
    TypeError: 'str' object does not support item assignment
    >>> 'J' + word[1:]
    'Jython'
    >>> word[:2] + 'py'
    'Pypy'
    >>> s = 'supercalifragilisticexpialidocious'
    >>> len(s)
    34
    

列表

• Python 有几个复合数据类型，用于表示其它的值。最通用的是 list (列表) ，它可以写作中括号之间的一列逗号分隔的值。

• 列表的元素不必是同一类型：

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

• 就像字符串(以及其它所有内建的序列类型)一样，列表可以被索引和切片。所有的切片操作都会返回一个包含请求的元素的新列表，列表支持连接操作。

  >>> squares[0]  	# 索引返回项
  1
  >>> squares[-1]
  25
  >>> squares[-3:]  	# 切片返回一个新列表
  [9, 16, 25]
  >>> squares + [36, 49, 64, 81, 100]
  [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  

• 不像不可变的字符串，列表是可变的，它允许修改元素。你还可以使用append()方法在列表的末尾添加新的元素。

  >>> cubes = [1, 8, 27, 65, 125]  
  >>> 4 ** 3 
  64
  >>> cubes[3] = 64  	# 替换错误的值
  >>> cubes
  [1, 8, 27, 64, 125]
  >>> cubes.append(216)  	# 加上6的立方
  >>> cubes.append(7 ** 3)  	# 7的立方
  >>> cubes
  [1, 8, 27, 64, 125, 216, 343]
  

• 也可以对切片赋值，此操作可以改变列表的尺寸，或清空它：

  >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  >>> letters
  ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  >>> # 替换一些值
  >>> letters[2:5] = ['C', 'D', 'E']
  >>> letters
  ['a', 'b', 'C', 'D', 'E', 'f', 'g']
  >>> # 现在删除它们
  >>> letters[2:5] = []
  >>> letters
  ['a', 'b', 'f', 'g']
  >>> # 通过将所有元素替换为空列表来清除列表
  >>> letters[:] = []
  >>> letters
  []
  

• 内置函数 len() 同样适用于列表并且允许嵌套列表(创建一个包含其它列表的列表)。

  >>> a = ['a', 'b', 'c']
  >>> n = [1, 2, 3]
  >>> x = [a, n]
  >>> x
  [['a', 'b', 'c'], [1, 2, 3]]
  >>> x[0]
  ['a', 'b', 'c']
  >>> x[0][1]
  'b'
  

编程的第一步

• 菲波那契子序列

  >>> # 菲波那契子序列
  ... # 两个元素的和定义了下一个元素
  ... a, b = 0, 1
  >>> while b < 10:
  ...     print(b)
  ...     a, b = b, a+b
  ...
  1
  1
  2
  3
  5
  8
  

  • 第一行包括了一个 多重赋值：变量 a 和 b 同时获得了新的值 0 和 1 ，最后一行又使用了一次。

  • 变量赋值前，右边首先完成计算。右边的表达式从左到右计算。

  • 条件（这里是 b < 10 ）为 true 时， while 循环执行。

  • 在 Python 中，类似于 C，任何非零整数都是 true ，0 是 false 。

  • 条件也可以是字符串或列表，实际上可以是任何序列。

  • 所有长度不为零的是 true，空序列是 false。

  • 标准比较操作符与 C 相同： < ， > ， == ， <=， >= 和 !=。

  • 循环体是缩进的，缩进是 Python 组织语句的方法。Python 不提供集成的行编辑功能，所以你要为每一个缩进行输入 TAB 或空格。

  • 大多数文本编辑器提供自动缩进。交互式录入复合语句时，必须在最后输入一个空行来标识结束（因为解释器没办法猜测你输入的哪一行是最后一行），需要 注意的是同一个语句块中的每一行必须缩进同样数量的空白。

  • 关键字 print() 语句输出给定表达式的值，它控制多个表达式和字符串输出为你想要字符串。

  • 字符串打印时不用引号包围，每两个子项之间插入空间，所以你可以把格式弄得很漂亮，用一个逗号结尾就可以禁止输出换行：

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