Introduction à l'apprentissage de base de Python

En Python, les noms dont la première lettre est en majuscule font référence aux classes. Les crochets dans cette définition de classe sont vides car nous créons cette classe à partir d'un espace vide. Nous avons écrit une docstring décrivant les fonctionnalités de cette classe. Les fonctions d'une classe sont appelées méthodes .

Prenons l'exemple de la classe Student. En Python, la définition d'une classe se fait via le mot-clé class :

class Student(object):

    pass

classe Étudiant(objet) :

réussite

Immédiatement après la classe se trouve le nom de la classe, c'est-à-dire Étudiant. Le nom de la classe est généralement un mot commençant par une majuscule, suivi de (objet), indiquant de quelle classe la classe est héritée. Habituellement, s'il n'y a pas d'héritage approprié. classe, utilisez l'objet Class, qui est la classe dont toutes les classes héritent en fin de compte.

class Student(object):

 

    def __init__(self, name, score):

        self.name = name

        self.score = score

9.1.1 Créer une classe

classe Étudiant(objet):

def __init__(self, name, score):

self.name = nom

self.score = score

　1. La méthode __init__() est une méthode spéciale qui l'exécutera automatiquement lors de la création d'une nouvelle instance. Il y a deux traits de soulignement au début et à la fin. Il s'agit d'une convention pour éviter les conflits de noms entre les méthodes Python par défaut et les méthodes ordinaires. Dans la définition de cette méthode, le paramètre formel self est essentiel et doit être situé

devant les autres paramètres formels.

　2. Chaque appel de méthode associé à une classe transmet automatiquement le paramètre réel self, qui est une référence à l'instance elle-même, permettant à l'instance d'accéder aux propriétés et méthodes de la classe. self est transmis automatiquement, nous n'avons donc pas besoin de le transmettre.

　3. Les variables préfixées par self sont disponibles pour toutes les méthodes de la classe, et nous pouvons également accéder à ces variables via n'importe quelle instance de la classe.

　4.self.name= name Les variables comme celle-ci, accessibles via les instances, sont appelées attributs

　5. Une fonctionnalité importante de la programmation orientée objet est l'encapsulation des données. Vous pouvez définir directement des fonctions pour accéder aux données à l'intérieur de la classe, encapsulant ainsi les "données". Ces

fonctions qui encapsulent les données

sont associées à la classe Student elle-même, que nous appelons méthodes de la classe

9.1.2 Créer une instance basée sur la classe

Nous. généralement, vous pouvez considérer un nom avec la première lettre en majuscule (comme Dog) comme faisant référence à la classe, tandis qu'un nom en minuscule (comme my_dog) fait référence à l'instance créée à partir de la classe.

1. Pour accéder aux attributs de l'instance, vous pouvez utiliser la notation

point

Nous avons écrit le code suivant pour accéder à la valeur du nom d'attribut de my_dog.

my_dog.name

La notation point est très couramment utilisée en Python. Cette syntaxe montre comment Python apprend la valeur d'un attribut.

2. Après avoir créé une instance basée sur la classe Dog, vous pouvez utiliser la notation point pour appeler n'importe quelle méthode définie dans la classe Dog.

　3. Vous pouvez créer n'importe quel nombre d'instances en fonction de la classe selon vos besoins.

9.2 Utilisation de classes et d'instances

class Student(object):

    name = 'Student'

　1. Une tâche importante que vous devez effectuer est de modifier les propriétés de l'instance. Vous pouvez modifier les propriétés d'une instance directement ou écrire des méthodes pour les modifier d'une manière spécifique. 2. Une classe est un modèle pour créer des instances, et les instances sont des objets spécifiques. Les données appartenant à chaque instance sont indépendantes les unes des autres et ne s'affectent pas. La méthode est la fonction liée à l'instance. , et la fonction ordinaire Différemment, les méthodes peuvent accéder directement aux données de l'instance ; en appelant la méthode sur l'instance, nous exploitons directement les données à l'intérieur de l'objet, mais il n'est pas nécessaire de connaître les détails d'implémentation à l'intérieur de la méthode. Contrairement aux langages statiques, Python permet de lier n'importe quelle donnée à des variables d'instance, c'est-à-dire que pour deux variables d'instance, bien qu'il s'agisse d'instances différentes de la même classe, elles peuvent avoir des noms de variable différents. 9.2.1 Définir la valeur initiale de la classe Chaque attribut de la classe doit avoir une valeur initiale, même si la valeur est 0 ou une chaîne vide. Dans certains cas, comme lors de la définition d'une valeur par défaut, il est possible de spécifier une telle valeur initiale dans la méthode __init__() ; si vous faites cela pour un attribut, vous n'avez pas besoin d'inclure des paramètres formels qui lui fournissent une initiale ; valeur. Définissez les attributs directement dans la classe, qui sont des attributs de classe :

classe Étudiant(objet) : nom = 'Étudiant'

Lors de l'écriture d'un programme, n'utilisez jamais le même nom pour les attributs d'instance et les attributs de classe, car les attributs d'instance portant le même nom bloqueront les attributs de classe, mais lorsque vous supprimez les attributs d'instance, utilisez à nouveau le même nom pour accéder à ce qui arrive. seront des attributs de classe.

9.2.2 Modifier la valeur de l'attribut

Vous pouvez modifier la valeur de l'attribut de trois manières différentes :

1. Modifier directement via l'instance

>　2. Définir via les méthodes

　3. Incrémenter via les méthodes (augmenter une valeur spécifique).

9.2.3 Restrictions d'accès

1. À l'intérieur d'une classe, il peut y avoir des propriétés et des méthodes, et le code externe peut manipuler les données en appelant directement la méthode de variable d'instance, cachant ainsi la logique complexe interne .

2. Si vous souhaitez empêcher l'accès aux attributs internes en externe, vous pouvez ajouter deux traits de soulignement __ avant le nom de l'attribut. En Python, si le nom de la variable de l'instance commence par __, il devient A. La variable privée (privée) n'est accessible qu'en interne et non en externe.

classe Étudiant (objet) :

class Student(object):

    def __init__(self, name, score):

        self.__name = name

        self.__score = score

 

    def print_score(self):

        print('%s: %s' % (self.__name, self.__score))

def __init__(soi, nom, score):

>>> bart = Student('Bart Simpson', 98)

>>> bart.__name

Traceback (most recent call last):

  File "", line 1, in

AttributeError: 'Student' object has no attribute '__name'

self.__name = nom

self.__score = score

class Student(object):

    ...

    def get_name(self):

        return self.__name

 

    def get_score(self):

        return self.__score

class Student(object):

    ...

    def set_score(self, score):

        self.__score = score

def print_score(self):

print('%s: %s' % (self.__name, self.__score))

class Student(object):

    ...

    def set_score(self, score):

        if 0 <= score <= 100:

self.__score = score

else:

raise ValueError('bad score')

<🎜>　3. Après la modification, il n'y a aucun changement dans le code externe, mais la variable d'instance .__name et la variable d'instance .__score ne sont plus accessibles de l'extérieur : <🎜>

<🎜>>>> bart = Étudiant('Bart Simpson', 98)>>> bart.__name Traceback (dernier appel le plus récent) : Fichier "", ligne 1, dans AttributeError : 'Student' l'objet n'a pas d'attribut '__name'

　4. Cela garantit que le code externe ne peut pas modifier l'état interne de l'objet à volonté, de sorte que via la protection des restrictions d'accès, le code Plus robuste. Mais si un code externe souhaite obtenir le nom et le score, vous pouvez ajouter des méthodes comme get_name et get_score à la classe Student :

class Student(object): ... def get_name(self): return self.__name def get_score(self): return self.__score

