php I O操作,python之面向对象、基本I/O操作(一)

一、I/O 操作：

open(name[,mode]) 等价于file(name[,mode])

模式说明：

r 打开只读文件，该文件必须存在。

r+ 打开可读写的文件，该文件必须存在。

w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。

w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。

a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。

a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。

上述的形态字符串都可以再加一个b字符，如rb、w+b或ab＋等组合，加入b 字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。不过在POSIX系统，包含Linux都会忽略该字符。In [1]: f = open('/tmp/test','w')

In [2]: f.write('okokokok')

In [3]: f.close()

在Linux中查看如下：#cat /tmp/test

okokokok

也可在python交互式解释器里面查看，如下所示：In [4]: f = open('/tmp/test','r')

In [5]: f.read()

Out[5]: 'okokokok'

In [6]: f.close()

追加模式的操作:In [7]: f = open('/tmp/test','a')

In [8]: f.write('hello')

In [9]: f.close()

In [10]: f = open('/tmp/test','r')

In [11]: f.read()

Out[11]: 'okokokokhello'

In [12]: f.close()

组合使用模式：In [13]: f = open('/tmp/test','r+')

In [14]: f = open('/tmp/test','w+')

In [15]: f = open('/tmp/test','a+')

将文件open打开以后(可以选择模式)，然后就可以对文件进行操作，下面说明一些经常使用的方法：In [21]: f = open('/tmp/test','a+')

In [20]: f.

f.close f.fileno f.name f.readinto f.softspace f.writelines

f.closed f.flush f.newlines f.readline f.tell f.xreadlines

f.encoding f.isatty f.next f.readlines f.truncate

f.errors f.mode f.read f.seek f.write

在ipython中可以使用tab补齐查看：

read()是读取文件的内容In [22]: f.read()

Out[22]: 'okokokok\n'

write()是写文件的内容，以追加模式打开在后面追加，以只写模式打开，会清空以前文件内容，只保留本次写入内容In [22]: f.write('hello')

readline()是按行进行读取In [29]: f.readline()

Out[29]: 'okokokok\n'

In [30]: f.readline()

Out[30]: 'hello'

readlines()是全部读取，以列表输出，每一行为列表的一个元素In [32]: f.readlines()

Out[32]: ['okokokok\n', 'hello']

tell()和seek()：

tell()是说明现在指针所指的位置

seek()是设置指针指向何In [35]: f.tell()

Out[35]: 9

In [36]: f.seek(0)

In [37]: f.tell()

Out[37]: 0

flush()是刷新所操作的内容In [39]: f.flush()

next()是按顺序读取一行，每次只读取一行In [41]: f.next()

Out[41]: 'okokokok\n'

In [42]: f.next()

Out[42]: 'hello'

close()是关闭打开的文件In [44]: f.close()

一些简单地基本操作：In [1]: a = 'hello to everyone'

In [2]: a

Out[2]: 'hello to everyone'

In [3]: a.split()

Out[3]: ['hello', 'to', 'everyone']

In [4]: a

Out[4]: 'hello to everyone'

In [5]: a.spli

a.split a.splitlines

In [5]: a.split('t')

Out[5]: ['hello ', 'o everyone']

In [6]: a.split('o')

Out[6]: ['hell', ' t', ' every', 'ne']

In [7]: a.split('o',1)

Out[7]: ['hell', ' to everyone']

In [8]: list(a)

Out[8]:

['h',

'e',

'l',

'l',

'o',

' ',

't',

'o',

' ',

'e',

'v',

'e',

'r',

'y',

'o',

'n',

'e']

In [14]: li = ['hello','everyone','ok']

In [15]: ';'.join(li)

Out[15]: 'hello;everyone;ok'

In [16]: 'hello {}'.format('everyone')

Out[16]: 'hello everyone'

In [17]: 'hello{}{}'.format('everyone',1314)

Out[17]: 'hello everyone1314'

In [18]: 'it is {}'.format('ok')

Out[18]: 'it is ok'

二、面向对象编程：

三大特性：继承，多态，封装

