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 según 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']Acceder 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 todas las clases 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 nada. 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 fue instanciado 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 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 propiedades, podemos 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 desee especificar tanto datos como 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 diccionarios o en otras ubicaciones donde un objeto requiere un valor hash.
Las tuplas se utilizan para almacenar datos, no comportamientos. En caso de que necesite un comportamiento para manipular una tupla, debe pasar la tupla a una función (o método en otro objeto) que realiza la acción.
Como la tupla puede actuar como 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 asignaciones 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 se incluye entre paréntesis en lugar de corchetes.
Al igual que cuando divide una lista, obtiene una nueva lista y cuando divide 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')
1Del código que se muestra arriba, podemos entender que las tuplas son inmutables y, por lo tanto,
usted cannot agregar elementos a una tupla.
usted cannot añadir o ampliar un método.
usted cannot eliminar elementos de una tupla.
Las tuplas tienen no quitar o hacer estallar el método.
El recuento y el í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 se encierra entre llaves.
El número 1 es la clave y msftes su valor. Similar,2 es la clave y IT es su valor.
Puede obtener valores por clave, pero no al revés. Así que cuando intentamosmy_dict[‘IT’] , genera una excepción, porque IT no es una clave.
Modificar 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:
No puede tener claves duplicadas en un diccionario. La alteración del valor de una clave existente eliminará el valor anterior.
Puede agregar nuevos pares clave-valor en cualquier momento.
Los diccionarios no tienen concepto de orden entre elementos. Son colecciones simples y desordenadas.
Mezcla de tipos de datos en un diccionario
Observe el siguiente código para comprender cómo mezclar tipos de datos en un diccionario:
>>> # 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'}Del código anterior podemos observar que:
No solo cadenas, sino que el valor del diccionario puede ser de cualquier tipo de datos, incluidas cadenas, números enteros, incluido el diccionario en sí.
A diferencia de los valores de diccionario, las claves de diccionario son más restringidas, pero pueden ser de cualquier tipo, como cadenas, números enteros o cualquier otro.
Eliminar elementos de diccionarios
Observe el siguiente código para comprender cómo eliminar elementos de un diccionario:
>>> # 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
{}Del código anterior podemos observar que:
del - le permite eliminar elementos individuales de un diccionario por clave.
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í mismo 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 mediante árboles, los conjuntos en Python se pueden implementar mediante una tabla hash. Esto le permite un método altamente optimizado para verificar si un elemento específico está contenido en el conjunto.
Creando un set
Un conjunto se crea colocando todos los elementos (elementos) dentro de llaves {}, separados por comas o usando la función incorporada 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 de 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()