5 . Si Pour permettre au code externe de modifier la partition, vous pouvez ajouter la méthode set_score à la classe Student :

class Étudiant(objet): ... def set_score(self, score): self.__score = score

　6. Par rapport aux paramètres d'appel direct d'origine, dans la méthode, les paramètres peuvent être vérifiés pour éviter de transmettre des paramètres non valides :

classe Étudiant(objet) : .. . def set_score(self, score): if 0 <= score <= 100 :<🎜><🎜> self.__score = score<🎜><🎜> else :<🎜> <🎜>                                    augmenter ValueError('mauvais score')<🎜>

7. Il convient de noter qu'en Python, les noms de variables sont similaires à __xxx__, c'est-à-dire qu'ils commencent par un double trait de soulignement et se terminent par un double trait de soulignement, ce sont des variables spéciales accessibles directement et ne sont pas privées. . variables, donc les noms de variables tels que __name__ et __score__ ne peuvent pas être utilisés. Parfois, vous verrez des noms de variables d'instance commençant par un trait de soulignement, tel que _name. Cependant, selon la convention, lorsque vous voyez une telle variable, cela signifie "Bien que je puisse le faire". être accessible, veuillez me traiter comme une variable privée et ne pas y accéder à volonté."

8. Les variables d'instance commençant par des doubles traits de soulignement ne sont pas nécessairement accessibles de l'extérieur. La raison pour laquelle __name n'est pas accessible directement est que l'interpréteur Python modifie en externe la variable __name en _Student__name, de sorte que la variable __name est toujours accessible via _Student__name.

9.3 Héritage

1. Si une classe est similaire à une version spéciale d'une autre classe, vous pouvez utiliser l'héritage. Si une classe hérite d'une autre classe, elle obtiendra automatiquement toutes les propriétés et méthodes. de l'autre classe. La classe d'origine est la classe parent et la nouvelle classe est la classe enfant.

2. La sous-classe hérite de tous les attributs et méthodes de la classe parent, et peut également définir ses propres attributs et méthodes. En programmation POO, lorsque nous définissons une classe, elle peut hériter d'une classe existante. La nouvelle classe est appelée une sous-classe (Sous-classe) et la classe héritée est appelée une classe de base, une classe parent ou une super classe (Classe de base, Super. classe).

class Dog(Animal): #继承Animal

pass

classe Chien(Animal) : #Hériter un animal

pass

9.3.1 Méthode de sous-classe __init__()

1. L'héritage doit être donné au parent class Tous les attributs se voient attribuer des valeurs et le __init__() de la sous-classe nécessite l'aide de la classe parent.

　2. Et la classe parent doit être dans le fichier d'héritage, avant la sous-classe.

　3. Lors de la définition d'une sous-classe, le nom de la classe parent doit être précisé entre parenthèses.

　4.

La fonction spéciale super()

aide Python à connecter les classes parentes et les sous-classes en parallèle. La classe parent est également appelée super classe, l'origine de super.

9.3.2 Définir les méthodes et attributs des sous-classes

Laisser une classe hériter d'une classe. Vous pouvez ajouter des propriétés et des méthodes qui distinguent les sous-classes des classes parentes.

9.3.3 Réécriture de la classe parent

Les méthodes correspondant à la classe parent ne peuvent être réécrites que si elles ne répondent pas aux besoins de la sous-classe. Ajoutez de nouvelles méthodes à la sous-classe pour décrire la. caractéristiques de la sous-classe. Débarrassez-vous du pire de la catégorie parentale et prenez le meilleur.

9.3.4 Polymorphisme

1. Lorsque la même méthode existe à la fois dans la sous-classe et dans la classe parent, on dit que la sous-classe remplace la méthode de la classe parent lorsque le code est en cours d'exécution. , Les méthodes de sous-classe sont toujours appelées. De cette façon, nous obtenons un autre avantage de l'héritage : le polymorphisme

