Rumah > pembangunan bahagian belakang > Tutorial Python > python之面向对象、基本I/O操作(一)

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

巴扎黑
Lepaskan: 2017-04-01 13:33:39
asal
1414 orang telah melayarinya

一、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()
Salin selepas log masuk



在Linux中查看如下:

#cat /tmp/test
okokokok
Salin selepas log masuk



也可在python交互式解释器里面查看,如下所示:

In [4]: f = open('/tmp/test','r')
In [5]: f.read()
Out[5]: 'okokokok'
In [6]: f.close()
Salin selepas log masuk



追加模式的操作:

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()
Salin selepas log masuk



组合使用模式:

In [13]: f = open('/tmp/test','r+')
In [14]: f = open('/tmp/test','w+')
In [15]: f = open('/tmp/test','a+')
Salin selepas log masuk



将文件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
Salin selepas log masuk



在ipython中可以使用tab补齐查看:
read()是读取文件的内容

In [22]: f.read()                  
Out[22]: 'okokokok\n'
Salin selepas log masuk



write()是写文件的内容,以追加模式打开在后面追加,以只写模式打开,会清空以前文件内容,只保留本次写入内容

In [22]: f.write('hello')
Salin selepas log masuk



readline()是按行进行读取

In [29]: f.readline()
Out[29]: 'okokokok\n'
In [30]: f.readline()
Out[30]: 'hello'
Salin selepas log masuk



readlines()是全部读取,以列表输出,每一行为列表的一个元素

In [32]: f.readlines()
Out[32]: ['okokokok\n', 'hello']
Salin selepas log masuk



tell()和seek():
tell()是说明现在指针所指的位置
seek()是设置指针指向何

In [35]: f.tell()
Out[35]: 9
In [36]: f.seek(0)
In [37]: f.tell()
Out[37]: 0
Salin selepas log masuk



flush()是刷新所操作的内容

In [39]: f.flush()
Salin selepas log masuk



next()是按顺序读取一行,每次只读取一行

In [41]: f.next()
Out[41]: 'okokokok\n'
In [42]: f.next()
Out[42]: 'hello'
Salin selepas log masuk



close()是关闭打开的文件

In [44]: f.close()
Salin selepas log masuk



一些简单地基本操作:

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'
Salin selepas log masuk



二、面向对象编程:
三大特性:继承,多态,封装

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

class类的定义方法:
经典类(尽量不要使用):

class Name():
pass
Salin selepas log masuk

object是python中所有类的基类

新式类的定义方法:

class Name(object):
defmethod(self):
pass
Salin selepas log masuk

初始化方法:

def __init__(self,name):
self.nane = name
Salin selepas log masuk

实例方法:

def print_info(self):
self.b = 200
print  ‘test’,self.b
Salin selepas log masuk


实例化

test = Name(tom)
print test.name
Salin selepas log masuk

定义私有方法,格式:以两个下划线开头,不以下划线结尾

def __test2(self):
pass
Salin selepas log masuk



下面是一些关于面向对象编程的示例,一些关于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()
Salin selepas log masuk

上面的程序中,定义了一个Cat类,其中首先执行__init__()方法,这是初始化方法,在实例化类的时候,解释器会自动首先执行这个方法,这里一般用来接收外部传递的参数,以及定义实例变量;还定义了几个函数方法,类实例化后,作为实例方法用来进行调用
在实例化时,首先将类实例化到一个对象上面,然后就可以进行调用类中的方法,也就是所谓的实例方法,注意方法的返回值是什么,在后面可以用到,这里为了直观显示,只用了print语句进行打印。

结果如下:

tom
tom is eating......
okok
Salin selepas log masuk



在下面这个示例中,在类中引入了私有方法和私有变量,它们的用法稍微和类中一般的函数方法有点区别:

#!/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()
Salin selepas log masuk

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

结果如下:

jerry
test1 200
test2 21
100
test4 225
300
Salin selepas log masuk



在下面的示例中,主要是展示了类变量和类参数的定义,以及使用,是为了让理解与实例方法和实例变量的区别:

#!/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
Salin selepas log masuk

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

结果如下:

tom
100
test2
300
tom
100
test2
300
Salin selepas log masuk



下面主要是练习类里面的类方法和静态方法:

#!/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)
Salin selepas log masuk

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

输出结果如下:

3 4
1 2
Salin selepas log masuk



逻辑上类方法应当只被类调用,实例方法实例调用,静态方法两者都能调用。主要区别在于参数传递上的区别,实例方法悄悄传递的是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 = &#39;2016-06-17 00:00:00&#39;
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
Salin selepas log masuk



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


输出结果如下:

True
False
#######################
2016-06-27 20:39:38
2016-06-17 00:00:00
######################
111
50
111
25
Salin selepas log masuk



下面是一个练习示例:

#!/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(&#39;Asia&#39;,&#39;China&#39;)
print f.flag()
 
print f.action
 
f.action = &#39;India&#39;
print f.action
Salin selepas log masuk



输出结果如下:

10000000000
Asia
China
India
Salin selepas log masuk



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

Atas ialah kandungan terperinci python之面向对象、基本I/O操作(一) . Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan