我正在进行文本处理并使用“readline()”函数，如下所示：ifd = open(...)
for line in ifd:
while (condition)
do something...
line = ifd.readline()
condition = ....
当条件变为false时，我需要倒带指针，以便“for”循环再次读取同一行。在
在ifd.fseek公司()后面跟readline是给我一个'\n'字符。如何倒带指针，以便重新读取整行。在
^{pr2}$
这是我的代码labtestnames = sorted(tmp)
#Now read each line in the inFile and write into outFile
ifd = open(inFile, "r")
ofd = open(outFile, "w")
#read the header
header = ifd.readline() #Do nothing with this line. Skip
#Write header into the output file
nl = "mrn\tspecimen_id\tlab_number\tlogin_dt\tfluid"
offset = len(nl.split("\t"))
nl = nl + "\t" + "\t".join(labtestnames)
ofd.write(nl+"\n")
lenFields = len(nl.split("\t"))
print "Reading the input file and converting into modified file for further processing (correlation analysis etc..)"
prevTup = (0,0,0)
rowComplete = 0
k=0
for line in ifd:
k=k+1
if (k==200): break
items = line.rstrip("\n").split("\t")
if((items[0] =='')):
continue
newline= list('' for i in range(lenFields))
newline[0],newline[1],newline[3],newline[2],newline[4] = items[0], items[1], items[3], items[2], items[4]
ltests = []
ltvals = []
while(cmp(prevTup, (items[0], items[1], items[3])) == 0): # If the same mrn, lab_number and specimen_id then fill the same row. else create a new row.
ltests.append(items[6])
ltvals.append(items[7])
pos = ifd.tell()
line = ifd.readline()
prevTup = (items[0], items[1], items[3])
items = line.rstrip("\n").split("\t")
rowComplete = 1
if (rowComplete == 1): #If the row is completed, prepare newline and write into outfile
indices = [labtestnames.index(x) for x in ltests]
j=0
ifd.seek(pos)
for i in indices:
newline[i+offset] = ltvals[j]
j=j+1
if (rowComplete == 0): #
currTup = (items[0], items[1], items[3])
ltests = items[6]
ltvals = items[7]
pos = ifd.tell()
line = ifd.readline()
items = line.rstrip("\n").split("\t")
newTup = (items[0], items[1], items[3])
if(cmp(currTup, newTup) == 0):
prevTup = currTup
ifd.seek(pos)
continue
else:
indices = labtestnames.index(ltests)
newline[indices+offset] = ltvals
ofd.write(newline+"\n")

文章目录
每日测验(默写上节课课堂代码)
昨日内容回顾
今日内容概要
今日内容详细
x模式
b模式
文件拷贝工具(b模式的运用)
反面教材版，一次性读入
正确版本，循环读取文件
文件操作的其他方法
读相关操作
1、readline：一次读一行
2、readlines：读取所有行
写相关操作
writelines
flush：
了解的方法
控制文件指针的移动
移动单位，模式
示范
作业

每日测验(默写上节课课堂代码)
1、注册功能
    用户输入账号密码，按照"egon:18"的格式存入文件
2、基于上述注册信息，完成验证功能
    即用户验证的账号密码来源于文件
    验证成功打印login sucessful
    验证错误输出账号or密码错误

3、编写文本文件copy程序
    with open(r'源文件',mode='rt',encoding='utf-8') as f1,\
        open(r'目标文件',mode='wt',encoding='utf-8') as f2:

        # data=f1.read()
        # f2.write(data)

        for line in f1:
            f2.write(line)

昨日内容回顾
1、什么是文件
    用户/应用程序（f=open(),获得文件对象/文件句柄）
    操作系统（文件）
    计算机硬件（硬盘）
2、为何要用文件
    用于应用程序操作硬盘，永久保存数据，或者从硬盘读数据

3、如何用
    f=open(r'C:\new_dir\a.txt',mode='r+t',encoding='gbk')
    res=f.read() # 读出硬盘的二进制（gbk）->t控制将二进制转换unicode->字符
    print(res)
    # f.write()
    f.close()
    print(f)
    f.read() # 抛出异常

    with open(...) as f,open(...) as f1:
        code1
        code2
        code3

今日内容概要
1、文件模式
    x模式（控制文件操作的模式）-》了解
        x， 只写模式【不可读；不存在则创建，存在则报错】

    b模式补充（控制文件读写内容的模式）
            bytes类型转换
                x=10 # int(10)
                '你'.encode('gbk') # bytes()

2、文件的操作的其他方法

3、文件的高级操作：控制文件指针的移动

今日内容详细
x模式
x模式（控制文件操作的模式）-》了解