2. Par conséquent, dans la relation d'héritage, si le type de données d'une instance est une sous-classe, son type de données peut également être considéré comme Est la classe parent . Cependant, l’inverse n’est pas vrai.

3. L'avantage du polymorphisme est que lorsqu'on doit passer en Chien, Chat, Tortue..., il suffit de recevoir le type Animal, car Chien, Chat, Tortue... sont tous des Animaux types , puis opèrez simplement en fonction du type Animal. Puisque le type Animal a une méthode run(), tout type transmis, tant qu'il s'agit d'une classe ou d'une sous-classe Animal, appellera automatiquement la méthode run() du type réel. C'est ce que signifie le polymorphisme.

• 4. Pour une variable, il suffit de savoir qu'elle est de type Animal, sans connaître exactement son sous-type, on peut appeler en toute sécurité la méthode run(), et la méthode run() spécifique appelée est la function Qu'il s'agisse d'un objet Animal, Chien, Chat ou Tortue est déterminé par le type exact de l'objet au moment de l'exécution. C'est le véritable pouvoir du polymorphisme : l'appelant ne se soucie que de l'appel, quels que soient les détails, et lorsque nous ajoutons. une nouvelle sous-classe d'Animal, assurez-vous simplement que la méthode run() est écrite correctement, quelle que soit la façon dont le code d'origine est appelé. C'est le fameux principe "ouvert et fermé" :

• Ouvert pour extension : de nouvelles sous-classes d'Animaux sont autorisées

Fermé pour modification : non ; Les fonctions telles que run_twice() qui dépendent du type Animal doivent être modifiées.

9.3.5 Utilisation de __slots__

class Student(object):

__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

<🎜> Afin d'obtenir des restrictions, Python vous permet de définir une variable __slots__ spéciale lors de la définition d'une classe pour limiter les attributs qui peuvent être ajoutés aux instances de classe. <🎜>

<🎜>classe Étudiant (objet) :<🎜><🎜> __slots__ = ('name', 'age') # Utilisez un tuple pour définir les noms d'attributs qui peuvent être liés <🎜>

Lorsque vous utilisez __slots__, veuillez noter que les attributs définis par __slots__ n'affectent que l'instance de classe actuelle et n'ont aucun effet sur les sous-classes héritées.

9.3.6 Héritage multiple

1. Grâce à l'héritage multiple, une sous-classe peut obtenir toutes les fonctions de plusieurs classes parents en même temps.

2. Lors de la conception de la relation d'héritage des classes, la ligne principale est généralement héritée d'une seule source. Par exemple, Ostrich hérite de Bird. Cependant, si vous avez besoin de « mélanger » des fonctionnalités supplémentaires, vous pouvez y parvenir grâce à un héritage multiple. Par exemple, laissez Ostrich hériter de Runnable en plus d'hériter de Bird. Cette conception est souvent appelée MixIn. Le but de MixIn est d'ajouter plusieurs fonctions à une classe. De cette façon, lors de la conception d'une classe, nous donnons la priorité à la combinaison de plusieurs fonctions MixIn via un héritage multiple au lieu de concevoir des relations d'héritage complexes à plusieurs niveaux.

　3. De cette façon, nous n'avons pas besoin d'une chaîne d'héritage compliquée et énorme. Tant que nous choisissons de combiner les fonctions de différentes classes, nous pouvons rapidement construire les sous-classes requises. Puisque Python autorise l’héritage multiple, MixIn est une conception courante. Les langages qui n'autorisent qu'un héritage unique (comme Java) ne peuvent pas utiliser la conception de MixIn.

9.3.7 Classes personnalisées

1. Il existe de nombreuses fonctions spéciales dans les classes Python qui peuvent nous aider à personnaliser les classes.

__str__

Après avoir défini la méthode __str__(), vous pouvez renvoyer une jolie chaîne :

>>> class Student(object):

...     def __init__(self, name):

...         self.name = name

...     def __str__(self):

...         return 'Student object (name: %s)' % self.name

...

>>> print(Student('Michael'))

Student object (name: Michael)

>>> classe Étudiant (objet) :

... def __init__(soi, nom) :

... self.name = nom

>>> s = Student('Michael')

>>> s

<__main__.Student object at 0x109afb310>

... def __str__(self):

... return 'Objet étudiant (nom : %s)' % self.name

class Student(object):

    def __init__(self, name):

        self.name = name

    def __str__(self):

        return 'Student object (name=%s)' % self.name

    __repr__ = __str__

...

>>> print(Étudiant('Michael'))

Objet étudiant (nom : Michael)

L'exemple imprimé de cette manière est non seulement beau, mais permet également de voir facilement les données importantes à l'intérieur de l'instance.

class Fib(object):

    def __init__(self):

        self.a, self.b = 0, 1 # 初始化两个计数器a，b

 

    def __iter__(self):

        return self # 实例本身就是迭代对象，故返回自己

 

    def __next__(self):

        self.a, self.b = self.b, self.a + self.b # 计算下一个值

        if self.a > 100000: # 退出循环的条件

            raise StopIteration()

        return self.a # 返回下一个值

Tapez les variables directement sans les imprimer. L'exemple imprimé n'a toujours pas l'air bien :

>>> for n in Fib():

...     print(n)

...

1

1

2

3

5

...

46368

75025

>>> s = Student('Michael')>>> s<__main__.Objet Student à 0x109afb310>

Cela est dû au fait que l'appel de variable d'affichage direct n'est pas __str__(), mais __repr__(). () renvoie la chaîne que l'utilisateur voit et __repr__() renvoie la chaîne que le développeur du programme voit. En d'autres termes, __repr__() est destiné au débogage. La solution est de définir un autre __repr__(). Mais généralement, les codes de __str__() et __repr__() sont les mêmes, il existe donc une façon paresseuse de l'écrire : tbody >

class Student(object): def __init__(self, name): self.name = name def __str__(self): return 'Objet étudiant (name=%s)' % self.name __repr__ = __str__

__iter__ Si une classe veut être utilisée dans une boucle for...in, comme une liste ou un tuple, elle doit implémenter une méthode __iter__(), qui renvoie un objet itérable, la boucle for de Python appellera en permanence la méthode __next__() de l'objet itération pour obtenir la valeur suivante de la boucle, jusqu'à ce qu'elle quitte la boucle lorsqu'une erreur StopIteration est rencontrée. Nous prenons la séquence de Fibonacci comme exemple et écrivons une classe Fib qui peut être utilisée dans les boucles : class Fib(object): def __init__(self): self.a, self.b = 0, 1 # Initialiser deux compteurs a, b def __iter__(self): return self # L'instance elle-même est un objet itératif, donc return self def __next__(self): self.a, self.b = self.b, self.a + self.b # Calculer la valeur suivante if self .a > 100000 : # Conditions pour quitter la boucle                                           > Maintenant, essayez d'appliquer l'instance Fib à la boucle for :

>>> pour n dans Fib() :... imprimer (n)...1 1235 ...4636875025

__getitem__

Bien que l'instance Fib puisse être utilisée dans des boucles for et ressemble un peu à une liste, il n'est toujours pas possible de l'utiliser comme liste. Par exemple, prenez le 5ème élément :

>>> >

>>> Fib()[5]

Traceback (most recent call last):

  File "", line 1, in

TypeError: 'Fib' object does not support indexing

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans

class Fib(object):

    def __getitem__(self, n):

        a, b = 1, 1

        for x in range(n):

            a, b = b, a + b

        return a

TypeError : l'objet 'Fib' ne prend pas en charge l'indexation

Pour se comporter comme une liste et supprimer des éléments en fonction des indices, vous devez implémenter la méthode __getitem__() :

class Fib(object):

def __getitem__(self, n ):

