Python学习笔记五——文件、os、类和对象

file

打开文件方式

open() 将会返回一个 file 对象，基本语法格式为：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)，file：包含了你要访问的文件名称的字符串值，mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见下表。这个参数是非强制的，默认文件访问模式为只读(r)。

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

几种模式对比如下：

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

写文件：f.write()
f.write(string) 将 string 写入到文件中，然后返回写入的字符数。

# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()

读文件：f.read()
调用 f.read(size)，这将读取一定数目的数据，然后作为字符串或字节对象返回。当 size 被忽略了或者为负，那么该文件的所有内容都将被读取并且返回。
```
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
# 关闭打开的文件
f.close()
```
按行读文件：
(1).f.readline()：
f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串，说明已经已经读取到最后一行。
(2).f.readlines()：
f.readlines() 将返回该文件中包含的所有行。如果设置可选参数 sizehint，则读取指定长度的字节，并且将这些字节按行分割。
(3).迭代一个文件对象然后读取每行：
```
# 打开一个文件
f = open("/tmp/foo.txt", "r")
for line in f:
   print(line, end='')
# 关闭打开的文件
f.close()
```

文件对象的操作方法

f.tell()：
f.tell() 返回文件对象当前所处的位置，它是从文件开头开始算起的字节数。
f.seek()：
如果要改变文件当前的位置，可以使用 f.seek(offset, from_what) 函数。
from_what 的值, 如果是 0 表示开头，如果是 1 表示当前位置， 2 表示文件的结尾，from_what 值为默认为0，即文件开头。例如：
(1).seek(x,0) ：从起始位置即文件首行首字符开始移动 x 个字符；
(2).seek(x,1) ：表示从当前位置往后移动x个字符；
(3).seek(-x,2)：表示从文件的结尾往前移动x个字符。
with：
使用 with 关键字处理文件对象，在使用结束后，它会正确的关闭文件。
```
with open('/tmp/foo.txt', 'r') as f:
read_data = f.read()
```

对excel及csv文件进行操作

写入excel：

import xlwt # 能写不能读
strust = [['姓名', '年龄', '性别', '分数'],['mary', 20, '女', 89.9],['Jack', 21, '男', 91.8]]
book = xlwt.Workbook() # 新建一个excel
sheet = book.add_sheet('case1_sheet') # 添加一个sheet页
myStyle = xlwt.easyxf('font: name Times New Roman, color-index red, bold on', num_format_str='#,##0.00')   # 数据格式
row = 0 # 控制行
for stru in strust:
    col = 0 # 控制列
    for s in stru: # 再循环里面list的值，每一列
        sheet.write(row,col,s,myStyle)
        col+=1
    row+=1
book.save('stru_1.xls') # 保存到当前目录下

读取excel数据：

import xlrd # 能读不能写
book = xlrd.open_workbook('stru_1.xls') # 打开一个excel
sheet = book.sheet_by_index(0) # 根据顺序获取sheet
sheet2 = book.sheet_by_name('case1_sheet') # 根据sheet页名字获取sheet
print(sheet.cell(0,0).value) # 指定行和列获取数据
print(sheet.cell(0,1).value)
print(sheet.cell(0,2).value)
print(sheet.cell(0,3).value)
print(sheet.ncols) # 获取excel里面有多少列
print(sheet.nrows) # 获取excel里面有多少行
print(sheet.get_rows()) # 获取所有行
for i in sheet.get_rows():
    print(i) # 获取每一行的数据
print(sheet.row_values(0)) # 获取第一行
for i in range(sheet.nrows): # 0 1 2
    print(sheet.row_values(i)) # 获取第几行的数据
print(sheet.col_values(0)) # 取第一列的数据
for i in range(sheet.ncols):
    print(sheet.col_values(i)) # 获取第几列的数据

写入CVS文件：

with open('test.csv','wb') as myFile:      
    myWriter=csv.writer(myFile)  
    myWriter.writerow([2,'t'])  
    myWriter.writerow([3,'s'])  
    myList=[[1,2,3],[4,5,6]]  
    myWriter.writerows(myList)

读取CVS文件：

import csv  
with open('test.csv','rb') as myFile:  
    lines=csv.reader(myFile)  
    for line in lines:  # 按行打印文本
        print line

os模块

导入os模块：import os

相关方法：

