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

文章目录

• ​​1. 前言​​
• ​​2. 核心概念之变量​​
• ​​3. Python的正式介绍​​

• ​​3.1 使用Python作为计算器​​

• ​​3.1.1 数值运算​​
• ​​3.1.2 字符串类型​​
• ​​3.1.3 列表​​

• ​​3.2 编程的第一步​​

1. 前言

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

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

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

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

2. 核心概念之变量

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

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

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

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

在计算机中，变量对应的值往往是能够改变的。

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 "<stdin>", 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语言只有双引号来表示字符串。

  在字符串中，可使用反斜杠\来表示转义字符，有关转义字符的概念请参考第二节：如何学习官网教程中的内容。

  在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 "<stdin>", 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中最通用复合类型的是列表。在列表中，用方括号表示起始和终止符号，不同元素之间以逗号隔开。不同元素可以是不同类型的，但通常是相同类型的。另外，逗号后面往往会跟一个空格，这个属于编程规范，编程规范的内容详见。

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

  对本系列课程感兴趣的同学可以。课程更新时间为每周至少一篇，希望能对大家学习Python有所帮助。