新手学Python之学习官网教程(三: An Informal Introduction to Python)

1. 前言

  系列课程第一节：如何掌握编程的基本概念讲解了为什么要学习基本概念以及如何学习。这节课是倾心打造的原创内容，对初学者学会自学很有帮助。

  除此之外，还详细介绍了Jupyter Notebook的使用、如何掌握编程规范、如何查阅API文档。之所以要花很多篇幅讲解上述内容，主要是想给大家传授学习编程的通用方法，不仅可以用在Pytho学习上，也可以用来学习其他编程语言中。

  课程的主要内容是通过讲解学习编程最权威的资料(第一手资料)，也就是官方文档。为了帮助大家更好的进行理解，会在课程中遇到的基本概念进行重点讲解。这节课是正式学习Python语法的第一节。正餐即将开始，敬请期待：

  之前课程已经讲过了Jupyter Notebook的使用方法。按理来说，直接使用Jupyter Notebook学习基础语法更方便快捷，但是考虑再三，为了让大家学的更加扎实，更推荐先使用Python解释器的交互模式进行练习。有余力的同学，建议在Jupyter Notebook中再练习一遍。

2. 核心概念之变量

  在正餐开始之前呢，我们先讲一个核心概念变量，首先变量在不同领域内是含义是不同的。

• 在数学中，变量是指数学表达式中的代表数量的符号，例如咱们常用的x、y、z。
• 在研究中，变量是指一系列的属性。
• 在计算机科学(Computer Science，简称CS)，变量是指存储在计算机中的数值相应的符号，通过表达式往往能够改变该值。

  可以看出，在数学中和在计算机科学中，变量都是用来表示数值的。那区别是在哪里呢？区别主要体现在以下两点：

1. 在计算机中，变量指的是存储在计算机中的数值。所以它只能存储一定范围的值。而且由于计算机的本质使用的是二进制，所以要对原始数值进行编码，最终存储到计算机中。
2. 在计算机中，变量对应的值往往是能够改变的。

3. Python的正式介绍

  本节课对应的官网链接为https://docs.python.org/3.6/tutorial/introduction.html，由于主要使用的是Python解释器的交互模式，所以再复习一下Python解释器的主要内容。

  在Python解释器中，代码输入和结果输出的区别之处在于，代码输入对应的行最前面有提示符(>>>或者…)，反之则为结果输出，如下图所示：

  上图中，出现了行首提示符(…)，则表示需要输入多行代码，而且最后一行必须为空行，即最后一行直接按回车即可。

  除此之外，在手册或者代码中，往往会看到另外一个符号的身影，也就是#。#表示注释的开头。那什么是注释呢？简单来说，注释就是对代码的说明，打个比方来说，注释相当于书评，并不会影响正文内容，也不会影响代码的实际运行。举个栗子：

# 这是第一句注释
spam = 1  # 第二句注释
          # ...第三句注释
text = "# This is not a comment because it's inside quotes."

  需要注意的是text = “# This is not a comment because it’s inside quotes.”，由于#是包含在双引号之内的，它是text字符串的一部分，所以就不是注释了。

3.1 使用Python作为计算器

3.1.1 数值运算

  Python解释器最简单的用法就是把它当成计算器进行使用，可以轻松的进行各种四则运算，如下所示：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating point number
1.6

  需要注意的是，数值类型包括两大类，一个是整型(整数类型)，一个是浮点型(小数类型)。在计算机中，3和3.0虽然值是相等的，但是它们在计算机中对应的二进制却并不相同。有同学可能在想，是不是在3对应的二进制的基础上将.对应的二进制进行拼接就能得到3.0对应的二进制呢？这个题作为一个思考题，请大家自行进行思考。

  除了除法运算/以外，还有除法后取整//、除法取余操作，分别如下所示：

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # result * divisor + remainder
17

  如果整型和浮点型数据之间进行四则运算的话，会自动将整型转换成浮点型进行运算：

>>> 4 * 3.75 - 1
14.0

  想把浮点型变量转换成整型也很容易，使用int函数即可，反之使用float函数即可

>>>price = 15.0
>>>int(price)
15
>>>price = 15
>>>float(price)
15.0

  在Python中，幂运算用**进行表示，如下所示：

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

  等号是用来对变量进行赋值的。 需要注意的是，赋值运算并不会产生任何输出，如下所示：

>>>
>>> width = 20
>>> height = 5 * 9
>>> width * height
900

  如果变量没有被定义(没有进行赋值操作)，使用未赋值的变量就会报错：

>>>
>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "", line 1, in <module>
NameError: name 'n' is not defined

  在Python解释器交互模式中，最后一个表达式的值会赋值给变量_，有时就会用起来很便利，如下所示：

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

  但需要注意的是，在进行变量命名时，请勿使用内置变量或者内置函数的名称，例如上述的_和int、float等。

  在数值类型中，除了int和float类型以外，还有Decimal和Fraction类型可以用来处理分数运算。另外，Python还支持复数运算，可使用j来表示虚部，如下所示：

3.1.2 字符串类型

  Python字符串的三种表示方法如下所示：

# 不同个数的引号在表示字符串时没有区别。但字符串开头结尾必须使用同一种引号。否则报错
url = 'http://www.python.org'  # 单引号
url = "http://www.python.org"  # 双引号
url_new = '''http://www.python.org'''  # 三引号
print(url)

  思考题：为什么Python设计了三种表达字符串的方法？而其他语言往往只有一种，如C语言只有双引号来表示字符串。

  在字符串中，可使用反斜杠\来表示转义字符，有关转义字符的概念请参考链接：https://blog.csdn.net/herosunly/article/details/114961274中第二节：如何学习官网教程中的内容。

  在Python中，可使用print函数来打印字符串变量的值，但输出时会忽略字符串中最开始和最末尾的引号，以及转义字符和其他特殊字符。

