python语句分为复合语句_python语句与语法

一、Python语句简介

1.1 一些语句的简单介绍

>>> whileTrue: #简单的while循环

... reply= input('Enter text:') #调用了Input，将输入传参给reply

...if reply == 'stop': break#如果输入的是stop就退出循环

...print(reply.upper()) #如果输入的不是stop就一直将输入的转换为大写字母

...

Enter text:abc #这是第一个输入abc，看到下面转换成大写的ABC了

ABC

Enter text:nihao123da

NIHAO123DA

Enter text:stop #这里输入了一个stop，然后循环就退出了

>>>

#上面的代码利用了Python的while循环，它是Python最通用的循环语句。简单的说，它的组成为：while这个单词，之后跟一个其结果为真或假的表达式，再接一个当顶端测试为真（这时的True看做是永远为真）时不停的迭代的嵌套代码块。

#这个Input内置函数，在这里用于通过控制台输出，它打印可选的参数字符串作为提示，并返回用户输入的回复字符串。

#利用嵌套代码块特殊规则的单行if语句也在这里出现：if语句体出现在冒号之后的首行，而并不是在首行的下一行缩进。

#最后，Python的break语句用于立即退出循环。也就是完全跳出循环语句而程序会继续循环之后的部分。如果没有这个退出语句，while循环会因为测试总是真值而永远循环下去。

>>> whileTrue:

... reply= input('Enter text:')

...if reply == 'stop': #如果是stop就退出

... break...elif not reply.isdigit(): #如果输入的不是数字类型就打印Bad1 8次

... print('Bad!' * 8)

...else: #否则就打印输入数字的2次方

... print(int(reply) ** 2)

...#按回车下面是测试结果

Enter text:abc

Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad!

Enter text:a

Bad!Bad!Bad!Bad!Bad!Bad!Bad!Bad!

Enter text:2

4Enter text:stop>>>

#Python会执行首次测试为真所想匹的代码块，按照由上至下的顺序，如果所有测试都是假，就执行else部分。

1.2 赋值、表达式和打印

赋值语句

赋值语句有些特性要专门记住，如下所示

赋值语句建立对象引用值，Python赋值语句会把对象引用值存储在变量名或数据结构的元素内。赋值语句总是建立对象的引用值，而不是赋值对象。因此，Python变量更像是指针，而不是数据存储区域。

变量名在首次赋值时会被创建。Python会在首次将（即对象引用值）赋值给变量时创建其变量名。有些（并非全部）数据结构元素也会在赋值时创建（例如，字典中的元素，一些对象属性）。一旦赋值了，每当这个变量名出线在表达式时，就会被其所引用的值取代。

变量名在引用前必须先赋值。使用尚未进行赋值的变量名是一种错误，如果你视图这么做，Python会引发异常，而不是返回某种模糊的默认值；如果返回默认值，就很难再程序中找出输入错误的地方。

执行隐式赋值的一些操作，在Python中，赋值语句会在许多情况下使用。例如，模块导入、函数和类的定义、for循环变量以及函数参数全都是隐式赋值运算。

>>> seq = [1,2,3,4]

>>> a,b,c,*d = seq

>>> print(a,b,c,d)

1 2 3 [4]

>>> L = [1,2,3,4]>>> whileL:

... front,*L =L

...print(front,L)

...1 [2, 3, 4]2 [3, 4]3 [4]4 []

#当使用一个带星号的名称的时候，左边的目标中的项数不需要与主题序列的长度匹配。实际上，带星号的名称可以出现在目标中的任何地方

打印操作

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

文件对象方法：例如file.write(str).打印操作是类似的，但更加专注--文件写入方法是把字符串写入到任意的文件，print默认地把对象打印到stdout流，添加了一些自动的格式化。和文件方法不同，在使用打印操作的时候，不需要把对象转换为字符串。

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

1.3 if测试和语法规则

Python语法规则

Python语法有些特性是我们需要知道的：

语句是逐个运行的：python一般都会按照次序从头到尾执行文件中嵌套块中的语句，但是像if（还有循环）这种语句会使得解释器在程序内跳跃。因为Python经过一个程序的路径叫做控制流程，像if这类会对其产生影响的语句，通常叫做控制流程语句。

块和语句的边界会自动检测。Python的程序块中没有大括号或“begin/end”等分隔字符；反之，Python使用首行下的语句缩进把嵌套块内的语句组合起来。同样地，Python语句一般是不以分号终止的，一行的末尾通常就是该行所写语句的结尾。

复合语句=首行+“： ” + 缩进语句。Python中所有复合语句都遵循相同格式：首行会以冒号终止，再接一个或多个嵌套语句，而且通常都是在首行下缩进的。缩进语句叫做块(有时叫做组)。在If语句中，elif和else分句是if的一部分，也是其本身嵌套块的首行。