x， 只写模式【不可读；不存在则创建，存在则报错】

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

with open('c.txt', mode='x', encoding='utf-8') as f:
    f.read()

with open('d.txt', mode='x', encoding='utf-8') as f:
    f.write('哈哈哈\n')


b模式
控制文件读写内容的模式
t：
	1、读写都是以字符串（unicode）为单位
	2、只能针对文本文件
	3、必须指定字符编码，即必须指定encoding参数
b：binary模式
	1、读写都是以bytes为单位
	2、可以针对所有文件
	3、一定不能指定字符编码，即一定不能指定encoding参数

总结：
1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便
2、针对非文本文件（如图片、视频、音频等）只能使用b模式

错误演示：t模式只能读文本文件

with open(r'爱nmlgb的爱情.mp4', mode='rt') as f:
    f.read()  # 硬盘的二进制读入内存-》t模式会将读入内存的内容进行decode解码操作

b模式演示
with open(r'test.jpg', mode='rb', encoding='utf-8') as f:
    res = f.read()  # 硬盘的二进制读入内存—>b模式下，不做任何转换，直接读入内存
    print(res)  # bytes类型
    print(type(res))

with open(r'd.txt', mode='rb') as f:
    res = f.read()  # utf-8的二进制
    print(res, type(res))

    print(res.decode('utf-8'))


with open(r'd.txt', mode='rt', encoding='utf-8') as f:
    res = f.read()  # utf-8的二进制->unicode
    print(res)


with open(r'e.txt', mode='wb') as f:
    f.write('你好hello'.encode('gbk'))

with open(r'f.txt', mode='wb') as f:
    f.write('你好hello'.encode('utf-8'))
    f.write('哈哈哈'.encode('gbk'))


文件拷贝工具(b模式的运用)
反面教材版，一次性读入
src_file = input('源文件路径>>: ').strip()
dst_file = input('源文件路径>>: ').strip()
with open(r'{}'.format(src_file), mode='rb') as f1,\
        open(r'{}'.format(dst_file), mode='wb') as f2:
    # res=f1.read() # 内存占用过大
    # f2.write(res)

    for line in f1:
        f2.write(line)

正确版本，循环读取文件
方式一：自己控制每次读取的数据的数据量
with open(r'test.jpg', mode='rb') as f:
    while True:
        res = f.read(1024)  
        if len(res) == 0:
            break
        print(len(res))


方式二：以行为单位读，当一行内容过长时会导致一次性读入内容的数据量过大
with open(r'g.txt', mode='rt', encoding='utf-8') as f:
    for line in f:
        print(len(line), line)

with open(r'g.txt', mode='rb') as f:
    for line in f:
        print(line)

with open(r'test.jpg', mode='rb') as f:
    for line in f:
        print(line)

文件操作的其他方法
读相关操作
1、readline：一次读一行
with open(r'g.txt', mode='rt', encoding='utf-8') as f:
    # res1=f.readline()
    # res2=f.readline()
    # print(res2)

    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print(line)

2、readlines：读取所有行
with open(r'g.txt', mode='rt', encoding='utf-8') as f:
    res = f.readlines()
    print(res)	

强调：
f.read()与f.readlines()都是将内容一次性读入内存，如果内容过大会导致内存溢出，若还想将内容全读入内存，

写相关操作
writelines
方法用于向文件中写入一序列的字符串。
这一序列字符串可以是由迭代对象产生的，如一个字符串列表。
换行需要制定换行符 \n。

with open('h.txt', mode='wt', encoding='utf-8') as f:
    # f.write('1111\n222\n3333\n')

    # l=['11111\n','2222','3333',4444]
    l = ['11111\n', '2222', '3333']
    # for line in l:
    #     f.write(line)
    f.writelines(l)

with open('h.txt', mode='wb') as f:
    # l = [
    #     '1111aaa1\n'.encode('utf-8'),
    #     '222bb2'.encode('utf-8'),
    #     '33eee33'.encode('utf-8')
    # ]

    # 补充1：如果是纯英文字符，可以直接加前缀b得到bytes类型
    # l = [
    #     b'1111aaa1\n',
    #     b'222bb2',
    #     b'33eee33'
    # ]

    # 补充2：'上'.encode('utf-8') 等同于bytes('上',encoding='utf-8')
    l = [
        bytes('上啊', encoding='utf-8'),
        bytes('冲呀', encoding='utf-8'),
        bytes('小垃圾们', encoding='utf-8'),
    ]
    f.writelines(l)

flush：
用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入。

一般情况下，文件关闭后会自动刷新缓冲区，但有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。

with open('h.txt', mode='wt', encoding='utf-8') as f:
    f.write('哈')
    f.flush()


