La colonne
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.
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
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'#私有变量访问不了，报错复制代码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.
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复制代码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复制代码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复制代码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复制代码
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.
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'复制代码
可以使用file类打开一个文件，使用file的read、readline和write来恰当的读写文件。对文件读写能力取决于打开文件时使用的模式， 常用模式
文件操作之后需要调用close方法来关闭文件。如果用with open就不用slose了。
还有r+，w+，a+
但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复制代码存储器，大家应该不知道。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"]复制代码当程序中出现某些异常的状况时，异常就发生了。
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!
Patch VIP Tonnerre
Comment résoudre le problème selon lequel tous les dossiers ne peuvent soudainement pas être ouverts dans Win10
Combien de personnes pouvez-vous élever sur Douyin ?
comment créer un site Web
Comment reprendre l'utilisation du gaz après le paiement
Comment utiliser la fonction fit en Python
Comment modifier le nom d'un fichier sous Linux
Comment modifier le texte dans l'image
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