方法	描述
os.access(path, mode)	检验权限模式
os.chdir(path)	改变当前工作目录
os.chflags(path, flags)	设置路径的标记为数字标记。
os.chmod(path, mode)	更改权限
os.chown(path, uid, gid)	更改文件所有者
os.chroot(path)	改变当前进程的根目录
os.close(fd)	关闭文件描述符 `fd`
os.closerange(fd_low, fd_high)	关闭所有文件描述符，从 `fd_low` (包含) 到 `fd_high` (不包含), 错误会忽略
os.dup(fd)	复制文件描述符 `fd`
os.dup2(fd, fd2)	将一个文件描述符 `fd` 复制到另一个 `fd2`
os.fchdir(fd)	通过文件描述符改变当前工作目录
os.fchmod(fd, mode)	改变一个文件的访问权限，该文件由参数`fd`指定，参数`mode`是`Unix`下的文件访问权限。
os.fchown(fd, uid, gid)	修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符`fd`指定。
os.fdatasync(fd)	强制将文件写入磁盘，该文件由文件描述符`fd`指定，但是不强制更新文件的状态信息。
os.fdopen(fd[, mode[, bufsize]])	通过文件描述符 `fd` 创建一个文件对象，并返回这个文件对象
os.fpathconf(fd, name)	返回一个打开的文件的系统配置信息。`name`为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
os.fstat(fd)	返回文件描述符`fd`的状态，像`stat()`。
os.fstatvfs(fd)	返回包含文件描述符`fd`的文件的文件系统的信息，像 `statvfs()`
os.fsync(fd)	强制将文件描述符为`fd`的文件写入硬盘。
os.ftruncate(fd, length)	裁剪文件描述符`fd`对应的文件, 所以它最大不能超过文件大小。
os.getcwd()	返回当前工作目录
os.getcwdu()	返回一个当前工作目录的`Unicode`对象
os.isatty(fd)	如果文件描述符`fd`是打开的，同时与`tty(-like)`设备相连，则返回`true`, 否则`False`。
os.lchflags(path, flags)	设置路径的标记为数字标记，类似 `chflags()`，但是没有软链接
os.lchmod(path, mode)	修改连接文件权限
os.lchown(path, uid, gid)	更改文件所有者，类似 `chown`，但是不追踪链接。
os.link(src, dst)	创建硬链接，名为参数 `dst`，指向参数 `src`
os.listdir(path)	返回`path`指定的文件夹包含的文件或文件夹的名字的列表，`[d for d in os.listdir('.')]`。
os.lseek(fd, pos, how)	设置文件描述符 `fd`当前位置为`pos`, `how`方式修改： `SEEK_SET` 或者 0 设置从文件开始的计算的`pos`； `SEEK_CUR`或者 1 则从当前位置计算； `os.SEEK_END`或者2则从文件尾部开始。在`unix`，`Windows`中有效。
os.lstat(path)	像`stat()`，但是没有软链接
os.major(device)	从原始的设备号中提取设备`major`号码 (使用`stat`中的`st_dev`或者`st_rdev field`)。
os.makedev(major, minor)	以`major`和`minor`设备号组成一个原始设备号
os.makedirs(path[, mode])	递归文件夹创建函数。像`mkdir()`, 但创建的所有`intermediate-level`文件夹需要包含子文件夹。
os.minor(device)	从原始的设备号中提取设备`minor`号码 (使用`stat`中的`st_dev`或者`st_rdev field` )。
os.mkdir(path[, mode])	以数字`mode`的`mode`创建一个名为`path`的文件夹.默认的 `mode` 是 `0777` (八进制)。
os.mkfifo(path[, mode])	创建命名管道，`mode` 为数字，默认为 `0666` (八进制)
os.mknod(filename[, mode=0600, device])	创建一个名为`filename`文件系统节点（文件，设备特别文件或者命名`pipe`）。
os.open(file, flags[, mode])	打开一个文件，并且设置需要的打开选项，`mode`参数是可选的
os.openpty()	打开一个新的伪终端对。返回 `pty` 和 `tty`的文件描述符。
os.pathconf(path, name)	返回相关文件的系统配置信息。
os.pipe()	创建一个管道. 返回一对文件描述符`(r, w)` 分别为读和写
os.popen(command[, mode[, bufsize]])	从一个 `command` 打开一个管道
os.read(fd, n)	从文件描述符 `fd` 中读取最多 `n` 个字节，返回包含读取字节的字符串，文件描述符 `fd`对应文件已达到结尾, 返回一个空字符串。
os.readlink(path)	返回软链接所指向的文件
os.remove(path)	删除路径为`path`的文件。如果`path` 是一个文件夹，将抛出`OSError`; 查看下面的`rmdir()`删除一个 `directory`。
os.removedirs(path)	递归删除目录。
os.rename(src, dst)	重命名文件或目录，从 `src` 到 `dst`
os.renames(old, new)	递归地对目录进行更名，也可以对文件进行更名。
os.rmdir(path)	删除path指定的空目录，如果目录非空，则抛出一个`OSError`异常。
os.stat(path)	获取`path`指定的路径的信息，功能等同于C API中的`stat()`系统调用。
os.stat_float_times([newvalue])	决定`stat_result`是否以`float`对象显示时间戳
os.statvfs(path)	获取指定路径的文件系统统计信息
os.symlink(src, dst)	创建一个软链接
os.tcgetpgrp(fd)	返回与终端`fd`（一个由`os.open()`返回的打开的文件描述符）关联的进程组
os.tcsetpgrp(fd, pg)	设置与终端`fd`（一个由`os.open()`返回的打开的文件描述符）关联的进程组为pg。
os.ttyname(fd)	返回一个字符串，它表示与文件描述符`fd` 关联的终端设备。如果`fd` 没有与终端设备关联，则引发一个异常。
os.unlink(path)	删除文件路径
os.utime(path, times)	返回指定的`path`文件的访问和修改的时间。
os.walk(top[, topdown=True[, None[, followlinks=False]]])	输出在文件夹中的文件名通过在树中游走，向上或者向下。
os.write(fd, str)	写入字符串到文件描述符 `fd`中. 返回实际写入的字符串长度
os.path 模块	获取文件的属性信息。