了解的方法
with open('h.txt', mode='wt', encoding='utf-8') as f:
    print(f.readable()) # False
    print(f.writable()) # True
    print(f.encoding) # utf-8
    print(f.name) # h.txt

print(f.closed) # True

控制文件指针的移动
移动单位，模式
指针移动的单位都是以bytes/字节为单位
只有一种情况特殊：
t模式下的read(n), n代表的是字符个数

with open('aaa.txt', mode='rt', encoding='utf-8') as f:
    res = f.read(4)
    print(res)

f.seek(n, 模式): n指的是移动的字节个数
模式：
模式0：参照物是文件开头位置
f.seek(9, 0)
f.seek(3, 0)  # 3

模式1：参照物是当前指针所在位置
f.seek(9, 1)
f.seek(3, 1)  # 12

模式2：参照物是文件末尾位置，应该倒着移动
f.seek(-9, 2)  # 3
f.seek(-3, 2)  # 9

强调：只有0模式可以在t下使用，1、2必须在b模式下用

f.tell()  # 获取文件指针当前位置

示范
with open('aaa.txt', mode='rb') as f:
    f.seek(9, 0)
    f.seek(3, 0)  # 3
    # print(f.tell())
    f.seek(4, 0)
    res = f.read()
    print(res.decode('utf-8'))


with open('aaa.txt', mode='rb') as f:
    f.seek(9, 1)
    f.seek(3, 1)  # 12
    print(f.tell())


with open('aaa.txt', mode='rb') as f:
    f.seek(-9, 2)
    # print(f.tell())
    f.seek(-3, 2)
    # print(f.tell())
    print(f.read().decode('utf-8'))


作业
1、通用文件copy工具实现

2、基于seek控制指针移动，测试r+、w+、a+模式下的读写内容

3、tail -f access.log程序实现

4、周末作业参考在老师讲解完毕后（下午17：30开始讲解），练习熟练，明早日考就靠他俩
  4.1：编写用户登录接口
  4.2：编写程序实现用户注册后（注册到文件中），可以登录（登录信息来自于文件）

c++智能指针介绍

由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete，比如流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见，并造成内存泄露。如此c++引入 智能指针 ，智能指针即是C++
 RAII的一种应用，可用于动态资源管理，资源即对象的管理策略。 智能指针在 <memory>标头文件的 std 命名空间中定义。 它们对 RAII 或 获取资源即初始化 编程惯用法至关重要。 RAII 的主要原则是为所有堆分配资源提供所有权，例如动态分配内存或系统对象句柄、析构函数包含要删除或释放资源的代码的堆栈分配对象，以及任何相关清理代码。

c++智能指针类别

c++ 智能指针主要包括：unique_ptr,shared_ptr, weak_ptr, 这三种，其中auto_ptr 已被遗弃。 


unique_ptr 

只允许基础指针的一个所有者。 可以移到新所有者(具有移动语义)，但不会复制或共享（即我们无法得到指向同一个对象的两个unique_ptr）。 替换已弃用的 auto_ptr。 相较于 boost::scoped_ptr。 unique_ptr 小巧高效；大小等同于一个指针，支持 rvalue 引用，从而可实现快速插入和对 STL 集合的检索。 头文件：<memory>。

使用unique_ptr，可以实现以下功能：

1、为动态申请的内存提供异常安全。 

2、将动态申请内存的所有权传递给某个函数。 

3、从某个函数返回动态申请内存的所有权。

4、在容器中保存指针。 

5、所有auto_ptr应该具有的（但无法在C++ 03中实现的）功能。 


如下代码所示：
class A;
// 如果程序执行过程中抛出了异常，unique_ptr就会释放它所指向的对象
// 传统的new 则不行
unique_ptr<A> fun1()
{
	unique_ptr p(new A);
	//do something
	return p;
}

void fun2()
{   //  unique_ptr具有移动语义
	unique_ptr<A> p = f();// 使用移动构造函数
	// do something
}// 在函数退出的时候，p以及它所指向的对象都被删除释放
 shared_ptr 
采用引用计数的智能指针。 shared_ptr基于“引用计数”模型实现，多个shared_ptr可指向同一个动态对象，并维护了一个共享的引用计数器，记录了引用同一对象的shared_ptr实例的数量。当最后一个指向动态对象的shared_ptr销毁时，会自动销毁其所指对象(通过delete操作符)。shared_ptr的默认能力是管理动态内存，但支持自定义的Deleter以实现个性化的资源释放动作。头文件：<memory>。 


