Die objektorientierten und grundlegenden E/A-Operationen von Python (1)

1. E/A-Vorgang:

open(name[,mode]) entspricht file(name[,mode])

Modusbeschreibung:
r öffnet eine schreibgeschützte Datei, die vorhanden sein muss.
r+ öffnet eine Datei, die gelesen und geschrieben werden kann. Die Datei muss vorhanden sein.
w öffnet eine schreibgeschützte Datei. Wenn die Datei vorhanden ist, wird die Dateilänge auf 0 gelöscht, d. h. der Dateiinhalt verschwindet. Wenn die Datei nicht vorhanden ist, erstellen Sie die Datei.
w+ öffnet eine lesbare und beschreibbare Datei. Wenn die Datei vorhanden ist, wird die Dateilänge auf Null gelöscht, d. h. der Dateiinhalt verschwindet. Wenn die Datei nicht vorhanden ist, erstellen Sie die Datei.
a Öffnen Sie eine schreibgeschützte Datei im Anhängemodus. Wenn die Datei nicht vorhanden ist, wird die Datei erstellt. Wenn die Datei vorhanden ist, werden die geschriebenen Daten am Ende der Datei hinzugefügt, dh der ursprüngliche Inhalt der Datei bleibt erhalten.
a+ Öffnen Sie eine Lese-/Schreibdatei im Anhängemodus. Wenn die Datei nicht vorhanden ist, wird die Datei erstellt. Wenn die Datei vorhanden ist, werden die geschriebenen Daten am Ende der Datei hinzugefügt, dh der ursprüngliche Inhalt der Datei bleibt erhalten.
Die oben genannten morphologischen Zeichenfolgen können mit einem b-Zeichen wie rb, w+b oder ab+ und anderen Kombinationen hinzugefügt werden. Das b-Zeichen wird hinzugefügt, um der Funktionsbibliothek mitzuteilen, dass es sich bei der geöffneten Datei um eine Binärdatei und nicht um einen einfachen Text handelt Datei. In POSIX-Systemen, einschließlich Linux, wird dieses Zeichen jedoch ignoriert.

In [1]: f = open('/tmp/test','w'）
In [2]: f.write('okokokok')
In [3]: f.close()

Unter Linux wie folgt anzeigen:

#cat /tmp/test
okokokok

kann auch mit interagiert werden in Python Zeigen Sie es im Formelinterpreter an, wie unten gezeigt:

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

Betrieb im Anhängemodus:

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()

Kombinierte Verwendungsmodi:

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

Nachdem Sie die Datei geöffnet haben (Sie können den Modus auswählen), können Sie die Datei dann bedienen. Hier sind einige häufig verwendete Methoden :

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

Sie können die Tab-Vervollständigung verwenden, um es in ipython anzuzeigen:
read() dient zum Lesen des Inhalts der Datei

In [22]: f.read()                  
Out[22]: 'okokokok\n'

write() dient dazu, den Inhalt der Datei im Anhängemodus zu schreiben und später im Schreibmodus anzuhängen, wodurch der vorherige Dateiinhalt gelöscht wird Nur den aktuellen Schreibinhalt behalten

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

readline() liest Zeile für Zeile

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

readlines () liest alles und gibt es in einer Liste aus, jede Zeile ist ein Element der Liste

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

tell() und see():
tell( ) gibt die Position an, auf die der aktuelle Zeiger zeigt
seek() dient dazu, den Zeiger dorthin zu setzen

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

flush() dient dazu, den bearbeiteten Inhalt zu aktualisieren

In [39]: f.flush()

next() liest eine Zeile nacheinander und liest jeweils nur eine Zeile

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

close() schließt die geöffnete Datei

In [44]: f.close()

Einige einfache Grundoperationen:

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'

2. Orientierung Objektprogrammierung:
Drei Hauptmerkmale: Vererbung, Polymorphismus, Kapselung

Instanzmethoden, Instanzvariablen, Klassenmethoden, Klassenvariablen, Eigenschaften, Initialisierung Methoden, private Variablen, private Methoden

Klassenklassendefinitionsmethode:
Klassische Klasse (versuchen Sie, sie nicht zu verwenden):

class Name():
pass

Objekt ist die Basisklasse von allen Klassen in Python

Neue Stilklassendefinitionsmethode:

class Name(object):
defmethod(self):
pass

Initialisierungsmethode:

def __init__(self,name):
self.nane = name

Instanzmethode:

def print_info(self):
self.b = 200
print  ‘test’,self.b

Instanziierung

test = Name(tom)
print test.name

Definieren Sie eine private Methode, Format: Beginnen Sie mit zwei Unterstrichen, enden Sie nicht mit einem Unterstrich

def __test2(self):
pass

Nachfolgend finden Sie einige Beispiele zur objektorientierten Programmierung. Einige Inhalte und Verteilungen zur Python-Programmierung werden in den Übungsbeispielen erläutert:

#!/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()

Im obigen Programm wird eine Cat-Klasse erstellt, in der die Methode __init__() zuerst ausgeführt wird. Dies ist die Initialisierungsmethode, die der Interpreter automatisch zuerst ausführt Wird im Allgemeinen verwendet, um extern übergebene Parameter zu empfangen und Instanzvariablen zu definieren. Nachdem die Klasse instanziiert wurde, wird sie als Instanzmethode zum Aufrufen von
verwendet. Während der Instanziierung wird die Klasse zunächst in ein Objekt instanziiert Dann können die Methoden in der Klasse aufgerufen werden, d. h. Die sogenannte Instanzmethode. Achten Sie auf den Rückgabewert der Methode, der später verwendet werden kann. Für die visuelle Anzeige wird nur die Druckanweisung zum Drucken verwendet.

Die Ergebnisse sind wie folgt:

tom
tom is eating......
okok

Im folgenden Beispiel werden private Methoden und private Variablen in die Klasse eingeführt und ihre Verwendung erfolgt etwas ähnlich wie die der Klasse Die allgemeinen Funktionsmethoden in Es werden nicht extern aufgerufen und sind für die Klasse privat. Wir können sehen, dass im Programm private Variablen und private Methoden von anderen Methoden in der Klasse aufgerufen werden können nützliche Informationen können durch die Operationen anderer Methoden weitergegeben werden

Die Ergebnisse sind wie folgt:

#!/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()

Im folgenden Beispiel sind die Definition und Die Verwendung von Klassenvariablen und Klassenparametern dient hauptsächlich dem Verständnis der Unterschiede zu Instanzmethoden und Instanzvariablen:

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 = &#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

在上面的程序中，主要是解释了属性在类中的定义，以及属性与方法的一些区别，并且简单说明了如何重定义属性的内容，其实@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

Das obige ist der detaillierte Inhalt vonDie objektorientierten und grundlegenden E/A-Operationen von Python (1). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!