空白行、空格以及注释通常都会忽略。文件中空白行将忽略（但在交互模式提示符下不会）。语句和表达式中的空格几乎都忽略（除了在字符串常量内，以及用在缩进时）。注释总是忽略：它们以#字符开头（不是在字符串常量内），而且延伸至该行的末尾。

文档字符串（docstring）会忽略，但会保存并由工具显示。Python支持的另一种注释，叫做文档字符串（简称docsting）。和#注释不同的是，文档字符串会在运行时保留下来以便查看。文档字符串只是出现在程序文件和一些语句顶端的字符串中。Python会忽略这些内容，但是，在运行时会自动将其附加在对象上，而且能由 文档工具显示。

1.4 while和for循环

while循环

while语句是Python语言中最通用的迭代结构。

>>> x = 'spam'

>>> whilex:

...print(x,end='')

... x= x[1:]

...

spampamamm>>>

#注意，这里使用end= ‘’关键字参数，使所有输出都出现在同一行，之间用空格隔开；

在python中：

break : 跳出最近所在的循环（跳过整个循环语句）

continue ： 跳到最近所在循环的开头处（来到循环的首行）

pass：什么事也不做，只是空占位语句

循环else块：只有当循环正常离开时才会执行（也就是没有碰到break语句）

>>> a = b // 2

>>> while a > 1:

...if b % a ==0:

...print(b,'has factor',a)

...break... x-= 1...else:

...print(b,'is prime')

...2 is prime

#除了设置标志位在循环结束时进行测试外，也可以在找到因子时插入break。这样一来，循环else分句可以视为只有当没有找到因子时才会执行。如果你没有碰到break，该数就是质数。

#如果循环主体没有执行过，循环else分局也会执行，因为你没在其中执行break语句。在while循环中，如果首行的测试一开始就是假，就会发生这种问题。因此在上面的例子中，如果a一开始就小于或等于1（例如，如果b是2），就会执行else的内容。

for循环

for循环在Python中是一个通用的序列迭代器：可以遍历任何有序的序列对象内的元素。for语句可用于字符串、列表、元组、其他内置可迭代对象以及之后能够通过类所创建的新对象。

>>> for x in ["spam","eggs","ham"]:

...print(x)

...

spam

eggs

ham

#for循环可以遍历任何一种序列对象。例如，上面的例子依次把变量名x由左至右赋值给列表中三个元素的每一个，而print语句将会每个元素都执行一次。在print语句内（循环主体），变量名x引用的是列表中的当前元素。

>>> S = "lumberjack"

>>> T = ("and","I'm","okay")>>> for x in S: print(x,end= '')

...

lumberjack>>>

>>> for x in T: print(x,end=' ')

...and I'm okay >>>

#任何序列都适用for循环，因它是通用的工具。例如，上面for循环可用于字符串和元组。

>>> D = {'a':1,'b':2,'c':3}>>> for key inD:

...print(key,'=>',D[key])

...

c=> 3a=> 1b=> 2

>>>list(D.items())

[('c', 3), ('a', 1), ('b', 2)]>>> for (key,value) inD.items():

...print(key,'=>',value)

...

c=> 3a=> 1b=> 2

#这也是for的一种常用方法，for循环中的元组使用items方法来遍历字典中的键和值变得很方便，而不必再遍历键并手动地索引以获取值。

>>> seq1 = 'spam'

>>> seq2 = 'scam'

>>> for x inseq1:

...if x inseq2:

... res.append(x)

...>>>res

['s', 'a', 'm']

#上面的例子是for循环里面嵌套if的方式。

循环计数器：while和range

range函数是通用的工具，可用于在各种环境下。虽然range常用在for循环中来产生索引，但也可以用在任何需要整数列表的地方。在Python 3.0中，range是一个迭代器，会根据需要产生元素，因此，我们需要将其包含到一个list调用中以一次性显示其结果。

>>> list(range(5)),list(range(2,5)),list(range(0,10,2))

([0,1, 2, 3, 4], [2, 3, 4], [0, 2, 4, 6, 8])

>>> list(range(-5,5)) #range页可以是非正数

