python的简单问题？

要把代码发现来才知道，以下是常见的错误下面终于要讲到当你用到更多的Python的功能（数据类型，函数，模块，类等等）时可能碰到的问题了。由于篇幅有限，这里尽量精简，尤其是对一些高级的概念。要想了解更多的细节，敬请阅读Learning Python, 2nd Edition的逗小贴士地以及逗Gotchas地章节。 打开文件的调用不使用模块搜索路径当你在Python中调用open()来访问一个外部的文件时，Python不会使用模块搜索路径来定位这个目标文件。它会使用你提供的绝对路径，或者假定这个文件是在当前工作目录中。模块搜索路径仅仅为模块加载服务的。不同的类型对应的方法也不同列表的方法是不能用在字符串上的，反之亦然。通常情况下，方法的调用是和数据类型有关的，但是内部函数通常在很多类型上都可以使用。举个例子来说，列表的reverse方法仅仅对列表有用，但是len函数对任何具有长度的对象都适用不能直接改变不可变数据类型记住你没法直接的改变一个不可变的对象（例如，元组，字符串）： T = (1, 2, 3) T[2] = 4 # 错误 用切片，联接等构建一个新的对象，并根据需求将原来变量的值赋给它。因为Python会自动回收没有用的内存，因此这没有看起来那么浪费： T = T[:2] + (4,) # 没问题了: T 变成了 (1, 2, 4) 使用简单的for循环而不是while或者range 当你要从左到右遍历一个有序的对象的所有元素时，用简单的for循环（例如，for x in seq:）相比于基于while-或者range-的计数循环而言会更容易写，通常运行起来也更快。除非你一定需要，尽量避免在一个for循环里使用range：让Python来替你解决标号的问题。在下面的例子中三个循环结构都没有问题，但是第一个通常来说更好；在Python里，简单至上。 S = "lumberjack" for c in S: print c # 最简单 for i in range(len(S)): print S[i] # 太多了 i = 0 # 太多了 while i len(S): print S[i]; i += 1 不要试图从那些会改变对象的函数得到结果诸如像方法list.append()和list.sort()一类的直接改变操作会改变一个对象，但不会将它们改变的对象返回出来（它们会返回None）；正确的做法是直接调用它们而不要将结果赋值。经常会看见初学者会写诸如此类的代码： mylist = mylist.append(X) 目的是要得到append的结果，但是事实上这样做会将None赋值给mylist，而不是改变后的列表。更加特别的一个例子是想通过用排序后的键值来遍历一个字典里的各个元素，请看下面的例子： D = {...} for k in D.keys().sort(): print D[k] 差一点儿就成功了——keys方法会创建一个keys的列表，然后用sort方法来将这个列表排序——但是因为sort方法会返回None，这个循环会失败，因为它实际上是要遍历None（这可不是一个序列）。要改正这段代码，将方法的调用分离出来，放在不同的语句中，如下： Ks = D.keys() Ks.sort() for k in Ks: print D[k] 只有在数字类型中才存在类型转换在Python中，一个诸如123+3.145的表达式是可以工作的——它会自动将整数型转换为浮点型，然后用浮点运算。但是下面的代码就会出错了： S = "42" I = 1 X = S + I # 类型错误 这同样也是有意而为的，因为这是不明确的：究竟是将字符串转换为数字（进行相加）呢，还是将数字转换为字符串（进行联接）呢看在Python中，我们认为逗明确比含糊好地（即，EIBTI（Explicit is better than implicit）），因此你得手动转换类型： X = int(S) + I # 做加法: 43 X = S + str(I) # 字符串联接: "421" 循环的数据结构会导致循环尽管这在实际情况中很少见，但是如果一个对象的集合包含了到它自己的引用，这被称为循环对象（cyclic object）。如果在一个对象中发现一个循环，Python会输出一个[…]，以避免在无限循环中卡住： L = ['grail'] # 在 L中又引用L自身会 L.append(L) # 在对象中创造一个循环 L ['grail', [...]] 除了知道这三个点在对象中表示循环以外，这个例子也是很值得借鉴的。因为你可能无意间在你的代码中出现这样的循环的结构而导致你的代码出错。如果有必要的话，维护一个列表或者字典来表示已经访问过的对象，然后通过检查它来确认你是否碰到了循环。赋值语句不会创建对象的副本，仅仅创建引用这是Python的一个核心理念，有时候当行为不对时会带来错误。在下面的例子中，一个列表对象被赋给了名为L的变量，然后L又在列表M中被引用。内部改变L的话，同时也会改变M所引用的对象，因为它们俩都指向同一个对象。 L = [1, 2, 3] # 共用的列表对象 M = ['X', L, 'Y'] # 嵌入一个到L的引用 M ['X', [1, 2, 3], 'Y'] L[1] = 0 # 也改变了M M ['X', [1, 0, 3], 'Y'] 通常情况下只有在稍大一点的程序里这就显得很重要了，而且这些共用的引用通常确实是你需要的。如果不是的话，你可以明确的给他们创建一个副本来避免共用的引用；对于列表来说，你可以通过使用一个空列表的切片来创建一个顶层的副本： L = [1, 2, 3] M = ['X', L[:], 'Y'] # 嵌入一个L的副本 L[1] = 0 # 仅仅改变了L，但是不影响M L [1, 0, 3] M ['X', [1, 2, 3], 'Y'] 切片的范围起始从默认的0到被切片的序列的最大长度。如果两者都省略掉了，那么切片会抽取该序列中的所有元素，并创造一个顶层的副本（一个新的，不被公用的对象）。对于字典来说，使用字典的dict.copy()方法。静态识别本地域的变量名 Python默认将一个函数中赋值的变量名视作是本地域的，它们存在于该函数的作用域中并且仅仅在函数运行的时候才存在。从技术上讲，Python是在编译def代码时，去静态的识别本地变量，而不是在运行时碰到赋值的时候才识别到的。如果不理解这点的话，会引起人们的误解。比如，看看下面的例子，当你在一个引用之后给一个变量赋值会怎么样： X = 99 def func(): ... print X # 这个时候还不存在 ... X = 88 # 在整个def中将X视作本地变量 ... func( ) # 出错了！ 你会得到一个逗未定义变量名地的错误，但是其原因是很微妙的。当编译这则代码时，Python碰到给X赋值的语句时认为在这个函数中的任何地方X会被视作一个本地变量名。但是之后当真正运行这个函数时，执行print语句的时候，赋值语句还没有发生，这样Python便会报告一个逗未定义变量名地的错误。事实上，之前的这个例子想要做的事情是很模糊的：你是想要先输出那个全局的X，然后创建一个本地的X呢，还是说这是个程序的错误看如果你真的是想要输出这个全局的X，你需要将它在一个全局语句中声明它，或者通过包络模块的名字来引用它。默认参数和可变对象在执行def语句时，默认参数的值只被解析并保存一次，而不是每次在调用函数的时候。这通常是你想要的那样，但是因为默认值需要在每次调用时都保持同样对象，你在试图改变可变的默认值（mutable defaults）的时候可要小心了。例如，下面的函数中使用一个空的列表作为默认值，然后在之后每一次函数调用的时候改变它的值： def saver(x=[]): # 保存一个列表对象 ... x.append(1) # 并每次调用的时候 ... print x # 改变它的值 ... saver([2]) # 未使用默认值 [2, 1] saver() # 使用默认值 [1] saver() # 每次调用都会增加！ [1, 1] saver() [1, 1, 1] 有的人将这个视作Python的一个特点——因为可变的默认参数在每次函数调用时保持了它们的状态，它们能提供像C语言中静态本地函数变量的类似的一些功能。但是，当你第一次碰到它时会觉得这很奇怪，并且在Python中有更加简单的办法来在不同的调用之间保存状态（比如说类）。要摆脱这样的行为，在函数开始的地方用切片或者方法来创建默认参数的副本，或者将默认值的表达式移到函数里面；只要每次函数调用时这些值在函数里，就会每次都得到一个新的对象： def saver(x=None): ... if x is None: x = [] # 没有传入参数看 ... x.append(1) # 改变新的列表 ... print x ... saver([2]) # 没有使用默认值 [2, 1] saver() # 这次不会变了 [1] saver() [1] 其他常见的编程陷阱下面列举了其他的一些在这里没法详述的陷阱：在顶层文件中语句的顺序是有讲究的：因为运行或者加载一个文件会从上到下运行它的语句，所以请确保将你未嵌套的函数调用或者类的调用放在函数或者类的定义之后。 reload不影响用from加载的名字：reload最好和import语句一起使用。如果你使用from语句，记得在reload之后重新运行一遍from，否则你仍然使用之前老的名字。在多重继承中混合的顺序是有讲究的：这是因为对superclass的搜索是从左到右的，在类定义的头部，在多重superclass中如果出现重复的名字，则以最左边的类名为准。在try语句中空的except子句可能会比你预想的捕捉到更多的错误。在try语句中空的except子句表示捕捉所有的错误，即便是真正的程序错误，和sys.exit()调用，也会被捕捉到。

