python文件定义
python存储的文件类型：
python存储的文件类型是根据你使用的open函数来确定的，如果使用open打开txt文件，那么存储的就是txt文件，如果打开的是jpg文件，那么存储的就是jpg文件
示例如下：
打开txt文件
执行结果：
打开jpg文件：
执行结果：
更多Python知识，请关注：Python自学网！！
⑵ Python 文件操作
open(filename[,mode,encoding="编码"]) ：第一个参数文件名如果不加路径，默认在该py文件目录下（路径举例： E:/XXX或E:\xxx ），第二个是模式，默认为 'r' ——只读，举例： f = open('E:/abc.txt') ，如果要转编码并写入模式：
f = open('E:/abc.txt','w',encoding='utf-8')
1. 模式
2. 方法
(1) close() : 关闭文件，因为文件写入时是写在内存，只有关闭时才写入硬盘，所以写完记得关闭
(2) read(size = -1) ：读取文件size个字符，不写默认是-1，此时读取所有内容（换行按
来表示，很不好看），并作为字符串返回，一定要注意 读完以后文件指针将会指向末尾 ，所以下一次在用read方法时会发现读取不出内容了，所以这个就要用seek移动指针或者关闭文件重新定义
(3) tell() ：返回当前文件指针指向的位置
(4) seek(offset,from) ：移动文件指针，代表从from参数开始偏移offset个字节，0代表起始位置，1代表当前位置，2代表文件末尾
(5) readline() ：按序列读取一行内容，默认
为边界
(6) write() ：写入内容，但必须要有写入权限才行，否则报错，写完会返回写入的长度，例如： len1 = f.write('abc') ，此时len1就为3
(7) truncate() ：删除内容，把当前指针以后的内容全删了，举例：
注：
1.文件还可以转化为 list 之类的，例如： list1 = list(f) ，此时文件内容的按
被隔开，然后可以用for语句读取文件所有内容，举例：
2.上面输出文件内容方法相对低效，所以一般都直接用for输出整个文件，举例：
通过 fileno 函数，我们可以查看一个文件对应的文件描述符，对应的是程序中打开的文件序号，举例：
可以看出python在启动时会先启动标准流的文件（文件描述符分别为：0/1/2），所以之后打开的文件就从3开始递增，当释放一个文件资源时，该描述符序号被释放，之后打开的文件可以继续使用该序号的文件描述符
python中的 print 的本质是通过 sys.stdout 来进行内容输出，而 sys.stdout 的本质是一个"文件"，相当于我们所有的输入输出的本质都是在对 sys.stdin / sys.stdout / sys.stderr 这些文件来进行读写操作，举例：
open 函数不仅可以打开本地文件，也可以打开文件描述符，而该参数默认为 True ，代表 close 后会将对应的文件资源释放，而对于一些文件描述符，我们只是希望 close 时将打开文件描述符的对象释放，而不释放对应的文件资源，那么则可以设置 closefd=False ，举例：
需要使用到 chardet 模块，按二进制可读打开文件，然后通过 detect() 方法查看，举例：
所以就可以根据文件来设置编码了：
有时候使用文件的编码解码也可能会出现无法解析的情况，例如两种编码混在同一个文件里的时候，此时可以设置 errors 参数为 ignore 来避免该问题，示例：
可用 os 模块下的 chmod() 函数，具体参考： http://www.runoob.com/python/os-chmod.html
使用 os 模块下的 remove() 函数可以实现删除文件，举例：
可以使用自带的 zipfile 模块来进行操作，举例：
可以使用自带的 tarfile 模块来进行操作，举例：
https://www.cnblogs.com/lotusto/p/5805543.html
⑶ python中的模块，库，包有什么区别
1.python模块是：
python模块：包含并且有组织的代码片段为模块。
表现形式为：写的代码保存为文件。这个文件就是一个模块。sample.py 其中文件名smaple为模块名字。
关系图：
3.库（library）
库的概念是具有相关功能模块的集合。这也是Python的一大特色之一，即具有强大的标准库、第三方库以及自定义模块。
⑷ 如何定义python源文件的文件编码
Python的源文件编码有许多种，其定义格式是：
##-*-coding:xxx-*-
或者
#coding:xxx
这些都可以保证解释器能够读懂的特殊注释。
常用的编码有如下几种：
cp936
utf-8
utf-16
gbk
⑸ 简述创建python文件的过程
首先，进行打开的pycharm软件界面当中，进行选中已经打开的项目文件。
⑹ 怎么样理解一个python项目的各种文件
在Python中引用是非常简单的事情，这里需要清楚三个概念就可以了包、模块、类。类这个就不用说了。
模块对应的是一个.py文件，那么mole_name就是这个文件去掉.py之后的文件名，py文件中可以直接定义一些变量、函数、类。
那么包我们可以看作一个包含__init__.py和一系列.py文件的文件夹，这样做的目的是为了区别包和普通字符串。
importmole_name
frompackage_nameimportmole_name
frompackage_nameimport *
那么如何import时，python解释器如何才能找到该模块放置的文件位置呢？python寻找模块的优先级如下：
1、当前文件目录
2、环境变量PYTHONPATH
3、sys.path(list类型)
sys.path是list类型，我们可以通过insert(), append()方法来增加模块导入的搜索路径，如：
import sys
path = “……” #需要增加的路径
sys.path.insert(0, path)
在import模块时，该模块的顶层代码将会被执行一次。如果该模块被import多次，例如import A, import B.其中B模块本身也有import A，那么只在第一次被import的时候顶层代码会被执行。
模块能像包含函数定义一样，可包含一些可执行语句。这些可执行语句通常用来进行模块的初始化工作。这些语句只在模块第一次被导入时被执行。这非常重要，有些人以为这些语句会多次导入多次执行，其实不然。
模块在被导入执行时，python解释器为加快程序的启动速度，会在与模块文件同一目录下生成.pyc文件。我们知道python是解释性的脚本语言，而.pyc是经过编译后的字节码，这一工作会自动完成，而无需程序员手动执行。
什么时候你应该使用frommoleimport？
如果你要经常访问模块的属性和方法，且不想一遍又一遍地敲入模块名，使用frommoleimport。
如果你想要有选择地导入某些属性和方法，而不想要其它的，使用frommoleimport。
如果模块包含的属性和方法与你的某个模块同名，你必须使用importmole来避免名字冲突。
除了这些情况，剩下的只是风格问题了，你会看到用两种方式编写的Python代码。
尽量少用from mole import *，因为判定一个特殊的函数或属性是从哪来的有些困难，并且会造成调试和重构都更困难。
其它要点：
包
在创建许许多多模块后，我们可能希望将某些功能相近的文件组织在同一文件夹下，这里就需要运用包的概念了。包对应于文件夹，使用包的方式跟模块也类似，唯一需要注意的是，当文件夹当作包使用时，文件夹需要包含__init__.py文件，主要是为了避免将文件夹名当作普通的字符串。__init__.py的内容可以为空，一般用来进行包的某些初始化工作或者设置__all__值，__all__是在from package-name import *这语句使用的，全部导出定义过的模块。
那么我们平常新建文件的时候，都是建一个.py文件（类似java，但是python不用建立类，是以模块为载体）至于怎样组织包就要功能需要了
在C/C++/Java中，main是程序执行的起点，Python中，也有类似的运行机制，但方式却截然不同：Python使用缩进对齐组织代码的执行，所有没有缩进的代码（非函数定义和类定义），都会在载入时自动执行，这些代码，可以认为是Python的main函数。
每个文件（模块）都可以任意写一些没有缩进的代码，并且在载入时自动执行，为了区分主执行文件还是被调用的文件，Python引入了一个变量__name__，当文件是被调用时，__name__的值为模块名，当文件被执行时，__name__为'__main__'。这个特性，为测试驱动开发提供了极好的支持，我们可以在每个模块中写上测试代码，这些测试代码仅当模块被Python直接执行时才会运行，代码和测试完美的结合在一起。
典型的Python文件结构：
python import模块方法
python包含子目录中的模块方法比较简单，关键是能够在sys.path里面找到通向模块文件的路径。
下面将具体介绍几种常用情况:
（1）主程序与模块程序在同一目录下:
如下面程序结构:
`-- src
|-- mod1.py
`-- test1.py
若在程序test1.py中导入模块mod1, 则直接使用importmod1或from mod1 import *;
（2）主程序所在目录是模块所在目录的父(或祖辈)目录
如下面程序结构:
`-- src
|-- mod1.py
|-- mod2
| `-- mod2.py
`-- test1.py
若在程序test1.py中导入模块mod2, 需要在mod2文件夹中建立空文件__init__.py文件(也可以在该文件中自定义输出模块接口); 然后使用 from mod2.mod2 import * 或import mod2.mod2.
（3）主程序导入上层目录中模块或其他目录(平级)下的模块
如下面程序结构:
`-- src
|-- mod1.py
|-- mod2
| `-- mod2.py
|-- sub
| `-- test2.py
`-- test1.py
若在程序test2.py中导入模块mod1和mod2。首先需要在mod2下建立__init__.py文件(同(2))，src下不必建立该文件。然后调用方式如下:
下面程序执行方式均在程序文件所在目录下执行，如test2.py是在cd sub;之后执行python test2.py
而test1.py是在cd src;之后执行python test1.py; 不保证在src目录下执行python sub/test2.py成功。
import sys
sys.path.append("..")
import mod1
import mod2.mod2
（4）从(3)可以看出，导入模块关键是能够根据
⑺ python怎么定义addcat
Python中的Mole是比较重要的概念。常见的情况是，事先写好一个.py文 件，在另一个文件中需要import时，将事先写好的.py文件拷贝 到当前目录，或者是在sys.path中增加事先写好的.py文件所在的目录，然后import。这样的做法，对于少数文件是可行的，但如果程序数目很 多，层级很复杂，就很吃力了。
有没有办法，像Java的Package一样，将多个.py文件组织起来，以便在外部统一调用，和在内部互相调用呢？答案是有的。
主要是用到python的包的概念，python
__init__.py在包里起一个比较重要的作用
要弄明白这个问题，首先要知道，python在执行import语句时，到底进行了什么操作，按照python的文档，它执行了如下操作：
第1步，创建一个新的，空的mole对象（它可能包含多个mole）；
第2步，把这个mole对象插入sys.mole中
第3步，装载mole的代码（如果需要，首先必须编译）
第4步，执行新的mole中对应的代码。
在执行第3步时，首先要找到mole程序所在的位置，其原理为：
如 果需要导入的mole的名字是m1，则解释器必须找到m1.py，它首先在当前目录查找，然后是在环境变量PYTHONPATH中查找。 PYTHONPATH可以视为系统的PATH变量一类的东西，其中包含若干个目录。如果PYTHONPATH没有设定，或者找不到m1.py，则继续搜索 与python的安装设置相关的默认路径，在Unix下，通常是/usr/local/lib/python。
事实上，搜索的顺序是：当前路径 （以及从当前目录指定的sys.path），然后是PYTHONPATH，然后是python的安装设置相关的默认路径。正因为存在这样的顺序，如果当前 路径或PYTHONPATH中存在与标准mole同样的mole，则会覆盖标准mole。也就是说，如果当前目录下存在xml.py，那么执 行import
xml时，导入的是当前目录下的mole，而不是系统标准的xml。
了解了这些，我们就可以先构建一个package，以普通mole的方式导入，就可以直接访问此package中的各个mole了。
Python中的package定义很简单，其层次结构与程序所在目录的层次结构相同，这一点与Java类似，唯一不同的地方在于，python中的package必须包含一个__init__.py的文件。
例如，我们可以这样组织一个package:
package1/
__init__.py
subPack1/
__init__.py
mole_11.py
mole_12.py
mole_13.py
subPack2/
__init__.py
mole_21.py
mole_22.py
……
__init__.py可以为空，只要它存在，就表明此目录应被作为一个package处理。当然，__init__.py中也可以设置相应的内容，下文详细介绍。
好了，现在我们在mole_11.py中定义一个函数：
def funA():
print "funcA in mole_11"
return
在顶层目录（也就是package1所在的目录，当然也参考上面的介绍，将package1放在解释器能够搜索到的地方）运行python:
>>>from package1.subPack1.mole_11 import funcA
>>>funcA()
funcA in mole_11
这样，我们就按照package的层次关系，正确调用了mole_11中的函数。
细心的用户会发现，有时在import语句中会出现通配符*，导入某个mole中的所有元素，这是怎么实现的呢？
答案就在__init__.py中。我们在subPack1的__init__.py文件中写
__all__ = ['mole_13', 'mole_12']
然后进入python
>>>from package1.subPack1 import *
>>>mole_11.funcA()
Traceback (most recent call last):
File "", line 1, in
ImportError: No mole named mole_11
也就是说，以*导入时，package内的mole是受__init__.py限制的。
好了，最后来看看，如何在package内部互相调用。
如果希望调用同一个package中的mole，则直接import即可。也就是说，在mole_12.py中，可以直接使用
import mole_11
如果不在同一个package中，例如我们希望在mole_21.py中调用mole_11.py中的FuncA，则应该这样：
from mole_11包名.mole_11 import
funcA
包机制
# a.py
def add_func(a,b):
return a+b
# b.py
from a import add_func # Also can be : import a
print ("Import add_func from mole a")
print ("Result of 1 plus 2 is: ")
print (add_func(1,2)) # If using "import a" , then here should be "a.add_func"
mole可以定义在包里面.Python定义包的方式稍微有点古怪,假设我们有一个parent文件夹,该文件夹有一个child子文件夹.child中有一个mole
a.py . 如何让Python知道这个文件层次结构?很简单,每个目录都放一个名为_init_.py 的文件.该文件内容可以为空.这个层次结构如下所示:
parent
--__init_.py
--child
-- __init_.py
--a.py
b.py
那么Python如何找到我们定义的mole?在标准包sys中,path属性记录了Python的包路径.你可以将之打印出来:
import sys
print(sys.path)
通常我们可以将mole的包路径放到环境变量PYTHONPATH中,该环境变量会自动添加到sys.path属性.另一种方便的方法是编程中直接指定我们的mole路径到sys.path 中:
import sys
import os
sys.path.append(os.getcwd()+'\\parent\\child')
print(sys.path)
from a import add_func
print (sys.path)
print ("Import add_func from mole a")
print ("Result of 1 plus 2 is: ")
print (add_func(1,2))
知识点:
如何定义模块和包
如何将模块路径添加到系统路径,以便python找到它们
如何得到当前路径
⑻ python文件操作
我觉得要逐行的话最好这样写：
forlineinfo.readlines():
至于为什么直接fo可以迭代出每行，应该是open函数返回值的内部实现和返回值类型决定的（应该在c代码里，直接转open定义看不见实现细节）。
⑼ 有哪位大神指导下，Python中文件、模块与包三者之间有什么区别呀麻烦解释的详细点哈，谢谢啦。。。。
Python在处理功能复用和功能颗粒度划分时采用了类、模块、包的结构。这种处理跟C++中的类和名字空间类似，但更接近于Java所采用的概念。
类
类的概念在许多语言中出现，很容易理解。它将数据和操作进行封装，以便将来的复用。
模块
模块，在Python可理解为对应于一个文件。在创建了一个脚本文件后，定义了某些函数和变量。你在其他需要这些功能的文件中，导入这模块，就可重用这些函数和变量。一般用mole_name.fun_name，和mole_name.var_name进行使用。这样的语义用法使模块看起来很像类或者名字空间，可将mole_name理解为名字限定符。模块名就是文件名去掉.py后缀。下面演示了一个简单的例子：
#moel1.py
def say(word):
print word
#caller.py
import mole1
print __name__
print mole1.__name__
mole1.say('hello')
$ python caller.py
__main__
mole1
hello
例子中演示了从文件中调用模块的方法。这里还展示了一个有趣的模块属性__name__，它的值由Python解释器设定。如果脚本文件是作为主程序调用，其值就设为__main__，如果是作为模块被其他文件导入，它的值就是其文件名。这个属性非常有用，常可用来进行模块内置测试使用，你会经常在一些地方看到类似于下面的写法，这些语句只在作为主程序调用时才被执行。
if __name__ == '__main__':
app = wxapp(0)
app.MainLoop()
模块搜索路径
上面的例子中，当mole1被导入后，python解释器就在当前目录下寻找mole1.py的文件，然后再从环境变量PYTHONPATH寻找，如果这环境变量没有设定，也不要紧，解释器还会在安装预先设定的的一些目录寻找。这就是在导入下面这些标准模块，一切美好事情能发生的原因。
import os
import sys
import threading
...
这些搜索目录可在运行时动态改变，比如将mole1.py不放在当前目录，而放在一个冷僻的角落里。这里你就需要通过某种途径，如sys.path，来告知Python了。sys.path返回的是模块搜索列表，通过前后的输出对比和代码，应能理悟到如何增加新路径的方法了吧。非常简单，就是使用list的append()或insert()增加新的目录。
#mole2.py
import sys
import os
print sys.path
workpath = os.path.dirname(os.path.abspath(sys.argv[0]))
sys.path.insert(0, os.path.join(workpath, 'moles'))
print sys.path
$ python mole2.py
['e:\Project\Python', 'C:\WINDOWS\system32\python25.zip', ...]
['e:\Project\Python\moles', 'e:\Project\Python', 'C:\WINDOWS\system32\python25.zip', ...]
其他的要点
模块能像包含函数定义一样，可包含一些可执行语句。这些可执行语句通常用来进行模块的初始化工作。这些语句只在模块第一次被导入时被执行。这非常重要，有些人以为这些语句会多次导入多次执行，其实不然。
模块在被导入执行时，python解释器为加快程序的启动速度，会在与模块文件同一目录下生成.pyc文件。我们知道python是解释性的脚本语言，而.pyc是经过编译后的字节码，这一工作会自动完成，而无需程序员手动执行。
包
在创建许许多多模块后，我们可能希望将某些功能相近的文件组织在同一文件夹下，这里就需要运用包的概念了。包对应于文件夹，使用包的方式跟模块也类似，唯一需要注意的是，当文件夹当作包使用时，文件夹需要包含__init__.py文件，主要是为了避免将文件夹名当作普通的字符串。__init__.py的内容可以为空，一般用来进行包的某些初始化工作或者设置__all__值，__all__是在from package-name import *这语句使用的，全部导出定义过的模块。