Raccourcis orientés objet

Ce chapitre décrit en détail diverses fonctions intégrées dans Python, les opérations d'E / S sur les fichiers et les concepts de surcharge.

Fonctions intégrées Python

L'interpréteur Python a un certain nombre de fonctions appelées fonctions intégrées qui sont facilement disponibles pour une utilisation. Dans sa dernière version, Python contient 68 fonctions intégrées répertoriées dans le tableau ci-dessous -

FONCTIONS INTÉGRÉES
abdos()	dict ()	Aidez-moi()	min ()	setattr ()
tout()	dir ()	hex ()	prochain()	tranche()
tout()	divmod ()	id ()	objet()	trié ()
ascii ()	énumérer()	contribution()	oct()	méthode statique ()
poubelle()	eval ()	int ()	ouvert()	str ()
booléen ()	exec ()	isinstance ()	ord ()	somme()
bytearray ()	filtre()	issubclass ()	pow ()	super()
octets ()	flotte()	iter ()	impression()	tuple ()
appelable ()	format()	len ()	propriété()	type()
chr ()	frozenset ()	liste()	intervalle()	vars ()
méthode de classe ()	getattr ()	des locaux()	repr ()	Zip *: français()
compiler()	globaux ()	carte()	renversé()	__importer__()
complexe()	hasattr ()	max ()	rond()
delattr ()	hacher()	mémoire visuelle()	ensemble()

Cette section décrit brièvement certaines des fonctions importantes -

fonction len ()

La fonction len () obtient la longueur des chaînes, des listes ou des collections. Il renvoie la longueur ou le nombre d'éléments d'un objet, où l'objet peut être une chaîne, une liste ou une collection.

>>> len(['hello', 9 , 45.0, 24])
4

La fonction len () fonctionne en interne comme list.__len__() ou tuple.__len__(). Ainsi, notez que len () ne fonctionne que sur les objets qui ont un __len__() méthode.

>>> set1
{1, 2, 3, 4}
>>> set1.__len__()
4

Cependant, en pratique, nous préférons len() à la place du __len__() fonctionner pour les raisons suivantes -

• C'est plus efficace. Et il n'est pas nécessaire qu'une méthode particulière soit écrite pour refuser l'accès à des méthodes spéciales telles que __len__.

• Il est facile à entretenir.

• Il prend en charge la compatibilité descendante.

Inversé (seq)

Il renvoie l'itérateur inverse. seq doit être un objet qui a la méthode __reversed __ () ou prend en charge le protocole de séquence (la méthode __len __ () et la méthode __getitem __ ()). Il est généralement utilisé dansfor boucles lorsque nous voulons boucler des éléments de l'arrière vers l'avant.

>>> normal_list = [2, 4, 5, 7, 9]
>>>
>>> class CustomSequence():
   def __len__(self):
      return 5
   def __getitem__(self,index):
      return "x{0}".format(index)
>>> class funkyback():
   def __reversed__(self):
      return 'backwards!'
>>> for seq in normal_list, CustomSequence(), funkyback():
      print('\n{}: '.format(seq.__class__.__name__), end="")
      for item in reversed(seq):
         print(item, end=", ")

La boucle for à la fin imprime la liste inversée d'une liste normale et les instances des deux séquences personnalisées. La sortie montre quereversed() fonctionne sur tous les trois, mais a des résultats très différents lorsque nous définissons __reversed__.

Production

Vous pouvez observer la sortie suivante lorsque vous exécutez le code donné ci-dessus -

list: 9, 7, 5, 4, 2,
CustomSequence: x4, x3, x2, x1, x0,
funkyback: b, a, c, k, w, a, r, d, s, !,

Énumérer

le enumerate () ajoute un compteur à un itérable et retourne l'objet énumérer.

La syntaxe de enumerate () est -

enumerate(iterable, start = 0)

Voici le deuxième argument start est facultatif et par défaut, l'index commence par zéro (0).

>>> # Enumerate
>>> names = ['Rajesh', 'Rahul', 'Aarav', 'Sahil', 'Trevor']
>>> enumerate(names)
<enumerate object at 0x031D9F80>
>>> list(enumerate(names))
[(0, 'Rajesh'), (1, 'Rahul'), (2, 'Aarav'), (3, 'Sahil'), (4, 'Trevor')]
>>>

Alors enumerate()renvoie un itérateur qui produit un tuple qui conserve le nombre d'éléments de la séquence passée. Puisque la valeur de retour est un itérateur, y accéder directement n'est pas très utile. Une meilleure approche pour enumerate () est de garder count dans une boucle for.

>>> for i, n in enumerate(names):
   print('Names number: ' + str(i))
   print(n)
Names number: 0
Rajesh
Names number: 1
Rahul
Names number: 2
Aarav
Names number: 3
Sahil
Names number: 4
Trevor

Il existe de nombreuses autres fonctions dans la bibliothèque standard, et voici une autre liste de certaines fonctions plus largement utilisées -

• hasattr, getattr, setattr et delattr, qui permet aux attributs d'un objet d'être manipulés par leurs noms de chaîne.

• all et any, qui acceptent un objet itérable et retournent True si tous les éléments, ou certains d'entre eux, sont considérés comme vrais.

• nzip, qui prend deux séquences ou plus et renvoie une nouvelle séquence de tuples, où chaque tuple contient une seule valeur de chaque séquence.