创新互联IDC提供业务:成都IDC机房托管,成都服务器租用,成都IDC机房托管,重庆服务器租用等四川省内主机托管与主机租用业务;数据中心含:双线机房,BGP机房,电信机房,移动机房,联通机房。

Python其实很简单 第十五章 文件操作

在各种变量中保存的数据都是临时的，随着程序运行结束都会丢失。要做到数据长期有效，必须建立在磁盘中建立文件，将数据输入到文件中并保存。需要获取数据时需要打开文件读取。

而我们自己建立的程序都是应用程序，从本质上讲，应用程序是无法直接操作计算机的硬件的，譬如读写磁盘中文件，这就需要调用操作系统中的相应命令。接下来我们使用的Python内置函数open()、write()都是通过调用操作系统的相关命令才实现文件读写的，至于其中的细节，我们就不需要考虑了。

15.1创建和打开文件

在Python 中创建或打开文件，实际上是建立一个对象，该对象通过调用内置的open()函数创建或打开一个文件。

语法：

file object = open(filename [, mode][, buffering])

参数说明如下：

filename：file_name变量是一个包含了你要访问的文件名称的字符串值；

mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

Buffering：如果buffering的值被设为0，就不会有寄存；如果buffering的值取1，访问文件时会寄存行；如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小；如果取负值，寄存区的缓冲大小则为系统默认。