基本操作：shared_ptr的创建、拷贝、绑定对象的变更(reset)、shared_ptr的销毁(手动赋值为nullptr或离开作用域)、指定deleter等操作。

 shared_ptr的创建,有两种方式，一，使用函数make_shared(会根据传递的参数调用动态对象的构造函数)；二，使用构造函数(可从原生指针、unique_ptr、另一个shared_ptr创建) 

shared_ptr<int> p1 = make_shared<int>(1);// 通过make_shared函数
    shared_ptr<int> p2(new int(2));// 通过原生指针构造
此外智能指针若为“空“，即不指向任何对象，则为false，否则为true，可作为条件判断。可以通过两种方式指定deleter，一是构造shared_ptr时，二是使用reset方法时。可以重载的operator->,
 operator *，以及其他辅助操作如unique()、use_count(), get()等成员方法。 


 weak_ptr 

结合 shared_ptr 使用的特例智能指针。 weak_ptr 提供对一个或多个 shared_ptr 实例所属对象的访问，但是，不参与引用计数。 如果您想要观察对象但不需要其保持活动状态，请使用该实例。 在某些情况下需要断开 shared_ptr 实例间的循环引用。 头文件：<memory>。 


weak_ptr的用法如下：

weak_ptr用于配合shared_ptr使用，并不影响动态对象的生命周期，即其存在与否并不影响对象的引用计数器。weak_ptr并没有重载operator->和operator *操作符，因此不可直接通过weak_ptr使用对象。提供了expired()与lock()成员函数，前者用于判断weak_ptr指向的对象是否已被销毁，后者返回其所指对象的shared_ptr智能指针(对象销毁时返回”空“shared_ptr)。循环引用的场景：如二叉树中父节点与子节点的循环引用，容器与元素之间的循环引用等。 


智能指针的循环引用

循环引用问题可以参考 这个链接 上的问题理解，“循环引用”简单来说就是：两个对象互相使用一个shared_ptr成员变量指向对方的会造成循环引用。导致引用计数失效。下面给段代码来说明循环引用：
#include <iostream>
#include <memory>
using namespace std;

class B;
class A
{
public:// 为了省去一些步骤这里 数据成员也声明为public
	//weak_ptr<B> pb;
	shared_ptr<B> pb;
	void doSomthing()
	{
//		if(pb.lock())
//		{
//
//		}
	}

	~A()
	{
		cout << "kill A\n";
	}
};

class B
{
public:
	//weak_ptr<A> pa;
	shared_ptr<A> pa;
	~B()
	{
		cout <<"kill B\n";
	}
};

int main(int argc, char** argv)
{
	shared_ptr<A> sa(new A());
	shared_ptr<B> sb(new B());
	if(sa && sb)
	{
		sa->pb=sb;
		sb->pa=sa;
	}
	cout<<"sa use count:"<<sa.use_count()<<endl;
	return 0;
}
上面的代码运行结果为：sa use count:2， 注意此时sa,sb都没有释放，产生了内存泄露问题！！！

即A内部有指向B，B内部有指向A，这样对于A，B必定是在A析构后B才析构，对于B，A必定是在B析构后才析构A，这就是循环引用问题，违反常规，导致内存泄露。

一般来讲，解除这种循环引用有下面有三种可行的方法( 参考 )： 
1 . 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。 
2 . 当A的生存期超过B的生存期的时候，B改为使用一个普通指针指向A。 
3 . 使用弱引用的智能指针打破这种循环引用。 

虽然这三种方法都可行，但方法1和方法2都需要程序员手动控制，麻烦且容易出错。我们一般使用第三种方法：弱引用的智能指针weak_ptr。 


强引用和弱引用 

一个强引用当被引用的对象活着的话，这个引用也存在（就是说，当至少有一个强引用，那么这个对象就不能被释放）。share_ptr就是强引用。相对而言，弱引用当引用的对象活着的时候不一定存在。仅仅是当它存在的时候的一个引用。弱引用并不修改该对象的引用计数，这意味这弱引用它并不对对象的内存进行管理，在功能上类似于普通指针，然而一个比较大的区别是，弱引用能检测到所管理的对象是否已经被释放，从而避免访问非法内存。 


使用weak_ptr来打破循环引用 


代码如下：
#include <iostream>
#include <memory>
using namespace std;

class B;
class A
{
public:// 为了省去一些步骤这里 数据成员也声明为public
	weak_ptr<B> pb;
	//shared_ptr<B> pb;
	void doSomthing()
	{
		if(pb.lock())
		{

		}
	}

	~A()
	{
		cout << "kill A\n";
	}
};

class B
{
public:
	//weak_ptr<A> pa;
	shared_ptr<A> pa;
	~B()
	{
		cout <<"kill B\n";
	}
};