实例方法、实例变量、类方法、类变量、属性、初始化方法、私有变量、私有方法

class类的定义方法：

经典类(尽量不要使用)：class Name():

pass

object是python中所有类的基类

新式类的定义方法：class Name(object):

defmethod(self):

pass

初始化方法：def __init__(self,name):

self.nane = name

实例方法：def print_info(self):

self.b = 200

print ‘test’,self.b

实例化test = Name(tom)

print test.name

定义私有方法，格式：以两个下划线开头，不以下划线结尾def __test2(self):

pass

下面是一些关于面向对象编程的示例，一些关于python编程的内容及发放将会在练习示例中进行说明：#!/usr/bin/env python

class Cat(): #定义一个类，名字为Cat，一般类名第一个字要大写

def __init__(self,name,age,color): #初始化方法，self传递的是实例本身

self.name = name #绑定示例变量self.name

self.age = age #绑定示例变量self.age

self.color = color #绑定示例变量self.color

#定义一个函数方法，实例化后可以进行调用使用

def eat(self):

print self.name,"iseating......"

def sleep(self):

print "sleeping,pleasedon't call me"

def push(self):

print self.name,'is push threelaoshu'

mery = Cat('mery',2,'white') #实例化，将类示例化，此时类中的self为mery

tom = Cat('tom',4,'black') #实例化，将类示例化，此时类中的self为tom

print tom.name #打印实例变量

tom.eat() #调用实例方法

def test(): #在外部定义一个test函数

print 'okok'

tom.test = test

tom.test()

上面的程序中，定义了一个Cat类，其中首先执行__init__()方法，这是初始化方法，在实例化类的时候，解释器会自动首先执行这个方法，这里一般用来接收外部传递的参数，以及定义实例变量；还定义了几个函数方法，类实例化后，作为实例方法用来进行调用

在实例化时，首先将类实例化到一个对象上面，然后就可以进行调用类中的方法，也就是所谓的实例方法，注意方法的返回值是什么，在后面可以用到，这里为了直观显示，只用了print语句进行打印。

结果如下：tom

tom is eating......

okok

在下面这个示例中，在类中引入了私有方法和私有变量，它们的用法稍微和类中一般的函数方法有点区别：#!/usr/bin/env python

class Tom(object): #定义一个新式类，object为python中所有类的基类

def __init__(self,name):

self.name = name

self.a = 100

self.b = None

self.__c = 300 #这是一个类的私有实例变量，在外面不能被调用，可以在类内进行调用处理

def test1(self):

print self.name

self.b = 200

print 'test1',self.b

def test2(self,age):

self.age = age

print 'test2',self.age

self.__test3() #在这里调用类的私有方法

def __test3(self): #这是一个私有方法，也是不能被外界调用，可以在类中被别的方法调用，也可以传递出去

print self.a

def print_c(self):

print self.__c #调用类的私有变量

t = Tom('jerry') #实例化

t.test1() #调用实例方法

t.test2(21)

def test4(num):

print 'test4',num

t.exam = test4

t.exam(225)

t.print_c()

在上面的程序中，我们定义了私有变量和私有方法，它们的命名格式是以双下划线开头的，这样在类的外部就不会被调用，是类私有的，我们可以看到在程序中，私有变量和私有方法在类中可以被其他方法调用，这样便可以通过其他方法的操作将有用的信息传递出去

结果如下：jerry

test1 200

test2 21

100

test4 225

300

在下面的示例中，主要是展示了类变量和类参数的定义，以及使用，是为了让理解与实例方法和实例变量的区别：#!/usr/bin/env python

class Dog(object):

a = 100

def test(self):

self.b = 200

print 'test'

@classmethod #装饰器，在类中用classmethod来装饰的方法，将直接成为类方法，所传递的参数也将是类本身，一般都要有cls作为类参数

def test2(cls,name):

print name

cls.b = 300 #类变量值，下面调用时可以看出有何不同

print cls.a

print 'test2'

Dog.test2('tom')

print Dog.b

d = Dog()

d.test2('tom')