mode参数的参数值及说明

对于其中最难区别的r、r+、w、w+、a、a+几个参数的区别总结如下，要特别注意指针的位置：

下面举例说明open( )函数的使用方法。

例1：

file=open('1.py')

如果文件“1.py”存在，则可以打开此文件；如果文件“1.py”不存在，则会出现如下提示：

Traceback (most recent call last):

File " ", line 1, in

file=open('1.py')

FileNotFoundError: [Errno 2] No such file or directory: '1.py'

例2：

file=open('4.py',’a+’)

虽然文件“4.py”不存在，但运行并未出现错误，参见上表，“a+”的含义是以读写模式打开文件，如果该文件已经存在，新内容将以追加方式写入；如果该文件不存在，则新建文件用于写入。查看文件夹，发现已经生成了一个新的文件4.py。

例3：

file=open('python.png','rb')

print(file)

运行结果：

这就是说，虽然Python可以打开一个图片格式的文件，但print()并不能将其输出，还需要第三方库中模块的相应方法去处理，如PIL中的open()f方法。

例4：

file = open("f.txt", "w",encoding='utf-8')

# 以只写模式打开文件f.txt，编码方式为utf-8

print( "文件名: ", file.name) # 输出文件名

print( "是否已关闭 : ", file.closed) # 文件是否打开

print( "访问模式 : ", file.mode) # 文件访问模式

运行结果：

文件名: f.txt

是否已关闭 : False

访问模式 : w

例5：

15.2关闭文件

打开文件使用后要及时关闭，以免造成不必要的破坏，同时也可以释放内存。在Python中使用close()方法可以关闭文件。

