Python orientado a objetos - Guía rápida

Python orientado a objetos - Introducción

Los lenguajes de programación están emergiendo constantemente, y también lo hacen diferentes

metodologías. La programación orientada a objetos es una de esas metodologías que se ha vuelto
bastante popular en los últimos años.

Este capítulo habla sobre las características del lenguaje de programación Python que lo convierte en
un lenguaje de programación orientado a objetos.

Programa de clasificación de programación de idiomas

Python se puede caracterizar bajo metodologías de programación orientadas a objetos. La siguiente
imagen muestra las características de varios lenguajes de programación. Observe las características
de Python que lo hacen orientado a objetos.

Clases de lenguaje Categorias Langauages

Paradigma de Procesal C, C ++, C #, Objective-C, java, Go

programación
Scripting CoffeeScript, JavaScript, Python, Perl, Php, Ruby

Funcional Clojure, Eralang, Haskell, Scala

Clase de compilación Estático C, C ++, C #, Objective-C, java, Go, Haskell, Scala

Dinámica CoffeeScript, JavaScript, Python, Perl, Php, Ruby, Clojure,

Erlang

Tipo de clase Fuerte C #, Java, Go, Python, Ruby, Clojure, Erlang, Haskell, Scala

Débiles C, C ++, C #, Objective-C, CoffeeScript, JavaScript, Perl, Php

Clase de memoria Gestionado Otros

No C, C ++, C #, Objetivo-C
gestionado

¿Qué es la programación orientada a objetos?

Orientado a objetos significa dirigido hacia objetos. En otras palabras, significa funcionalmente
dirigido a modelar objetos. Esta es una de las muchas técnicas utilizadas para modelar sistemas
complejos al describir una colección de objetos interactivos a través de sus datos y comportamiento.

Python, una programación orientada a objetos (OOP), es una forma de programación que se enfoca
en usar objetos y clases para diseñar y construir aplicaciones. Los principales pilares de la
programación orientada a objetos (OOP) son herencia, polimorfismo, abstracción y
encapsulación .

El análisis orientado a objetos (OOA) es el proceso de examinar un problema, sistema o tarea e

identificar los objetos e interacciones entre ellos.

¿Por qué elegir la programación orientada a objetos?

Python fue diseñado con un enfoque orientado a objetos. OOP ofrece las siguientes ventajas:
Proporciona una estructura de programa clara, que facilita el mapeo de problemas del mundo
real y sus soluciones.

Facilita el fácil mantenimiento y modificación del código existente.

Mejora la modularidad del programa porque cada objeto existe de forma independiente y se
pueden agregar fácilmente nuevas características sin perturbar las existentes.

Presenta un buen marco para bibliotecas de códigos donde los componentes suministrados
pueden ser fácilmente adaptados y modificados por el programador.

Imparte la reutilización del código

Programación vs Programación Orientada a Objetos

La programación basada en procedimientos se deriva de la programación estructural basada en los
conceptos de funciones / procedimientos / rutinas . Es fácil acceder y cambiar los datos en
programación orientada a procedimientos. Por otro lado, la Programación Orientada a Objetos (OOP)
permite la descomposición de un problema en varias unidades llamadas objetos y luego construir los
datos y funciones alrededor de estos objetos. Se enfatiza más en los datos que en el procedimiento o
las funciones. También en OOP, los datos están ocultos y no se puede acceder mediante un
procedimiento externo.

La tabla en la siguiente imagen muestra las principales diferencias entre el enfoque POP y OOP.

Diferencia entre programación orientada a procedimientos (POP) vs. Programación Orientada a

Objetos (OOP).
 Programación Orientada a
Programación orientada a objetos
Procedimientos

Vaya se basa en un escenario del mundo

En Pop, todo el foco está en datos y
Residencia en real. Todo el programa se divide en pequeñas
funciones
partes llamadas objeto

Reusabilidad Reutilización limitada del código Reutilización de código

Acercarse Enfoque de arriba hacia abajo Diseño centrado en objetos

Especificadores
No cualquiera Público, privado y protegido
de acceso

Los datos pueden moverse libremente En Oops, los datos pueden moverse y
Movimiento de
de funciones a funciones en el sistema comunicarse entre sí a través de funciones
datos miembro

En pop, la mayoría de las funciones En Oops, los datos no pueden moverse

Acceso a los utilizan datos globales para compartir a libremente de un método a otro, se pueden
datos los que se puede acceder libremente de mantener en público o en privado para que
una función a otra en el sistema
podamos controlar el acceso a los datos.

En pop, una forma tan específica de Proporciona ocultación de datos, mucho más
Ocultar datos
ocultar datos, un poco menos segura segura.

Sobrecarga Imposible Funciones y sobrecarga del operador

Idiomas de
C, VB, Fortran, Pascal C ++, Python, Java, C #
ejemplo

Utiliza abstracción a nivel de Utiliza abstracción a nivel de clase y objeto

Abstracción
procedimiento

Principios de la programación orientada a objetos

La programación orientada a objetos (OOP) se basa en el concepto de objetos en lugar de acciones,

y datos en lugar de lógica. Para que un lenguaje de programación esté orientado a objetos, debe
tener un mecanismo que permita trabajar con clases y objetos, así como la implementación y el uso
de los principios y conceptos fundamentales orientados a objetos, a saber, herencia, abstracción,
encapsulación y polimorfismo.
Vamos a comprender cada uno de los pilares de la programación orientada a objetos en breve:

Encapsulación

Esta propiedad oculta detalles innecesarios y facilita la administración de la estructura del programa.
La implementación y el estado de cada objeto están ocultos detrás de límites bien definidos y eso
proporciona una interfaz limpia y simple para trabajar con ellos. Una forma de lograr esto es haciendo
que los datos sean privados.

Herencia

La herencia, también llamada generalización, nos permite capturar una relación jerárquica entre
clases y objetos. Por ejemplo, una 'fruta' es una generalización de 'naranja'. La herencia es muy útil
desde la perspectiva de reutilización de código.

Abstracción

Esta propiedad nos permite ocultar los detalles y exponer solo las características esenciales de un
concepto u objeto. Por ejemplo, una persona que conduce un scooter sabe que al presionar una
bocina, se emite sonido, pero no tiene idea de cómo se genera el sonido al presionar la bocina.

Polimorfismo

Polimorfismo significa muchas formas. Es decir, una cosa o acción está presente en diferentes formas
o formas. Un buen ejemplo de polimorfismo es la sobrecarga del constructor en las clases.

Python orientado a objetos

El corazón de la programación de Python es el objeto y la POO , sin embargo, no necesita
restringirse para usar la POO al organizar su código en clases. OOP se suma a toda la filosofía de
diseño de Python y fomenta una forma limpia y pragmática de programar. OOP también permite
escribir programas más grandes y complejos.

Módulos vs. Clases y Objetos

Los módulos son como "Diccionarios"

Cuando trabaje en módulos, tenga en cuenta los siguientes puntos:

Un módulo de Python es un paquete para encapsular código reutilizable.

Los módulos residen en una carpeta con un archivo __init__.py .

Los módulos contienen funciones y clases.
Los módulos se importan usando la palabra clave import .

Recuerde que un diccionario es un par clave-valor . Eso significa que si tiene un diccionario con una
clave EmployeID y desea recuperarlo, deberá usar las siguientes líneas de código:

employee = {“EmployeID”: “Employee Unique Identity!”}

print (employee [‘EmployeID])

Deberá trabajar en módulos con el siguiente proceso:

Un módulo es un archivo de Python con algunas funciones o variables.

Importa el archivo que necesitas.

Ahora, puede acceder a las funciones o variables en ese módulo con el '.' (punto) Operador.

Considere un módulo llamado employee.py con una función llamada empleado . El código de la
función se da a continuación:

# this goes in employee.py

def EmployeID():
print (“Employee Unique Identity!”)

Ahora importe el módulo y luego acceda a la función EmployeID -

import employee
employee. EmployeID()

Puede insertar una variable llamada Age , como se muestra:

def EmployeID():
print (“Employee Unique Identity!”)
# just a variable
Age = “Employee age is **”

Ahora, acceda a esa variable de la siguiente manera:

import employee
employee.EmployeID()
 print(employee.Age)

Ahora, comparemos esto con el diccionario:

Employee[‘EmployeID’] # get EmployeID from employee

Employee.employeID() # get employeID from the module
Employee.Age # get access to variable

Tenga en cuenta que hay un patrón común en Python:

Tome una clave = contenedor de estilo de valor

Saca algo de eso por el nombre de la llave

Al comparar el módulo con un diccionario, ambos son similares, excepto con lo siguiente:
En el caso del diccionario , la clave es una cadena y la sintaxis es [clave].

En el caso del módulo , la clave es un identificador y la sintaxis es .key.

Las clases son como módulos

El módulo es un diccionario especializado que puede almacenar código Python para que pueda
acceder a él con el '.' Operador. Una clase es una forma de tomar una agrupación de funciones y
datos y colocarlos dentro de un contenedor para que pueda acceder a ellos con el operador '.'.

Si tiene que crear una clase similar al módulo de empleado, puede hacerlo usando el siguiente
código:

class employee(object):
def __init__(self):
self. Age = “Employee Age is ##”
def EmployeID(self):
print (“This is just employee unique identity”)

Nota : las clases son preferibles a los módulos porque puede reutilizarlos como están y sin mucha
interferencia. Mientras que con los módulos, solo tiene uno con todo el programa.

Los objetos son como miniimportaciones

Una clase es como un mini módulo y puede importar de manera similar a como lo hace para las
clases, utilizando el concepto llamado instanciar . Tenga en cuenta que cuando crea una instancia de
una clase, obtiene un objeto .

You can instantiate an object, similar to calling a class like a function, as shown −

this_obj = employee() # Instantiatethis_obj.EmployeID() # get EmployeId from the class

print(this_obj.Age) # get variable Age

You can do this in any of the following three ways −

# dictionary style
Employee[‘EmployeID’]
# module style
Employee.EmployeID()
Print(employee.Age)
 # Class style
this_obj = employee()
this_obj.employeID()
Print(this_obj.Age)

Object Oriented Python - Environment Setup

This chapter will explain in detail about setting up the Python environment on your local computer.

Prerequisites and Toolkits

Before you proceed with learning further on Python, we suggest you to check whether the following
prerequisites are met −

Latest version of Python is installed on your computer

An IDE or text editor is installed

You have basic familiarity to write and debug in Python, that is you can do the following in
Python −
Able to write and run Python programs.

Debug programs and diagnose errors.

Work with basic data types.

Write for loops, while loops, and if statements

Funciones de código

Si no tiene experiencia en lenguaje de programación, puede encontrar muchos tutoriales para

principiantes en Python en
https://www.tutorialpoints.com/

Instalando Python

Los siguientes pasos le muestran en detalle cómo instalar Python en su computadora local:
Paso 1 : vaya al sitio web oficial de Python https://www.python.org/ , haga clic en el menú
Descargas y elija la última versión o cualquier versión estable de su elección.
Paso 2 : guarde el archivo exe del instalador de Python que está descargando y, una vez que lo haya
descargado, ábralo. Haga clic en Ejecutar y elija la opción Siguiente de forma predeterminada y
finalice la instalación.

Paso 3 : después de haber instalado, ahora debería ver el menú de Python como se muestra en la
imagen a continuación. Inicie el programa eligiendo IDLE (Python GUI).

Esto iniciará el shell de Python. Escriba comandos simples para verificar la instalación.
Elegir un IDE

Un entorno de desarrollo integrado es un editor de texto orientado al desarrollo de software. Tendrá

que instalar un IDE para controlar el flujo de su programación y agrupar proyectos cuando trabaje en
Python. Aquí hay algunos IDE disponibles en línea. Puede elegir uno a su conveniencia.
IDE Pycharm
IDE de Komodo
Eric Python IDE

Nota : Eclipse IDE se usa principalmente en Java, sin embargo, tiene un complemento de Python.

Pycharm

Pycharm, el IDE multiplataforma es uno de los IDE más

populares actualmente disponibles. Proporciona
asistencia y análisis de codificación con finalización de
código, navegación de proyecto y código, prueba de
unidad integrada, integración de control de versión,
depuración y mucho más.

Enlace de descarga

https://www.jetbrains.com/pycharm/download/#section=windows

Idiomas admitidos : Python, HTML, CSS, JavaScript, Coffee Script, TypeScript, Cython, AngularJS,
Node.js, lenguajes de plantilla.

Captura de pantalla
¿Por qué elegir?

PyCharm ofrece las siguientes características y beneficios para sus usuarios:

IDE multiplataforma compatible con Windows, Linux y Mac OS
Incluye Django IDE, además de soporte CSS y JavaScript
Incluye miles de complementos, terminal integrado y control de versiones
Se integra con Git, SVN y Mercurial
Ofrece herramientas de edición inteligentes para Python
Fácil integración con Virtualenv, Docker y Vagrant.
Navegación simple y funciones de búsqueda
Análisis de código y refactorización
Inyecciones configurables
Admite toneladas de bibliotecas de Python
Contiene plantillas y depuradores de JavaScript
Incluye depuradores Python / Django
Funciona con Google App Engine, marcos adicionales y bibliotecas.
Tiene IU personalizable, emulación VIM disponible

IDE de Komodo

Es un IDE políglota que admite más de 100 idiomas y

básicamente para lenguajes dinámicos como Python,
PHP y Ruby. Es un IDE comercial disponible durante 21
días de prueba gratuita con funcionalidad completa.
ActiveState es la compañía de software que gestiona el
desarrollo del IDE de Komodo. También ofrece una
versión recortada de Komodo conocida como Komodo
Edit para tareas de programación simples.

Este IDE contiene todo tipo de características, desde el

nivel más básico hasta el avanzado. Si eres un
estudiante o un profesional independiente, puedes
comprarlo casi la mitad del precio real. Sin embargo, es completamente gratuito para profesores y
profesores de instituciones y universidades reconocidas.
Obtuvo todas las características que necesita para el desarrollo web y móvil, incluida la compatibilidad
con todos sus idiomas y marcos.

Enlace de descarga

Los enlaces de descarga para Komodo Edit (versión gratuita) y Komodo IDE (versión de pago) se
muestran aquí:

Edición de Komodo (gratis)

https://www.activestate.com/komodo-edit

IDE de Komodo (pago)

https://www.activestate.com/komodo-ide/downloads/ide
Captura de pantalla

¿Por qué elegir?

Potente IDE con soporte para Perl, PHP, Python, Ruby y muchos más.
IDE multiplataforma.

It includes basic features like integrated debugger support, auto complete, Document Object
Model(DOM) viewer, code browser, interactive shells, breakpoint configuration, code profiling,
integrated unit testing. In short, it is a professional IDE with a host of productivity-boosting features.

Eric Python IDE

It is an open-source IDE for Python and Ruby. Eric is a

full featured editor and IDE, written in Python. It is based
on the cross platform Qt GUI toolkit, integrating the
highly flexible Scintilla editor control. The IDE is very
much configurable and one can choose what to use and
what not. You can download Eric IDE from below link:
https://eric-ide.python-projects.org/eric-download.html

Why to Choose

Great indentation, error highlighting.

Code assistance
Code completion
Code cleanup with PyLint
Quick search
Integrated Python debugger.

Screenshot
Elegir un editor de texto
Es posible que no siempre necesite un IDE. Para tareas como aprender a codificar con Python o
Arduino, o cuando se trabaja en un script rápido en script de shell para ayudarlo a automatizar
algunas tareas, un editor de texto centrado en el código simple y liviano hará. Además, muchos
editores de texto ofrecen características como el resaltado de sintaxis y la ejecución de scripts en el
programa, similares a los IDE. Algunos de los editores de texto se dan aquí:
Átomo
Texto sublime
Notepad ++

Atom Text Editor

Atom es un editor de texto pirateable creado por el
equipo de GitHub. Es un editor de texto y código gratuito
y de código abierto, lo que significa que todo el código
está disponible para que lo lea, modifique para su propio
uso e incluso contribuya con mejoras. Es un editor de
texto multiplataforma compatible para macOS, Linux y
Microsoft Windows con soporte para complementos
escritos en Node.js y Git Control incorporado.

Enlace de descarga

https://atom.io/

Captura de pantalla
Idiomas admitidos

C / C ++, C #, CSS, CoffeeScript, HTML, JavaScript, Java, JSON, Julia, Objective-C, PHP, Perl,
Python, Ruby on Rails, Ruby, script de Shell, Scala, SQL, XML, YAML y muchos más.

Sublime Text Editor

Sublime Text es un software patentado y le ofrece una
versión de prueba gratuita para probarlo antes de
comprarlo. Según stackoverflow.com , es el cuarto
entorno de desarrollo más popular.
Algunas de las ventajas que brinda es su increíble
velocidad, facilidad de uso y soporte comunitario.
También es compatible con muchos lenguajes de
programación y lenguajes de marcado, y los usuarios
pueden agregar funciones con complementos,
generalmente creados y mantenidos por la comunidad
bajo licencias de software libre.

Captura de pantalla
Idioma soportado

Python, Ruby, JavaScript, etc.

¿Por qué elegir?

Personalice las combinaciones de teclas, menús, fragmentos, macros, terminaciones y más.

Característica de finalización automática
Inserte rápidamente texto y código con fragmentos de texto sublimes utilizando fragmentos,
marcadores de campo y marcadores de posición

Se abre rápidamente

Soporte multiplataforma para Mac, Linux y Windows.

Salta el cursor hacia donde quieres ir
Seleccione múltiples líneas, palabras y columnas

Notepad ++
Es un editor de código fuente gratuito y un reemplazo de
Bloc de notas que admite varios idiomas desde
ensamblado a XML e incluye Python. Ejecutando en el
entorno de MS Windows, su uso se rige por la licencia
GPL. Además del resaltado de sintaxis, Notepad ++
tiene algunas características que son particularmente
útiles para los codificadores.

Captura de pantalla
Características clave

Resaltado de sintaxis y plegado de sintaxis

PCRE (expresión regular compatible con Perl) Buscar / reemplazar
GUI completamente personalizable
Finalización automática
Edición con pestañas
Vista múltiple
Entorno multilingüe
Lanzable con diferentes argumentos.

Idioma soportado

Casi todos los idiomas (más de 60 idiomas) como Python, C, C ++, C #, Java, etc.

Python orientado a objetos - Estructuras de datos

Las estructuras de datos de Python son muy intuitivas desde el punto de vista de la sintaxis y ofrecen
una gran variedad de operaciones. Debe elegir la estructura de datos de Python en función de lo que
implican los datos, si es necesario modificarlos o si son datos fijos y qué tipo de acceso se requiere,
como al principio / final / aleatorio, etc.

Liza
Una lista representa el tipo de estructura de datos más versátil en Python. Una lista es un contenedor
que contiene valores separados por comas (elementos o elementos) entre corchetes. Las listas son
útiles cuando queremos trabajar con múltiples valores relacionados. Como las listas mantienen los
datos juntos, podemos realizar los mismos métodos y operaciones en múltiples valores a la vez. Los
índices de listas comienzan desde cero y, a diferencia de las cadenas, las listas son mutables.
Estructura de datos - Lista

>>>
>>> # Any Empty List
>>> empty_list = []
>>>
>>> # A list of String
>>> str_list = ['Life', 'Is', 'Beautiful']
>>> # A list of Integers
>>> int_list = [1, 4, 5, 9, 18]
>>>
>>> #Mixed items list
>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>> # To print the list
>>>
>>> print(empty_list)
[]
>>> print(str_list)
['Life', 'Is', 'Beautiful']
>>> print(type(str_list))
<class 'list'>
>>> print(int_list)
[1, 4, 5, 9, 18]
>>> print(mixed_list)
['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']

Acceso a elementos en la lista de Python

A cada elemento de una lista se le asigna un número, que es el índice o la posición de ese número.
La indexación siempre comienza desde cero, el segundo índice es uno y así sucesivamente. Para
acceder a los elementos de una lista, podemos usar estos números de índice dentro de un corchete.
Observe el siguiente código, por ejemplo:

>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>>
>>> # To access the First Item of the list
>>> mixed_list[0]
'This'
>>> # To access the 4th item
>>> mixed_list[3]
18
>>> # To access the last item of the list
>>> mixed_list[-1]
'list'

Objetos vacíos
Los objetos vacíos son los tipos integrados de Python más simples y básicos. Los hemos usado
varias veces sin darnos cuenta y lo hemos extendido a cada clase que hemos creado. El propósito
principal de escribir una clase vacía es bloquear algo por el momento y luego extenderlo y agregarle
un comportamiento.
Agregar un comportamiento a una clase significa reemplazar una estructura de datos con un objeto y
cambiar todas las referencias a él. Por lo tanto, es importante verificar los datos, ya sea un objeto
disfrazado, antes de crear algo. Observe el siguiente código para una mejor comprensión:

>>> #Empty objects

>>>
>>> obj = object()
>>> obj.x = 9
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
obj.x = 9
AttributeError: 'object' object has no attribute 'x'

Entonces, desde arriba, podemos ver que no es posible establecer ningún atributo en un objeto que
se instancia directamente. Cuando Python permite que un objeto tenga atributos arbitrarios, se
necesita una cierta cantidad de memoria del sistema para realizar un seguimiento de los atributos que
tiene cada objeto, para almacenar tanto el nombre del atributo como su valor. Incluso si no se
almacenan atributos, se asigna una cierta cantidad de memoria para posibles nuevos atributos.

Por lo tanto, Python deshabilita las propiedades arbitrarias en el objeto y varios otros elementos
integrados, de forma predeterminada.

>>> # Empty Objects

>>>
>>> class EmpObject:
pass
>>> obj = EmpObject()
>>> obj.x = 'Hello, World!'
>>> obj.x
'Hello, World!'

Por lo tanto, si queremos agrupar las propiedades, podríamos almacenarlas en un objeto vacío como
se muestra en el código anterior. Sin embargo, este método no siempre se sugiere. Recuerde que las
clases y los objetos solo deben usarse cuando desea especificar datos y comportamientos.

Tuplas
Las tuplas son similares a las listas y pueden almacenar elementos. Sin embargo, son inmutables, por
lo que no podemos agregar, eliminar o reemplazar objetos. Los principales beneficios que brinda la
tupla debido a su inmutabilidad es que podemos usarlos como claves en los diccionarios, o en otras
ubicaciones donde un objeto requiere un valor hash.
Las tuplas se usan para almacenar datos y no comportamientos. En caso de que requiera un
comportamiento para manipular una tupla, debe pasar la tupla a una función (o método en otro objeto)
que realice la acción.

Como la tupla puede actuar como una clave de diccionario, los valores almacenados son diferentes
entre sí. Podemos crear una tupla separando los valores con una coma. Las tuplas están entre
paréntesis pero no son obligatorias. El siguiente código muestra dos tareas idénticas.

>>> stock1 = 'MSFT', 95.00, 97.45, 92.45

>>> stock2 = ('MSFT', 95.00, 97.45, 92.45)
>>> type (stock1)
<class 'tuple'>
 >>> type(stock2)
<class 'tuple'>
>>> stock1 == stock2
True
>>>

Definiendo una tupla

Las tuplas son muy similares a la lista, excepto que todo el conjunto de elementos está encerrado
entre paréntesis en lugar de corchetes.
Al igual que cuando corta una lista, obtiene una nueva lista y cuando corta una tupla, obtiene una
nueva tupla.

>>> tupl = ('Tuple','is', 'an','IMMUTABLE', 'list')

>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl[0]
'Tuple'
>>> tupl[-1]
'list'
>>> tupl[1:3]
('is', 'an')

Métodos de tupla de Python

El siguiente código muestra los métodos en las tuplas de Python:

>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl.append('new')
Traceback (most recent call last):
File "<pyshell#148>", line 1, in <module>
tupl.append('new')
AttributeError: 'tuple' object has no attribute 'append'
>>> tupl.remove('is')
Traceback (most recent call last):
File "<pyshell#149>", line 1, in <module>
tupl.remove('is')
AttributeError: 'tuple' object has no attribute 'remove'
>>> tupl.index('list')
4
>>> tupl.index('new')
Traceback (most recent call last):
File "<pyshell#151>", line 1, in <module>
tupl.index('new')
ValueError: tuple.index(x): x not in tuple
>>> "is" in tupl
True
>>> tupl.count('is')
1

Del código que se muestra arriba, podemos entender que las tuplas son inmutables y, por lo tanto,
 No puede agregar elementos a una tupla.
No puede agregar o extender un método.
No puede eliminar elementos de una tupla.

Las tuplas no tienen método de eliminación o pop.

Cuenta e índice son los métodos disponibles en una tupla.

Diccionario
El diccionario es uno de los tipos de datos integrados de Python y define las relaciones uno a uno
entre claves y valores.

Definición de diccionarios

Observe el siguiente código para comprender cómo definir un diccionario:

>>> # empty dictionary

>>> my_dict = {}
>>>
>>> # dictionary with integer keys
>>> my_dict = { 1:'msft', 2: 'IT'}
>>>
>>> # dictionary with mixed keys
>>> my_dict = {'name': 'Aarav', 1: [ 2, 4, 10]}
>>>
>>> # using built-in function dict()
>>> my_dict = dict({1:'msft', 2:'IT'})
>>>
>>> # From sequence having each item as a pair
>>> my_dict = dict([(1,'msft'), (2,'IT')])
>>>
>>> # Accessing elements of a dictionary
>>> my_dict[1]
'msft'
>>> my_dict[2]
'IT'
>>> my_dict['IT']
Traceback (most recent call last):
File "<pyshell#177>", line 1, in <module>
my_dict['IT']
KeyError: 'IT'
>>>

Del código anterior podemos observar que:

Primero creamos un diccionario con dos elementos y lo asignamos a la variable my_dict .
Cada elemento es un par clave-valor, y todo el conjunto de elementos está encerrado entre
llaves.

El número 1 es la clave y msft es su valor. Del mismo modo, 2 es la clave y TI es su valor.

Puede obtener valores por clave, pero no al revés. Por lo tanto, cuando probamos my_dict
['IT'] , genera una excepción, porque TI no es una clave.
Modificando Diccionarios

Observe el siguiente código para comprender cómo modificar un diccionario:

>>> # Modifying a Dictionary

>>>
>>> my_dict
{1: 'msft', 2: 'IT'}
>>> my_dict[2] = 'Software'
>>> my_dict
{1: 'msft', 2: 'Software'}
>>>
>>> my_dict[3] = 'Microsoft Technologies'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}

Del código anterior podemos observar que:

You cannot have duplicate keys in a dictionary. Altering the value of an existing key will delete
the old value.

You can add new key-value pairs at any time.

Dictionaries have no concept of order among elements. They are simple unordered
collections.

Mixing Data types in a Dictionary

Observe the following code to understand about mixing data types in a dictionary −

>>> # Mixing Data Types in a Dictionary

>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}
>>> my_dict[4] = 'Operating System'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>> my_dict['Bill Gates'] = 'Owner'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}

From the above code we can observe that −

Not just strings but dictionary value can be of any data type including strings, integers,
including the dictionary itself.
Unlike dictionary values, dictionary keys are more restricted, but can be of any type like
strings, integers or any other.

Deleting Items from Dictionaries

Observe the following code to understand about deleting items from a dictionary −

>>> # Deleting Items from a Dictionary

>>>
 >>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}
>>>
>>> del my_dict['Bill Gates']
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>>
>>> my_dict.clear()
>>> my_dict
{}

From the above code we can observe that −

del − lets you delete individual items from a dictionary by key.

clear : elimina todos los elementos de un diccionario.

Conjuntos

Set () es una colección desordenada sin elementos duplicados. Aunque los elementos individuales
son inmutables, el conjunto en sí es mutable, es decir, podemos agregar o eliminar elementos /
elementos del conjunto. Podemos realizar operaciones matemáticas como unión, intersección, etc.
con set.
Aunque los conjuntos en general se pueden implementar usando árboles, el conjunto en Python se
puede implementar usando una tabla hash. Esto le permite un método altamente optimizado para
verificar si un elemento específico está contenido en el conjunto