int main(int argc, char** argv)
{
	shared_ptr<A> sa(new A());
	shared_ptr<B> sb(new B());
	if(sa && sb)
	{
		sa->pb=sb;
		sb->pa=sa;
	}
	cout<<"sb use count:"<<sb.use_count()<<endl;
	return 0;
}

参考：

http://msdn.microsoft.com/zh-cn/library/hh279674.aspx

http://www.dewen.org/q/8560/%E5%85%B3%E4%BA%8E%E9%81%BF%E5%85%8D%E5%BE%AA%E7%8E%AF%E5%BC%95%E7%94%A8 

'''
open_demos.py

（open()/获取File文件对象；
File文件对象相关属性及方法：File.read()/readline()/readlines()/write()/writelines()；
File文件指针：File.tell()、File.seek(offse,whence)；
File文件对象迭代器：可迭代/循环/list/序列解包等；
上下文管理器：实现__enter__() 和 __exit__() 两个魔法方法）



使用：

####################
#打开文件 获取 文件对象File

#####
#使用：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
#来打开 参数file文件 并返回一个流stream即_io.TextIOWrapper类对象。失败时提出OSError。

#参数file        : 要创建或打开文件的文件名称，该名称要用引号（单引号或双引号都可以）括起来。
#参数mode='r'    : 可选参数，用于指定文件的打开模式。默认以只读（r）模式打开文件。
#注意：参数mode='r'文件打开模式，直接决定了后续可以对文件做哪些操作。
#例如，使用 r 模式打开的文件，后续编写的代码只能读取文件，而无法改动文件内容。


####################
#File文件对象 相关属性、方法

#####
#使用：File.encoding 来获取对象的编码方式
#使用：File.mode     来获取对象的打开模式
#使用：File.closed   来获取对象是否处于关闭状态，返回布尔值
#使用：File.name     来获取对象打开的文件名

#####
#使用：File.read([size]) 来读取文件对象File的内容。
#参数size: 用于指定要读取的字符/字节的数量。默认一次性读取所有内容字符/字节
#注意：（File文件对象打开模式为 b 二进制则按字节读取，其他模式则按字符读取）

#####
#使用：File.readline([size]) 来读取File文件对象的一行。
#参数size: 用于指定读取一行时最多读取的字符/字节 的数量。
#注意：（File文件对象打开模式为 B 二进制则按字节读取，其他模式则按字符读取）
#注意：File.readline()会连行尾的换行符一块读取。

#####
#使用：File.readlines([size]) 来读取File文件对象中的所有行。
#参数size: 用于指定返回 size行 的列表，默认返回全部所有行。

#注意：File.readlines([size]) 和调用不指定 size 参数的 File.read() 函数类似，只是返回类型不同，一个是列表，一个是str
#注意：File.readlines([size]) 返回是一个字符串列表，其中每个元素为文件中的一行内容。
#注意：readline() 函数一样，readlines() 函数在读取每一行时，会连同行尾的换行符一块读取。

#####
#使用：File.write(string) 来在File文件对象中写入 参数string 内容。
#参数string: 表示要写入文件的字符串，也可以是二进制数据。
#注意：File是一个已经打开的文件对象。

#####
#使用：File.writelines([str]) 来将 字符串列表/序列 写入到File文件对象中。
#参数str: 表示要写入文件的字符串序列。

#####
#使用：File.close() 来将open()已经打开的File文件对象关闭。
#注意：如果打开的文件对象File不进行close()操作的话，会影响 譬如 os.remove('b.txt') 删除文件等的操作


####################
#File文件指针File.tell()/File.seek(offse,whence)  

##### 
#使用：File.tell() 来判断文件指针当前所处的位置。

#使用：File.seek(offset,whence) 来移动文件指针到指定位置。
#参数offset: 表示偏移量，+正数表示向后偏移，-负数表示向前偏移。
#参数whence: 可选参数0/1/2，指定文件指针的放置位置。三个选择：0 代表文件头（默认值）、1 代表当前位置、2 代表文件尾。

#注意：File文件对象以 b 模式打开，每个数据就是一个字节；以普通模式打开，每个数据就是一个字符。


####################
#File文件对象迭代器
#open()读取后的File文件对象 可以被当做 迭代器 来使用，可循环，可操作，可list、序列解包、多重赋值等

#####
#使用：list 或 for循环等迭代 可作用于File文件对象
#来将文件转换成字符串列表，效果等同于 File.readlines()

#####
#使用：print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
#参数file：实现将 参数value 写入输出到 参数file文件中 的操作

#####
#使用：多重赋值 可作用于File文件对象


####################
#使用：上下文管理器，即：同时包含__enter__() 和 __exit__() 两个魔法方法的对象就是上下文管理器，
#上下文管理器 可以通过使用 with as 语句来管理。
#参考链接：http://c.biancheng.net/view/5319.html

#__enter__(self)
#__exit__（self, exc_type, exc_value, exc_traceback）
#参数exc_traceback：判断其是否为None，即可判断出 with 代码块执行时是否遇到了异常。
'''