a, b = 1, 1

pour x dans la plage(n):

a, b = b, a + b

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

return a __getattr__ Python a un autre mécanisme, qui consiste à écrire une méthode __getattr__() pour renvoyer dynamiquement un attribut . Lors de l'appel d'un attribut inexistant, tel que score, l'interpréteur Python tentera d'appeler __getattr__(self, 'score') pour tenter d'obtenir l'attribut, afin que nous ayons la possibilité de renvoyer la valeur de score. Les attributs existants, tels que le nom, ne seront pas recherchés dans __getattr__. __call__ 1. Pour n'importe quelle classe, il vous suffit de définir une méthode __call__() pour appeler directement l'instance. 2. Grâce à la fonction callable(), nous pouvons déterminer si un objet est un objet "appelable". 9.3.8 Classe d'énumération Définissez un type de classe pour un tel type d'énumération, puis chaque constante est une instance unique de la classe. Python fournit la classe Enum pour implémenter cette fonction :

from enum import EnumMois = Enum('Month', ('Jan', 'Feb', 'Mar', 'Avr', 'May', 'Jun', 'Jul', 'Août', ' Sep', 'Oct', 'Nov', 'Dec'))

9.3.9 Métaclasse

type()

Pour créer un objet classe, la fonction type() passe 3 paramètres en séquence :

1. Le nom de la classe ;

2. Une collection de classes parents héritées. Notez que Python prend en charge l'héritage multiple. S'il n'y a qu'une seule classe parent, n'oubliez pas l'élément unique. méthode d'écriture du tuple ;

3. Le nom de la méthode de la classe est lié à la fonction. Ici, nous lions la fonction fn au nom de la méthode bonjour.

métaclasse

Métaclasse, traduit littéralement par métaclasse, l'explication simple est : après avoir défini une classe, nous pouvons créer une instance basée sur cette classe, donc : d'abord Définissez la classe, puis créez des instances. Mais que se passe-t-il si nous voulons créer une classe ? Ensuite, vous devez créer une classe basée sur la métaclasse, donc : définissez d'abord la métaclasse, puis créez la classe. La connexion est la suivante : définissez d’abord la métaclasse, puis vous pouvez créer la classe et enfin créer l’instance. Les paramètres reçus par la méthode

__new__() sont :

1. L'objet de la classe en cours de création ;

2. class Le nom ; la collection de classes parent héritées par la classe

3.  ; la collection de méthodes de la classe

4. .

9.3.10 Utiliser des instances comme propriétés

Lorsque vous utilisez du code pour simuler des objets réels, vous trouverez des propriétés et des méthodes à mesure que vous ajoutez de plus en plus de fonctionnalités et de détails. Et les fichiers de code deviennent de plus en plus longs, une partie d'entre eux peut être séparée et réorganisée en classe. Une grande catégorie peut être divisée en plusieurs sous-catégories.

9.3.11 Simulation d'objets physiques

Pour simuler des objets physiques plus complexes, vous devez les considérer à partir d'un niveau logique supérieur. Afin d'écrire du code plus efficace, concis et précis, vous devrez peut-être constamment réorganiser les cours.

9.4 Importation de classes

1. Au fur et à mesure que des classes continuent d'être ajoutées, même un excellent héritage rendra le code très long, donc python vous permet d'importer des classes dans des modules. Et importez les modules requis pour les utiliser dans le programme principal.

2. Rédigez une chaîne de documentation pour chaque module, expliquez la fonction du module et décrivez brièvement le contenu.

3. Importez plusieurs classes d'un module, séparez-les par des virgules et créez des instances selon vos besoins.

4. Vous pouvez également importer la classe entière, ajouter le nom de la classe avant l'instance et accéder à la classe requise.

5. Importez un module dans un autre module.

9.5 bibliothèque standard python (module)

La bibliothèque standard Python est un ensemble de modules qui peuvent être importés et utilisés uniquement avec l'instruction import.