Crear un conjunto

Un conjunto se crea colocando todos los elementos (elementos) dentro de llaves {} , separadas por
comas o utilizando la función integrada set () . Observe las siguientes líneas de código:

>>> #set of integers

>>> my_set = {1,2,4,8}
>>> print(my_set)
{8, 1, 2, 4}
>>>
>>> #set of mixed datatypes
>>> my_set = {1.0, "Hello World!", (2, 4, 6)}
>>> print(my_set)
{1.0, (2, 4, 6), 'Hello World!'}
>>>

Métodos para conjuntos

Observe el siguiente código para comprender los métodos para conjuntos:

>>> >>> #METHODS FOR SETS

>>>
>>> #add(x) Method
>>> topics = {'Python', 'Java', 'C#'}
>>> topics.add('C++')
 >>> topics
{'C#', 'C++', 'Java', 'Python'}
>>>
>>> #union(s) Method, returns a union of two set.
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>> team = {'Developer', 'Content Writer', 'Editor','Tester'}
>>> group = topics.union(team)
>>> group
{'Tester', 'C#', 'Python', 'Editor', 'Developer', 'C++', 'Java', 'Content
Writer'}
>>> # intersets(s) method, returns an intersection of two sets
>>> inters = topics.intersection(team)
>>> inters
set()
>>>
>>> # difference(s) Method, returns a set containing all the elements of
invoking set but not of the second set.
>>>
>>> safe = topics.difference(team)
>>> safe
{'Python', 'C++', 'Java', 'C#'}
>>>
>>> diff = topics.difference(group)
>>> diff
set()
>>> #clear() Method, Empties the whole set.
>>> group.clear()
>>> group
set()
>>>

Operadores para Conjuntos

Observe el siguiente código para comprender los operadores para conjuntos:

>>> # PYTHON SET OPERATIONS

>>>
>>> #Creating two sets
>>> set1 = set()
>>> set2 = set()
>>>
>>> # Adding elements to set
>>> for i in range(1,5):
set1.add(i)
>>> for j in range(4,9):
set2.add(j)
>>> set1
{1, 2, 3, 4}
>>> set2
{4, 5, 6, 7, 8}
>>>
>>> #Union of set1 and set2
>>> set3 = set1 | set2 # same as set1.union(set2)
 >>> print('Union of set1 & set2: set3 = ', set3)
Union of set1 & set2: set3 = {1, 2, 3, 4, 5, 6, 7, 8}
>>>
>>> #Intersection of set1 & set2
>>> set4 = set1 & set2 # same as set1.intersection(set2)
>>> print('Intersection of set1 and set2: set4 = ', set4)
Intersection of set1 and set2: set4 = {4}
>>>
>>> # Checking relation between set3 and set4
>>> if set3 > set4: # set3.issuperset(set4)
print('Set3 is superset of set4')
elif set3 < set4: #set3.issubset(set4)
print('Set3 is subset of set4')
else: #set3 == set4
print('Set 3 is same as set4')
Set3 is superset of set4
>>>
>>> # Difference between set3 and set4
>>> set5 = set3 - set4
>>> print('Elements in set3 and not in set4: set5 = ', set5)
Elements in set3 and not in set4: set5 = {1, 2, 3, 5, 6, 7, 8}
>>>
>>> # Check if set4 and set5 are disjoint sets
>>> if set4.isdisjoint(set5):
print('Set4 and set5 have nothing in common\n')
Set4 and set5 have nothing in common
>>> # Removing all the values of set5
>>> set5.clear()
>>> set5 set()

Python orientado a objetos: bloques de construcción

En este capítulo, discutiremos en detalle los términos orientados a objetos y los conceptos de
programación. Class es solo una fábrica para una instancia. Esta fábrica contiene el plan que
describe cómo hacer las instancias. Se crean instancias u objetos a partir de la clase. En la mayoría
de los casos, podemos tener más de una instancia de una clase. Cada instancia tiene un conjunto de
atributos y estos atributos se definen en una clase, por lo que se espera que cada instancia de una
clase en particular tenga los mismos atributos.

Paquetes de clase: comportamiento y estado

Una clase le permitirá agrupar el comportamiento y el estado de un objeto. Observe el siguiente
diagrama para una mejor comprensión:
The following points are worth notable when discussing class bundles −
The word behavior is identical to function – it is a piece of code that does something (or
implements a behavior)
The word state is identical to variables – it is a place to store values within a class.
When we assert a class behavior and state together, it means that a class packages functions
and variables.

Classes have methods and attributes

In Python, creating a method defines a class behavior. The word method is the OOP name given to a
function that is defined within a class. To sum up −
Class functions − is synonym for methods
Class variables − is synonym for name attributes.
Clase : un plano para una instancia con comportamiento exacto.
Objeto : una de las instancias de la clase, realiza la funcionalidad definida en la clase.
Tipo : indica la clase a la que pertenece la instancia

Atributo : cualquier valor de objeto: object.attribute

Método : un "atributo invocable" definido en la clase

Observe el siguiente fragmento de código, por ejemplo:

var = “Hello, John”

print( type (var)) # < type ‘str’> or <class 'str'>
print(var.upper()) # upper() method is called, HELLO, JOHN

Creación e instanciación
El siguiente código muestra cómo crear nuestra primera clase y luego su instancia.

class MyClass(object):
pass
# Create first instance of MyClass
this_obj = MyClass()
print(this_obj)
# Another instance of MyClass
that_obj = MyClass()
print (that_obj)

Aquí hemos creado una clase llamada MyClass y que no realiza ninguna tarea. El objeto de
argumento en la clase MyClass implica herencia de clase y se discutirá en capítulos posteriores.
pasar el código anterior indica que este bloque está vacío, es decir, es una definición de clase vacía.
Vamos a crear una instancia this_obj de la clase MyClass () e imprimirla como se muestra:

<__main__.MyClass object at 0x03B08E10>

<__main__.MyClass object at 0x0369D390>

Aquí, hemos creado una instancia de MyClass. El código hexadecimal se refiere a la dirección donde
se almacena el objeto. Otra instancia apunta a otra dirección.
Ahora definamos una variable dentro de la clase MyClass () y obtengamos la variable de la instancia
de esa clase como se muestra en el siguiente código:

class MyClass(object):
var = 9

# Create first instance of MyClass

this_obj = MyClass()
print(this_obj.var)

# Another instance of MyClass

that_obj = MyClass()
print (that_obj.var)

Salida

Puede observar el siguiente resultado cuando ejecuta el código dado anteriormente:

9
9

Como la instancia sabe de qué clase se instancia, entonces cuando se solicita un atributo de una
instancia, la instancia busca el atributo y la clase. Esto se llama la búsqueda de atributos.

Métodos de instancia

Una función definida en una clase se llama método. Un método de instancia requiere una instancia
para llamarlo y no requiere decorador. Al crear un método de instancia, el primer parámetro siempre
es self. Aunque podemos llamarlo (self) con cualquier otro nombre, se recomienda usar self, ya que
es una convención de nomenclatura.

class MyClass(object):
var = 9
def firstM(self):
print("hello, World")
obj = MyClass()
print(obj.var)
obj.firstM()

Salida

Puede observar el siguiente resultado cuando ejecuta el código dado anteriormente:

9
hello, World

Tenga en cuenta que en el programa anterior, definimos un método con self como argumento. Pero no
podemos llamar al método ya que no le hemos declarado ningún argumento.

class MyClass(object):
def firstM(self):
print("hello, World")
print(self)
obj = MyClass()
obj.firstM()
print(obj)

Salida

Puede observar el siguiente resultado cuando ejecuta el código dado anteriormente:

hello, World
<__main__.MyClass object at 0x036A8E10>
<__main__.MyClass object at 0x036A8E10>

Encapsulación

La encapsulación es uno de los fundamentos de OOP. OOP nos permite ocultar la complejidad del
funcionamiento interno del objeto que es ventajoso para el desarrollador de las siguientes maneras:
Simplifica y facilita la comprensión del uso de un objeto sin conocer los elementos internos.
Cualquier cambio puede ser fácilmente manejable.

La programación orientada a objetos depende en gran medida de la encapsulación. Los términos

encapsulación y abstracción (también llamados ocultación de datos) a menudo se usan como
sinónimos. Son casi sinónimos, ya que la abstracción se logra a través de la encapsulación.
La encapsulación nos proporciona el mecanismo para restringir el acceso a algunos de los
componentes del objeto, esto significa que la representación interna de un objeto no se puede ver
desde fuera de la definición del objeto. El acceso a estos datos generalmente se logra a través de
métodos especiales: Getters y Setters.
Estos datos se almacenan en atributos de instancia y se pueden manipular desde cualquier lugar
fuera de la clase. Para asegurarlo, solo se debe acceder a esos datos utilizando métodos de
instancia. No se debe permitir el acceso directo.

class MyClass(object):
def setAge(self, num):
self.age = num

def getAge(self):
return self.age

zack = MyClass()
zack.setAge(45)
print(zack.getAge())

zack.setAge("Fourty Five")
print(zack.getAge())

Salida

Puede observar el siguiente resultado cuando ejecuta el código dado anteriormente:

45
Fourty Five

Los datos deben almacenarse solo si son correctos y válidos, utilizando construcciones de manejo de
excepciones. Como podemos ver arriba, no hay restricción en la entrada del usuario al método
setAge (). Puede ser una cadena, un número o una lista. Por lo tanto, debemos verificar el código
anterior para garantizar la exactitud del almacenamiento.

class MyClass(object):
def setAge(self, num):
self.age = num

def getAge(self):
return self.age

zack = MyClass()
zack.setAge(45)
print(zack.getAge())
zack.setAge("Fourty Five")
print(zack.getAge())

Init Constructor

El método __ init __ se llama implícitamente tan pronto como se instancia un objeto de una clase.
Esto inicializará el objeto.

x = MyClass()
The line of code shown above will create a new instance and assigns this object to the local variable x.
The instantiation operation, that is calling a class object, creates an empty object. Many classes like
to create objects with instances customized to a specific initial state. Therefore, a class may define a
special method named ‘ __init__() ‘ as shown −

def __init__(self):
self.data = []

Python calls __init__ during the instantiation to define an additional attribute that should occur when a
class is instantiated that may be setting up some beginning values for that object or running a routine
required on instantiation. So in this example, a new, initialized instance can be obtained by −

x = MyClass()

El método __init __ () puede tener argumentos únicos o múltiples para una mayor flexibilidad. El init
significa inicialización, ya que inicializa los atributos de la instancia. Se llama el constructor de una
clase.

class myclass(object):
def __init__(self,aaa, bbb):
self.a = aaa
self.b = bbb

x = myclass(4.5, 3)
print(x.a, x.b)

Salida

4.5 3

Atributos de clase
El atributo definido en la clase se denomina "atributos de clase" y los atributos definidos en la función
se denominan "atributos de instancia". Mientras se definen, estos atributos no tienen el prefijo self, ya
que son propiedad de la clase y no de una instancia en particular.

La clase misma (className.attributeName) y las instancias de la clase (inst.attributeName) pueden

acceder a los atributos de la clase. Por lo tanto, las instancias tienen acceso tanto al atributo de
instancia como a los atributos de clase.

>>> class myclass():

age = 21
>>> myclass.age
21
>>> x = myclass()
>>> x.age
21
>>>
Un atributo de clase se puede anular en una instancia, aunque no es un buen método para romper la
encapsulación.
Hay una ruta de búsqueda de atributos en Python. El primero es el método definido dentro de la
clase, y luego la clase por encima.

>>> class myclass(object):

classy = 'class value'
>>> dd = myclass()
>>> print (dd.classy) # This should return the string 'class value'
class value
>>>
>>> dd.classy = "Instance Value"
>>> print(dd.classy) # Return the string "Instance Value"
Instance Value
>>>
>>> # This will delete the value set for 'dd.classy' in the instance.
>>> del dd.classy
>>> >>> # Since the overriding attribute was deleted, this will print 'class
value'.

>>> print(dd.classy)
class value
>>>

Estamos anulando el atributo de clase 'con clase' en la instancia dd. Cuando se anula, el intérprete de
Python lee el valor anulado. Pero una vez que el nuevo valor se elimina con 'del', el valor anulado ya
no está presente en la instancia y, por lo tanto, la búsqueda sube un nivel y se obtiene de la clase.

Trabajar con datos de clase e instancia

En esta sección, comprendamos cómo se relacionan los datos de la clase con los datos de la
instancia. Podemos almacenar datos en una clase o en una instancia. Cuando diseñamos una clase,
decidimos qué datos pertenecen a la instancia y qué datos deben almacenarse en la clase general.
Una instancia puede acceder a los datos de la clase. Si creamos varias instancias, estas instancias
pueden acceder a sus valores de atributo individuales así como a los datos generales de la clase.
Por lo tanto, los datos de una clase son los datos que se comparten entre todas las instancias.
Observe el código que figura a continuación para una mejor comprensión:

class InstanceCounter(object):
count = 0 # class attribute, will be accessible to all instances
def __init__(self, val):
self.val = val
InstanceCounter.count +=1 # Increment the value of class attribute, accessible through
# In above line, class ('InstanceCounter') act as an object
def set_val(self, newval):
self.val = newval

def get_val(self):
return self.val

def get_count(self):
return InstanceCounter.count
 a = InstanceCounter(9)
b = InstanceCounter(18)
c = InstanceCounter(27)

for obj in (a, b, c):

print ('val of obj: %s' %(obj.get_val())) # Initialized value ( 9, 18, 27)
print ('count: %s' %(obj.get_count())) # always 3

Salida

val of obj: 9
count: 3
val of obj: 18
count: 3
val of obj: 27
count: 3

En resumen, los atributos de clase son los mismos para todas las instancias de clase, mientras que
los atributos de instancia son particulares para cada instancia. Para dos instancias diferentes,
tendremos dos atributos de instancia diferentes.

class myClass:
class_attribute = 99

def class_method(self):
self.instance_attribute = 'I am instance attribute'

print (myClass.__dict__)

Salida

Puede observar el siguiente resultado cuando ejecuta el código dado anteriormente:

{'__module__': '__main__', 'class_attribute': 99, 'class_method': <function myClass.class_met

El atributo de instancia myClass .__ dict__ como se muestra:

>>> a = myClass()
>>> a.class_method()
>>> print(a.__dict__)
{'instance_attribute': 'I am instance attribute'}

Atajos orientados a objetos

Este capítulo habla en detalle sobre varias funciones integradas en Python, operaciones de E / S de
archivos y conceptos de sobrecarga.
Funciones integradas de Python

El intérprete de Python tiene una serie de funciones llamadas funciones integradas que están
fácilmente disponibles para su uso. En su última versión, Python contiene 68 funciones integradas
que se enumeran en la tabla a continuación:

FUNCIONES INTEGRADAS

abdominales() dict () ayuda() min () setattr ()

todos() dir () maleficio() siguiente() rebanada()

ninguna() divmod () carné de identidad() objeto() ordenado ()

ascii () enumerar() entrada() oct() método estático ()

compartimiento() eval () En t() abierto() str ()

bool () exec () isinstance () ord () suma()

bytearray () filtrar() issubclass () pow () súper()

bytes () flotador() iter () impresión() tupla ()

invocable () formato() len () propiedad() tipo()

chr () frozenset () lista() rango() vars ()

método de clase () getattr () locales () repr () Código Postal()

compilar() globales () mapa() invertido () __importar__()

complejo() hasattr () max () redondo()

delattr () picadillo() vista de la memoria() conjunto()

Esta sección discute algunas de las funciones importantes en breve:

función len ()

La función len () obtiene la longitud de cadenas, listas o colecciones. Devuelve la longitud o el número
de elementos de un objeto, donde el objeto puede ser una cadena, una lista o una colección.

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

4

La función len () funciona internamente como list .__ len __ () o tuple .__ len __ () . Por lo tanto,
tenga en cuenta que len () funciona solo en objetos que tienen un método __ len __ () .

>>> set1
{1, 2, 3, 4}
>>> set1.__len__()
4
Sin embargo, en la práctica, preferimos len () en lugar de la función __len __ () debido a las
siguientes razones:

Es mas eficiente. Y no es necesario que se escriba un método particular para negar el

acceso a métodos especiales como __len__.
Es fácil de mantener.
Es compatible con la compatibilidad con versiones anteriores.

Invertido (seq)

Devuelve el iterador inverso. seq debe ser un objeto que tenga el método __ invertido __ () o que
admita el protocolo de secuencia (el método __len __ () y el método __getitem __ ()). Generalmente
se usa para bucles cuando queremos recorrer los elementos de atrás hacia adelante.

>>> 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=", ")

El bucle for al final imprime la lista invertida de una lista normal y las instancias de las dos secuencias
personalizadas. El resultado muestra que reverse () funciona en los tres, pero tiene resultados muy
diferentes cuando definimos __reversed__ .

Salida

Puede observar el siguiente resultado cuando ejecuta el código dado anteriormente:

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

Enumerar

El método enumerate () agrega un contador a un iterable y devuelve el objeto enumerate.

La sintaxis de enumerate () es -

enumerate(iterable, start = 0)

Aquí el inicio del segundo argumento es opcional, y por defecto el índice comienza con cero (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')]
>>>

Entonces enumerate () devuelve un iterador que produce una tupla que mantiene el recuento de los
elementos en la secuencia pasada. Dado que el valor de retorno es un iterador, acceder directamente
a él no es muy útil. Un mejor enfoque para enumerate () es mantener el conteo dentro de un ciclo 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

Hay muchas otras funciones en la biblioteca estándar, y aquí hay otra lista de algunas funciones más
utilizadas:
hasattr, getattr, setattr y delattr, que permiten que los atributos de un objeto sean
manipulados por sus nombres de cadena.
all and any, que aceptan un objeto iterable y devuelven True si todos o alguno de los
elementos se evalúan como verdaderos.
nzip, que toma dos o más secuencias y devuelve una nueva secuencia de tuplas, donde
cada tupla contiene un solo valor de cada secuencia.

E / S de archivo

El concepto de archivos está asociado con el término programación orientada a objetos. Python ha
incluido la interfaz que los sistemas operativos proporcionan en abstracción que nos permite trabajar
con objetos de archivo.
La función incorporada open () se utiliza para abrir un archivo y devolver un objeto de archivo. Es la
función más utilizada con dos argumentos:

open(filename, mode)

La función open () llama a dos argumentos, primero es el nombre del archivo y el segundo es el
modo. Aquí el modo puede ser 'r' para el modo de solo lectura, 'w' para solo escribir (se borrará un
archivo existente con el mismo nombre) y 'a' abre el archivo para agregarlo, cualquier dato escrito en
el archivo se agrega automáticamente hasta el final. 'r +' abre el archivo para leer y escribir. El modo
predeterminado es de solo lectura.
En Windows, 'b' agregado al modo abre el archivo en modo binario, por lo que también hay modos
como 'rb', 'wb' y 'r + b'.

>>> text = 'This is the first line'

>>> file = open('datawork','w')
>>> file.write(text)
22
>>> file.close()

En algunos casos, solo queremos agregar al archivo existente en lugar de sobrescribirlo, para eso
podríamos proporcionar el valor 'a' como argumento de modo, para agregar al final del archivo, en
lugar de sobrescribir completamente el archivo existente contenido.

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

Una vez que se abre un archivo para leer, podemos llamar al método read, readline o readlines para
obtener el contenido del archivo. El método de lectura devuelve todo el contenido del archivo como un
objeto str o bytes, dependiendo de si el segundo argumento es 'b'.

Para facilitar la lectura y evitar leer un archivo grande de una vez, a menudo es mejor usar un bucle
for directamente en un objeto de archivo. Para los archivos de texto, leerá cada línea, una a la vez, y
podemos procesarla dentro del cuerpo del bucle. Sin embargo, para archivos binarios es mejor leer
fragmentos de datos de tamaño fijo utilizando el método read (), pasando un parámetro para la
cantidad máxima de bytes a leer.

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

Al escribir en un archivo, a través del método de escritura en objetos de archivo, se escribirá un objeto
de cadena (bytes para datos binarios) en el archivo. El método de líneas de escritura acepta una
secuencia de cadenas y escribe cada uno de los valores iterados en el archivo. El método de líneas
de escritura no agrega una nueva línea después de cada elemento de la secuencia.

Finalmente, se debe llamar al método close () cuando hayamos terminado de leer o escribir el
archivo, para garantizar que las escrituras almacenadas en el búfer se escriban en el disco, que el
archivo se haya limpiado correctamente y que todos los recursos vinculados al archivo se vuelvan a
liberar El sistema operativo. Es un mejor enfoque llamar al método close (), pero técnicamente esto
sucederá automáticamente cuando exista el script.

Una alternativa a la sobrecarga de métodos.

La sobrecarga de métodos se refiere a tener múltiples métodos con el mismo nombre que aceptan
diferentes conjuntos de argumentos.
Dado un único método o función, podemos especificar el número de parámetros nosotros mismos.
Dependiendo de la definición de la función, se puede llamar con cero, uno, dos o más parámetros.

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')

Salida

Hello
Hello Rahul

Argumentos predeterminados

Las funciones son objetos también

Un objeto invocable es un objeto que puede aceptar algunos argumentos y posiblemente devolverá
un objeto. Una función es el objeto invocable más simple en Python, pero también hay otros como
clases o ciertas instancias de clase.
Cada función en un Python es un objeto. Los objetos pueden contener métodos o funciones, pero el
objeto no es necesariamente una función.

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)

En el código anterior, podemos pasar dos funciones diferentes como argumento a nuestra tercera
función y obtener diferentes resultados para cada una:

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

objetos invocables

Así como las funciones son objetos que pueden tener atributos establecidos en ellas, es posible crear
un objeto al que se pueda llamar como si fuera una función.
En Python, cualquier objeto con un método __call __ () puede llamarse utilizando la sintaxis de
llamada a función.

Herencia y polimorfismo

Herencia y polimorfismo: este es un concepto muy importante en Python. Debes entenderlo mejor si
quieres aprender.

Herencia

Una de las principales ventajas de la programación orientada a objetos es la reutilización. La herencia

es uno de los mecanismos para lograr lo mismo. La herencia permite al programador crear primero
una clase general o una clase base y luego extenderla a una clase más especializada. Permite al
programador escribir mejor código.
Al usar la herencia, puede usar o heredar todos los campos de datos y métodos disponibles en su
clase base. Más tarde, puede agregar sus propios métodos y campos de datos, por lo que la herencia
proporciona una forma de organizar el código, en lugar de reescribirlo desde cero.
En la terminología orientada a objetos, cuando la clase X extiende la clase Y, entonces Y se llama
clase super / padre / base y X se llama clase subclase / hijo / derivada. Un punto a tener en cuenta
aquí es que solo los campos de datos y el método que no son privados son accesibles para las clases
secundarias. Los campos y métodos de datos privados solo son accesibles dentro de la clase.

la sintaxis para crear una clase derivada es:

 class BaseClass:
Body of base class
class DerivedClass(BaseClass):
Body of derived class

Heredar atributos
Ahora mira el siguiente ejemplo:

Salida

Primero creamos una clase llamada Fecha y pasamos el objeto como argumento, aquí-objeto es una
clase incorporada proporcionada por Python. Más tarde creamos otra clase llamada time y llamamos
a la clase Date como argumento. A través de esta llamada, tenemos acceso a todos los datos y
atributos de la clase Fecha en la clase Hora. Por eso, cuando intentamos obtener el método get_date
del objeto de clase Time tm que creamos antes posible.
Objeto Jerarquía de búsqueda de atributos
La instancia
La clase
Cualquier clase de la cual esta clase hereda

Ejemplos de herencia

Echemos un vistazo al ejemplo de herencia:

Creemos un par de clases para participar en ejemplos:
Animal - Clase simula un animal
Gato - Subclase de animales
Perro - Subclase de animales

En Python, el constructor de clase utilizado para crear un objeto (instancia) y asignar el valor de los
atributos.

El constructor de subclases siempre llama a un constructor de la clase principal para inicializar el

valor de los atributos en la clase principal, luego comienza a asignar valor para sus atributos.

Salida

En el ejemplo anterior, vemos los atributos o métodos de comando que colocamos en la clase
primaria para que todas las subclases o clases secundarias hereden esa propiedad de la clase
primaria.
Si una subclase intenta heredar métodos o datos de otra subclase, entonces se producirá un error,
como vemos cuando la clase Dog intenta llamar a los métodos swatstring () de esa clase cat, arroja
un error (como AttributeError en nuestro caso).

Polimorfismo ("MUCHAS FORMAS")

El polimorfismo es una característica importante de la definición de clase en Python que se utiliza
cuando comúnmente se nombran métodos entre clases o subclases. Esto permite que las funciones
usen entidades de diferentes tipos en diferentes momentos. Por lo tanto, proporciona flexibilidad y
acoplamiento flexible para que el código se pueda extender y mantener fácilmente con el tiempo.

Esto permite que las funciones usen objetos de cualquiera de estas clases polimórficas sin necesidad
de conocer las distinciones entre las clases.
El polimorfismo se puede llevar a cabo mediante herencia, con subclases que utilizan métodos de
clase base o los anulan.
Dejemos entender el concepto de polimorfismo con nuestro ejemplo de herencia anterior y
agreguemos un método común llamado show_affection en ambas subclases:
A partir del ejemplo que podemos ver, se refiere a un diseño en el que un objeto de tipo diferente
puede tratarse de la misma manera o más específicamente dos o más clases con un método del
mismo nombre o una interfaz común porque el mismo método (show_affection en el siguiente
ejemplo) se llama con cualquier tipo de objetos.

Salida

Entonces, todos los animales muestran afecto (show_affection), pero lo hacen de manera diferente. El
comportamiento de "show_affection" es, por lo tanto, polimórfico en el sentido de que actuó de
manera diferente dependiendo del animal. Por lo tanto, el concepto abstracto de "animal" en realidad
no "show_affection", pero los animales específicos (como perros y gatos) tienen una implementación
concreta de la acción "show_affection".
Python en sí tiene clases que son polimórficas. Por ejemplo, la función len () se puede usar con varios
objetos y todos devuelven la salida correcta en función del parámetro de entrada.
Primordial

En Python, cuando una subclase contiene un método que anula un método de la superclase, también
puede llamar al método de la superclase llamando a
Super (subclase, self) .method en lugar de self.method.

Ejemplo

class Thought(object):
def __init__(self):
pass
def message(self):
print("Thought, always come and go")

class Advice(Thought):
def __init__(self):
super(Advice, self).__init__()
def message(self):
print('Warning: Risk is always involved when you are dealing with market!')

Heredar al constructor
Si vemos en nuestro ejemplo de herencia anterior, __init__ estaba ubicado en la clase padre en la
parte superior porque el perro o gato de la clase infantil no tenía el método __init__. Python usó la
búsqueda de atributos de herencia para encontrar __init__ en la clase animal. Cuando creamos la
clase secundaria, primero verá el método __init__ en la clase de perro, luego no lo encontró, luego
buscó en la clase principal Animal y lo encontró allí y lo llamó allí. Entonces, a medida que nuestro
diseño de clase se volvió complejo, es posible que deseamos inicializar una instancia procesándola
primero a través del constructor de clase padre y luego a través del constructor de clase hijo.
Salida

En el ejemplo anterior, todos los animales tienen un nombre y todos los perros una raza en particular.
Llamamos constructor de clase padre con super. Entonces el perro tiene su propio __init__ pero lo
primero que sucede es que llamamos super. Super está integrado en la función y está diseñado para
relacionar una clase con su superclase o su clase principal.
En este caso, decimos que obtenga la superclase de perro y pase la instancia de perro a cualquier
método que digamos aquí, el constructor __init__. En otras palabras, estamos llamando a la clase
padre Animal __init__ con el objeto perro. Puede preguntar por qué no solo diremos Animal __init__
con la instancia del perro, podríamos hacer esto, pero si el nombre de la clase animal cambiara, en
algún momento en el futuro. ¿Qué pasa si queremos reorganizar la jerarquía de clases, por lo que el
perro heredó de otra clase? Usar super en este caso nos permite mantener las cosas modulares y
fáciles de cambiar y mantener.
En este ejemplo, podemos combinar la funcionalidad general __init__ con una funcionalidad más
específica. Esto nos da la oportunidad de separar la funcionalidad común de la funcionalidad
específica que puede eliminar la duplicación de código y relacionar la clase entre sí de una manera
que refleje el diseño general del sistema.

Conclusión

__init__ es como cualquier otro método; puede ser heredado

Si una clase no tiene un constructor __init__, Python verificará su clase principal para ver si
puede encontrar uno.
Tan pronto como encuentra uno, Python lo llama y deja de buscar
 Podemos usar la función super () para llamar a métodos en la clase padre.
Es posible que queramos inicializar tanto en el padre como en nuestra propia clase.

Herencia múltiple y el árbol de búsqueda

Como su nombre lo indica, la herencia múltiple es Python cuando una clase hereda de varias clases.
Por ejemplo, un niño hereda los rasgos de personalidad de ambos padres (Madre y Padre).

Sintaxis de herencia múltiple de Python

Para hacer que una clase herede de varias clases de padres, escribimos los nombres de estas clases
dentro de los paréntesis en la clase derivada mientras la definimos. Separamos estos nombres con
comas.
A continuación se muestra un ejemplo de eso:

>>> class Mother:

pass

>>> class Father:

pass

>>> class Child(Mother, Father):

pass

>>> issubclass(Child, Mother) and issubclass(Child, Father)

True

La herencia múltiple se refiere a la capacidad de heredar de dos o más de dos clases. La complejidad
surge cuando el hijo hereda de los padres y los padres heredan de la clase de los abuelos. Python
trepa a un árbol heredado en busca de atributos que se solicitan que se lean desde un objeto.
Verificará en la instancia, dentro de la clase, luego en la clase padre y, por último, en la clase abuelo.
Ahora surge la pregunta en qué orden se buscarán las clases: primero la respiración o la profundidad
primero. Por defecto, Python va con la profundidad primero.
Es por eso que en el diagrama a continuación, Python busca el método dothis () primero en la clase
A. Por lo tanto, el orden de resolución del método en el ejemplo a continuación será

Mro- D → B → A → C
Mire el siguiente diagrama de herencia múltiple:
Veamos un ejemplo para comprender la característica "mro" de un Python.

Salida

Ejemplo 3

Tomemos otro ejemplo de herencia múltiple de "forma de diamante".

El diagrama anterior se considerará ambiguo. De nuestro ejemplo anterior entendiendo el "orden de
resolución del método" .ie mro será D → B → A → C → A pero no lo es. Al obtener la segunda A de la
C, Python ignorará la A. anterior, por lo que la mro será en este caso D → B → C → A.

Creemos un ejemplo basado en el diagrama anterior:

Salida
La regla simple para comprender el resultado anterior es: si la misma clase aparece en el orden de
resolución del método, las apariencias anteriores de esta clase se eliminarán del orden de resolución
del método.

En conclusión
Cualquier clase puede heredar de múltiples clases

Python normalmente usa un orden de "profundidad primero" cuando busca clases

heredadas.

Pero cuando dos clases heredan de la misma clase, Python elimina las primeras apariciones
de esa clase del mro.

Decoradores, Estáticos y Métodos de Clase

Las funciones (o métodos) se crean mediante la declaración def.

Aunque los métodos funcionan exactamente de la misma manera que una función, excepto en un
punto donde el primer argumento del método es objeto de instancia.

Podemos clasificar los métodos en función de cómo se comportan, como

Método simple : definido fuera de una clase. Esta función puede acceder a los atributos de
clase al alimentar el argumento de instancia:

def outside_func(():

Método de instancia -

def func(self,)

Método de clase : si necesitamos usar atributos de clase

@classmethod
def cfunc(cls,)

Método estático : no tengo ninguna información sobre la clase

@staticmethod
def sfoo()

Hasta ahora hemos visto el método de instancia, ahora es el momento de obtener una idea de los
otros dos métodos,

Método de clase

El decorador @classmethod es un decorador de funciones incorporado que pasa la clase a la que se

llamó o la clase de la instancia a la que se llamó como primer argumento. El resultado de esa
evaluación sombrea la definición de su función.

sintaxis
 class C(object):
@classmethod
def fun(cls, arg1, arg2, ...):
....
fun: function that needs to be converted into a class method
returns: a class method for function

Tienen acceso a este argumento cls, no puede modificar el estado de la instancia del objeto. Eso
requeriría acceso a uno mismo.

Está vinculado a la clase y no al objeto de la clase.

Los métodos de clase aún pueden modificar el estado de la clase que se aplica en todas las
instancias de la clase.

Método estático

Un método estático no toma un parámetro self ni cls (clase) pero es libre de aceptar un número
arbitrario de otros parámetros.

sintaxis

class C(object):
@staticmethod
def fun(arg1, arg2, ...):
...
returns: a static method for function funself.

Un método estático no puede modificar el estado del objeto ni el estado de la clase.

Están restringidos a qué datos pueden acceder.

Cuándo usar qué

Generalmente usamos el método de clase para crear métodos de fábrica. Los métodos de
fábrica devuelven un objeto de clase (similar a un constructor) para diferentes casos de uso.

Generalmente usamos métodos estáticos para crear funciones de utilidad.

Patrón de diseño de Python

Visión general
El desarrollo de software moderno necesita abordar requisitos comerciales complejos. También debe
tener en cuenta factores como la extensibilidad y la mantenibilidad futuras. Un buen diseño de un
sistema de software es vital para lograr estos objetivos. Los patrones de diseño juegan un papel
importante en tales sistemas.

Para comprender el patrón de diseño, consideremos el siguiente ejemplo:

El diseño de cada automóvil sigue un patrón de diseño básico, cuatro ruedas, volante, el
sistema de transmisión central como el acelerador-freno-embrague, etc.
Entonces, todas las cosas construidas / producidas repetidamente, inevitablemente seguirán un
patrón en su diseño ... autos, bicicletas, pizzas, cajeros automáticos, lo que sea ... incluso su sofá
cama.

Los diseños que casi se han convertido en una forma estándar de codificar alguna lógica / mecanismo
/ técnica en software, por lo tanto, se conocen o estudian como Patrones de diseño de software.

¿Por qué es importante el patrón de diseño?

Los beneficios de usar patrones de diseño son:

Le ayuda a resolver problemas de diseño comunes a través de un enfoque probado.

No hay ambigüedad en la comprensión, ya que están bien documentados.

Reduzca el tiempo de desarrollo general.

Le ayuda a lidiar con futuras extensiones y modificaciones con más facilidad que de otra
manera.
Puede reducir los errores en el sistema, ya que son soluciones comprobadas para problemas
comunes.

Clasificación de patrones de diseño

Los patrones de diseño GoF (Gang of Four) se clasifican en tres categorías, a saber, creacional,
estructural y conductual.

Patrones creacionales

Los patrones de diseño de creación separan la lógica de creación de objetos del resto del sistema. En
lugar de crear objetos, los patrones de creación los crean para usted. Los patrones de creación
incluyen Abstract Factory, Builder, Factory Method, Prototype y Singleton.
Los patrones de creación no se usan comúnmente en Python debido a la naturaleza dinámica del
lenguaje. Además, el lenguaje en sí mismo nos proporciona toda la flexibilidad que necesitamos para
crear de una manera elegante y suficiente, rara vez necesitamos implementar algo en la parte
superior, como singleton o Factory.

Además, estos patrones proporcionan una forma de crear objetos mientras se oculta la lógica de
creación, en lugar de crear instancias de objetos directamente utilizando un nuevo operador.

Patrones estructurales

A veces, en lugar de comenzar desde cero, debe construir estructuras más grandes utilizando un
conjunto de clases existente. Ahí es donde los patrones de clase estructural usan la herencia para
construir una nueva estructura. Los patrones de objetos estructurales usan composición / agregación
para obtener una nueva funcionalidad. Adaptador, Puente, Compuesto, Decorador, Fachada,
Flyweight y Proxy son Patrones Estructurales. Ofrecen las mejores formas de organizar la jerarquía
de clases.

Patrones de comportamiento

Los patrones de comportamiento ofrecen las mejores formas de manejar la comunicación entre
objetos. Los patrones que se incluyen en estas categorías son: visitante, cadena de responsabilidad,
comando, intérprete, iterador, mediador, recuerdo, observador, estado, estrategia y método de
plantilla son patrones de comportamiento.

Debido a que representan el comportamiento de un sistema, se usan generalmente para describir la

funcionalidad de los sistemas de software.

Patrones de diseño comúnmente utilizados

único

Es uno de los patrones de diseño más controvertidos y famosos. Se utiliza en lenguajes demasiado
orientados a objetos, y es una parte vital de la programación tradicional orientada a objetos.
El patrón Singleton se usa para,

Cuando el registro necesita ser implementado. La instancia del registrador es compartida por
todos los componentes del sistema.
Los archivos de configuración lo utilizan porque todos los componentes del sistema deben
mantener y compartir la memoria caché de la información.

Gestionar una conexión a una base de datos.

Aquí está el diagrama UML,

class Logger(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, '_logger'):
cls._logger = super(Logger, cls).__new__(cls, *args, **kwargs)
return cls._logger

En este ejemplo, Logger es un Singleton.

Cuando se llama __new__, normalmente construye una nueva instancia de esa clase. Cuando lo
anulamos, primero verificamos si nuestra instancia singleton se ha creado o no. Si no, lo creamos
usando una súper llamada. Por lo tanto, cada vez que llamamos al constructor en Logger, siempre
obtenemos exactamente la misma instancia.

>>>
>>> obj1 = Logger()
>>> obj2 = Logger()
>>> obj1 == obj2
True
>>>
 >>> obj1
<__main__.Logger object at 0x03224090>
>>> obj2
<__main__.Logger object at 0x03224090>

Python orientado a objetos: características avanzadas

En esto analizaremos algunas de las características avanzadas que proporciona Python

Sintaxis central en nuestro diseño de clase

En esto veremos cómo Python nos permite aprovechar los operadores en nuestras clases. Python es
en gran medida objetos y métodos que recurren a objetos y esto incluso continúa incluso cuando está
oculto por alguna sintaxis conveniente.

>>> var1 = 'Hello'

>>> var2 = ' World!'
>>> var1 + var2
'Hello World!'
>>>
>>> var1.__add__(var2)
'Hello World!'
>>> num1 = 45
>>> num2 = 60
>>> num1.__add__(num2)
105
>>> var3 = ['a', 'b']
>>> var4 = ['hello', ' John']
>>> var3.__add__(var4)
['a', 'b', 'hello', ' John']

Entonces, si tenemos que agregar el método mágico __add__ a nuestras propias clases, ¿podríamos
hacerlo también? Intentemos hacer eso.
Tenemos una clase llamada Sumlist que tiene un constructor __init__ que toma la lista como un
argumento llamado my_list.

class SumList(object):
def __init__(self, my_list):
self.mylist = my_list
def __add__(self, other):
new_list = [ x + y for x, y in zip(self.mylist, other.mylist)]

return SumList(new_list)

def __repr__(self):
return str(self.mylist)

aa = SumList([3,6, 9, 12, 15])

bb = SumList([100, 200, 300, 400, 500])

 cc = aa + bb # aa.__add__(bb)
print(cc) # should gives us a list ([103, 206, 309, 412, 515])

Salida

[103, 206, 309, 412, 515]

Pero hay muchos métodos que son manejados internamente por otros métodos mágicos. A
continuación hay algunos de ellos,

'abc' in var # var.__contains__('abc')

var == 'abc' # var.__eq__('abc')
var[1] # var.__getitem__(1)
var[1:3] # var.__getslice__(1, 3)
len(var) # var.__len__()
print(var) # var.__repr__()

Heredar de tipos incorporados

Las clases también pueden heredar de los tipos integrados, esto significa que heredan de cualquier
tipo incorporado y aprovechar toda la funcionalidad que se encuentra allí.

En el siguiente ejemplo estamos heredando del diccionario pero luego estamos implementando uno
de sus métodos __setitem__. Este (setitem) se invoca cuando establecemos clave y valor en el
diccionario. Como este es un método mágico, esto se llamará implícitamente.

class MyDict(dict):

def __setitem__(self, key, val):

print('setting a key and value!')
dict.__setitem__(self, key, val)

dd = MyDict()
dd['a'] = 10
dd['b'] = 20

for key in dd.keys():

print('{0} = {1}'.format(key, dd[key]))

Salida

setting a key and value!

setting a key and value!
a = 10
b = 20

Extendamos nuestro ejemplo anterior, a continuación hemos llamado dos métodos mágicos llamados
__getitem__ y __setitem__ mejor invocados cuando tratamos con el índice de lista.

# Mylist inherits from 'list' object but indexes from 1 instead for 0!
class Mylist(list): # inherits from list
 def __getitem__(self, index):
if index == 0:
raise IndexError
if index > 0:
index = index - 1
return list.__getitem__(self, index) # this method is called when

# we access a value with subscript like x[1]

def __setitem__(self, index, value):
if index == 0:
raise IndexError
if index > 0:
index = index - 1
list.__setitem__(self, index, value)

x = Mylist(['a', 'b', 'c']) # __init__() inherited from builtin list

print(x) # __repr__() inherited from builtin list

x.append('HELLO'); # append() inherited from builtin list

print(x[1]) # 'a' (Mylist.__getitem__ cutomizes list superclass

# method. index is 1, but reflects 0!

print (x[4]) # 'HELLO' (index is 4 but reflects 3!

Salida

['a', 'b', 'c']

a
HELLO

En el ejemplo anterior, establecemos una lista de tres elementos en Mylist e implícitamente se llama
al método __init__ y cuando imprimimos el elemento x, obtenemos la lista de tres elementos (['a', 'b',
'c']). Luego agregamos otro elemento a esta lista. Más tarde pedimos el índice 1 y el índice 4. Pero si
ve el resultado, estamos obteniendo elementos del (índice-1) de lo que hemos pedido. Como
sabemos, la indexación de la lista comienza desde 0, pero aquí la indexación comienza desde 1 (es
por eso que estamos obteniendo el primer elemento de la lista).

Convenciones de nombres

En esto analizaremos los nombres que usaremos para las variables, especialmente las variables
privadas y las convenciones utilizadas por los programadores de Python en todo el mundo. Aunque
las variables se designan como privadas, no hay privacidad en Python y esto por diseño. Al igual que
cualquier otro lenguaje bien documentado, Python tiene convenciones de nomenclatura y estilo que
promueve, aunque no las impone. Hay una guía de estilo escrita por " Guido van Rossum", el
creador de Python, que describe las mejores prácticas y el uso del nombre y se llama PEP8.
Aquí está el enlace para esto, https://www.python.org/dev/peps/pep-0008/
PEP significa propuesta de mejora de Python y es una serie de documentación que se distribuye
entre la comunidad de Python para discutir los cambios propuestos. Por ejemplo, se recomienda todo,
 Nombres de módulos - all_lower_case
Nombres de clase y nombres de excepción - CamelCase
Nombres globales y locales - all_lower_case
Funciones y nombres de métodos - all_lower_case
Constantes: ALL_UPPER_CASE

Estas son solo la recomendación, puede variar si lo desea. Pero como la mayoría de los
desarrolladores siguen estas recomendaciones, podría ser que su código sea menos legible.

¿Por qué conformarse a la convención?

Podemos seguir la recomendación de PEP que nos permite obtener,

Más familiar para la gran mayoría de los desarrolladores.
Más claro para la mayoría de los lectores de su código.
Igualará el estilo de otros contribuyentes que trabajan en la misma base de código.
Marca de un desarrollador de software profesional
Todos te aceptarán.

Nombramiento variable - 'Público' y 'Privado'

En Python, cuando tratamos con módulos y clases, designamos algunas variables o atributos como
privados. En Python, no existe una variable de instancia "Privada" a la que no se pueda acceder
excepto dentro de un objeto. Privado simplemente significa que simplemente no están destinados a
ser utilizados por los usuarios del código, sino que están destinados a ser utilizados internamente. En
general, la mayoría de los desarrolladores de Python siguen una convención, es decir, un nombre con
un guión bajo, por ejemplo. _attrval (ejemplo a continuación) debe tratarse como una parte no pública
de la API o cualquier código de Python, ya sea una función, un método o un miembro de datos. A
continuación se muestra la convención de nomenclatura que seguimos,
Atributos o variables públicas (destinados a ser utilizados por el importador de este módulo o
usuario de esta clase) - regular_lower_case

Atributos o variables privadas (uso interno por el módulo o clase) -

_single_leading_underscore
Atributos privados que no deberían subclasificarse - __double_leading_underscore

Atributos mágicos: __double_underscores__ ( úsalos , no los crees )

class GetSet(object):

instance_count = 0 # public

__mangled_name = 'no privacy!' # special variable

def __init__(self, value):

self._attrval = value # _attrval is for internal use only
GetSet.instance_count += 1

@property
def var(self):
print('Getting the "var" attribute')
 return self._attrval

@var.setter
def var(self, value):
print('setting the "var" attribute')
self._attrval = value

@var.deleter
def var(self):
print('deleting the "var" attribute')
self._attrval = None

cc = GetSet(5)
cc.var = 10 # public name
print(cc._attrval)
print(cc._GetSet__mangled_name)

Salida

setting the "var" attribute

10
no privacy!

Python orientado a objetos - Archivos y cadenas

Instrumentos de cuerda
Las cadenas son los tipos de datos más populares utilizados en cada lenguaje de programación. ¿Por
qué? Porque entendemos el texto mejor que los números, por lo que al escribir y hablar usamos texto
y palabras, de manera similar en la programación también usamos cadenas. En la cadena analizamos
el texto, analizamos la semántica del texto y hacemos minería de datos, y todos estos datos son texto
consumido por humanos. La cadena en Python es inmutable.

Manipulación de cuerdas

En Python, la cadena se puede marcar de múltiples maneras, usando comillas simples ('), comillas
dobles (“) o incluso comillas triples (' '') en el caso de cadenas de líneas múltiples.

>>> # String Examples

>>> a = "hello"
>>> b = ''' A Multi line string,
Simple!'''
>>> e = ('Multiple' 'strings' 'togethers')

La manipulación de cadenas es muy útil y muy utilizada en todos los idiomas. A menudo, los
programadores deben descomponer las cadenas y examinarlas de cerca.

Las cadenas pueden ser iteradas (carácter por carácter), cortadas o concatenadas. La sintaxis es la
misma que para las listas.
La clase str tiene numerosos métodos para facilitar la manipulación de cadenas. Los comandos dir y
help proporcionan orientación en el intérprete de Python sobre cómo usarlos.

A continuación se presentan algunos de los métodos de cadena que usamos comúnmente.

 No Método y descripción
Señor.

1
isalpha ()
Comprueba si todos los personajes son alfabetos

2
isdigit ()

Comprueba caracteres de dígitos

3
isdecimal ()

Comprueba caracteres decimales

44
isnumeric ()
comprueba caracteres numéricos

55
encontrar()
Devuelve el índice más alto de subcadenas

66
istitle ()

Comprobaciones para cadenas con título

77
unirse()
Devuelve una cadena concatenada

8
inferior()
devuelve una cadena en minúsculas

99
Superior()

devuelve cadena en mayúscula

10
partion ()
Devuelve una tupla

11
bytearray ()
Devuelve la matriz del tamaño de byte dado

12
enumerar()
 Devuelve un objeto de enumeración

13
isprintable ()
Comprueba el carácter imprimible

Intentemos ejecutar un par de métodos de cadena,

>>> str1 = 'Hello World!'

>>> str1.startswith('h')
False
>>> str1.startswith('H')
True
>>> str1.endswith('d')
False
>>> str1.endswith('d!')
True
>>> str1.find('o')
4
>>> #Above returns the index of the first occurence of the character/substring.
>>> str1.find('lo')
3
>>> str1.upper()
'HELLO WORLD!'
>>> str1.lower()
'hello world!'
>>> str1.index('b')
Traceback (most recent call last):
File "<pyshell#19>", line 1, in <module>
str1.index('b')
ValueError: substring not found
>>> s = ('hello How Are You')
>>> s.split(' ')
['hello', 'How', 'Are', 'You']
>>> s1 = s.split(' ')
>>> '*'.join(s1)
'hello*How*Are*You'
>>> s.partition(' ')
('hello', ' ', 'How Are You')
>>>

Formato de cadena

En Python 3.x el formato de las cadenas ha cambiado, ahora es más lógico y es más flexible. El
formateo se puede hacer usando el método format () o el signo% (estilo antiguo) en la cadena de
formato.

La cadena puede contener texto literal o campos de reemplazo delimitados por llaves {} y cada campo
de reemplazo puede contener el índice numérico de un argumento posicional o el nombre de un
argumento de palabra clave.

sintaxis
 str.format(*args, **kwargs)

Formato básico

>>> '{} {}'.format('Example', 'One')

'Example One'
>>> '{} {}'.format('pie', '3.1415926')
'pie 3.1415926'

El siguiente ejemplo permite reorganizar el orden de visualización sin cambiar los argumentos.

>>> '{1} {0}'.format('pie', '3.1415926')

'3.1415926 pie'

Acolchado y alineación de cuerdas

Un valor puede rellenarse a una longitud específica.

>>> #Padding Character, can be space or special character

>>> '{:12}'.format('PYTHON')
'PYTHON '
>>> '{:>12}'.format('PYTHON')
' PYTHON'
>>> '{:<{}s}'.format('PYTHON',12)
'PYTHON '
>>> '{:*<12}'.format('PYTHON')
'PYTHON******'
>>> '{:*^12}'.format('PYTHON')
'***PYTHON***'
>>> '{:.15}'.format('PYTHON OBJECT ORIENTED PROGRAMMING')
'PYTHON OBJECT O'
>>> #Above, truncated 15 characters from the left side of a specified string
>>> '{:.{}}'.format('PYTHON OBJECT ORIENTED',15)
'PYTHON OBJECT O'
>>> #Named Placeholders
>>> data = {'Name':'Raghu', 'Place':'Bangalore'}
>>> '{Name} {Place}'.format(**data)
'Raghu Bangalore'
>>> #Datetime
>>> from datetime import datetime
>>> '{:%Y/%m/%d.%H:%M}'.format(datetime(2018,3,26,9,57))
'2018/03/26.09:57'

Las cadenas son Unicode

Cadenas como colecciones de caracteres Unicode inmutables. Las cadenas Unicode brindan la
oportunidad de crear software o programas que funcionan en todas partes porque las cadenas
Unicode pueden representar cualquier carácter posible, no solo los caracteres ASCII.

Muchas operaciones de E / S solo saben cómo tratar con bytes, incluso si el objeto de bytes se refiere
a datos textuales. Por lo tanto, es muy importante saber cómo intercambiar entre bytes y Unicode.

Convertir texto a bytes

La conversión de cadenas en objetos de bytes se denomina codificación. Existen numerosas formas
de codificación, las más comunes son: PNG; JPEG, MP3, WAV, ASCII, UTF-8, etc. También este
(codificación) es un formato para representar audio, imágenes, texto, etc. en bytes.
Esta conversión es posible a través de encode (). Toma la técnica de codificación como argumento.
Por defecto, utilizamos la técnica 'UTF-8'.

>>> # Python Code to demonstrate string encoding

>>>
>>> # Initialising a String
>>> x = 'TutorialsPoint'
>>>
>>> #Initialising a byte object
>>> y = b'TutorialsPoint'
>>>
>>> # Using encode() to encode the String >>> # encoded version of x is stored in z using ASC
>>> z = x.encode('ASCII')
>>>
>>> # Check if x is converted to bytes or not
>>>
>>> if(z==y):
print('Encoding Successful!')
else:
print('Encoding Unsuccessful!')
Encoding Successful!

Convertir bytes a texto

La conversión de bytes a texto se denomina decodificación. Esto se implementa a través de decode

(). Podemos convertir una cadena de bytes en una cadena de caracteres si sabemos qué codificación
se utiliza para codificarla.
Entonces, la codificación y la decodificación son procesos inversos.

>>>
>>> # Python code to demonstrate Byte Decoding
>>>
>>> #Initialise a String
>>> x = 'TutorialsPoint'
>>>
>>> #Initialising a byte object
>>> y = b'TutorialsPoint'
>>>
>>> #using decode() to decode the Byte object
>>> # decoded version of y is stored in z using ASCII mapping
>>> z = y.decode('ASCII')
>>> #Check if y is converted to String or not
>>> if (z == x):
print('Decoding Successful!')
else:
print('Decoding Unsuccessful!') Decoding Successful!
>>>
E / S de archivo
Los sistemas operativos representan los archivos como una secuencia de bytes, no como texto.

Un archivo es una ubicación con nombre en el disco para almacenar información relacionada. Se
utiliza para almacenar permanentemente datos en su disco.
En Python, una operación de archivo tiene lugar en el siguiente orden.
Abrir un archivo
Leer o escribir en un archivo (operación). Abrir un archivo
Cierra el archivo.

Python envuelve el flujo entrante (o saliente) de bytes con llamadas de decodificación (o codificación)
apropiadas para que podamos tratar directamente con los objetos str.

Abrir un archivo

Python tiene una función incorporada open () para abrir un archivo. Esto generará un objeto de
archivo, también llamado un identificador, ya que se utiliza para leer o modificar el archivo en
consecuencia.

>>> f = open(r'c:\users\rajesh\Desktop\index.webm','rb')
>>> f
<_io.BufferedReader name='c:\\users\\rajesh\\Desktop\\index.webm'>
>>> f.mode
'rb'
>>> f.name
'c:\\users\\rajesh\\Desktop\\index.webm'

Para leer el texto de un archivo, solo necesitamos pasar el nombre del archivo a la función. El archivo
se abrirá para su lectura y los bytes se convertirán a texto utilizando la codificación predeterminada de
la plataforma.

Excepción y clases de excepción

En general, una excepción es cualquier condición inusual. La excepción generalmente indica errores,
pero a veces pone intencionalmente en el programa, en casos como terminar un procedimiento antes
o recuperarse de una escasez de recursos. Hay varias excepciones integradas, que indican
condiciones como leer más allá del final de un archivo o dividir por cero. Podemos definir nuestras
propias excepciones llamadas excepción personalizada.

El manejo de excepciones le permite manejar errores con gracia y hacer algo significativo al respecto.
El manejo de excepciones tiene dos componentes: "lanzar" y "atrapar".

Excepción de identificación (errores)

Cada error que se produce en Python resulta en una excepción que será una condición de error
identificada por su tipo de error.

>>> #Exception
>>> 1/0
 Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
1/0
ZeroDivisionError: division by zero
>>>
>>> var = 20
>>> print(ver)
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
print(ver)
NameError: name 'ver' is not defined
>>> #Above as we have misspelled a variable name so we get an NameError.
>>>
>>> print('hello)

SyntaxError: EOL while scanning string literal

>>> #Above we have not closed the quote in a string, so we get SyntaxError.
>>>
>>> #Below we are asking for a key, that doen't exists.
>>> mydict = {}
>>> mydict['x']
Traceback (most recent call last):
File "<pyshell#15>", line 1, in <module>
mydict['x']
KeyError: 'x'
>>> #Above keyError
>>>
>>> #Below asking for a index that didn't exist in a list.
>>> mylist = [1,2,3,4]
>>> mylist[5]
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
mylist[5]
IndexError: list index out of range
>>> #Above, index out of range, raised IndexError.

Excepción de captura / captura

Cuando ocurre algo inusual en su programa y desea manejarlo utilizando el mecanismo de excepción,
'lanza una excepción'. Las palabras clave try y except se utilizan para detectar excepciones. Cada vez
que ocurre un error dentro de un bloque de prueba, Python busca una coincidencia, excepto el bloque
para manejarlo. Si hay uno, la ejecución salta allí.

sintaxis

try:
#write some code
#that might throw some exception
except <ExceptionType>:
# Exception handler, alert the user

El código dentro de la cláusula try se ejecutará declaración por declaración.

Si se produce una excepción, se omitirá el resto del bloque try y se ejecutará la cláusula except.

try:
some statement here
except:
exception handling

Escribamos un código para ver qué sucede cuando no utiliza ningún mecanismo de manejo de
errores en su programa.

number = int(input('Please enter the number between 1 & 10: '))

print('You have entered number',number)

El programa anterior funcionará correctamente siempre que el usuario ingrese un número, pero qué
sucede si los usuarios intentan poner algún otro tipo de datos (como una cadena o una lista).

Please enter the number between 1 > 10: 'Hi'

Traceback (most recent call last):
File "C:/Python/Python361/exception2.py", line 1, in <module>
number = int(input('Please enter the number between 1 & 10: '))
ValueError: invalid literal for int() with base 10: "'Hi'"

Ahora ValueError es un tipo de excepción. Intentemos reescribir el código anterior con manejo de
excepciones.

import sys

print('Previous code with exception handling')

try:
number = int(input('Enter number between 1 > 10: '))

except(ValueError):
print('Error..numbers only')
sys.exit()

print('You have entered number: ',number)

Si ejecutamos el programa e ingresamos una cadena (en lugar de un número), podemos ver que
obtenemos un resultado diferente.

Previous code with exception handling

Enter number between 1 > 10: 'Hi'
Error..numbers only

Elevar excepciones

Para aumentar sus excepciones de sus propios métodos, debe usar la palabra clave raise como esta

raise ExceptionClass(‘Some Text Here’)

Tomemos un ejemplo.
 def enterAge(age):
if age<0:
raise ValueError('Only positive integers are allowed')
if age % 2 ==0:
print('Entered Age is even')
else:
print('Entered Age is odd')

try:
num = int(input('Enter your age: '))
enterAge(num)
except ValueError:
print('Only positive integers are allowed')

Ejecute el programa e ingrese un entero positivo.

Rendimiento esperado

Enter your age: 12

Entered Age is even

Pero cuando intentamos ingresar un número negativo obtenemos,

Rendimiento esperado

Enter your age: -2

Only positive integers are allowed

Crear clase de excepción personalizada

Puede crear una clase de excepción personalizada extendiendo la clase BaseException o la subclase
de BaseException.
En el diagrama anterior, podemos ver que la mayoría de las clases de excepción en Python se
extienden desde la clase BaseException. Puede derivar su propia clase de excepción de la clase
BaseException o de su subclase.

Cree un nuevo archivo llamado NegativeNumberException.py y escriba el siguiente código.

class NegativeNumberException(RuntimeError):
def __init__(self, age):
super().__init__()
self.age = age

El código anterior crea una nueva clase de excepción llamada NegativeNumberException, que consta
de un solo constructor que llama al constructor de la clase padre usando super () __ init __ () y
establece la edad.
Ahora, para crear su propia clase de excepción personalizada, escribirá un código e importará la
nueva clase de excepción.

from NegativeNumberException import NegativeNumberException

def enterage(age):
if age < 0:
raise NegativeNumberException('Only positive integers are allowed')

if age % 2 == 0:
print('Age is Even')
 else:
print('Age is Odd')

try:
num = int(input('Enter your age: '))
enterage(num)
except NegativeNumberException:
print('Only positive integers are allowed')
except:
print('Something is wrong')

Salida

Enter your age: -2

Only positive integers are allowed

Otra forma de crear una clase de excepción personalizada.

class customException(Exception):
def __init__(self, value):
self.parameter = value

def __str__(self):
return repr(self.parameter)
try:
raise customException('My Useful Error Message!')
except customException as instance:
print('Caught: ' + instance.parameter)

Salida

Caught: My Useful Error Message!

Jerarquía de excepción

La jerarquía de clases para las excepciones incorporadas es:

+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
+-- StopIteration
+-- StopAsyncIteration
+-- ArithmeticError
| +-- FloatingPointError
| +-- OverflowError
| +-- ZeroDivisionError
+-- AssertionError
+-- AttributeError
+-- BufferError
+-- EOFError
+-- ImportError
+-- LookupError
| +-- IndexError
| +-- KeyError
+-- MemoryError
+-- NameError
| +-- UnboundLocalError
+-- OSError
| +-- BlockingIOError
| +-- ChildProcessError
| +-- ConnectionError
| | +-- BrokenPipeError
| | +-- ConnectionAbortedError
| | +-- ConnectionRefusedError
| | +-- ConnectionResetError
| +-- FileExistsError
| +-- FileNotFoundError
| +-- InterruptedError
| +-- IsADirectoryError
| +-- NotADirectoryError
| +-- PermissionError
| +-- ProcessLookupError
| +-- TimeoutError
+-- ReferenceError
+-- RuntimeError
| +-- NotImplementedError
| +-- RecursionError
+-- SyntaxError
| +-- IndentationError
| +-- TabError
+-- SystemError
+-- TypeError
+-- ValueError
| +-- UnicodeError
| +-- UnicodeDecodeError
| +-- UnicodeEncodeError
| +-- UnicodeTranslateError
+-- Warning
+-- DeprecationWarning
+-- PendingDeprecationWarning
+-- RuntimeWarning
+-- SyntaxWarning
+-- UserWarning
+-- FutureWarning
+-- ImportWarning
+-- UnicodeWarning
+-- BytesWarning
+-- ResourceWarning

Python orientado a objetos: serialización de objetos

En el contexto del almacenamiento de datos, la serialización es el proceso de traducir las estructuras
de datos o el estado del objeto a un formato que puede almacenarse (por ejemplo, en un archivo o
memoria intermedia) o transmitirse y reconstruirse más tarde.

En la serialización, un objeto se transforma en un formato que puede almacenarse, para poder

deserializarlo más tarde y recrear el objeto original del formato serializado.

Pepinillo
El decapado es el proceso mediante el cual una jerarquía de objetos de Python se convierte en una
secuencia de bytes (generalmente no legible por humanos) para escribirse en un archivo, esto
también se conoce como serialización. Unpickling es la operación inversa, mediante la cual una
secuencia de bytes se convierte nuevamente en una jerarquía de objetos Python en funcionamiento.

Pickle es la forma operacionalmente más simple de almacenar el objeto. El módulo Python Pickle es
una forma orientada a objetos para almacenar objetos directamente en un formato de
almacenamiento especial.

¿Qué puede hacer?

Pickle puede almacenar y reproducir diccionarios y listas con mucha facilidad.

Almacena atributos de objeto y los restaura de nuevo al mismo estado.

¿Qué pepinillo no puede hacer?

No guarda un código de objetos. Solo se trata de valores de atributos.

No puede almacenar identificadores de archivos o tomas de conexión.

En resumen, podemos decir que el decapado es una forma de almacenar y recuperar variables de
datos dentro y fuera de archivos donde las variables pueden ser listas, clases, etc.

Para encurtir algo debes:

pepinillo de importación
Escribe una variable para archivar, algo así como

pickle.dump(mystring, outfile, protocol),

donde el protocolo del tercer argumento es opcional Para desempaquetar algo debe:

Encurtido de importación

Escribir una variable en un archivo, algo así como

myString = pickle.load(inputfile)

Métodos
La interfaz de pickle proporciona cuatro métodos diferentes.
dump () : el método dump () se serializa en un archivo abierto (objeto similar a un archivo).

dumps () - Serializa a una cadena

 load () - Deserializa desde un objeto abierto.

cargas () - Deserializa desde una cadena.

Según el procedimiento anterior, a continuación se muestra un ejemplo de "decapado".

Salida

My Cat pussy is White and has 4 legs

Would you like to see her pickled? Here she is!
b'\x80\x03c__main__\nCat\nq\x00)\x81q\x01}q\x02(X\x0e\x00\x00\x00number_of_legsq\x03K\x04X\x0

Entonces, en el ejemplo anterior, hemos creado una instancia de una clase Cat y luego la hemos
encurtido, transformando nuestra instancia "Cat" en una simple matriz de bytes.

De esta manera, podemos almacenar fácilmente la matriz de bytes en un archivo binario o en un

campo de base de datos y restaurarla a su forma original desde nuestro soporte de almacenamiento
en un momento posterior.
Además, si desea crear un archivo con un objeto en escabeche, puede usar el método dump () (en
lugar de los volcados * () * uno) pasando también un archivo binario abierto y el resultado del
encurtido se almacenará en el archivo automáticamente.

[….]
binary_file = open(my_pickled_Pussy.bin', mode='wb')
my_pickled_Pussy = pickle.dump(Pussy, binary_file)
binary_file.close()

Unpickling
El proceso que toma una matriz binaria y la convierte en una jerarquía de objetos se llama
descortezado.

El proceso de desempaquetado se realiza utilizando la función load () del módulo pickle y devuelve
una jerarquía de objetos completa desde una matriz de bytes simple.
Usemos la función de carga en nuestro ejemplo anterior.
Salida

MeOw is black
Pussy is white

JSON
JSON (JavaScript Object Notation) ha sido parte de la biblioteca estándar de Python, es un formato
ligero de intercambio de datos. Es fácil para los humanos leer y escribir. Es fácil de analizar y generar.

Debido a su simplicidad, JSON es una forma en la que almacenamos e intercambiamos datos, lo cual
se logra a través de su sintaxis JSON y se usa en muchas aplicaciones web. Como está en formato
legible para humanos, y esta puede ser una de las razones para usarlo en la transmisión de datos,
además de su efectividad al trabajar con API.
Un ejemplo de datos con formato JSON es el siguiente:

{"EmployID": 40203, "Name": "Zack", "Age":54, "isEmployed": True}

Python simplifica el trabajo con archivos Json. El módulo sused para este propósito es el módulo
JSON. Este módulo debe incluirse (integrado) dentro de su instalación de Python.

Entonces, veamos cómo podemos convertir el diccionario de Python a JSON y escribirlo en un

archivo de texto.

JSON a Python

Leer JSON significa convertir JSON en un valor de Python (objeto). La biblioteca json analiza JSON
en un diccionario o lista en Python. Para hacer eso, usamos la función cargas () (carga desde una
cadena), como sigue:

Salida
A continuación se muestra un archivo json de muestra,

data1.json
{"menu": {
"id": "file",
"value": "File",
"popup": {
"menuitem": [
{"value": "New", "onclick": "CreateNewDoc()"},
{"value": "Open", "onclick": "OpenDoc()"},
{"value": "Close", "onclick": "CloseDoc()"}
]
}
}}

El contenido anterior (Data1.json) se parece a un diccionario convencional. Podemos usar pickle para
almacenar este archivo, pero el resultado no es legible por humanos.

JSON (Java Script Object Notification) es un formato muy simple y esa es una de las razones de su
popularidad. Ahora veamos la salida de json a través del siguiente programa.

Salida

Arriba abrimos el archivo json (data1.json) para leer, obtener el controlador de archivos y pasar a
json.load y recuperar el objeto. Cuando intentamos imprimir la salida del objeto, es lo mismo que el
archivo json. Aunque el tipo del objeto es diccionario, sale como un objeto Python. Escribir a JSON es
simple, ya que vimos este pepinillo. Arriba cargamos el archivo json, agregamos otro par de valores
clave y lo escribimos de nuevo en el mismo archivo json. Ahora, si vemos data1.json, se ve diferente
.ie no en el mismo formato que vemos anteriormente.
Para que nuestra salida se vea igual (formato legible por humanos), agregue el par de argumentos en
nuestra última línea del programa,

json.dump(conf, fh, indent = 4, separators = (‘,’, ‘: ‘))

Del mismo modo que Pickle, podemos imprimir la cadena con volcados y cargar con cargas. A
continuación se muestra un ejemplo de eso,

Ñame
YAML puede ser el estándar de serialización de datos más amigable para los humanos para todos los
lenguajes de programación.

El módulo Python yaml se llama pyaml

YAML es una alternativa a JSON -

Código legible por humanos : YAML es el formato más legible por humanos, de modo que
incluso su contenido de primera plana se muestra en YAML para aclarar esto.
Código compacto : en YAML usamos sangría de espacios en blanco para denotar la
estructura, no los corchetes.

Sintaxis para datos relacionales : para referencias internas utilizamos anclas (&) y alias (*).

Una de las áreas donde se usa ampliamente es para ver / editar estructuras de datos ,
por ejemplo, archivos de configuración, volcado durante la depuración y encabezados de
documentos.

Instalando YAML
Como yaml no es un módulo incorporado, necesitamos instalarlo manualmente. La mejor manera de
instalar yaml en la máquina de Windows es a través de pip. Ejecute el siguiente comando en su
terminal de Windows para instalar yaml,

pip install pyaml (Windows machine)

sudo pip install pyaml (*nix and Mac)

Al ejecutar el comando anterior, la pantalla mostrará algo como a continuación en función de cuál es
la última versión actual.

Collecting pyaml
Using cached pyaml-17.12.1-py2.py3-none-any.whl
Collecting PyYAML (from pyaml)
Using cached PyYAML-3.12.tar.gz
Installing collected packages: PyYAML, pyaml
Running setup.py install for PyYAML ... done
Successfully installed PyYAML-3.12 pyaml-17.12.1

Para probarlo, vaya al shell de Python e importe el módulo yaml, importe yaml, si no se encuentra
ningún error, entonces podemos decir que la instalación fue exitosa.
Después de instalar pyaml, veamos el siguiente código,

script_yaml1.py

Arriba creamos tres estructuras de datos diferentes, diccionario, lista y tupla. En cada una de las
estructuras, hacemos yaml.dump. El punto importante es cómo se muestra la salida en la pantalla.

Salida
La salida del diccionario se ve limpia .ie. valor clave.
Espacio en blanco para separar diferentes objetos.

La lista se anota con guión (-)

La tupla se indica primero con !! Python / tuple y luego en el mismo formato que las listas.
Cargando un archivo yaml

Digamos que tengo un archivo yaml, que contiene,

---
# An employee record
name: Raagvendra Joshi
job: Developer
skill: Oracle
employed: True
foods:
- Apple
- Orange
- Strawberry
- Mango
languages:
Oracle: Elite
power_builder: Elite
Full Stack Developer: Lame
education:
4 GCSEs
3 A-Levels
MCA in something called com

Ahora escribamos un código para cargar este archivo yaml a través de la función yaml.load. A
continuación hay un código para lo mismo.
Como la salida no parece tan legible, la presento usando json al final. Compare la salida que
obtuvimos y el archivo yaml real que tenemos.

Salida

Uno de los aspectos más importantes del desarrollo de software es la depuración. En esta sección
veremos diferentes formas de depuración de Python, ya sea con depurador incorporado o con
depuradores de terceros.

PDB - El depurador de Python

El módulo PDB admite la configuración de puntos de interrupción. Un punto de interrupción es una
pausa intencional del programa, donde puede obtener más información sobre el estado de los
programas.

Para establecer un punto de interrupción, inserte la línea

pdb.set_trace()

Ejemplo

pdb_example1.py
import pdb
x = 9
y = 7
 pdb.set_trace()
total = x + y
pdb.set_trace()

Hemos insertado algunos puntos de interrupción en este programa. El programa hará una pausa en
cada punto de interrupción (pdb.set_trace ()). Para ver el contenido de una variable, simplemente
escriba el nombre de la variable.

c:\Python\Python361>Python pdb_example1.py
> c:\Python\Python361\pdb_example1.py(8)<module>()
-> total = x + y
(Pdb) x
9
(Pdb) y
7
(Pdb) total
*** NameError: name 'total' is not defined
(Pdb)

Presione co o continúe con la ejecución de los programas hasta el próximo punto de interrupción.

(Pdb) c
--Return--
> c:\Python\Python361\pdb_example1.py(8)<module>()->None
-> total = x + y
(Pdb) total
16

Eventualmente, necesitará depurar programas mucho más grandes, programas que usan subrutinas.
Y a veces, el problema que está tratando de encontrar se encuentra dentro de una subrutina.
Considere el siguiente programa.

import pdb
def squar(x, y):
out_squared = x^2 + y^2
return out_squared
if __name__ == "__main__":
#pdb.set_trace()
print (squar(4, 5))

Ahora al ejecutar el programa anterior,

c:\Python\Python361>Python pdb_example2.py
> c:\Python\Python361\pdb_example2.py(10)<module>()
-> print (squar(4, 5))
(Pdb)

Podemos usar ? para obtener ayuda, pero la flecha indica la línea que se va a ejecutar. En este
punto, es útil presionar s to s para entrar en esa línea.

(Pdb) s
--Call--
 >c:\Python\Python361\pdb_example2.py(3)squar()
-> def squar(x, y):

Esta es una llamada a una función. Si desea una descripción general de dónde se encuentra en su
código, pruebe l -

(Pdb) l
1 import pdb
2
3 def squar(x, y):
4 -> out_squared = x^2 + y^2
5
6 return out_squared
7
8 if __name__ == "__main__":
9 pdb.set_trace()
10 print (squar(4, 5))
[EOF]
(Pdb)

Puede presionar n para avanzar a la siguiente línea. En este punto, está dentro del método
out_squared y tiene acceso a la variable declarada dentro de la función .ie x e y.

(Pdb) x
4
(Pdb) y
5
(Pdb) x^2
6
(Pdb) y^2
7
(Pdb) x**2
16
(Pdb) y**2
25
(Pdb)

Entonces podemos ver que el operador ^ no es lo que queríamos, sino que necesitamos usar el
operador ** para hacer cuadrados.
De esta manera podemos depurar nuestro programa dentro de las funciones / métodos.

Inicio sesión
El módulo de registro ha sido parte de la Biblioteca estándar de Python desde Python versión 2.3.
Como es un módulo incorporado, todos los módulos de Python pueden participar en el registro, de
modo que nuestro registro de aplicaciones puede incluir su propio mensaje integrado con los
mensajes del módulo de terceros. Proporciona mucha flexibilidad y funcionalidad.

Beneficios de la tala

Registro de diagnóstico : registra eventos relacionados con el funcionamiento de la

aplicación.
 Registro de auditoría : registra eventos para análisis de negocios.

Los mensajes se escriben y registran en niveles de "severidad" y minu

DEBUG (debug ()) : mensajes de diagnóstico para el desarrollo.

INFO (info ()) - mensajes estándar de "progreso".

ADVERTENCIA (advertencia ()) : se detectó un problema no grave.

ERROR (error ()) : se encontró un error, posiblemente grave.

CRÍTICO (crítico ()) : generalmente un error fatal (el programa se detiene).

Veamos el siguiente programa simple,

import logging

logging.basicConfig(level=logging.INFO)

logging.debug('this message will be ignored') # This will not print

logging.info('This should be logged') # it'll print
logging.warning('And this, too') # It'll print

Arriba estamos registrando mensajes en el nivel de gravedad. Primero importamos el módulo,

llamamos a basicConfig y establecemos el nivel de registro. El nivel que establecimos arriba es INFO.
Luego tenemos tres declaraciones diferentes: declaración de depuración, declaración de información
y una declaración de advertencia.

Salida de logging1.py

INFO:root:This should be logged

WARNING:root:And this, too

Como la declaración de información está debajo de la declaración de depuración, no podemos ver el

mensaje de depuración. Para obtener la declaración de depuración también en el terminal de Salida,
todo lo que necesitamos cambiar es el nivel basicConfig.

logging.basicConfig(level = logging.DEBUG)

Y en la salida podemos ver,

DEBUG:root:this message will be ignored

INFO:root:This should be logged
WARNING:root:And this, too

Además, el comportamiento predeterminado significa que si no establecemos ningún nivel de registro

es una advertencia. Simplemente comente la segunda línea del programa anterior y ejecute el código.

#logging.basicConfig(level = logging.DEBUG)

Salida
 WARNING:root:And this, too

Python integrado en el nivel de registro son en realidad enteros.

>>> import logging

>>>
>>> logging.DEBUG
10
>>> logging.CRITICAL
50
>>> logging.WARNING
30
>>> logging.INFO
20
>>> logging.ERROR
40
>>>

También podemos guardar los mensajes de registro en el archivo.

logging.basicConfig(level = logging.DEBUG, filename = 'logging.log')

Ahora todos los mensajes de registro irán al archivo (logging.log) en su directorio de trabajo actual en
lugar de la pantalla. Este es un enfoque mucho mejor, ya que nos permite hacer un análisis posterior
de los mensajes que recibimos.

También podemos establecer el sello de fecha con nuestro mensaje de registro.

logging.basicConfig(level=logging.DEBUG, format = '%(asctime)s %(levelname)s:%(message)s')

La salida tendrá algo como,

2018-03-08 19:30:00,066 DEBUG:this message will be ignored

2018-03-08 19:30:00,176 INFO:This should be logged
2018-03-08 19:30:00,201 WARNING:And this, too

Benchmarking
La evaluación comparativa o la creación de perfiles es básicamente para probar qué tan rápido se
ejecuta su código y dónde están los cuellos de botella. La razón principal para hacer esto es para la
optimización.

cronométralo

Python viene con un módulo incorporado llamado timeit. Puede usarlo para cronometrar pequeños
fragmentos de código. El módulo timeit utiliza funciones de tiempo específicas de la plataforma para
que obtenga los tiempos más precisos posibles.

Por lo tanto, nos permite comparar dos envíos de código tomados por cada uno y luego optimizar los
scripts para obtener un mejor rendimiento.
El módulo timeit tiene una interfaz de línea de comandos, pero también se puede importar.
Hay dos formas de llamar a un script. Primero usemos el script, para eso ejecute el siguiente código y
vea la Salida.

import timeit
print ( 'by index: ', timeit.timeit(stmt = "mydict['c']", setup = "mydict = {'a':5, 'b':10,
print ( 'by get: ', timeit.timeit(stmt = 'mydict.get("c")', setup = 'mydict = {"a":5, "b":10,
"b":10

Salida

by index: 0.1809192126703489
by get: 0.6088525265034692

Above we use two different method .i.e. by subscript and get to access the dictionary key value. We
execute statement 1 million times as it executes too fast for a very small data. Now we can see the
index access much faster as compared to the get. We can run the code multiply times and there will
be slight variation in the time execution to get the better understanding.

Another way is to run the above test in the command line. Let’s do it,

c:\Python\Python361>Python -m timeit -n 1000000 -s "mydict = {'a': 5, 'b':10, 'c':15}" "mydic

1000000 loops, best of 3: 0.187 usec per loop

c:\Python\Python361>Python -m timeit -n 1000000 -s "mydict = {'a': 5, 'b':10, 'c':15}" "mydic

1000000 loops, best of 3: 0.659 usec per loop

Above output may vary based on your system hardware and what all applications are running currently
in your system.
Below we can use the timeit module, if we want to call to a function. As we can add multiple statement
inside the function to test.

import timeit

def testme(this_dict, key):

return this_dict[key]

print (timeit.timeit("testme(mydict, key)", setup = "from __main__ import testme; mydict = {

Output

0.7713474590139164

Object Oriented Python - Libraries

Requests − Python Requests Module

Requests es un módulo de Python que es una biblioteca HTTP elegante y simple para Python. Con
esto puede enviar todo tipo de solicitudes HTTP. Con esta biblioteca podemos agregar encabezados,
datos de formularios, archivos y parámetros de varias partes y acceder a los datos de respuesta.
Como Requests no es un módulo integrado, debemos instalarlo primero.

Puede instalarlo ejecutando el siguiente comando en la terminal:

pip install requests

Una vez que haya instalado el módulo, puede verificar si la instalación se realizó correctamente
escribiendo el siguiente comando en el shell de Python.

import requests

Si la instalación ha sido exitosa, no verá ningún mensaje de error.

Hacer una solicitud GET

Como ejemplo, utilizaremos el "pokeapi"

Salida -

Hacer solicitudes POST

Los métodos de la biblioteca de solicitudes para todos los verbos HTTP actualmente en uso. Si desea
realizar una simple solicitud POST a un punto final de la API, puede hacerlo así:

req = requests.post(‘http://api/user’, data = None, json = None)

Esto funcionaría exactamente de la misma manera que nuestra solicitud GET anterior, sin embargo,
presenta dos parámetros de palabras clave adicionales:

datos que se pueden completar con digamos un diccionario, un archivo o bytes que se
pasarán en el cuerpo HTTP de nuestra solicitud POST.
json que se puede completar con un objeto json que también se pasará en el cuerpo de
nuestra solicitud HTTP.

Pandas: Pandas de la Biblioteca Python

Pandas es una biblioteca de Python de código abierto que proporciona una herramienta de análisis y
manipulación de datos de alto rendimiento utilizando sus poderosas estructuras de datos. Pandas es
una de las bibliotecas de Python más utilizadas en ciencia de datos. Se utiliza principalmente para
mezclar datos y con una buena razón: grupo de funciones potente y flexible.

Construido sobre el paquete Numpy y la estructura de datos clave se llama DataFrame. Estos marcos
de datos nos permiten almacenar y manipular datos tabulares en filas de observaciones y columnas
de variables.
Hay varias formas de crear un DataFrame. Una forma es usar un diccionario. Por ejemplo

Salida

De la salida podemos ver el nuevo Data Frame de brics, Pandas ha asignado una clave para cada
país como los valores numéricos del 0 al 4.

Si en lugar de proporcionar valores de indexación de 0 a 4, nos gustaría tener valores de índice

diferentes, digamos el código de país de dos letras, también puede hacerlo fácilmente:
Agregar debajo de una línea en el código anterior, da

brics.index = ['BR', 'RU', 'IN', 'CH', 'SA']

Salida
Marcos de datos de indexación

Salida

Pygame
Pygame es la biblioteca de código abierto y multiplataforma que sirve para crear aplicaciones
multimedia, incluidos juegos. Incluye gráficos de computadora y bibliotecas de sonido diseñadas para
ser utilizadas con el lenguaje de programación Python. Puedes desarrollar muchos juegos geniales
con Pygame '.

Visión general

Pygame se compone de varios módulos, cada uno de los cuales se ocupa de un conjunto específico
de tareas. Por ejemplo, el módulo de visualización se ocupa de la ventana y la pantalla de
visualización, el módulo de dibujo proporciona funciones para dibujar formas y el módulo de teclas
funciona con el teclado. Estos son solo algunos de los módulos de la biblioteca.

El hogar de la biblioteca Pygame está en https://www.pygame.org/news

Para hacer una aplicación Pygame, sigue estos pasos:

Importar la biblioteca Pygame

import pygame

Inicializa la biblioteca Pygame

pygame.init()

Crea una ventana.

screen = Pygame.display.set_mode((560,480))
Pygame.display.set_caption(‘First Pygame Game’)

Inicializar objetos del juego

En este paso cargamos imágenes, cargamos sonidos, hacemos posicionamiento de objetos,
configuramos algunas variables de estado, etc.

Comienza el ciclo del juego.

Es solo un ciclo donde manejamos eventos continuamente, verificamos la entrada, movemos objetos
y los dibujamos. Cada iteración del bucle se llama marco.
Pongamos toda la lógica anterior en un programa a continuación,

Pygame_script.py
Salida

Beautiful Soup: Raspado web con Beautiful Soup

La idea general detrás del raspado web es obtener los datos que existen en un sitio web y convertirlos
a algún formato que pueda usarse para el análisis.

Es una biblioteca de Python para extraer datos de archivos HTML o XML. Con su analizador favorito,
proporciona formas idiomáticas de navegar, buscar y modificar el árbol de análisis.
Como BeautifulSoup no es una biblioteca incorporada, necesitamos instalarla antes de intentar usarla.
Para instalar BeautifulSoup, ejecute el siguiente comando
 $ apt-get install Python-bs4 # For Linux and Python2
$ apt-get install Python3-bs4 # for Linux based system and Python3.

$ easy_install beautifulsoup4 # For windows machine,

Or
$ pip instal beatifulsoup4 # For window machine

Una vez que se realiza la instalación, estamos listos para ejecutar algunos ejemplos y explora
Beautifulsoup en detalle,

Salida

A continuación hay algunas formas simples de navegar esa estructura de datos:

Una tarea común es extraer todas las URL que se encuentran dentro de las etiquetas <a> de una
página:

Otra tarea común es extraer todo el texto de una página: