Le troisième point de connaissance Python compilé pour les débutants

La colonne

Tutoriel vidéo Python présente le troisième point de connaissance Python.

Cet article est le troisième. Il y a quatre articles au total pour jeter les bases de Python

Les deux ci-dessus ont essentiellement résolu la structure des données. en Python. Parlons-en dans un article.

7. Programmation orientée objet

Tout est un objet, et Python prend certainement en charge la programmation orientée objet. Les classes et les objets sont les deux principaux aspects de la programmation orientée objet. Une classe crée un nouvel objet et l'objet est une instance de cette classe.

Les objets peuvent utiliser des variables de la classe. Les variables appartenant à l'objet ou à la classe sont appelées champs ; les objets peuvent également utiliser des fonctions appartenant à la classe. De telles fonctions sont appelées méthodes de la classe ; appelées propriétés.

Il existe deux types de champs

• Appartiennent aux instances
• Appartient à la classe elle-même

Ils sont appelés variables d'instance et classes respectivement variables. La classe

est créée à l'aide du mot-clé class et les champs et méthodes de la classe sont répertoriés dans un bloc en retrait. La méthode de la classe

doit avoir un premier paramètre supplémentaire, mais ce paramètre ne reçoit aucune valeur lorsqu'il est appelé. Cette variable spéciale fait référence à l'objet lui-même. Par convention, son nom est self, similaire à celui de Java. .

Vous devez faire attention aux deux méthodes spéciales suivantes dans la classe :

• __init__ méthode : Cette méthode est appelée lorsqu'un objet de la classe est créé ; équivalent à c++ Le constructeur dans est que lorsque cette classe est appelée, alors la méthode __init__ sera exécutée.

• __del__Méthode : Cette méthode est appelée lorsque l'objet de la classe est détruit, équivalent au destructeur en C++ ; Lorsque vous utilisez del pour supprimer un objet, la méthode __del__ est également appelée et __del__ est la dernière appelée.

Tous les membres de classe (y compris les membres de données) en Python sont publics. Il n'y a pas de classes privées en Java, c'est-à-dire que tout le monde a une classe appelante. Bien que l'écriture soit très simple, Cependant, chacun peut allouer et accéder aux ressources à volonté, ce qui est effectivement une mauvaise chose dans le projet.

Cependant, les classes Python ont des variables privées et des méthodes privées. Si le membre de données utilisé est préfixé par un double trait de soulignement, il s'agit d'une variable privée.

Vous instanciez cette classe et ne pouvez pas y accéder. C'est quelque chose que beaucoup de gens ignorent

Par exemple :

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()复制代码

Mais les propriétés et méthodes privées peuvent être appelées dans la même classe

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

Ce qui précède est ce que beaucoup de gens font. Je ne sais pas, et ce qui suit, permettez-moi de déclarer une classe 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. Héritage

Programmation orientée objet (POO), le nom anglais complet : Programmation orientée objet, l'un des principaux Les fonctions de programmation orientée objet sont « l'héritage ». L'héritage fait référence à la possibilité d'utiliser toutes les fonctionnalités d'une classe existante et de l'étendre sans avoir à réécrire la classe d'origine.

L'héritage, en fait compris de cette façon, c'est que j'ai écrit une classe père et une classe fils. Le père a de l'argent, mais le fils n'a pas d'argent, alors le fils a décidé d'hériter de son père et d'appeler l'argent de son père. (variables et méthodes de la classe père) .

Héritez d'une classe et utilisez essentiellement les cinq méthodes suivantes.

8.1 Appelez directement la méthode d'attribut de classe parent ;

Le père a de l'argent, mais le fils n'a pas d'argent, donc le fils utilise l'argent de son père

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 Appel forcé de la méthode d'attribut privé de la classe parent ;

Papa a dit, ton fils utilise toujours mon argent, alors j'ai décidé de cacher mon argent privé. Fils, essayez super() d'obtenir votre argent privé, mais vous devez faire attention ici super() pour forcer l'appel de la méthode d'attribut privé de la classe parent, qui consiste à remplacer la méthode. Les variables privées ne peuvent pas être héritées par le souper, et. les propriétés privées de la classe parent ne sont pas accessibles. La variable de la méthode d'attribut signifie que le fils ne peut pas obtenir d'argent privé.

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 Réécrivez la méthode d'attribut de classe parent ;

Soudain, le fils s'est avéré riche et a décidé de ne pas utiliser l'argent de son père, mais d'utiliser son propre argent, et a décidé de passer outre. la méthode d'attribut de classe parent.

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 Appelez la méthode __init__ de la classe parent

Si le père met l'argent dans __init__, est-il possible pour le fils d'obtenir l'argent du père. Ce ne sont pas des variables privées ? , donc ils ne sont pas privés. Bien sûr, vous pouvez obtenir de l'argent

Voyons d'abord si nous pouvons l'obtenir sans utiliser super.

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'复制代码

Même si tu n'utilises pas de super, c'est comme prendre de l'argent. Tu méprises ton père et moi.

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复制代码

8.5 Hériter des paramètres dans le processus d'initialisation de la classe parent

Parfois, papa a besoin de gagner et de dépenser de l'argent, qui sont les paramètres de notre processus d'initialisation. Le fils était très curieux et. a décidé de jeter un œil à son père. Combien d'argent as-tu encore en poche ?

Nous avons d'abord noté gagner_argent et dépenser_argent

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复制代码

Le fils a découvert que son père n'avait pas assez d'argent, alors il a secrètement pris de l'argent.

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复制代码

Ce qui précède couvre essentiellement l'héritage des classes Python et le contenu de base de l'appel des attributs et des méthodes de la classe parent. Vous pouvez écrire vous-même quelques cas pour approfondir votre compréhension.

9. Entrée/Sortie

L'interaction entre le programme et l'utilisateur nécessite l'utilisation d'entrée/sortie, qui comprend principalement la console et les fichiers pour la console, l'entrée et l'impression peuvent être utilisées ; . entrée (xxx) entrée xxx, Lisez ensuite l'entrée de l'utilisateur et revenez.

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视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!