因为中间停了一段时间没有更新,python3.6已经升级到了Python3.7,通过比较,在基础部分两者并未出现本质上的差异,故,从此以后按照python3.7的文档为准。

3. Python的非正式介绍

在以下示例中,输入和输出通过是否存在提示符来区分( >>>... ):要重复示例,必须在提示符出现后输入全部类容;没有提示符的是从解释器输出内容。请注意,示例中一行内出现的次级提示符意味着您必须输入一个空行;这用于结束多行命令。

本手册中的许多示例,即使是在交互式提示符下输入的示例,都包含注释。 Python中的注释以井号字符#开头,并延伸到物理行的末尾。 注释可能出现在行的开头或跟随空格或代码,但不在字符串文字中。 字符串文字中的哈希字符只是一个哈希字符。 由于注释是为了澄清代码而不是由Python解释,因此在输入示例时可以省略它们。

一些例子:

 # 第一个注释
spam = 1  # 第二个注释
          # ... 第二个注释
text = "# 这里不是注释,因为在位于引号之中。"

3.1 使用Python作为计算器

让我们尝试一些简单的Python命令。 启动解释器并等待主要提示, >>> 。 (不会花很长时间。)

3.1.1 数字

解释器充当一个简单的计算器:您可以在其上输入表达式,它将会计算结果。 表达式语法很简单:运算符+-*/就像大多数其他语言一样(例如,Pascal或C); 括号( () )可用于分组。 例如:

>>>  2 + 2
4
>>>  50 - 5 * 6
20
>>>  ( 50 - 5 * 6 ) / 4
5.0
>>>  8 / 5  # 所有的除法结果都是一个浮点数
1.6

整数(例如20 )具有int类型,具有小数部分(例如1.6 )的是float类型。 我们将在本教程后面看到有关数值类型的更多信息。

除( / )总是返回一个浮点数。 要进行取整即获得整数结果(丢弃任何小数结果),您可以使用//运算符; 要得到余数可以使用%

 >>>  17 / 3  # 典型的除法计算结果
5.666666666666667
>>>
>>>  17 // 3  # 取整后只得到整数部分的结果
5
>>>  17 % 3  # 取余后只得到余数
2
>>>  5 * 3 + 2  # 结果*除数+余数
17

使用Python,可以使用**运算符来计算次方[1]

 >>>  5 ** 2  # 5的平方
25
>>>  2 ** 7  # 2的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支持浮点数;具有混合类型数的运算,将会变为符将整数操作数转换为浮点数:

 >>>  4 * 3.75 - 1
14.0

在交互模式下,最后打印的表达式将分配给变量_ 。 这意味着当您使用Python作为桌面计算器时,继续计算会更容易一些,例如:

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

该变量应该被视为只读,不要为其显式赋值。

除了intfloat ,Python还支持其他类型的数字,例如DecimalFraction 。 Python还内置了对复数的支持,并使用jJ后缀来表示虚部(例如3+5j )。

3.1.2 字符串

除了数字,Python还可以操作字符串,并可以通过多种方式表达。它们可以用单引号( '...' )或双引号( "..." )括起来,结果相同[2]\可用于转义引号:

>>>  'spam eggs'  # 单引号
'spam eggs'
>>>  'doesn \' t'  # 使用 \' 防止错误识别单引号
"doesn't"
>>>  "doesn't"  # 或者使用双引号代替
"doesn't"
>>>  '"Yes," they said.'
'"Yes," they said.'
>>>  " \" Yes, \"  they said."
'"Yes," they said.'
>>>  '"Isn \' t," they said.'
'"Isn\'t," they said.'

在交互式解释器中,输出字符串用引号括起来,特殊字符用反斜杠转义。 虽然这有时可能与输入看起来不同(封闭的引号可能会改变),但这两个字符串是等价的。 如果字符串包含单引号而没有双引号,则该字符串用双引号括起来,否则用单引号括起来。 print()函数通过省略括号引号和打印转义字符和特殊字符来产生更易读的输出:

 >>>  '"Isn \' t," they said.'
'"Isn\'t," they said.'
>>>  print ( '"Isn \' t," they said.' )
"Isn't," they said.
>>>  s = 'First line. \n Second line.'  # \n 表示新一行
>>>  s  # without print(), \n 被包括在输出中
'First line.\nSecond line.'
>>>  print ( s )  # with print(), \n 产生新一行
First line.
Second line.

如果您不希望将前缀为\字符解释为特殊字符,则可以通过在第一个引号之前添加r来使用原始字符串

>>>  print ( 'C:\some \n ame' )  # \n 表示新一行
C:\some
ame
>>>  print ( r 'C:\some\name' )  # 主要r是在引号之前
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个'un',之后是'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'  # 无法连接变量和字符串文字
  File "<stdin>" , line 1
    prefix 'thon'
                ^
