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

缺乏、安全感 2023-01-16 02:57 137阅读 0赞

### 文章目录 ###

*  1. 前言
 *  2. 核心概念之变量
 *  3. Python的正式介绍
 *   *  3.1 使用Python作为计算器
     *   *  3.1.1 数值运算
         *  3.1.2 字符串类型
         *  3.1.3 列表
     *  3.2 编程的第一步

# 1. 前言 #

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

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hlcm9zdW5seQ_size_16_color_FFFFFF_t_70_20_20_pic_center][]

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

# 2. 核心概念之变量 #

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

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

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

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

# 3. Python的正式介绍 #

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

在Python解释器中，代码输入和结果输出的区别之处在于，代码输入对应的行最前面有提示符(>>>或者…)，反之则为结果输出，如下图所示：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hlcm9zdW5seQ_size_16_color_FFFFFF_t_70_pic_center][]  
  上图中，出现了行首提示符(…)，则表示需要输入多行代码，而且最后一行必须为空行，即最后一行直接按回车即可。

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

# 这是第一句注释
    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来表示虚部，如下所示：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hlcm9zdW5seQ_size_16_color_FFFFFF_t_70_pic_center 1][]

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

>>>
    >>> 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][https_blog.csdn.net_herosunly_category_10831935.html]。课程更新时间为每周至少一篇，希望能对大家学习Python有所帮助。

[Link 1]: https://blog.csdn.net/herosunly/article/details/114067137
[Jupyter Notebook]: https://blog.csdn.net/herosunly/article/details/114132752
[Link 2]: https://blog.csdn.net/herosunly/article/details/114313439
[API]: https://blog.csdn.net/herosunly/article/details/114534983
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hlcm9zdW5seQ_size_16_color_FFFFFF_t_70_20_20_pic_center]: /images/20221022/1aaddac3f6d84b86a9d8bf430af96b90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hlcm9zdW5seQ_size_16_color_FFFFFF_t_70_20_20_pic_center 1]: /images/20221022/6b9f03f7917b42fda1e2f5b665b7564c.png
[https_docs.python.org_3.6_tutorial_introduction.html]: https://docs.python.org/3.6/tutorial/introduction.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hlcm9zdW5seQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/b3d2e453dfb746aabe7f52452c44837c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hlcm9zdW5seQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221022/56b9c1245a0d4bb8b03d09b4d154c24f.png
[https_blog.csdn.net_herosunly_article_details_114961274]: https://blog.csdn.net/herosunly/article/details/114961274
[https_blog.csdn.net_herosunly_category_10831935.html]: https://blog.csdn.net/herosunly/category_10831935.html