# =============================================================================
# #open()
# #open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
# #open() 函数位于自动导入的模块_io中
# =============================================================================

help(open)
####################
#打开文件 获取 文件对象

#####
#使用：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
#来打开 参数file文件 并返回一个流stream即_io.TextIOWrapper类对象。失败时提出OSError。

#参数file        : 要创建或打开文件的文件名称，该名称要用引号（单引号或双引号都可以）括起来。
#参数mode='r'    : 可选参数，用于指定文件的打开模式。默认以只读（r）模式打开文件。
#注意：参数mode='r'文件打开模式，直接决定了后续可以对文件做哪些操作。
#例如，使用 r 模式打开的文件，后续编写的代码只能读取文件，而无法改动文件内容。
"""
#注意：open(file, mode='r') 函数中 参数mode='r'支持的打开模式有如下类型：
#------------------------------------------------------------------------------
模式	    意义	                                                    注意事项
r	    只读模式打开文件，读文件内容的指针会放在文件的开头。	    注意：操作的文件必须存在。
rb	    以二进制格式、采用只读模式打开文件，读文件内容的指针位于文件的开头，一般用于非文本文件，如图片文件、音频文件等。
r+	    打开文件后，既可以从头读取文件内容，也可以从开头向文件中写入新的内容，写入的新内容会覆盖文件中等长度的原有内容。
rb+	    以二进制格式、采用读写模式打开文件，读写文件的指针会放在文件的开头，通常针对非文本文件（如音频文件）。
w	    以只写模式打开文件，若该文件存在，打开时会清空文件中原有的内容。	若文件存在，会清空其原有内容（覆盖文件）；反之，则创建新文件。
wb	    以二进制格式、只写模式打开文件，一般用于非文本文件（如音频文件）
w+	    打开文件后，会对原有内容进行清空，并对该文件有读写权限。
wb+	    以二进制格式、读写模式打开文件，一般用于非文本文件
a	    以追加模式打开一个文件，对文件只有写入权限，如果文件已经存在，文件指针将放在文件的末尾（即新写入内容会位于已有内容之后）；反之，则会创建新文件。	 
ab	    以二进制格式打开文件，并采用追加模式，对文件只有写权限。如果该文件已存在，文件指针位于文件末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。	 
a+	    以读写模式打开文件；如果文件存在，文件指针放在文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。	 
ab+	    以二进制模式打开文件，并采用追加模式，对文件具有读写权限，如果文件存在，则文件指针位于文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。
#------------------------------------------------------------------------------
"""
#参数buffing=-1  : 可选参数，用于指定对文件做读写操作时，是否使用缓冲区。
#如果 buffering 的值被设为 0，就不会有寄存。
#如果 buffering 的值取 1，访问文件时会寄存行。
#如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。
#如果取负值，寄存区的缓冲大小则为系统默认。

#参数encoding=None: 指定打开文件的编码格式，默认为GBK编码。
file=open(r'open_cases\open_case1_testOpen_A.txt','w+',-1,encoding='utf-8')   #指定打开模式 w+ 为新建读写模式，若无则创建，若存在则替换覆盖
type(file)
file.write('这里是第一次写入内容')            #write()方法按行写入内容
#print(file)                                 #通过file.reade()等读取方法才能输出内容
file.close()


####################
#文件对象 相关属性、方法

#####
#使用：File.encoding 来获取对象的编码方式
#使用：File.mode     来获取对象的打开模式
#使用：File.closed   来获取对象是否处于关闭状态，返回布尔值
#使用：File.name     来获取对象打开的文件名


#####
#使用：File.read([size]) 来读取文件对象File的内容。
#参数size: 用于指定要读取的字符/字节的数量。默认一次性读取所有内容字符/字节
#注意：（File文件对象打开模式为 b 二进制则按字节读取，其他模式则按字符读取）
help(open)
help(print)

f=open(r'open_cases\open_case1_testOpen_A.txt','r',True,encoding='utf-8')
while True:
    ch=f.read(1)                #读取一个字符/字节，循环一直读取。#注意：（File文件对象打开模式为 B 二进制则按字节读取，其他模式则按字符读取）
    if not ch:                  #如果读取不到内容，则退出；否则输出读取的内容。
        break
    print(ch,end='')            #自定义结束字符串为 空  以此输出原文原样。默认为换行符