SyntaxError : invalid syntax
>>>  ( 'un' * 3 ) 'ium'
  File "<stdin>" , line 1
    ( 'un' * 3 ) 'ium'
                   ^
SyntaxError : invalid syntax

如果要连接变量或变量和文字,请使用+

 >>>  prefix + 'thon'
'Python'

字符串可以被索引 (下标),第一个字符具有索引0.没有单独的字符类型; 一个字符只是一个大小为1的字符串:

>>>  word = 'Python'
>>>  word [ 0 ]  # 单词的第0个字母
'P'
>>>  word [ 5 ]  # 单词的第5个字母
'n'

指数也可能是负数,从右边开始计算:

>>>  word [ - 1 ]  # 最后一个字母
'n'
>>>  word [ - 2 ]  # 倒数第二个字母
'o'
>>>  word [ - 6 ]
'P'

请注意,由于-0与0相同,因此负索引从-1开始。

除索引外,还支持切片 。 虽然索引用于获取单个字符,但切片允许您获取子字符串:

>>>  word [ 0 : 2 ]  # 从0(含)到2(不含)的字母
'Py'
>>>  word [ 2 : 5 ]  # 从2(含)到5(不含)的字母
'tho'

请注意如何始终包含开始,并始终排除结束。 这确保了s[:i] + s[i:]总是等于s

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

切片索引具有有用的默认值; 省略的第一个索引默认为零,省略的第二个索引默认为要切片的字符串的大小。

>>>  word [: 2 ]   # 从开始到第二个(不含)字母位置
'Py'
>>>  word [ 4 :]   # 从第四个(含)的字母位置到最后
'on'
>>>  word [ - 2 :]  # 从倒数第二个(含)字母位置到最后
'on'

记住切片如何工作的一种方法是将索引视为指向字符之间 ,第一个字符的左边缘编号为0.然后, n个字符的字符串的最后一个字符的右边缘具有索引n ,例如:

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

第一行数字给出了字符串中索引0 ... 6的位置; 第二行给出相应的负指数。 从ij的切片分别由标记为ij的边之间的所有字符组成。

对于非负索引,切片的长度是索引的差异,如果两者都在边界内。 例如, word[1:3]的长度为2。

尝试使用过大的索引将导致错误:

>>>  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'
Traceback (most recent call last):
  File "<stdin>" , line 1 , in <module>
TypeError : 'str' object does not support item assignment
>>>  word [ 2 :] = 'py'
Traceback (most recent call last):
  File "<stdin>" , line 1 , in <module>
TypeError : 'str' object does not support item assignment

如果您需要不同的字符串,则应创建一个新字符串:

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

内置函数len()返回字符串的长度:

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

也可以看看

字符串是序列类型的示例,并支持此类型支持的常见操作。

字符串支持大量基本转换和搜索方法。

具有嵌入式表达式的字符串文字。

有关str.format()字符串格式的信息。

当字符串是%运算符的左操作数时调用的旧格式化操作在此处更详细地描述。

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]

列表还支持串联等操作:

不可变的字符串不同,列表是可变类型,即可以更改其内容:

>>>  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系列的初始子序列,如下所示:

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

此示例介绍了几个新功能。

  • 第一行包含多个赋值 :变量ab同时获取新值0和1.在最后一行再次使用它,证明右侧的表达式在任何赋值之前都是首先计算的发生。 右侧表达式从左到右进行评估。
  • 只要条件(此处: a < 10 )保持为真, while循环就会执行。 在Python中,就像在C中一样,任何非零整数值都是真的; 零是假的。 条件也可以是字符串或列表值,实际上是任何序列; 任何长度非零的东西都是真的,空序列都是假的。 该示例中使用的测试是简单的比较。 标准比较运算符与C中的相同: < (小于), >(大于), == (等于), <= (小于或等于), >= (大于或等于)和!= (不等于)。
  • 循环缩进的 :缩进是Python对语句进行分组的方式。 在交互式提示符下,您必须为每个缩进行键入一个选项卡或空格。 在实践中,您将使用文本编辑器为Python准备更复杂的输入; 所有体面的文本编辑都有自动缩进功能。 当以交互方式输入复合语句时,必须后跟一个空行以指示完成(因为解析器在您键入最后一行时无法猜出)。 请注意,基本块中的每一行必须缩进相同的数量。
  • 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,

脚注

[1]由于**优先级高于- ,因此-3**2将被解释为-(3**2) ,因此结果为-9 。 要避免这种情况并获得9 ,您可以使用(-3)**2
[2]与其他语言不同, \n等特殊字符与单引号( '...' )和双引号( "..." )具有相同的含义。 两者之间的唯一区别是在单引号内你不需要逃避" (但你必须逃避\' ),反之亦然。

标签: python

添加新评论