1 python语句介绍

python的结构层次：1) 程序由模块构成 2) 模块包含语句 3）语句包含表达式 4）表达式建立并处理对象。

python的语法实质上是由语句和表达式组成的。

 

print在python3.0中不是一个保留字，也不是一条语句，而是一个内置的函数调用，由于它几乎总是作为一条表达式语句运行，通常将其看作一条语句类型。

yield实际上是一个表达式，而不是一条语句。与print不同，作为一个表达式，yield也是一个保留字。

与其他语言相比，python增加了语法成分是冒号(:)。所有python的复合语句都有相同的一般形式，也就是首行以冒号结尾。首行下一行嵌套的代码往往按缩进的格式书写。 

python中的括号是可选的；终止行就是终止语句（没有分号）；缩进的结束就是代码块的结束（没有大括号；缩进能提高程序代码的可读性和质量）。

特殊实例：我们可以编辑单行if语句、单行循环。只有当复合语句本身不包含任何复合语句的时候，才可以这样做。

>>> x = 10; y = 5
>>> if x > y: print(x)
...
10

简单的交互式循环：input内置函数，用于通用控制台输出，它打印可选的参数字符串作为提示，并返回用户输入的回复字符串。 

>>> while True:
...     reply = input('Enter text:')
...     if reply == 'stop':break
...     print(reply.upper())
...
Enter text:66
66
Enter text:spam
SPAM
Enter text:stop

注意：while首行下面嵌套的三行的缩进是相同的，属于同一代码块。源文件的结束或是一个缩进较少的语句可以终止这个循环体块。 

 在IDLE中写入，并保存为文件。当输入无效数字时，可以事先用字符串对象的isdigit方法检查字符串的内容。

while True:reply = input('Enter text:')if reply == 'stop':breakelif not reply.isdigit():print('Bad'*4)else:print(int(reply)**2)
print('Bye')

来自用户的输入返回脚本时一定是一个字符串，所以要手动将其转换为整数。 

但在python中处理错误时，通常使用try语句。

# 在IDLE写入
while True:reply = input('Enter text:')if reply == 'stop':breaktry:num = int(reply)except:print('Bad!'*4)else:print(int(reply)**2)
print('Bye')# 示例结果
Enter text:44
1936
Enter text:tt
Bad!Bad!Bad!Bad!
Enter text:stop
Bye

2 赋值语句

其基本形式是在等号左边写赋值语句的目标，而要赋值的对象位于右侧。左边的目标可以是变量名或对象元素，而右侧的对象可以是任何会计算得到的对象的表达式。

赋值语句建立对象引用值，而不是赋值对象。python变量更像指针，而不是数据存储区域。变量名在首次赋值时会被创建。变量名在引用前必须先赋值。执行隐式赋值的一些操作，在很多情况下使用赋值语句，如模块导入、函数和类的定义、for循环变量以及函数参数。

元组和列表分解赋值：python会按照位置把右边的对象和左边的目标从左向右相配对。现已统一为序列赋值语句，任何变量名的序列都可赋值给任何值的序列。甚至可以混合和比对涉及的序列类型，如第4行，把变量名的元组和字符的字符串对应起来。

扩展的序列解包允许我们更灵活的选择要赋值的一个序列的部分。这是手动分片操作的简单替代方法。

增强赋值语句：输入较少，并且通常执行的更快。

1）序列赋值

 元组和列表赋值语句可以接受右侧可以是任何类型的序列，只要长度相等即可。序列赋值语句实际上支持右侧任何可迭代的对象，而不仅局限于任何序列。

>>> a, b, c, d = 'spam'
>>> a
's'
>>> a,b,c,d
('s', 'p', 'a', 'm')
>>> [e,f] = [a,b]       
>>> e,f
('s', 'p')>>> [a,b,c] = 'ABC'
>>> a
'A'
>>> nudge = 1
>>> wink = 2
>>> nudge,wink = wink,nudge         # 交换两变量的值
>>> nudge,wink
(2, 1)