E / S de fichier

Le concept de fichiers est associé au terme de programmation orientée objet. Python a enveloppé l'interface fournie par les systèmes d'exploitation dans l'abstraction qui nous permet de travailler avec des objets fichier.

le open()La fonction intégrée est utilisée pour ouvrir un fichier et renvoyer un objet fichier. C'est la fonction la plus couramment utilisée avec deux arguments -

open(filename, mode)

La fonction open () appelle deux arguments, le premier est le nom du fichier et le second est le mode. Ici, le mode peut être 'r' pour le mode lecture seule, 'w' pour l'écriture uniquement (un fichier existant avec le même nom sera effacé), et 'a' ouvre le fichier pour l'ajout, toutes les données écrites dans le fichier sont automatiquement ajoutées jusqu'à la fin. «r +» ouvre le fichier en lecture et en écriture. Le mode par défaut est en lecture seule.

Sous Windows, «b» ajouté au mode ouvre le fichier en mode binaire, il existe donc également des modes comme «rb», «wb» et «r + b».

>>> text = 'This is the first line'
>>> file = open('datawork','w')
>>> file.write(text)
22
>>> file.close()

Dans certains cas, nous voulons simplement ajouter au fichier existant plutôt que de l'écraser, pour cela nous pourrions fournir la valeur 'a' comme argument de mode, à ajouter à la fin du fichier, plutôt que d'écraser complètement le fichier existant Contenu.

>>> f = open('datawork','a')
>>> text1 = ' This is second line'
>>> f.write(text1)
20
>>> f.close()

Une fois qu'un fichier est ouvert pour la lecture, nous pouvons appeler la méthode read, readline ou readlines pour obtenir le contenu du fichier. La méthode read renvoie tout le contenu du fichier sous la forme d'un objet str ou bytes, selon que le deuxième argument est «b».

Pour la lisibilité, et pour éviter de lire un fichier volumineux en une seule fois, il est souvent préférable d'utiliser une boucle for directement sur un objet fichier. Pour les fichiers texte, il lira chaque ligne, une à la fois, et nous pouvons la traiter à l'intérieur du corps de la boucle. Pour les fichiers binaires, il est cependant préférable de lire des blocs de données de taille fixe en utilisant la méthode read (), en passant un paramètre pour le nombre maximum d'octets à lire.

>>> f = open('fileone','r+')
>>> f.readline()
'This is the first line. \n'
>>> f.readline()
'This is the second line. \n'

L'écriture dans un fichier, via la méthode d'écriture sur les objets fichier, écrit un objet chaîne (octets pour les données binaires) dans le fichier. La méthode writelines accepte une séquence de chaînes et écrit chacune des valeurs itérées dans le fichier. La méthode writelines n'ajoute pas de nouvelle ligne après chaque élément de la séquence.

Enfin, la méthode close () doit être appelée lorsque nous avons terminé de lire ou d'écrire le fichier, pour garantir que toutes les écritures en mémoire tampon sont écrites sur le disque, que le fichier a été correctement nettoyé et que toutes les ressources liées au fichier sont renvoyées vers le système d'exploitation. C'est une meilleure approche d'appeler la méthode close (), mais techniquement, cela se produira automatiquement lorsque le script existe.

Une alternative à la surcharge de méthode

La surcharge de méthode fait référence au fait d'avoir plusieurs méthodes avec le même nom qui acceptent différents ensembles d'arguments.

Étant donné une seule méthode ou fonction, nous pouvons spécifier nous-mêmes le nombre de paramètres. Selon la définition de la fonction, elle peut être appelée avec zéro, un, deux paramètres ou plus.

class Human:
   def sayHello(self, name = None):
      if name is not None:
         print('Hello ' + name)
      else:
         print('Hello ')

#Create Instance
obj = Human()

#Call the method, else part will be executed
obj.sayHello()

#Call the method with a parameter, if part will be executed
obj.sayHello('Rahul')

Production

Hello
Hello Rahul

Arguments par défaut

Les fonctions sont aussi des objets

Un objet appelable est un objet qui peut accepter certains arguments et peut éventuellement retourner un objet. Une fonction est l'objet appelable le plus simple en Python, mais il en existe d'autres comme des classes ou certaines instances de classe.

Chaque fonction d'un Python est un objet. Les objets peuvent contenir des méthodes ou des fonctions mais l'objet n'est pas nécessairement une fonction.

def my_func():
   print('My function was called')
my_func.description = 'A silly function'
def second_func():

   print('Second function was called')

   second_func.description = 'One more sillier function'

def another_func(func):
   print("The description:", end=" ")
   print(func.description)
   print('The name: ', end=' ')
   print(func.__name__)
   print('The class:', end=' ')
   print(func.__class__)
   print("Now I'll call the function passed in")
   func()

another_func(my_func)
another_func(second_func)

Dans le code ci-dessus, nous pouvons passer deux fonctions différentes en argument dans notre troisième fonction et obtenir une sortie différente pour chacune -

The description: A silly function
The name: my_func
The class: 
      
        Now I'll call the function passed in My function was called The description: One more sillier function The name: second_func The class: 
       
         Now I'll call the function passed in Second function was called 
       
      

callable objects

Just as functions are objects that can have attributes set on them, it is possible to create an object that can be called as though it were a function.

In Python any object with a __call__() method can be called using function-call syntax.