Der dritte Python-Wissenspunkt, zusammengestellt für Anfänger

Python-Video-TutorialDie Kolumne stellt den dritten Python-Wissenspunkt vor.

Dieser Artikel ist der dritte. Es gibt insgesamt vier Artikel, die den Grundstein für Python legen. Die beiden oben genannten haben im Wesentlichen die Datenstruktur in Python gelöst.

7. Objektorientierte Programmierung

Alles ist ein Objekt, und Python unterstützt zweifellos die objektorientierte Programmierung. Klassen und Objekte sind die beiden Hauptaspekte der objektorientierten Programmierung. Eine Klasse erstellt ein neues Objekt und das Objekt ist eine Instanz dieser Klasse.

Objekte können Variablen der Klasse verwenden, die als Felder bezeichnet werden. Objekte können auch als Methoden der Klasse bezeichnet werden Klasse.

Es gibt zwei Arten von Feldern

die zu Instanzen gehören

• die zur Klasse selbst gehören
• Sie werden Instanzvariablen bzw. Klassenvariablen genannt.

Klassen werden mit dem Schlüsselwort class erstellt und die Felder und Methoden der Klasse werden in einem eingerückten Block aufgelistet.

Die Methode der Klasse muss einen zusätzlichen ersten Parameter haben, aber diesem Parameter wird beim Aufruf kein Wert zugewiesen. Diese spezielle Variable bezieht sich konventionell auf das Objekt selbst, ähnlich wie in Java. class创建，类的域和方法被列在一个缩进块中。

类的方法必须有一个额外的第一个参数，但是在调用时不为这个参数赋值，这个特殊变量指对象本身，按照惯例它的名称是self，类似Java中的this。

在类中下面两个特都方法需要注意：

• __init__方法：在类的一个对象被创建时调用该方法；相当于c++中的构造函数，就是当这个类调用了，那么这个__init__ 方法就要执行。

• __del__方法：在类的对象被销毁时调用该方法；相当于c++中的析构函数。在使用del删除一个对象时也就调用__del__方法，__del__是最后调用的。

Python中所有的类成员(包括数据成员)都是public的，没有Java的私有类，也就是人人都有调用类，虽然编写变成很简单， 但是资源人人都可以随意分配访问，在项目中确实一个不好的东西。

但是Python 类的却有私有变量和私有方法之说，这个是一个例外，如果使用的数据成员以双下划线为前缀，则为私有变量。

你实例化这个类，访问不了。这是很多人忽略 的

比如：

class public():
    _name = 'protected类型的变量'
    __info = '私有类型的变量'
    def _f(self):
        print("这是一个protected类型的方法")    def __f2(self):
        print('这是一个私有类型的方法')    def get(self):
        return(self.__info)
pub = public()# 先打印可以访问的print(pub._name)
pub._f()####结果如下####protected类型的变量
这是一个protected类型的方法# 打印下类 私有变量和私有方法print(pub.__info)
报错：'public' object has no attribute '__info'pub._f2()
报错：pub._f2()复制代码

但是私有属性和方法可以在同一个类中被调用

pub.get()#######'私有类型的变量'复制代码

上面是很多人不知道的，下面，我来声明一个Person类

   class Person():
    Count = 0
    def __init__(self, name, age):
        Person.Count += 1
        self.name = name
        self.__age = age
    
p = Person("Runsen", 20)

print(p.Count)# 1 说明我实例化，这个__init__方法就要执行print(p.name) #Runsenprint (p.__age) 
#AttributeError: Person instance has no attribute '__age'#私有变量访问不了，报错复制代码

8、继承

面向对象编程 (OOP)，英语全称：Object Oriented Programming，面向对象编程的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

继承，其实这样理解，就是我写了一个爸爸类和儿子类，爸爸有钱，儿子却没钱，于是儿子决定继承爸爸，调用爸爸的钱（爸爸类的变量和方法）。

继承一个类，基本使用下面的五个方法。

8.1 直接调用父类属性方法；

爸爸有钱，儿子却没钱，于是儿子用爸爸的钱

class Father():
    def __init__(self):
        self.money= 1000 
    def action(self):
        print('调用父类的方法') 
class Son(Father):
    pass
 son=Son()     # 子类Son 继承父类Father的所有属性和方法son.action()  # 调用父类属性输出：调用父类的方法
son.money     # 调用父类属性输出：1000复制代码

8,2 强制调用父类私有属性方法；

爸爸说，你这个儿子，老是用我的钱，我决定藏私房钱。儿子试试super()拿你的私房钱，但是这里需要注意super()强制调用父类私有属性方法，就是重写方法，私有变量是不能用supper继承不了，还不可以访问父类中的私有属性方法的变量，就是儿子是拿不了私房钱的。

class Father():
    __money  = 1000 #私有变量是继承不了
    
    def __action(self):  # 父类的私有方法
        money = 1000
        print('调用父类的方法') 
class Son(Father):
        
    def action(self):
        super()._Father__action()
        print(money) 
        
son=Son()
son.action() 

调用父类的方法
name 'money' is not defined复制代码

8.3 重写父类属性方法；

突然间儿子竟然有钱，决定不用爸爸的钱，用自己的钱，决定重写父类属性方法。

class Father():
    def __init__(self):
        self.money = 0
    
    def action(self):
        print('调用父类的方法') 
class Son(Father):
    def __init__(self):
        self.money = 1000
      
    def action(self):
        print('子类重写父类的方法')
 
son=Son()     # 子类Son继承父类Father的所有属性和方法son.action()  # 子类Son调用自身的action方法而不是父类的action方法son.money     # 自己的1000复制代码

8.4 调用父类的__init__方法

如果爸爸把钱放在__init__

Sie müssen auf die folgenden zwei speziellen Methoden in der Klasse achten:

__init__-Methode: Diese Methode wird aufgerufen, wenn ein Objekt der Klasse erstellt wird; sie entspricht dem Konstruktor in C++, das heißt, wenn diese Klasse aufgerufen wird, wird die Methode __init__ ausgeführt.

__del__-Methode: Diese Methode wird aufgerufen, wenn das Objekt der Klasse zerstört wird; das entspricht dem Destruktor in C++. Wenn Sie del zum Löschen eines Objekts verwenden, wird auch die Methode __del__ aufgerufen, und __del__ ist die letzte, die aufgerufen wird.

Alle Klassenmitglieder (einschließlich Datenmitglieder) in Java sind öffentlich. Es gibt keine privaten Klassen, das heißt, jeder hat eine aufrufende Klasse. Aber Ressourcen können von jedem nach Belieben zugewiesen und abgerufen werden, was in dem Projekt tatsächlich eine schlechte Sache ist.

Python-Klassen verfügen jedoch über private Variablen und private Methoden. Dies ist eine Ausnahme. Wenn dem verwendeten Datenelement ein doppelter Unterstrich vorangestellt ist, handelt es sich um eine private Variable.

Wenn Sie diese Klasse instanziieren, kann nicht auf sie zugegriffen werden. Das ignorieren viele Leute

Zum Beispiel:🎜

class Father():
    def __init__(self):
        self.money = 1000
 class Son(Father):
    def __init__(self):
        pass
    son=Son()
print(son.money)# 报错：'Son' object has no attribute 'money'复制代码

🎜Aber private Eigenschaften und Methoden können in derselben Klasse aufgerufen werden🎜

class Father():
    def __init__(self):
        self.money = 1000
 class Son(Father):
    def __init__(self):
        super().__init__()        #也可以用 Father.__init__(self)  这里面的self一定要加上(上面两个相同)
        
        son=Son()
print(son.money) 

1000复制代码

🎜Viele Leute wissen das oben Genannte nicht. Lassen Sie mich als Nächstes eine Personenklasse deklarieren🎜

class Father():
    def __init__(self):
        self.earn_money=1000
        self.spend_money= -500
 class Son(Father):
    def __init__(self):
        super().__init__()        #也可以用 Father.__init__(self)  这里面的self一定要加上
        
    def add(self):
        return self.earn_money+self.spend_money
        
        
son=Son()
print(son.add())500复制代码

8. Vererbung🎜🎜Objektorientierte Programmierung (OOP), vollständiger englischer Name: Object Oriented Programming, eine der Hauptfunktionen der objektorientierten Programmierung ist „Vererbung“. Unter Vererbung versteht man die Möglichkeit, die gesamte Funktionalität einer vorhandenen Klasse zu nutzen und diese zu erweitern, ohne die ursprüngliche Klasse neu schreiben zu müssen. 🎜🎜Vererbung, so verstanden, ist, dass ich eine Vaterklasse und eine Sohnklasse geschrieben habe. Der Vater hat Geld, aber der Sohn hat kein Geld, also hat der Sohn beschlossen, seinen Vater zu erben und das Geld seines Vaters zu nennen (Variablen und Methoden). der Vaterklasse). 🎜🎜Erben Sie eine Klasse und verwenden Sie grundsätzlich die folgenden fünf Methoden. 🎜

8.1 Rufen Sie direkt die Attributmethode der übergeordneten Klasse auf 🎜🎜Der Vater hat Geld, aber der Sohn hat kein Geld, also verwendet der Sohn das Geld seines Vaters🎜

class Father():
    def __init__(self,a,b):
        self.earn_money = a
        self.spend_money= b    def add(self):
        return self.a + self.b 
#调用父类初始化参数a,b并增加额外参数cclass Son(Father):
    def __init__(self,a,b,c=1000):  # c固定值
        Father.__init__(self,a,b)  
        self.son_money = c        
    def add(self):
        return self.earn_money+self.spend_money + self.son_money
        
   
        
son=Son(1000,-500)   # 所以c可以不用显示表达出来print(son.add())     # 调用子类add函数1500复制代码

8,2 Rufen Sie die private Attributmethode der übergeordneten Klasse zwangsweise auf. 🎜🎜Dad sagte, Ihr Sohn verwendet immer mein Geld, also habe ich beschlossen, mein privates Geld zu verstecken. Sohn, versuchen Sie es mit super(), um Ihr privates Geld zu erhalten, aber hier müssen Sie beachten, dass super() einen Aufruf der privaten Attributmethode der übergeordneten Klasse erzwingt, bei der es sich um eine handelt Überschriebene Methoden können nicht mit supper erbt werden, und Sie können nicht auf die Variablen der privaten Attributmethoden in der übergeordneten Klasse zugreifen. Das heißt, der Sohn kann kein privates Geld erhalten. 🎜

In [1]: input()1Out[1]: '1'复制代码

8.3 Schreiben Sie die Attributmethode der übergeordneten Klasse neu. 🎜🎜Plötzlich erwies sich der Sohn als reich und beschloss, nicht das Geld seines Vaters, sondern sein eigenes Geld zu verwenden beschlossen, die Attributmethode der übergeordneten Klasse zu überschreiben. 🎜

test = '''\
This is a program about file I/O.
Author: Runsen
Date: 2020/3/31
'''f = open("test.txt", "w") 
f.write(test) 
f.close() 

f = open("test.txt") #默认rwhile True:
    line = f.readline()    if len(line) == 0:  
        break
    print(line)
f.close()######This is a program about file I/O.

Author: Runsen

Date: 2020/3/31复制代码

8.4 Rufen Sie die __init__-Methode der übergeordneten Klasse auf🎜🎜Wenn der Vater das Geld in __init__ einzahlt, ist es für den Sohn möglich, das Geld zu bekommen? Das Geld des Vaters? Es handelt sich nicht um private Variablen, also ist es kein privates Geld. Natürlich können Sie es bekommen. Mal sehen, ob wir es bekommen können, ohne Super zu verwenden. 🎜

import pickle

datafile = "data.data"mylist = ["Runsen", "is", "20"]

f = open("test.txt", "wb+")
pickle.dump(mylist, f)
f.close()del mylist

f = open(datafile,'rb+')
mylist = pickle.load(f)

print(mylist)#["Runsen", "is", "20"]复制代码

🎜Super nicht einmal zu benutzen ist wie Geld zu nehmen, du schaust auf deinen Vater und mich herab. 🎜

try:    print (1/0)except ZeropisionError as e:
    print(e)except:
    print( "error or exception occurred.")#integer pision or modulo by zero复制代码

🎜8.5 Erben Sie die Parameter im Initialisierungsprozess der übergeordneten Klasse🎜🎜Manchmal muss Papa Geld verdienen und ausgeben, das sind die Parameter in unserem Initialisierungsprozess und beschloss, zu sehen, wie viel Geld sein Vater hat noch in der Tasche hatte. 🎜🎜Wir haben zuerst Geld verdienen und Geld ausgeben aufgeschrieben🎜rrreee🎜Der Sohn stellte fest, dass sein Vater nicht genug Geld hatte, also nahm er heimlich etwas Geld. 🎜rrreee🎜Das Obige behandelt im Wesentlichen die Vererbung von Python-Klassen und den grundlegenden Inhalt des Aufrufs der Attribute und Methoden der übergeordneten Klasse. Sie können einige Fälle selbst schreiben, um Ihr Verständnis zu vertiefen. 🎜🎜9. Eingabe/Ausgabe🎜🎜Die Interaktion zwischen dem Programm und dem Benutzer erfordert die Verwendung von Eingabe/Ausgabe, die hauptsächlich Konsole und Dateien umfasst, die für die Eingabe und den Druck verwendet werden können. Eingabe(xxx) Eingabe xxx, Lesen Sie dann die Eingabe des Benutzers und kehren Sie zurück. 🎜

In [1]: input()1Out[1]: '1'复制代码

10、文件输入/输出

可以使用file类打开一个文件，使用file的read、readline和write来恰当的读写文件。对文件读写能力取决于打开文件时使用的模式， 常用模式

• 读模式("r")
• 写模式("w")
• 追加模式("a")

文件操作之后需要调用close方法来关闭文件。如果用with open就不用slose了。

还有r+，w+，a+

• r：仅仅表示读入
• r+：既可以读取还可以写入
• w: 仅仅表示写入
• w+：既可以读取还可以写入

但r+与w+不同的是，不会把原先存在txt中的东西清空，下面是他们的对比，反正尽量用a+，基本没什么错报出来。

描述	r+	w+	a+
当前文件不存在时文件	抛出异常	创建文件	创建文件
打开后原文件内容	保留	清空	保留
初始位置	0	0	文件尾
写入位置	标记位置	标记位置	写入时默认跳至文件尾

补充个例子吧：

test = '''\
This is a program about file I/O.
Author: Runsen
Date: 2020/3/31
'''f = open("test.txt", "w") 
f.write(test) 
f.close() 

f = open("test.txt") #默认rwhile True:
    line = f.readline()    if len(line) == 0:  
        break
    print(line)
f.close()######This is a program about file I/O.

Author: Runsen

Date: 2020/3/31复制代码

11、存储器

存储器，大家应该不知道。python提供一个标准的模块，成为pickle，使用它可以在一个文件中存储任何python对象，之后可以完整的取出来，这被称为持久地存储对象；还有另外一个模块成为cPickle，它的功能和pickle完全一样，只不过它是用c写的，要比pickle速度快(大约快1000倍)。

import pickle

datafile = "data.data"mylist = ["Runsen", "is", "20"]

f = open("test.txt", "wb+")
pickle.dump(mylist, f)
f.close()del mylist

f = open(datafile,'rb+')
mylist = pickle.load(f)

print(mylist)#["Runsen", "is", "20"]复制代码

12、异常

当程序中出现某些异常的状况时，异常就发生了。

python中可以使用try ... except 处理。

try:    print (1/0)except ZeropisionError as e:
    print(e)except:
    print( "error or exception occurred.")#integer pision or modulo by zero复制代码

相关免费学习推荐：python视频教程

Das obige ist der detaillierte Inhalt vonDer dritte Python-Wissenspunkt, zusammengestellt für Anfänger. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!