2）扩展解包语法

在2.x中手动分片才能使序列赋值更为通用（要保持赋值目标中的项数和主体数目必须一致）。在3.x中，这个过程变得更简单。一个带星号的名称，可以在赋值目标中使用，以指定一个更为通用的匹配——一个列表赋给带星号的名称，该列表收集序列没有赋值给其他名称的所有项。一个序列解包总是返回多个匹配项的一个列表，而分片把相同类型的一个序列作为分片对象返回。

>>> seq = [1,2,3,4]
>>> a, *b = seq
>>> a
1
>>> b
[2, 3, 4]>>> a,*b = 'spam'
>>> a,b
('s', ['p', 'a', 'm'])
>>> a,*b,c = 'spam'
>>> a
's'
>>> b
['p', 'a']>>> S = 'spam'
>>> S[1:2]
'p'

和常规的序列赋值一样，扩展的序列解包语法对于任何序列类型都有效，而不只是对列表有效。 

带星号的名称可能只匹配单个的项；如果没有，它将赋值一个空的列表。如果有多个带星号的名称，或者如果值少了而没有带星号的名称，以及如果带星号的名称自身没有编写到一个列表中，这些都会引发错误。

序列解包只是一种便利形式，通常可以使用显式的索引和分片实现同样的效果

>>> seq
[1, 2, 3, 4]
>>> *a =seq                        # 带星号的名称自身没有编写到一个列表中引发错误File "<stdin>", line 1
SyntaxError: starred assignment target must be in a list or tuple
>>> *a, = seq
>>> a
[1, 2, 3, 4]>>> seq
[1, 2, 3, 4]
>>> a,b = seq[0],seq[1:]
>>> a,b
(1, [2, 3, 4])

 3）增强赋值

是二元表达式和赋值语句的组合。有三个优点：输入减少；左侧只需要计算一次；优化技术会自动选择：对于支持在原处修改的对象而言，增强形式会自动执行原处的修改运算，而不是相比来说速度更慢的复制。

>>> L = [1,2]
>>> L = L + [3]            # 添加一个元素，用合并或append
>>> L
[1, 2, 3]
>>> L.append(4)
>>> L
[1, 2, 3, 4]
>>> L = L + [5,6]        # 添加一组元素用合并或者extend
>>> L
[1, 2, 3, 4, 5, 6]
>>> L.extend([7,8])
>>> L
[1, 2, 3, 4, 5, 6, 7, 8]
>>> L += [9,10]            # 在原处修改，自动调用extend
>>> L
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 合并对共享对象引产生的副作用可能会更小，但是通常比原处形式运行的更慢。

3 变量命名规则

变量名语法：下划线或字母+任意数目的字母、数字或下划线；区分大小写；禁止使用保留字（3.0)

1)命名惯例

• 以单个下划线开头的变量名（_X）不会被from module import * 语句导入
• 前后有下划线的变量名（_X_）是系统定义的变量名，对解释器有特殊意义
• 以两下划线开头，但结尾没有两个下划线的变量名（__X）是类的本地（压缩）变量
• 通过交互模式运行时，只有单个下划线的变量名（_）会保存最后表达式的结果

类变量名通常以一个大写字母开头 ；模块变量名以小写字母开头。

4 表达式语句

 可以使用表达式作为语句（本身只占一行），因为表达式结果不会存储。通常在两种情况下表达式用作语句：

1）调用函数和方法  有些函数和方法会做很多工作，而不会有返回值。这种函数在其他语言中有时称作过程。

2）在交互模式提示符下打印值 ，会响应输入的表达式结果。这些都是表达式语句，作为输入print语句的简写方法

表达式语句通常用于执行原处修改列表的列表方法，但这些方法在列表修改后并不会把列表返回，实际上，他们返回的是None对象。

>>> x = print('spam')
spam
>>> x
>>> print(x)
None

5 打印操作

在python中，print语句可以实现打印——只是对程序员友好的标准输出流接口而已。 它把一个或多个对象转换为文本表达形式，然后发送给标准输出或另一个类似文件的流。