f.close()

f=open(r'open_cases\open_case1_testOpen_A.txt','r',True,encoding='utf-8')
print(f.read())                 #File.read()参数size为空则默认读取所有字符/字节。
f.close()

f=open(r'open_cases\open_case1_testOpen_A.txt','rb',True)#用二进制模式打开文件，获取得到bytes文件对象
print(f.read().decode('GBK'))   #open()的默认encoding='GBK',注意需要一致编解码。
f.close()

#####
#使用：File.readline([size]) 来读取File文件对象的一行。
#参数size: 用于指定读取一行时最多读取的字符/字节 的数量。
#注意：（File文件对象打开模式为 B 二进制则按字节读取，其他模式则按字符读取）
#注意：File.readline()会连行尾的换行符一块读取。
f=open(r'open_cases\open_case1_testOpen_A.txt','r',encoding='utf-8')
print(f.readline(1))
f.close()

#####
#使用：File.readlines([size]) 来读取File文件对象中的所有行。
#参数size: 用于指定返回 size行 的列表，默认返回全部所有行。

#注意：File.readlines([size]) 和调用不指定 size 参数的 File.read() 函数类似，只是返回类型不同，一个是列表，一个是str
#注意：File.readlines([size]) 返回是一个字符串列表，其中每个元素为文件中的一行内容。
#注意：readline() 函数一样，readlines() 函数在读取每一行时，会连同行尾的换行符一块读取。
f=open(r'open_cases\open_case1_testOpen_A.txt','r',encoding='utf-8')
print(f.readlines())
f.close()


#####
#使用：File.write(string) 来在File文件对象中写入 参数string 内容。
#参数string: 表示要写入文件的字符串，也可以是二进制数据。
#注意：File是一个已经打开的文件对象。
f=open(r'open_cases\open_case1_testOpen_A.txt','a+',encoding='utf-8')
f.write('\n这是第二次写入数据内容  追加写入')              #注意 a+为追加读写模式在末尾，注意内容自行添加换行符\n
f.close()

f=open(r'open_cases\open_case1_testOpen_A.txt','r',encoding='utf-8')
print(f.read())
f.close()

#####
#使用：File.writelines([str]) 来将 字符串列表/序列 写入到File文件对象中。
#参数str: 表示要写入文件的字符串序列。
f=open(r'open_cases\open_case1_testOpen_A.txt','r',encoding='utf-8')
n=open(r'open_cases\open_case2_testOpen_B.txt','w+',encoding='utf-8')     
n.writelines(f.readlines())                      #readlines()读取文件中的所有行，返回列表结构。  writelines()写入列表结构
n.close()
f.close()


#美化输出
import pprint
pprint.pprint(open(r'open_cases\open_case1_testOpen_A.txt',encoding='utf-8').readlines())


#####
#使用：File.close() 来将open()已经打开的File文件对象关闭。
#注意：如果打开的文件对象File不进行close()操作的话，会影响 譬如 os.remove('b.txt') 删除文件等的操作



####################
#File文件指针File.tell()/File.seek(offse,whence)  

##### 
#使用：File.tell() 来判断文件指针当前所处的位置。

#使用：File.seek(offset,whence) 来移动文件指针到指定位置。
#参数offset: 表示偏移量，+正数表示向后偏移，-负数表示向前偏移。
#参数whence: 可选参数0/1/2，指定文件指针的放置位置。三个选择：0 代表文件头（默认值）、1 代表当前位置、2 代表文件尾。

#注意：File文件对象以 b 模式打开，每个数据就是一个字节；以普通模式打开，每个数据就是一个字符。

f=open(r'open_cases\open_case4_testOpen_D.txt','r',encoding='utf-8')
print(f.tell())            #输出当前文件指针位置
print(f.read(3))           #按行读取字符3个字符
print(f.tell())            #输出当前文件指针位置
f.close() 


f=open(r'open_cases\open_case4_testOpen_D.txt','r',encoding='utf-8')
print(f.tell())            #输出当前文件指针位置
print(f.read(1))           #按行读取1个字节，现文件指针位置在1
print(f.tell())            #输出当前文件指针位置

f.seek(5)                  #设置文件指针位置至 5   
print(f.tell())            #输出当前文件指针位置
print(f.read(1))           #按行读取1个字节
print(f.tell())

f.seek(5,1)                #设置文件指针至 当前指针向后移动5个字节 的位置
print(f.tell())
print(f.read(1))
print(f.tell())

f.seek(-1,2)               #设置文件指针至 文件结尾向前移动1个字节 的位置
print(f.tell())
print(f.read(1))
print(f.tell())
f.close()



