当前位置:Gxlcms > Python > python之面向对象、基本I/O操作(一)

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

时间:2021-07-01 10:21:17 帮助过:9人阅读

一、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    #<当有@property装饰器时,作为属性直接使用> 区别于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

以上就是python之面向对象、基本I/O操作(一) 的详细内容,更多请关注Gxl网其它相关文章!

人气教程排行