print默认把对象打印到stdout流，并添加一些自动的格式化。与文件方法不同，在使用打印操作的时候，不需要把对象转换为字符串。

标准输出流只是发送一个程序的文本输出默认的地方，加上标准输入流和错误流，它只是脚本启动时创建3种数据连接中的一种。标准输出流通常映射到启动python程序的窗口，除非他已经在操作系统的shell中重定向到一个文件或管道。

1）调用格式

print([object,...][,sep = '   '][,end = '\n'][,file = sys.stdout])    (方括号中的项可选， = 都给出了默认参数)

sep、end和file如果给出的话，必须作为关键字参数给定——必须使用一种特殊的“name = value”语法来根据名称而不是位置来传递参数。

sep：在每一个对象的文本之间插入一个字符串，如果没有，默认为单个空格

end：添加打印文本末尾的一个字符串，如果没有，默认是一个\n换行符

file：指定文本要发送的文件、标准流或者其他类似文件的对象。如果没有传递的话，它默认的是sys.stdout

2) python3.X的print函数的应用

>>> X = 'spam'
>>> Y = 99
>>> Z = ['eggs']
>>> print(X, Y, Z)                 # 默认情况下打印的对象之间添加一个空格
spam 99 ['eggs']
>>> print(X, Y, Z, sep = '')
spam99['eggs']
>>> print(X, Y, Z, end = '')        # 向end关键字参数传递一个空字符来避免换行
spam 99 ['eggs']>>>

>>> x = 'spam'
>>> y = 99
>>> z = ['eggs']
>>> print(x, y, z, sep='...', file = open('data.txt','w'))  # 在单个打印过程中，直接把文本打印到一个输出文件或其他的兼容对象
>>> print(open('data.txt').read())
spam...99...['eggs']

 print操作提供的分隔符和行末选项只是为了方便起见。如想显示更具体的格式，提前构建一个更复杂的字符串或者在print自身中使用字符串工具。

>>> text = '%s:%-.4f,%05d'% ('Result',3.14159, 42)
>>> print(text)
Result:3.1416,00042
>>> print('%s:%-.4f,%05d'% ('Result',3.14159, 42))
Result:3.1416,00042

3）打印流重定向

  打印默认发送到标准输出流。通常发送到其他的地方也是有用的。一般在脚本中重定向到一个脚本的流也是能做到的。

print语句只是python的人性化的特性，提供了sys.stdout对象的简单接口，再加上一些默认的格式化设置。你可以使用下面方式编写打印操作。

>>> import sys
>>> sys.stdout.write('hello world\n')
hello world
12

 print和sys.stdout的关系：

print(x,y)等价于import sys         sys.stdout.wirte(str(x) + ' ' + str(Y) + '\n')

可以将print语句将文字传送到其他地方。把sys.stdout重设为已打开的文件对象（也可是非文件对象吗，只要该对象有write方法），print会持续调用sys.stdout的write方法。 zhi-

但是由于sys.stdout只是普通的文件对象，你可以需要保存原始的输出流。在打印至文件后，可以切换回来

>>> import sys
>>> temp = sys.stdout
>>> sys.stdout = open('log.txt', 'a')
>>> print('spam')
>>> print(1,2,3)
>>> sys.stdout.close()
>>> sys.stdout = temp        # 切换回来
# sys.stdout = sys.__stdout__        
>>> print('back here')
back here
>>> print(open('log.txt').read())
spam
1 2 3

手动保存和恢复原始的输出流包含相当多的额外的工作。file关键字允许一个单个的print调用其文本发送给一个文件的write方法，而不是重设sys.stdout。这只是暂时的，其他的print语句还会继续打印到原始的输出流。

>>> log = open('log.txt', 'w')
>>> print(1, 2, 3, file = log)
>>> print(4, 5, 6, file = log)
>>> log.close()
>>> print(7, 8, 9)
7 8 9
>>> print(open('log.txt').read())
1 2 3
4 5 6>>>