####################
#File文件对象迭代器
#open()读取后的File文件对象 可以被当做 迭代器 来使用，可循环，可操作，可list、序列解包、多重赋值等

#####
#使用：list 或 for循环等迭代 可作用于File文件对象
#来将文件转换成字符串列表，效果等同于 File.readlines()
list(open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8'))

with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
    for line in f:
        print(line)

for line in open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8'):
    print(line)

#####
#使用：print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
#参数file：实现将 参数value 写入输出到 参数file文件中 的操作
help(print)
f=open(r'open_cases\open_case4_testOpen_D.txt','w',encoding='utf-8')
print('First','line',file=f)                            #输出内容到指定文件
print('Second','line',file=f)
print('Third','and final','line',file=f)
f.close()

#####
#使用：多重赋值 可作用于File文件对象
first,second,third=open(r'open_cases\open_case4_testOpen_D.txt','r',encoding='utf-8')     #给文件内容的每行进行赋值操作
print(first)
print(second)
print(third)



####################
#使用：上下文管理器，即：同时包含__enter__() 和 __exit__() 两个魔法方法的对象就是上下文管理器，
#上下文管理器 可以通过使用 with as 语句来管理。
#参考链接：http://c.biancheng.net/view/5319.html

#__enter__(self)
#__exit__（self, exc_type, exc_value, exc_traceback）
#参数exc_traceback：判断其是否为None，即可判断出 with 代码块执行时是否遇到了异常。

with open(r'open_cases\open_case5_testOpen_E.txt','a+',encoding='utf-8')  as f:
    f.write('\nPython大法')


#####示例：
#自定义类   实现上下文管理协议的类，并尝试用 with as 语句来管理它：
class FkResource:
    """
    自定义一个实现上下文管理协议的类，并尝试用 with as 语句来管理它.
    只要一个类实现了 __enter__() 和 __exit__() 这 2 个方法，程序就可以使用 with as 语句来管理它，
    
    通过 __exit__() 方法的参数exc_traceback是否为None，即可判断出 with 代码块执行时是否遇到了异常。
    """
    def __init__(self,tag):                                       #初始化构造器方法
        self.tag=tag
        print('构造器，初始化资源：{}'.format(tag))
    def __enter__(self):                                          #定义__enter__魔法方法，即with体之前执行的方法
        print('[__enter__方法: {}]'.format(self.tag))
        return 'fkit'                                             #可以返回任何类型来测试该自建类方法
    def __exit__(self, exc_type, exc_value, exc_traceback):       #定义__exit__魔法方法，即with体之后执行的方法
        print('[__exit__方法: {}]'.format(self.tag))
        """参数exc_traceback    为None，代表没有异常"""
        if exc_traceback is None:                                          
            print('没有异常,关闭资源')
        else:
            print('遇到异常,关闭资源')
            return False                                          #可以省略，默认返回None也被看成是False
with FkResource('孙悟空') as dr:
    print(dr)

#测试异常
with FkResource('白骨精'):
    print('[with代码块]异常之前的代码')
    raise Exception
    print('[with代码块]异常之后的代码----------------不会再显示，因为已经异常')
    





##########
#示例：
#通过readlines()读取全部内容成列表后，修改列表元素，然后添加该列表，形成修改后的新的文本文件

f=open(r'open_cases\open_case1_testOpen_A.txt',encoding='utf-8')
lines=f.readlines()      #读取文件所有行，返回列表结构
f.close()
print(lines)

lines[-1]="通过提取f.readlines()的列表，然后对列表进行赋值操作。所以这里进行了添加和新的修改。"
print(lines)

f=open(r'open_cases\open_case3_testOpen_C.txt','w+',encoding='utf-8')
f.writelines(lines)      #注意 a+为追加读写模式在末尾，添加换行符\n
f.close()


##########
#示例：
#迭代文件内容的多重方式（read,readline,readlines)

#自建虚构的 内容处理函数
def process(string):
    """此函数用作展示，即处理字符或行，可换做其他处理方法"""
    print('Processing: ',string)
    
#通过read方式读取 单个字符 来循环迭代
with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
    char=f.read(1)        
    while char:
        process(char)
        char=f.read(1)
        
with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
    while True:
        char=f.read(1)
        if not char:
            break
        print(char,end='')                      #去除输出结尾的默认换行符，从而达到连续输出的目的。

#通过readline读取 单行 来进行循环迭代 
with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
    while True:
        char=f.readline()
        if not char:
            break
        process(char)
        
#通过read 和 readlines 读取全部内容，来进行循环迭代
with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
    for char in f.read():
        process(char)
        
with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
    for char in f.readlines():
        process(char)