语法格式：

file.close()

其中，file为文件对象。

15.3 with语句

with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。

with语句的语法格式如下：

with expression as target:

with-body

其中，expression用于指定一个表达式，譬如打开文件的open()函数。target用于指定一个变量，并且将expression的结果保存到该变量中，譬如文件对象file。with-body用于指定with语句体，譬如一些文件操作的相关语句，如果没有要执行的语句体，则直接用pass语句代替。

假设python当前目录下存在一个test.txt文件，其内容如下：

Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

Python是交互式语言： 这意味着，您可以在一个 Python 提示符 后直接执行代码。

Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

Python是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。

举例如下：

with open('test.txt','r',encoding='utf-8') as file:

line=file.readline() # readline()方法可以读取文件一行数据，接下来就会讲到。

print(line)

运行结果如下：

Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

而此时，我们给该段代码with语句之外再增加一个读取文件的语句，代码如下：

with open('test.txt','r',encoding='utf-8') as file:

line=file.readline()

print(line)

line2=file.readline()

print(line2)

发现出现了如下错误提示：

Traceback (most recent call last):

File "C:/Users/zym/AppData/Local/Programs/Python/Python39/3.py", line 5, in

line2=file.readline()

ValueError: I/O operation on closed file.

意思是要读取的文件已经被关闭了。

由此可知，当with语句运行结束后，被打开的test.txt文件就自动关闭了。

15.4读取文件

在Python 中读取文件的方法有：

1、读取指定个数的字符

格式如下：

File.read([size])

其中，file为打开的文件对象。size为可选参数，可以指定要读取的字符个数，省缺表示读取所有内容。

