一、打开文件，写入文件，关闭文件，读文件，清空文件内容

f = open('buffer.py','w+')#打开文件，如果没有该文件则新建文件
 f.write(data)#写入文件
 f.close()#关闭文件

file1 = open('/usr/share/openstack-dashboard/openstack_dashboard/dashboards/project/telemetry/buffer.py','w+')#打开文件
a_string =file1.read()#读文件

file1 = open('/usr/share/openstack-dashboard/openstack_dashboard/dashboards/project/telemetry/buffer.py','w+')#打开文件
file1.truncate()#清空文件内容

二、Python中的类和对象、

1.类的好处主要有 方便复用（如果你用函数写，就要复制整块代码，增加了代码量，增加了出错率）方便扩展（函数写段代码，若要升级、扩展，都十分复杂，容易出错，用类来扩展，则方便清晰）方便维护（因为类是把抽象的东西映射成我们常见的，摸得到的东西，容易理解，维护也方便

def dagEar():
    #这里可以放其他制作细节
    print('狗耳朵制作完毕')

def dagEye():
    #这里可以放其他制作细节
    print('狗眼睛制作完毕')

def dagBody():
    #这里可以放其他制作细节
    print('狗身体制作完毕')

def catEar():
    #这里可以放其他制作细节
    print('猫耳朵制作完毕')

def catEye():
    #这里可以放其他制作细节
    print('猫眼睛制作完毕')

def catBody():
    #这里可以放其他制作细节
    print('猫身体制作完毕')

dag Ear()
dag Eye()
dag Body()
cat Ear()
cat Eye()
cat Body()

是不是觉得，狗和猫有相似之处？

如果你学会了，类的用法，可以非常轻松，下面是类的用法
类就像是基因的制造图纸，我们人类，生的小孩，也是两只手，两只脚，一个嘴巴，除非变异，否则不会多出一只脚的，之所以这样有序的发展，是因为我们身体里，有基因这张图纸控制着我们的繁衍现在我们给上面例子中的制作 狗和猫建立一个通用的制作基因表，利用他们相似制作流程 建立基因表

class Animal(object):
    '''
    狗和猫的基类（基因图纸表）
    '''
    def __init__(self, name): # 实例化的时候传入要制作的东西名字，如狗、猫
            self.name = name 
    def Ear(self):
            #这里可以放其他制作细节  
            print(self.name+'的耳朵 制作完毕') 
    def Eye(self):
            #这里可以放其他制作细节  
            print(self.name+'的眼睛 制作完毕')
    def Body(self):
            #这里可以放其他制作细节  
            print(self.name+'的身体 制作完毕')
    def All(self): 
            # 一条龙。直接跑完整个流水线
self.Ear()
self.Eye()
self.Body()

三、‘魔方’方法

Python的魔术方法是Python中那些预定义的像XXX类型的函数。
使用Python的魔术方法的最大优势在于python提供了简单的方法让对象可以表现得像内置类型一样。

str函数

str函数用于处理打印实例本身的时候的输出内容。如果没有覆写该函数，则默认输出一个对象名称和内存地址。
例如：

class Student(object):
     def __init__(self,name):
             self._name = name

print Student()

输出

__main__.Student object at 0x0000000002A929E8

那么我们如何让输出的结果可读性更高一点呢？我们可以覆写str函数。例如

class Student(object):
     def __init__(self, name):
             self._name = name
     def __str__(self):
             return  "I'm a student, named %s" % self._name

print Student("Charlie")

输出结果就是：I'm a student, named Charlie.
我们将str()函数作用于该对象的时候，其实是调用了该对象的str函数。

四、单例模式

new与init的区别：
__new:创建实例对象时调用的构造方法
init：初始化方法，用于设置实例的相关属性
python创建实例时，会先调用new构造方法，然后使用init进行实例初始化。
我们可以通过new来影响实例的创建，从而实现单例。

class A(object):
    __instance = None
    def __new__(cls,*args,**kwargs):
        if not cls. __instance:
            cls.__instance = super().__new__(cls,*args,**kwargs)
        return cls.__instance

a = A()
b = A()
print(a == b)
print(id(a) == id(b))

上面代码中，声明了一个私有类变量__instance,当__instance不为None时，代表系统中已有实例，直接返回该实例，若__instance为None时，表示系统中还没有该类实例，则创建新实例并返回。

五、异常处理

1、try...except
有时候我们写程序的时候，会出现一些错误或异常，导致程序终止。例如，做除法时，除数为0，会引起一个ZeroDivisionError 例子：

a=10
b=0
c=a/b
print "done"

结果：
Traceback (most recent call last):
File "C:/Users/lirong/PycharmProjects/untitled/openfile.py", line 3, in <module>
c=a/b
ZeroDivisionError: integer division or modulo by zero

我们发现程序因为ZeroDivisionError而中断了，语句print "done" 没有运行。为了处理异常，我们使用try...except,更改代码：

a=10
b=0
try:
    c=a/b
    print c
except ZeroDivisionError,e:
    print e.message
print "done"

运行结果：
integer division or modulo by zero
done
这样程序就不会因为异常而中断，从而print "done"语句正常执行。
我们把可能发生错误的语句放在try模块里，用except来处理异常。except可以处理一个专门的异常，也可以处理一组圆括号中的异常，如果except后没有指定异常，则默认处理所有的异常。每一个try，都必须至少有一个except
处理一组异常可以这样写（其中e代表异常的实例）：

try：
    pass
except (IOError ,ZeroDivisionError),e:
    print e

try ....except...else 语句，当没有异常发生时，else中的语句将会被执行。
例子：

a=10
b=0
try:
    c = b/ a
    print c
except (IOError ,ZeroDivisionError),x:
    print x
else:
    print "no error"
print "done"

运行结果：
0
no error
done

2、try ...finally
无论异常是否发生，在程序结束前，finally中的语句都会被执行。

a=10
b=0
try:
    print a/b
finally:
    print "always excute"

运行结果：

Traceback (most recent call last):
always excute
File "C:/Users/lirong/PycharmProjects/untitled/openfile.py", line 4, in <module>
print a/b
ZeroDivisionError: integer division or modulo by zero
虽然有异常发生，但在程序终止前，finally中的语句也能正常执行。。
finally语句也可以和except语句一起使用。

a=10
b=0
try:
    print a/b
except:
    print "error"
finally:
    print "always excute"

运行结果：
error
always excute