[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

>>> list(range(5,-5,-1)) #range也可以是非递增的

[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]

#一个参数时，range会产生从零算起的整数列表，但其中不包括该参数的值。如果传进两个参数，第一个将视为下边界，第三个选用参数可以提供步进值。使用时，Python会对每个连续整数加上步进值从而得到结果（步进值默认为1）。

并行遍历： zip和map

内置的zip函数可以使用for循环来并行使用多个序列。在基本运算中,zip会取得一个或多个序列为参数，然后返回元组的列表，将这些序列中的并排的元素配成对。

>>> L1 = [1,2,3,4,5]>>> L2 = [5,6,7,8,9]>>>zip(L1,L2)

>>>list(zip(L1,L2))

[(1, 5), (2, 6), (3, 7), (4, 8), (5, 9)]

>>> for (x,y) in zip(L1,L2):

... print(x,y, '---', x+y)

...

1 5 --- 6

2 6 --- 8

3 7 --- 10

4 8 --- 12

5 9 --- 14

#上面的例子定义了两个列表，可以使用zip来创建一个元组对的列表（和range一样，zip在Python3.0中也是一个可迭代对象）合并列表中的元素。这样的结果在其他环境下也有用，然后搭配for循环时，它就会支持并行迭代。

二、迭代器和解析

2.1 迭代器初探

文件迭代器

>>> f = open('D://test.txt')>>>f.readline()'the is noe\n'

>>>f.readline()'the is two\n'

>>>f.readline()'the is three'

>>>f.readline()''

>>> f = open('D://test.txt')

>>> f.__next__()

'the is noe\n'

>>> f.__next__()

'the is two\n'

>>> f.__next__()

'the is three'

>>> f.__next__()

Traceback (most recent call last):

File "", line 1, in

StopIteration

#从上面的例子可以看到每次调用readline方法，就会读取一行至到末尾，就会返回空字符串，可以通过它来检测，从而跳出循环。

#从上面的第二个例子看出可以通过__next__的方法，差不多有相同的效果，但是到达文件末尾时，__next__会引发内置的异常而不是空字符串。这个接口就是Python中所谓的迭代协议：有__next__方法的对象会前进到下一个结果，而在一系列结果的末尾时，则会引发StopIteration。在Python中，任何这类对象都认为是可迭代的。任何这类对象也能以for循环或其他迭代工具遍历，因为所有迭代工具内部工作起来都是在每次迭代中调用__next__，并且捕捉StopIteration异常来确定何时离开。

>>> for line in open('D://test.txt'):

... print(line.upper(),end='')

...

THE IS NOE

THE IS TWO

THE IS THREE>

#逐行读取文本文件的最佳方式就是根本不要去读取；其替代的办法就是让for循环在每轮自动调用next从而前进到下一行。上面的第一个例子是逐行读取文件（程序执行时打印每行的大写版本），但没有刻意从文件中读取内容。注意，这里的print使用end=''来抑制添加一个\n，因为行字符串已经有了一个（如果没有这点，我们的输出将变成两行隔开）。上面的例子是读取文本文件的最佳方式，原因有三点：这是最简单的写法，运行最快，并且从内存使用情况来说也是最好的。相同效果的原始方式，是以for循环调用文件的readlines方法，将文件内容加载到内存，做成行字符串的列表。但是如今这种readlines不是最好的使用方法了，从内存的使用情况来看，效果很差。因为它是一次把整个文件加载到内存，如果文件太大，会导致计算机内存空间不够，甚至不能够工作。

>>> f = open('D://test.txt')>>> whileTrue:

... line=f.readline()

...if not line: break...print(line.upper(),end='')

...

THE IS NOE

THE IS TWO

THE IS THREE

#当然也可以用while循环逐行读取文件，尽管这样，比起迭代器for循环的版本可能运行得更慢一些，因为迭代器在Python中是以C语言的速度运行的，而while循环版本则是通过Python虚拟机运行Python字节码的。任何时候，把Python代码换成C程序代码，速度应该会变快，当然也绝非如此，尤其是在Python 3.0中，通过技时技术，可以来衡量各种方案的相对速度。

>>> f = open('D://test.txt')>>> f.__next__()'the is noe\n'

>>>next(f)'the is two\n'

>>>next(f)'the is three'

>>>next(f)

Traceback (most recent call last):

File"", line 1, in StopIteration

>>> f = open('D://test.txt')

>>> while True:

... try: #当然我们也可以通过try捕捉错误然后让其做其他操作的方式防止错误输出

... next(f)

... except StopIteration:

... print('Is output over!')

... break

...

'the is noe\n'

'the is two\n'

'the is three'

Is output over!

#为了支持手工迭代代码，python 3.0提供了一个内置函数next,它会自动调用一个对象的__next__方法。给定一个可迭代对象X，调用next(X)等同于X.__next__()。从技术角度来说，迭代协议还有一点值得注意。当for循环开始时，会通过它传给Iter内置函数，以便从可迭代对象中获得一个迭代器，返回的对象含有需要的next方法。如果看for循环内部如何处理列表这类内置序列类型的话，就会变得一目了然了。

其他内置类型迭代器

除了文件以及像列表这样的实际的序列外，其他类型也有其适用的迭代器。

>>> D = {'a':1,'b':2,'c':3} #遍历字典键让其明确的获取其键的列表

>>> for key inD.keys():

...print(key,D[key])

...

a1b2c3

>>> I = iter(D) #在最近的Python版本中，字典有一个迭代器，在迭代环境中，会自动一次返回一个键

>>> next(I)

'a'

>>> next(I)

'b'

>>> for key in D:

... print(key,D[key])

...

a 1

b 2

c 3

#注意上面的最后一个例子，在新版的python中，不再需要keys方法来遍历字典键，for循环，将使用迭代协议在每次迭代的时候获取一个值。

2.2 Python文档资源

#注释（文件中的文档）

dir函数（对象中可用属性的列表）

文档字符串：__doc__（附加在对象上的文件中的文档）

PyDoc:help函数（对象的交互帮助）

PyDoc:HTML报表（浏览器中的模块文档）

标准手册（正式的语言和库的说明）

#注释

井字号注释是代码编写文档的最基本方式。Python会忽略#之后所有文字（只要#不是位于字符串常量中）。

dir函数

内置的dir函数是抓取对象内可用所有属性列表的简单方式。它能够调用任何有属性的对象。

>>> importsys>>>dir(sys)

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current

_frames','_debugmallocstats','_getframe','_home','_mercurial','_xoptions','api_version','argv','base_exec_prefix','base_prefix','builtin_module_names','byteorder','call_tracing','call

stats','copyright','displayhook','dllhandle','dont_write_bytecode','exc_info','excepthook','exec_prefix','executable','exit','flags','float_info','float_repr_style','get_coroutine_wra

pper','getallocatedblocks','getcheckinterval','getdefaultencoding','getfilesystemencoding','getprofile','getrecursionlimit','getrefcount','getsizeof','getswitchinterval','gettrace','get

windowsversion','hash_info','hexversion','implementation','int_info','intern','is_finalizing','last_traceback','last_type','last_value','maxsize','maxunicode','meta_path','modules','path','path_hooks','path_importer_cache','platform','prefix','ps1','ps2','set_coroutine_wrapper','setcheckinterval','setprofile','setrecursionlimit','setswitchinterval','settrace','st

derr','stdin','stdout','thread_info','version','version_info','warnoptions','winver']

#上面是查看内置sys模块有哪些可以用

>>>dir([])

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__','__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem_

_','__sizeof__','__str__','__subclasshook__','append','clear','copy','count','extend','index','insert','pop','remove','reverse','sort']

>>> dir('')

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__','__iter__','__le__','__len__','__lt__','__mod__','__mul__','__ne__','__new__','__reduce__','__reduce_ex__','__repr__','__rmod__','__rmul__','__setattr__','__sizeof__','__str__','__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isident

ifier','islower','isnumeric','isprintable','isspace','istitle','isupper','join','ljust','lower','lstrip','maketrans','partition','replace','rfind','rindex','rjust','rpartition','rsplit','rstrip','split','splitlines','startswith','strip','swapcase','title','translate','upper','zfill']

#上面是找出内置对象类型提供了哪些属性，可运行dir并传入所需要类型的常量。任何内置类型的dir结果都包含了一组属性，这些属性和该类型的实现相关，他们的开头和结尾都是双下划线，从而保证了其独特性。

文档字符串：__doc__

除了#注释外，Python也支持可自动附加在对象上的文档，而且在运行时还可保存查看。从语法上来说，这类注释是写成字符串，放在模块文件、函数以及类语句的顶端，就在任何可执行程序代码前。Python会自动封装这个字符串，也就是成为所谓的文档字符串，使其成为相应对象的__doc__属性。

>>> importsys>>> print(sys.__doc__) >>> print(sys.maxsize .__doc__) #查看内置模块内的函数、类以及方法在其__doc__属性内也有附加的说明信息。

>>> print(int.__doc__) #通过文档字符串读取内置函数的说明

>>> print(map.__doc__)

map(func, *iterables) --> map object

Make an iterator that computes the function using arguments from each of the iterables. Stops when the shortest iterable is exhausted.

#通过上面的方式查看其文档字符串，从而得到内置工具的大量信息。

PyDoc:help函数

>>> importsys>>> dir(sys) #查看sys内置的方法

>>> help(sys) #查看哪些方法可以用find函数查看完整的报表>>> help(sys.find) #查看find方法的详细使用

#注意调用Help时，不是一定要导入sys，但是要取得sys的辅助信息时，就得导入sys，help期待有个对象的引用值传入。就较大对象而言，诸如，模块和类，help显示内容会分为几段，而其中有一些会在这里显示。