Les dictionnaires vous permettent d'associer des informations, mais n'enregistrent pas l'ordre dans lequel vous ajoutez des paires clé-valeur. Pour créer un dictionnaire et enregistrer l'ordre dans lequel vous ajoutez des paires clé-valeur, vous pouvez utiliser le orderDict. classe dans le module collections. Les instances de OrderedDict sont identiques aux dictionnaires, mais enregistrent l'ordre dans lequel les paires clé-valeur sont ajoutées.

OrderdDict est très bien, il possède à la fois les caractéristiques d'une liste et d'un dictionnaire, ce qui est parfois nécessaire.

module aléatoire

Contient des fonctions permettant de générer des nombres aléatoires de différentes manières. Où randint() renvoie un entier dans la plage spécifiée.

datetime est un module

Le module datetime contient également une classe datetime La classe datetime est importée via from datetime import datetime. Si vous importez uniquement import datetime, vous devez citer le nom complet datetime.datetime.

datetime.now() renvoie la date et l'heure actuelles, son type est datetime.

Bibliothèques tierces couramment utilisées

Il existe également des pilotes MySQL : mysql-connector-python, la bibliothèque NumPy pour le calcul scientifique : numpy, l'outil de modèle Jinja2 pour générer du texte, etc.

　1.urlparse module, le module urlpasrse fournit quelques fonctions de base pour le traitement des chaînes d'URL. Ces fonctions incluent urlparse(), urlunparse() et urljoin().

　2.urlparse() analyse urlstr en un 6-tuple (prot_sch, net_loc, path, params, query, frag). Chaque composant ici a été décrit précédemment.

3. La fonction de urlunparse() est complètement opposée à urlpase(). Elle génère un urltup 6-tuple (prot_sch, net_loc, path, params, query, frag) à partir de l'URL traitée par urlparse(), et le fusionne dans une URL et renvoie.

　4. Le module urllib fournit de nombreuses fonctions qui peuvent être utilisées pour télécharger des données à partir d'une URL spécifiée. Il peut également encoder et décoder des chaînes afin qu'elles puissent être affichées sous la forme correcte dans l'URL. Les fonctions à présenter ci-dessous incluent urlopen(), urlretrieve(), quote(), unquote(), quote_plus(), unquote_plus() et urlencode().

5.urlopen() ouvre une connexion Web représentée par une chaîne URL donnée et renvoie un objet de type fichier.

6. urlretrieve() ne sert pas à accéder et à ouvrir l'URL sous forme de fichier, mais à télécharger le HTML complet et à l'enregistrer sous forme de fichier.

9.6 Style de codage des classes

Être familier avec le style de codage lié aux classes, surtout lorsque le programme est complexe.

1. Le nom de la classe doit utiliser la méthode de dénomination en casse chameau , c'est-à-dire que la première lettre de la classe est en majuscule, sans traits de soulignement, tandis que la première lettre du nom de l'instance et du module le nom est en minuscules et les traits de soulignement sont utilisés pour relier les mots.

2. Ajoutez une description de chaîne de documentation après chaque définition de classe pour décrire brièvement la fonction de la classe, et ajoutez une description de chaîne de documentation sous chaque module pour décrire ce que les classes sous le module peuvent faire.

3. Utilisez des lignes vides pour organiser le code, mais n'en abusez pas. Vous pouvez utiliser une ligne vide pour séparer les méthodes dans une classe et utiliser deux lignes vides pour séparer les classes.

4. Lorsque vous devez importer des modules dans la bibliothèque standard et des modules écrits par vous-même en même temps, écrivez d'abord l'instruction d'importation pour importer le module de bibliothèque standard, séparé par une ligne vide, puis importez le déclaration d'importation de module que vous avez écrite. Lorsque plusieurs instructions d'importation sont incluses, il est plus facile de comprendre l'origine de chaque module du programme.

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!