在调用read()方法读取文件内容时，文件必须是以r（只读）或者r+(读写）方式打开。

如：

with open('test.txt','r',encoding='utf-8') as file:

txt=file.read() （或txt=file.read(10)）

print(txt)

将读取、输出test.txt文件的全部内容（或前10个字符）。

2、移动文件的指针

对于刚打开的文件，文件指针总是指向文件头的。也可以通过seek()方法将文件的指针移动到新的位置。

格式如下：

file.seek(offset[,whence])

其中，file表示已经打开的文件对象；offset用于指定移动的字符个数；whence表示从哪个位置起始计算个数，其值为0表示从文件头开始计算，其值为1表示从当前位置开始计算，其值为2表示从文件尾开始计算，默认值为0。

例如：

with open('test.txt','r',encoding='utf-8') as file:

string=file.read(9)

print('取9个字符： '+string)

file.seek(2) #指针从文件头开始移动2个字符

string=file.read(9) #从当前位置读取10个字符

输出结果：

取9个字符：

Python是一种

取9个字符：

thon是一种解释

而下面的代码会抛出错误：

with open('test.txt','r',encoding='utf-8') as file:

file.seek(2,1) #指针从当前位置开始移动2个字符

string=file.read(10) #从当前位置读取10个字符

print('取10个字符： '+string)

错误提示为：

Traceback (most recent call last):

File "C:UserszymAppDataLocalProgramsPythonPython393.py", line 7, in

file.seek(2,1) #指针从当前位置开始移动2个字符

io.UnsupportedOperation: can't do nonzero cur-relative seeks

原因在于，必须使用b模式（即rb）打开文件，才能使用whence参数。但是，b模式（二进制）不适合文本文件。对于test.txt这样的文本文件，为了解决通过改变指针读取任意位置字符，可以采用加一个位置变量的方法来存储指针的值。

例如：

with open('test.txt','r',encoding='utf-8') as file:

#utf-8汉字与英文字符都占一个字符

string='' #设置一个空字符串

pointer=0 #当前指针为0

str1=file.read(6) #读取6个字符

pointer+=6 #指针变量后移6个字符

string+=str1 #string用来存放已读取的字符

print('取6个字符： ',str1)

file.seek(pointer) #指针从文件头开始移动2个字符

str1=file.read(8) #从当前位置读取10个字符

pointer+=8 #指针跳过已读取的字符

string+=str1

print('再取8个字符： ',str1)

print('所有读取的字符： ',string)

print('当前指针所处的位置： ',pointer)

str1=file.read(1)

print('当前指针所处的字符： ',str1)

运行结果如下：

取6个字符：

Python

再取8个字符：

是一种解释型语言

所有读取的字符：

Python是一种解释型语言

当前指针所处的位置：

14

当前指针所处的字符：

：

3、读取一行数据readline()方法

语法格式：

file.readline()

例：

with open('test.txt','r',encoding='utf-8') as f:

string=f.read(1) # 读取文件的第一个字符

if string != '': # 防止文件为空文件

lineno=0

while True:

line=f.readline()

if line != '':

lineno+=1

print('第'+str(lineno)+'行：'+line,end='')

# 因为每行都有自带的分行符，print()语句不允许换行

else:

break # 出现空行时停止读取

else:

print('要读取的文件为空文件！')

运行结果：

第1行：ython是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

第2行：Python是交互式语言： 这意味着，您可以在一个 Python 提示符 后直接执行代码。

第3行：Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

第4行：Python是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。

4、读取全部行命令readlines()方法

语法格式：

File.readlines()

该方法与read()方法一样，在调用read()方法读取文件内容时，文件必须是以r（只读）或者r+(读写）方式打开。

例：

with open('test.txt','r',encoding='utf-8') as f:

txt=f.readlines()

print(txt)

运行结果：

['Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。 ', 'Python是交互式语言： 这意味着，您可以在一个 Python 提示符 后直接执行代码。 ', 'Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。 ', 'Python是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。 ']

从上面的运行结果可以看出，readlines()方法的返回值为一个字符串列表。所以，也可以以读取列表元素的方法输出。如下所示：

with open('test.txt','r',encoding='utf-8') as f:

txt=f.readlines()

for line in txt:

print(line,end='')

运行结果：

Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

Python是交互式语言： 这意味着，您可以在一个 Python 提示符 后直接执行代码。

Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

Python是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。

15.5 写入文件内容

语法格式如下：

file.write(string)

其中，file为打开的文件对象，string为要写入的字符串。

写入文件内容时，文件必须以w（可写）或a（追加）模式打开。否则，会抛出如下异常提示：

Traceback (most recent call last):

File "C:UsersAdministratorAppDataLocalProgramsPythonPython383.py", line 2, in

f.write('人生苦短，我用Python！')

io.UnsupportedOperation: not writable

关于write()方法的用法举例如下：

with open('test.txt','a',encoding='utf-8') as f:

f.write('人生苦短，我用Python！')

with open('test.txt','r',encoding='utf-8') as f:

txt=f.read()

print(txt)

运行结果：

Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

Python是交互式语言： 这意味着，您可以在一个 Python 提示符 后直接执行代码。

Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

Python是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。

人生苦短，我用Python！

可以看出，由于文件的打开方式为a模式（追加模式），写入的内容被写入到文件的末尾。

在Python中，文件操作方法里没有类似于字符串内的计算长度、查找、替换、截取、分隔等方法，为什么没有？原因可能是文件的类型太复杂，譬如说二进制文件，上述操作的意义不大。如果仅仅要对文本文件进行上述操作，完全可以先把文件的内容读取到字符串中，再用相应的字符串函数或方法去操作就可以了。譬如，要将test.txt文件中的字符串‘Python’替换为’PHP’，则可以用如下代码完成：

txt1=''

with open('test.txt','r',encoding='utf-8') as f:

txt1=f.read() #先将文件内容存入字符串txt1中

txt2=txt1.replace('Python','PHP') #将txt1中的'Python'替换为'PHP'，并存入txt2

with open('test.txt','w',encoding='utf-8') as f:

f.write(txt2) #将字符串txt2的内容写回到文件中

这里之所以分两步打开文件（第一次为r模式，第二次为w模式），而没有采用一次读写（r+、w+方式），因为那样比较容易出错。实践证明，将文件的读操作和写操作分开其实是非常正确的选择。

Python 有哪些新手不会了解的深入细节

了解内建的几大容器list/dict/set用什么数据结构实现，以及一些基本操作的时间复杂度。这个不难，python的list实际上就是个vector，不是linked list，dict/set就是hash table。然后避免犯频繁在list中间插入/删除之类的错误

这也使得python不适合函数式编程，像什么lambda不能跨行都是小事，但是标准库里连持久化的列表/搜索树都没有。自己实现也不是不行，CPython函数调用开销又大。

所以还是老老实实写循环、抛异常吧，When in Rome, do as the Romans do。

在Python中定义Main函数

目录

许多编程语言都有一个特殊的函数，当操作系统开始运行程序时会自动执行该函数。这个函数通常被命名为main()，并且依据语言标准具有特定的返回类型和参数。另一方面，Python解释器从文件顶部开始执行脚本，并且没有自动执行的特殊函数。

尽管如此，为程序的执行定义一个起始点有助于理解程序是如何运行的。Python程序员提出了几种方式对此进行实现。

本文结束时，您将了解以下内容：

Python中的基本main()函数

一些Python脚本中，包含一个函数定义和一个条件语句，如下所示：

此代码中，包含一个main()函数，在程序执行时打印Hello World!。此外，还包含一个条件（或if）语句，用于检查__name__的值并将其与字符串"__main__"进行比较。当if语句为True时，Python解释器将执行main()函数。更多关于Python条件语句的信息可以由此获得。

这种代码模式在Python文件中非常常见，它将作为脚本执行并导入另一个模块。为了帮助理解这段代码的执行方式，首先需要了解Python解释器如何根据代码的执行方式设置__name__。

Python中的执行模式

Python解释器执行代码有两种方式：

更多内容可参考如何运行Python脚本。无论采用哪种方式，Python都会定义一个名为__name__的特殊变量，该变量包含一个字符串，其值取决于代码的使用方式。

本文将如下示例文件保存为execution_methods.py，以 探索 代码如何根据上下文改变行为：

在此文件中，定义了三个对print()函数的调用。前两个打印一些介绍性短语。第三个print()会先打印短语The value __name__ is，之后将使用Python内置的repr()函数打印出__name__变量。

在Python中，repr()函数将对象转化为供解释器读取的形式。上述示例通过使用repr()函数来强调__name__的值为字符串。更多关于repr()的内容可参考Python文档。

在本文中，您将随处可见文件(file)，模块(module)和脚本(script)这三个字眼。实际上，三者之间并无太大的差别。不过，在强调代码目的时，还是存在细微的差异：

“如何运行Python脚本”一文也讨论了三者的差别。

基于命令行执行

在这类方法中，Python脚本将通过命令行来执行。

执行脚本时，无法与Python解释器正在执行的代码交互。关于如何通过命令行执行代码的详细信息对本文而言并不重要，但您可以通过展开下框阅读更多有关Windows，Linux和macOS之间命令行差异的内容。

命令行环境

不同的操作系统在使用命令行执行代码时存在细微的差异。

在Linux和macOS中，通常使用如下命令：

美元符号($)之前的内容可能有所不同，具体取决于您的用户名和计算机名称。您键入的命令位于$之后。在Linux或macOS上，Python3的可执行文件名为python3，因此可以通过输入python3 script_name.py来运行python脚本。

在Windows上，命令提示符通常如下所示：

根据您的用户名，之前的内容可能会有所不同，您输入的命令位于之后。在Windows上，Python3的可执行文件通常为python。因此可以通过输入python script_name.py来运行python脚本。

无论哪种操作系统，本文的Python脚本的输出结果都是相同的。因此本文以Linux和macOS为例。

使用命令行执行execution_methods.py，如下所示：

在这个示例中，__name__具有值'__main__'，其中引号(')表明该值为字符串类型。

请记住，在Python中，使用单引号(')和双引号(")定义的字符串没有区别。更多关于字符串的内容请参考Python的基本数据类型。

如果在脚本中包含"shebang行"并直接执行它(./execution_methods.py)，或者使用IPython或Jupyter Notebook的%run，将会获取相同的结果。

您还可以通过向命令行添加-m参数的方法实现以模块的方式执行。通常情况下，推荐如下方式pip: python3 -m pip install package_name。

添加-m参数将会运行包中__main__.py的代码。更多关于__main__.py文件的内容可参考如何将开源Python包发布到PyPI中。

在三种情况中，__name__都具有相同的值：字符串'__main__'。

技术细节：Python文档中具体定义了__name__何时取值为'__main__'。

当通过标准输入，脚本或者交互提示中读取数据时，模块的__name__将取值为'__main__'。（来源）

__name__与__doc__，__package__和其他属性一起存储在模块的全局命名空间。更多关于属性的信息可参考Python数据模型文档，特别是关于模块和包的信息，请参阅Python Import文档。

导入模块或解释器

接下来是Python解释器执行代码的第二种方式：导入。在开发模块或脚本时，可以使用import关键字导入他人已经构建的模块。

在导入过程中，Python执行指定模块中定义的语句（但仅在第一次导入模块时）。要演示导入execution_methods.py文件的结果，需要启动Python解释器，然后导入execution_methods.py文件：

在此代码输出中，Python解释器执行了三次print()函数调用。前两行由于没有变量，在输出方面与在命令行上作为脚本执行时完全相同。但是第三个输出存在差异。

当Python解释器导入代码时，__name__的值与要导入的模块的名称相同。您可以通过第三行的输出了解这一点。__name__的值为'execution_methods'，是Python导入的.py文件。

注意如果您在没有退出Python时再次导入模块，将不会有输出。

注意：更多关于导入在Python中如何工作的内容请参考官方文档和Python中的绝对和相对导入。

Main函数的最佳实践

既然您已经了解两种执行方式上的差异，那么掌握一些最佳实践方案还是很有用的。它们将适用于编写作为脚本运行的代码或者在另一个模块导入的代码。

如下是四种实践方式：

将大部分代码放入函数或类中

请记住，Python解释器在导入模块时会执行模块中的所有代码。有时如果想要实现用户可控的代码，会导致一些副作用，例如：

在这种情况下，想要实现用户控制触发此代码的执行，而不是让Python解释器在导入模块时执行代码。

因此，最佳方法是将大部分代码包含在函数或类中。这是因为当Python解释器遇到def或class关键字时，它只存储这些定义供以后使用，并且在用户通知之前不会实际执行。

将如下代码保存在best_practices.py以证明这个想法：

在此代码中，首先从time模块中导入sleep()。

在这个示例中，参数以秒的形式传入sleep()函数中，解释器将暂停一段时间再运行。随后，使用print()函数打印关于代码描述的语句。

之后，定义一个process_data()函数，执行如下五项操作：

在命令行中执行

当你将此文件作为脚本用命令行执行时会发生什么呢？

Python解释器将执行函数定义之外的from time import sleep和print()，之后将创建函数process_data()。然后，脚本将退出而不做任何进一步的操作，因为脚本没有任何执行process_data()的代码。

如下是这段脚本的执行结果：

我们在这里看到的输出是第一个print()的结果。注意，从time导入和定义process_data()函数不产生结果。具体来说，调用定义在process_data()内部的print()不会打印结果。

导入模块或解释器执行

在会话（或其他模块）中导入此文件时，Python解释器将执行相同的步骤。

Python解释器导入文件后，您可以使用已导入模块中定义的任何变量，类或函数。为了证明这一点，我们将使用可交互的Python解释器。启动解释器，然后键入import best_practices：

导入best_practices.py后唯一的输出来自process_data()函数外定义的print()。导入模块或解释器执行与基于命令行执行类似。

使用__name__控制代码的执行

如何实现基于命令行而不使用Python解释器导入文件来执行呢？

您可以使用__name__来决定执行上下文，并且当__name__等于"__main__"时才执行process_data()。在best_practices.py文件中添加如下代码：

这段代码添加了一个条件语句来检验__name__的值。当值为"__main__"时，条件为True。记住当__name__变量的特殊值为"__main__"时意味着Python解释器会执行脚本而不是将其导入。

条件语块内添加了四行代码（第12，13，14和15行）：

现在，在命令行中运行best_practices.py，并观察输出的变化：

首先，输出显示了process_data()函数外的print()的调用结果。

之后，data的值被打印。因为当Python解释器将文件作为脚本执行时，变量__name__具有值"__main__"，因此条件语句被计算为True。

接下来，脚本将调用process_data()并传入data进行修改。当process_data执行时，将输出一些状态信息。最终，将输出modified_data的值。

现在您可以验证从解释器（或其他模块）导入best_practices.py后发生的事情了。如下示例演示了这种情况：

注意，当前结果与将条件语句添加到文件末尾之前相同。因为此时__name__变量的值为"best_practices"，因此条件语句结果为False，Python将不执行process_data()。

创建名为main()的函数来包含要运行的代码

现在，您可以编写作为脚本由从命令行执行并导入且没有副作用的Python代码。接下来，您将学习如何编写代码并使其他程序员能轻松地理解其含义。

许多语言，如C，C++，Java以及其他的一些语言，都会定义一个叫做main()的函数，当编译程序时，操作系统会自动调用该函数。此函数通常被称为入口点(entry point)，因为它是程序进入执行的起始位置。

相比之下，Python没有一个特殊的函数作为脚本的入口点。实际上在Python中可以将入口点定义成任何名称。

尽管Python不要求将函数命名为main()，但是最佳的做法是将入口点函数命名为main()。这样方便其他程序员定位程序的起点。

此外，main()函数应该包含Python解释器执行文件时要运行的任何代码。这比将代码放入条件语块中更好，因为用户可以在导入模块时重复使用main()函数。

修改best_practices.py文件如下所示：

在这个示例中，定义了一个main()函数，它包含了上面的条件语句块。之后修改条件语块执行main()。如果您将此代码作为脚本运行或导入，将获得与上一节相同的输出。

在main()中调用其他函数

另一种常见的实现方式是在main()中调用其他函数，而不是直接将代码写入main()。这样做的好处在于可以实现将几个独立运行的子任务整合。

例如，某个脚本有如下功能：

如果在单独的函数中各自实现这些子任务，您（或其他用户）可以很容易地实现代码重用。之后您可以在main()函数中创建默认的工作流。

您可以根据自己的情况选择是否使用此方案。将任务拆分为多个函数会使重用更容易，但会增加他人理解代码的难度。

修改best_practices.py文件如下所示：

在此示例代码中，文件的前10行具有与之前相同的内容。第12行的第二个函数创建并返回一些示例数据，第17行的第三个函数模拟将修改后的数据写入数据库。

第21行定义了main()函数。在此示例中，对main()做出修改，它将调用数据读取，数据处理以及数据写入等功能。

首先，从read_data_from_web()中创建data。将data作为参数传入process_data()，之后将返回modified_data。最后，将modified_data传入write_data_to_database()。

脚本的最后两行是条件语块用于验证__name__，并且如果if语句为True，则执行main()。

在命令行中运行如下所示：

根据执行结果，Python解释器在执行main()函数时，将依次执行read_data_from_web()，process_data()以及write_data_to_database()。当然，您也可以导入best_practices.py文件并重用process_data()作为不同的数据输入源，如下所示：

在此示例中，导入了best_practices并且将其简写为bp。

导入过程会导致Python解释器执行best_practices.py的全部代码，因此输出显示解释文件用途的信息。

然后，从文件中存储数据而不是从Web中读取数据。之后，可以重用best_practices.py文件中的process_data()和write_data_to_database()函数。在此情况下，可以利用代码重写来取代在main()函数中实现全部的代码逻辑。

实践总结

以下是Python中main()函数的四个关键最佳实践：

结论

恭喜！您现在已经了解如何创建Python main()函数了。

本文介绍了如下内容：

现在，您可以开始编写一些非常棒的关于Python main()函数代码啦！

标题名称：python函数细节,python函数与方法的详细
本文路径：http://ybzwz.com/article/hschdc.html