datetime模块

datatime模块重新封装了time模块，提供更多接口，提供的类有：date,time,datetime,timedelta,tzinfo。

datetime.date(year, month, day)；
datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ) ；
datetime相当于date和time结合起来，datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )；
使用timedelta可以很方便的在日期上做天days、小时hour、分钟、秒、毫秒、微秒的时间计算；
tzinfo是关于时区信息的类。

类和对象

类(Class)：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。对象可以包含任意数量和类型的数据。类对象支持两种操作：属性引用和实例化。

类的专有方法：

方法	描述
__init__	构造函数，在生成对象时调用
__del__	析构函数，释放对象时使用
__repr__	打印，转换
__setitem__	按照索引赋值
__getitem__	按照索引获取值
__len__	获得长度
__cmp__	比较运算
__call__	函数调用
__add__	加运算
__sub__	减运算
__mul__	乘运算
__truediv__	除运算
__mod__	求余运算
__pow__	乘方

正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re模块

正则表达式是用来匹配处理字符串的，python 中使用正则表达式需要引入re模块。

re.match：

re.match从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。re.match(pattern, string, flags=0)，pattern：匹配的正则表达式；string：要匹配的字符串；flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等。

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配

输出：

(0, 3)
None

实例：

import re
line = "Cats are smarter than dogs"
# .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I) # re.M将字符串视为多行；re.I 忽略大小写
# (.*) 第一个匹配分组，.*代表匹配除换行符之外的所有字符
# (.*?)第二个匹配分组，.*?后面多个问号，代表非贪婪模式，也就是说只匹配符合条件的最少字符
# 后面的一个.*  没有括号包围，所以不是分组，匹配效果和第一个一样，但是不计入匹配结果中
if matchObj:
   print ("matchObj.group() : ", matchObj.group()) # matchObj.group() 等同于matchObj.group(0)，表示匹配到的完整文本字符
   print ("matchObj.group(1) : ", matchObj.group(1)) # matchObj.group(1) 得到第一组匹配结果，也就是(.*)匹配到的
   print ("matchObj.group(2) : ", matchObj.group(2)) # matchObj.group(2) 得到第二组匹配结果，也就是(.*?)匹配到的
else:
   print ("No match!!")

输出：

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

re.search：

re.search 扫描整个字符串并返回第一个成功的匹配，re.search(pattern, string, flags=0)。

import re
print(re.search('www', 'www.runoob.com').span()) # 在起始位置匹配
print(re.search('com', 'www.runoob.com').span())  # 不在起始位置匹配

输出：

(0, 3)
(11, 14)

实例：

import re
line = "Cats are smarter than dogs";
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
if searchObj:
   print ("searchObj.group() : ", searchObj.group())
   print ("searchObj.group(1) : ", searchObj.group(1))
   print ("searchObj.group(2) : ", searchObj.group(2))
else:
   print ("Nothing found!!")

输出：

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

re.match与re.search的区别：
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

import re
line = "Cats are smarter than dogs";
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print ("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print ("search --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

输出：

No match!!
search --> matchObj.group() :  dogs

re.sub用于替换字符串中的匹配项：
re.sub(pattern, repl, string, count=0)，pattern：正则中的模式字符串；repl：替换的字符串，也可为一个函数；string：要被查找替换的原始字符串；count：模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

import re
phone = "2004-959-559 # 这是一个电话号码"
# 删除注释，$匹配一行的结束
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num) 
# 移除非数字的内容，\D 匹配一个非数字字符
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num)

repl 参数是一个函数。

import re
# 将匹配的数字乘于 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s)) # (?P)为命名捕获，名称为value；\d 表示匹配的是数字 + 表示重复一次或者多次 * 表示重复零次或者多次

输出：A46G8HFD1134。

compile 函数：
re.compile(pattern[, flags])用于编译正则表达式，生成一个正则表达式 Pattern 对象，供 match() 和 search() 这两个函数使用。

标志位	描述
re.I	忽略大小写
re.L	表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M	多行模式
re.S	即为’ . ‘并且包括换行符在内的任意字符（’ . '不包括换行符）
re.U	表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X	为了增加可读性，忽略空格和’ # '后面的注释

http请求

HTTP头部的格式如下：HTTP 字段名: 字段内容，如：Content-type: text/html。

扫描二维码关注公众号，回复： 5469403 查看本文章

头	描述
Content-type:	请求的与实体对应的`MIME`信息。例如: `Content-type:text/html`
Expires: Date	响应过期的日期和时间
Location: URL	用来重定向接收方到非请求`URL`的位置来完成请求或标识新的资源
Last-modified: Date	请求资源的最后修改时间
Content-length: N	请求的内容长度
Set-Cookie: String	设置`Http Cookie`