print d.b

在上面的程序中，我们可以看到，test方法为实例方法，test2方法为类方法，定义的区别主要就是类方法使用装饰器classmethod装饰的，并且类方法传递的参数为cls，即类本身，实例方法传递的参数是self，即实例本身，这就是区别，至于在最后的调用，明显可以看出，实例方法首先要实例化，再用实例去调用方法与变量；类方法则是直接通过类来进行调用。

结果如下：tom

100

test2

300

tom

100

test2

300

下面主要是练习类里面的类方法和静态方法：#!/usr/bin/env python

class Dog(object):

a = 100

def __init__(self,name): #初始化方法

self.n = name

@classmethod

def cls_m(cls): #类方法

print 'cls_m'

@staticmethod

def static_m(a,b): #静态方法

print a,b

Dog.static_m(3,4)

d = Dog(200)

d.static_m(1,2)

在上面的程序中，主要是区别了类方法和静态方法；静态方法由staticmethod装饰器装饰，类方法由classmethod装饰器装饰；静态方法没有cls或self，可被实例和类调用

输出结果如下：3 4

1 2

逻辑上类方法应当只被类调用，实例方法实例调用，静态方法两者都能调用。主要区别在于参数传递上的区别，实例方法悄悄传递的是self引用作为参数，而类方法悄悄传递的是cls引用作为参数。

下面主要练习和说明了在面向对象编程中，一些类中的属性#!/usr/bin/env python

#coding=utf-8

import datetime

class Dog(object): #新式类的定义

def __init__(self,n): #初始化方法

self.n = n

self.__a = None #私有变量

@property #装饰器，将方法作为属性使用

def open_f(self): #调用这个open_f属性将返回self_a和None比较的布尔值

return self.__a == None

@open_f.setter #setter是重新定义属性，在这里定义的属性名字要和上面的保持一致

def open_f(self,value):

self.__a = value

d = Dog(22)

print d.open_f

d.open_f = 'ok' #重新定义属性

print d.open_f

print "#######################"

class Timef(object):

def __init__(self):

self.__time =datetime.datetime.now() #获取当前时间

@property

def time(self):

returnself.__time.strftime('%Y-%m-%d %H:%M:%S') #打印事件，格式是%Y-%m-%d %H:%M:%S

@time.setter

def time(self,value):

self.__time =datetime.datetime.strptime(value,'%Y-%m-%d%H:%M:%S') #重新获取自定义的事件

t = Timef()

print t.time # 区别于printt.time()

#方法的调用和函数类似，方法就是讲函数绑定到实例化的实例上，属性是作为实例的属性直接进行调用的

t.time = '2016-06-17 00:00:00'

print t.time

print "######################"

#这是一个练习的小程序，参考上面理解练习

class Hello(object):

def __init__(self,num):

self.mon = num

self.rmb = 111

@property

def money(self):

print self.rmb

return self.mon

@money.setter

def money(self,value):

self.mon = value

m = Hello(50)

print m.money

m.money = 25

print m.money

在上面的程序中，主要是解释了属性在类中的定义，以及属性与方法的一些区别，并且简单说明了如何重定义属性的内容，其实@proerty装饰的函数就相当于get属性来使用，@method.setter就是作为set进行重定义使用的。

方法就是讲函数绑定到实例化的实例上，属性是作为实例的属性直接进行调用的

输出结果如下：True

False

#######################

2016-06-27 20:39:38

2016-06-17 00:00:00

######################

111

50

111

25

下面是一个练习示例：#!/usr/bin/env python

class World(object):

def __init__(self,name,nation):

self.name = name

self.nation = nation

self.__money = 10000000000

def flag(self):

print self.__money

return self.name

@property

def action(self):

return self.nation

@action.setter

def action(self,num):

self.nation = num

f = World('Asia','China')

print f.flag()

print f.action

f.action = 'India'

print f.action

输出结果如下：10000000000

Asia

China

India

本文出自 “ptallrights” 博客，请务必保留此出处http://ptallrights.blog.51cto.com/11151122/1793483