'"Isn\'t," they said.'
>>> print('"Isn\'t," they said.')
"Isn't," they said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a new line
First line.
Second line.

  如果不想让反斜杠\来表示转义字符，可以在字符串最起始的位置(起始引号)之前加上r，如下所示：

>>>
>>> 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

  三引号除了在字符串内能同时使用单引号和双引号以外，它的另一个主要作用是用来表示多行字符串。可在第一行的三引号后紧跟一个反斜杠(大家可以试试不加的效果，看看有什么差异)，代码如下所示：

print('''\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
''')

  显示结果如下所示：

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

  字符串之间可使用+来进行拼接，也可以使用*表示相同字符串重复拼接在一起，如下所示：

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

  相邻的两个字符串常量会自动进行拼接：

>>>
>>> 'Py' 'thon'
'Python'

  过长的字符串可以通过上述分段表示：

>>>
>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

  但只能用在两个字符串常量，而不能使用在变量和常量之间：

>>>
>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

  连接字符串变量和常量之间，请使用+：

>>>
>>> prefix + 'thon'
'Python'

  除了拼接以外，字符串可以进行索引访问，例如通过索引0来访问字符串中最起始的字符。需要注意的是，在Python中并没有单独的字符类型（C语言有）

>>>
>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

  索引也可以是负值，负号后面的值表示从最右端开始计算的索引，需要注意的是最右边的字符索引为-1(思考一下，为什么是从-1开始呢)：

>>>
>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

  除了索引操作以外，字符串也支持切片操作。切片是索引的升级操作，索引是取出单个字符，而切片是取出字符串的子串：

>>>
>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

  需要注意的是，切片取的是位于左闭右开区间的子串。所以，s[:i] + s[i:] 和s是等价的。

>>>
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

  为了简单起见，如果在使用切片时省略起始参数，则表示起始位置为0：

>>>
>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'on'

  为了帮助初学者理解，特意将一个特定字符串每个位置对应的索引标出，请先用笔自己写一下每个位置的正负索引，然后进行对照学习：

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

  思考题：如果给出了字符串切片的起始参数和终止参数，是否能计算出字符串的长度呢？

  但是索引超出了字符串的范围，就会报错：

>>>
>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "", line 1, in <module>
IndexError: string index out of range

  但是切片操作就会规避以上的错误，如下所示：

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

  Python字符串是不能改变的，即无法通过索引或者切片的方式修改字符串的值，否则会报错。

>>>
>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'

  如果需要一个新的字符串，请重新创建字符串:

>>>
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

  那么就有同学对下列表达式有疑问，这是属于改变字符串的值吗？

>>> a = '123'
>>> a = '456'

  其实不是的，它本质是创建了一个新的字符串然后再传给a，那不是把字符串123修改成了字符串456。如果大家有兴趣，可以了解一下值传递和址传递。

  内置函数len()将会返回字符串的长度：

>>>
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

3.1.3 列表

  上述的数据类型为基本类型，那能否把相同类型或者不同的类型组合在一起，构成复合类型呢？

  在Python中最通用复合类型的是列表。在列表中，用方括号表示起始和终止符号，不同元素之间以逗号隔开。不同元素可以是不同类型的，但通常是相同类型的。另外，逗号后面往往会跟一个空格，这个属于编程规范，编程规范的内容详见链接：https://blog.csdn.net/herosunly/article/details/114313439。

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

  字符串和列表都属于序列类型，所以也支持索引和切片操作：

>>>
>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

  切片和索引操作后会返回一个新的列表，这是对原有列表进行浅拷贝：

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

  列表也支持拼接操作：

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

  与字符串类型不同的是，字符串是不可变的，而列表是可变的。

>>>
>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

  也可以使用append方法在列表最后拼接新的元素：

>>>
>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 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']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

  同样可以使用内置函数len()来求得列表的长度：

>>>
>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

  列表也支持嵌套操作，即列表中的元素也可以为列表：

>>>
>>> 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'

3.2 编程的第一步

  除了完成四则运算等简单任务以外，可以用Python来完成更加复杂的任务，例如得到斐波那契数列。

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

  a, b = 0, 1，在这行代码中使用了多个变量的赋值，从而同时把0赋值给a、把1赋值给b。最后一行代码a, b = b, a+b也是相同的。

  Python比较运算和C语言是类似的: < (小于), > (大于), == (等于), <= (小于等于), >= (大于等于) and != (不等于)。

  循环包括循环条件和循环体。while循环是在条件为真(b < 10)时多次执行，直至条件为假时退出。在Python中(与C类似)，非零为真，零为假。这里的零，不仅指的是数值0，而且如果当序列长度为0时，也为零。

  而循环体需要添加缩进符号。在交互式模式中，缩进可通过一个TAB或者若干个空格进行表示。需要注意的是，缩进符号一旦指定之后，后续必须使用相同的缩进符号。但最好使用四个空格来表示缩进。可在代码编辑器中进行设置，将TAB自动转换成四个空格。

  print()函数可以将字符串和变量的值放到一起进行打印，如下所示：

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

  在print()函数中可重新指定参数end，从而替换默认的换行符：

>>>
>>> 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,

  对本系列课程感兴趣的同学可以点击链接：https://blog.csdn.net/herosunly/category_10831935.html。课程更新时间为每周至少一篇，希望能对大家学习Python有所帮助。