Tuplas y conjuntos

Para los que quieren entender más a fondo las diferencias entre listas y duplas:
listas vs duplas

"""
------ TUPLAS ------
Las tuplas (tuples) son similares a las listas.
La unica diferencia es que las tuplas son inmutables.
La diferencia con los strings es que pueden recibir muchos tipos valores.
Son una serie de valores separados por comas, casi siempre se le agregan
paréntesis para que sea mucho más legible.
tup = 1,2,3
tup = (1,2,3)-->Esta opción es la más se utiliza

Para poderla inicializar utilizamos la función 'tuple'.
Un uso muy común es utilizarlas para regresar más de
un valor en una función.
return (students,teachers)

------ CONJUNTOS ------
Los conjuntos (sets) son una colección sin orden que no 
permite elementos duplicados. A diferencia de los tuples podemos
agregar y eliminar, son mutables.
Los sets se inicializan con la función 'set'.
Para añadir elementos utilizamos el método 'add' y para eliminarlos
utilizamos el método 'remove'
"""

## LISTA --> ages = [12,18,24,34,50]
## TUPLA --> ages = (12,18,24,34,50)
## CONJUNTOS --> ages = {12,18,24,34,50}

"""Con las tuplas que pueden utilizar casi todas las (las mismas)
funciones y métodos que funcionan con las listas"""

##------ TUPLAS ------
a = (1,2,2,3)
b = (3,4,5)
c = b+a
print(c)

print(a.count(2)) ## Nos dice cuantas veces aparece el numero 2 en la tupla
print(b.index(4)) ## NOs dice en que posición aparece por primera el numero 4 en la tupla

##Esto no lo podemos hacer porque son inmutables, al contrario que las listas, que son mutables
##a[1]= 10
##c[2] = 22

##------ CONJUNTOS ------
# Creando un conjunto en python
print('-'*30)
A = {1,2,3}
print(A)

# Creando un conjunto a partir de una lista
print('-'*30)
lista = ["bananas", "manzanas", "naranjas", "limones"]
B = set(lista)
print(B)

# Los conjuntos eliminan los elementos duplicados
print('-'*30)
lista = ["bananas", "manzanas", "naranjas", "limones",
        "bananas", "bananas", "limones", "naranjas"]
B = set(lista)
print(B)

# Creando el conjunto vacío
print('-'*30)
C = set()
print(C)

# Cardinalidad de un conjunto con len().
print('-'*30)
print("La cardinalidad del conjunto A = {0} es {1}".format(A,len(A)))

# comprobando membresía
print('-'*30)
print(2 in A)
print(0 in A)

# Igualdad entre conjuntos. El orden de los elementos no importa.
print('-'*30)
A = {1,2,3,4}
B = {4,2,3,1}
print(A == B)

# Subconjunto. No hay distincion entre subconjunto y propio
# para el conjunto por defecto de python.
print('-'*30)
A = {1,2,3}
B = {1,2,4,3,5}
"""issubset() busca si los valores de A están en B, sin importar el orden"""
print(A.issubset(B))

# Union de conjuntos. Omite los valores repetidos
print('-'*30)
A = {1,2,3,4,5}
B = {4,5,6,7,8,9,10}
print(A.union(B))

# Intersección de conjuntos, es decir, los valores que se repiten
print('-'*30)
print(A.intersection(B))

# Diferencia entre conjuntos
print('-'*30)
print(A.difference(B))
print(B.difference(A))
print(A - B)
print(B - A)

##------ Utilizando sympy -------
# Utilizando FiniteSet de sympy
"""Para que el import no de error, abrir el power shell como admin
en la carpeta donde este el archivo (en mi caso, que utilizo el 
sublime text 3) o si ejecutais desde el interprete por consola, en ambos
casos teneis que poner pip install sympy"""
print('-'*30)
from sympy import FiniteSet
C = FiniteSet(1, 2, 3)
print(C)

# Generando el conjunto potencia. Esto no se puede
# hacer utilizando el conjunto por defecto de python.
print('-'*30)
print(C.powerset())

# Cardinalidad
print('-'*30)
print("La cardinalidad del conjunto potencia del conjunto C = {0} es {1}".
     format(C, len(C.powerset())))

# Igualdad
print('-'*30)
A = FiniteSet(1, 2, 3)
B = FiniteSet(1, 3, 2)
print(A == B)

A = FiniteSet(1, 2, 3)
B = FiniteSet(1, 3, 4)
print(A == B)

# Subconjunto y subconjunto propio
print('-'*30)
A = FiniteSet(1,2,3)
B = FiniteSet(1,2,3,4,5)
print(A.is_subset(B))

# A == B. El test de subconjunto propio da falso
print('-'*30)
B = FiniteSet(2,1,3)
print(A.is_proper_subset(B))

# Union de dos conjuntos
print('-'*30)
A = FiniteSet(1, 2, 3)
B = FiniteSet(2, 4, 6)
print(A.union(B))

# Interseccion de dos conjuntos
print('-'*30)
A = FiniteSet(1, 2) 
B = FiniteSet(2, 3) 
print(A.intersect(B))

# Diferencia entre conjuntos
print('-'*30)
print(A - B)

# Calculando el producto cartesiano. Con el conjunto por 
# defecto de python no podemos hacer esto con el operador *
print('-'*30)
A = FiniteSet(1, 2)
B = FiniteSet(3, 4)
P = A * B
print(P)

for elem in P:
    print(elem)

# Elevar a la n potencia un conjunto. Calcula el n 
# producto cartesiano del mismo conjunto.
print('-'*30)
A = FiniteSet(1, 2, 3, 4)
P2 = A ** 2
print(P2)

P3 = A ** 3
print(P3)

for elem in P3:
    print(elem)

# Dibujanto el diagrama de venn de 2 conjuntos
"""Para que el import no de error, abrir el power shell como admin
en la carpeta donde este el archivo (en mi caso, que utilizo el 
sublime text 3) o si ejecutais desde el interprete por consola, en ambos
casos teneis que poner pip install 'matplotlib'
y ' pip install matplotlib_venn'"""
print('-'*30)
from matplotlib_venn import venn2, venn2_circles
import matplotlib.pyplot as plt
   
print(dir(plt))
A = FiniteSet(1, 3, 5, 7, 9, 11, 13, 15, 17, 19)
B = FiniteSet(2, 3, 5, 7, 11, 13, 17, 19, 8)

plt.figure(figsize=(10, 8))
v = venn2(subsets=[A, B], set_labels=('A', 'B'))
v.get_label_by_id('10').set_text(A - B)
v.get_label_by_id('11').set_text(A.intersection(B))
v.get_label_by_id('01').set_text(B - A)
c = venn2_circles(subsets=[A, B], linestyle='dashed')
c[0].set_ls('solid')
plt.show()

Los mejores trabajos son aquellos que utilizan la herramienta correcta para el trabajo correcto

Estos conceptos de conjuntos en Python los son buenos para practicar con clases de Matemáticas Discretas

Podemos pasar de listas a tuplas asi

tupla = tuple(lista)

y de tupla a lista asi

lista = list(tupla)

Compa David. Que bien explicaste listas, diccionarios y tuplas. Ahora sí estructuraste bien el desarrollo de estos temas. No se nota improvisado como el curso anterior que te aventaste XD
Excelente.

Casi muero con el reto.

Los sets nacen de la teoría de conjuntos. No permiten elementos duplicados.

la mayor diferencia de una tupla con una lista es que la lista es inmutable

ventajas de una tupla frente a una lista, la tupla puede regresar varios valores

los conjuntos se parecen a la teoría de conjuntos donde se pueden añadir varios elementos al conjunto pero no existe elementos duplicados su palabra es set

listas = [] , list
diccionarios = {}. dict
tuplas = ().
conjuntos = set, {}

POV: En la prepa pensaste que jámas usarías conjuntos en la vida real 🤡

me gusta mucho ver la teoría aplicada

Los buenos programas, son los que utilizan la herramienta correcta para el trabajo correcto.

Sets

.

.

Ejercita tus conocimientos con simples ejercicios de SETS

.
1.- Crea un SET

primos = set()

# primos = {} un set vacion

# Podemos agregar valores a partir de una lista o una tupla conviertiendo esas estructuras a sets con el método set()

mi_lista  = [3,5,7,9,11,13]

primos = set(mi_lista)

# primos = {3, 5, 7, 9, 11, 13}

>>> primos = {3,5,7,9,11,13}
	
>>> type(primos)
<class 'set'>

# Puedes agregar valores con add(). También agregarlos a partir de otra estructura con .update() 

primos.add(21)

# {3,5,7,9,11,13}

# Tambien podrás eliminar valores del set con .discard() y .remove(). La diferencia es que si el elemento no se encuentra en el ser .remove reportará un error mientras que .discard no lo hará.

primos.discard(3)

# {5, 7, 9, 11, 13}

platzi = set('NuncaParesdeAprender')
print(platzi)

# {'P', 'n', 'N', 'p', 'A', 'c', 's', 'e', 'u', 'd', 'a', 'r'}

# Eliminando el contenido de un set con .clear()

platzi.clear()

# platzi = {}

.

Sets para teoría de conjuntos

# Los siguientes símbolos se utilizan para operar conjuntos con sets: 

se1 = [1, 2, 3]
set2 = [3, 4, 5]

Unión: ( | ) ......................................sets = set1 | set2
Intersección: (&) .............................sets = set1 & set2
Diferencia: (-) ..................................sets = set1 - set2
Diferencia simétrica: (^) ..................sets = set1 ^ set2
Comparando dos Sets: (==)............sets = set1 == set2
Comprobando membresía: (in) .......sets = set1 in set2

Tuples

======

A pesar de parecerse a las listas, las tuplas son más livianas y tienen menos métodos disponibles, esto sucede debido a que las tuplas son inmutables, es decir, no se pueden modificar, a diferencia de las listas. Un punto a favor de las tuplas es que al ser más livianas se pueden trabajar mejor con grandes extensiones de datos.

Si se desea crear una tupla que sólo contenga un elemento, esto se puede hacer con la siguiente sintaxis

prueba = a,


type(prueba)
<class 'tuple'>

Teoría de conjuntos

======

La teoría de conjuntos es una parte de la matemática que estudia como se relacionan un tipo especial de objetos llamados conjuntos, esta se suele hacer de forma gráfica a través de los diagramas de Venn.

La teoría de conjuntos posee además una álgebra de conjuntos que tiene las siguientes operaciones básicas:

• Union: que enlaza dos conjuntos y se representa (A ∪ B)

• Intersección: en esta se ubican todos los elementos que esten en ambos objetos (A ∩ B)

• Diferencia: (A \ B) nos muestra los elementos que estan en A y no pertenecen a B, (B \ A) Tiene todos los elementos de B que no pertenercen a A.

Sets

No son ordenados, es decir, no importa el orden en que agregues datos a el set, estos pueden aparecer en diferente orden. Por otro lado si se agregan dos veces el mismo dato en un set, este agregara el dato la primera vez y la segunda lo ignorara.

Por ejemplo si yo creo el siguiente set en mi computadora

examp = set({1, 9, 'casa', 'hoy'})


#Luego imprimp examp me da el siguiente valor
examp
{'casa', 1, 9, 'hoy'}

En caso de intentarlo en tu computadora con los exactos mismos números y strings, es muy probable que cuando imprimas examp te de un orden distinto.

Los sets tienen los siguientes métodos para las operaciones de conjuntos

• para la unión se usa el método union.

• para intersección posee intersection.

• para diferencia se usa difference.

• además posee distintos métodos para otras operaciones como symmetric_difference, issubset, copy.

• Para borrar todo un set se utiliza clear.

Ahí va mi solución:

import sys

clientes = [
    {
        'nombre': 'Pablo',
        'empresa': 'Google',
        'email': '[email protected]',
        'posicion': 'Software Engineer'
    },
    {
        'nombre': 'Ricardo',
        'empresa': 'Facebook',
        'email': '[email protected]',
        'posicion': 'Data Engineer'
    }
] 

def crear_cliente( cliente ):
    global clientes

    if cliente not in clientes:
        clientes.append( cliente )
    else:
        print('El cliente ya se encuentra en la lista.')


def listar_cliente():
    global clientes

    for indice, cliente in enumerate( clientes ):
        _mostrar_cliente( indice )


def actualizar_cliente(id_cliente, cliente_nuevo):
    global clientes

    clientes[id_cliente] = cliente_nuevo


def eliminar_cliente( id_cliente ):
    global clientes

    del clientes[ id_cliente ]


def buscar_cliente( ):
    global clientes

    nombre_cliente = _obtener_campo_cliente( 'nombre' )

    for cliente in clientes:
        if cliente['nombre'] == nombre_cliente:
            return True
    else:
        return False

def _buscar_cliente_x_nombre():
    global clientes

    nombre_cliente = _obtener_campo_cliente( 'nombre' )

    for indice, valor in enumerate( clientes ):
        if valor['nombre'] == nombre_cliente:
            return indice
    else:
        return -1

def _mostrar_cliente( indice ):
    global clientes

    print( '{uid} | {nombre} | {empresa} | {email} | {posicion}'.format( 
        uid=indice, 
        nombre=clientes[indice]['nombre'],
        empresa=clientes[indice]['empresa'],
        email=clientes[indice]['email'],
        posicion=clientes[indice]['posicion'] ) )


def _obtener_campo_cliente( nombre_campo ):
    campo = None

    while not campo:
        campo = input( '¿Cuál es el {} del cliente?: '.format(nombre_campo) )
    
    return campo

def _obtener_cliente( ):
    cliente = {
        'nombre': _obtener_campo_cliente('nombre'),
        'empresa': _obtener_campo_cliente('empresa'),
        'email': _obtener_campo_cliente('email'),
        'posicion': _obtener_campo_cliente('posicion')
    }
    return cliente

def _imprimir_bienvenida():
    print( 'BIENVENIDO A PLATZI VENTAS' )
    print( '*' * 50 )
    print( '¿Qué te gustaría realizar?: ' )
    print( '[C]rear Cliente' )
    print( '[L]istar Cliente' )
    print( '[A]ctualizar Cliente' )
    print( '[E]liminar Cliente' )
    print( '[B]uscar Cliente' )
    print( '[S]alir' )


if __name__ == "__main__":
    while True:
        _imprimir_bienvenida()

        comando = input()
        comando = comando.upper()

        if comando == 'C':
            cliente = _obtener_cliente()
            crear_cliente( cliente )
            listar_cliente()
        elif comando == 'L':
            listar_cliente()
        elif comando == 'A':
            id_cliente = _buscar_cliente_x_nombre()
            if id_cliente != -1:
                _mostrar_cliente( id_cliente )
                cliente_nuevo = _obtener_cliente()
                actualizar_cliente( id_cliente, cliente_nuevo )
                listar_cliente()
            else:
                print('El cliente no se encuentra en la lista de clientes.')
        elif comando == 'E':
            id_cliente = _buscar_cliente_x_nombre()
            if id_cliente != -1:
                eliminar_cliente( id_cliente )
                listar_cliente()
            else:
                print('El cliente no se encuentra en la lista de clientes.')
        elif comando == 'B':
            encontrado = buscar_cliente( )
            if encontrado:
                print( 'El cliente se encuentra en la lista.' )
            else:
                print( 'El cliente no se encuentra en la lista.' )

            listar_cliente()
        elif comando == 'S':
            break
        else:
            print( 'Comando inválido.' )

Mil disculpas que está todo en español, tan solo que aprovecho y genero material para mis clases.

Conjuntos o Sets

Matemáticas discretas!!!

Las tuplas se comportan similar a las listas, pero la diferencia es que son inmutables.

En otro curso se manejaron los conceptos muy de la mano.

<class 'tuple'>
<class 'set'>

a = {1, 2, 3, 4, 'perro', 'gato'}

b = {2,4,'perro', 'tucan', '33'}

print(a.difference(b))

print(b.difference(a))

{1, 3, 'gato'}
{'33', 'tucan'}

Esta fué mi solución:

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software engineer'
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data engineer'
    },
]

def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the client\'s list')


def list_clients():
    for idx, client in enumerate(clients):
        print(' id: {uid} \n name: {name} \n company: {company} \n email: {email} \n position: {position} \n {separator}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position'],
            separator='=' * 50
        ))


def _update_field(field, client):
    global clients
    client_id = clients.index(client)
    new_value = input('What is the new {}? '.format(field.capitalize()))
    client[field] = new_value
    clients[client_id] = client


def update_client(client):
    if client in clients:
        field_to_change = None
        while not field_to_change:
            field_to_change = input('What field do you want update?\n[N]ame\n[C]ompany\n[E]mail\n[P]osition\n[A]ll\n')
            field_to_change = field_to_change.upper()
            if field_to_change == 'N':
                _update_field('name', client)
            elif field_to_change == 'C':
                _update_field('company', client)
            elif field_to_change == 'E':
                _update_field('email', client)
            elif field_to_change == 'P':
                _update_field('position', client)
            elif field_to_change == 'A':
                _update_field('name', client)
                _update_field('company', client)
                _update_field('email', client)
                _update_field('position', client)
            else:
                print('!! Invalid Option !! \n Please select one of the following options:\n')
                field_to_change = None
    else:
        print("Client is not in client's list")


def delete_client(client):
    global clients

    if client in clients:
        clients.remove(client)
    else:
        print('Client is not in clients list')


def search_client(client):
    return client in clients        


def _print_welcome():
    print('WELCOME TO CLI VENTAS')
    print('*' * 50)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[L]ist clients')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}? '.format(field_name))

    return field


def _get_client():
    client = {
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'email': _get_client_field('email'),
        'position': _get_client_field('position'),
    }

    return client


if __name__ == '__main__':
    _print_welcome()

    command = input()
    command = command.upper()

    if command == 'C':
        client = _get_client()
        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'U':
        client = _get_client()
        update_client(client)
        list_clients()
    elif command == 'D':
        client = _get_client()
        delete_client(client)
        list_clients()
    elif command == 'S':
        client = _get_client()
        found = search_client(client)

        if found:
            print("The client is in the client's list")
        else:
            print('The client with data:\n name: {name} \n company: {company} \n email: {email} \n position: {position} \n {separator} \n is not in our client\'s list'.format(
                name=client['name'],
                company=client['company'],
                email=client['email'],
                position=client['position'],
                separator='=' * 50
            ))
    else:
        print('Invalid command')

Recuerden : Tuplas son inmutables y Sets no permiten elementos repetidos

para tener en cuenta
add nos sirve añadir elementos.
remove nos permite eliminar elementos.

Gracias!!

Genial!!

Python 3.7.3 (default, Mar 27 2019, 17:13:21) [MSC v.1915 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> a=1,2,3
>>> b=[1,2,3]
>>> c={1,2,3}
>>> d={}
>>> d["pizza"]="es lo mas chido"
>>> type(a)
<class 'tuple'>
>>> type(b)
<class 'list'>
>>> type(c)
<class 'set'>
>>> type(d)
<class 'dict'>
>>>```

Pueden utilizar esta librería matplotlib para dibujar sus diagramas de venn la pueden instalar en un ambiente venv con pip

https://recursospython.com/guias-y-manuales/diagramas-de-venn-con-matplotlib/

Reto anterior:

import sys
clients=[
    {
        'name':'Alexander',
        'company':'Google',
        'email':'[email protected]',
        'position':'Sotware engineer',
    },
    {
        'name':'Kenyu',
        'company':'Amazon',
        'email':'[email protected]',
        'position':'data engineer',
    }   

]

def create_client(client):
        global clients
        if client not in clients:
            clients.append(client)
        else:
            print('Client already is in the client\'s list')


def update_client(client_old):
    global clients
    exits='false'
    for idx, client in enumerate(clients):
       	if client_old == client['name']:
       	    updates_client=_get_client()
            clients[idx].update(updates_client)
            exits='false'
            break
        else:
            exits='true'
    if(exits=='true'):
        print('client is not in clients list')


def delete_client(client_name):
    global clients
    exits='false'
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            clients.pop(idx)
            exits='false'
            break
        else:
            exits='true'
    if(exits=='true'):
        print('client is not in clients list')


def search_client(client_name):
    global clients
    
    for client in clients:
        if client != client_name:
            continue
        else:
            return True


def list_clients():
    global clients

    for idx, client in enumerate(clients):
        print('{dx}|{name}|{company}|{email}|{position}'.format(
            dx=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position'],
            ))


def _get_client_field(field_name):
    field = None
    while not field:
        field = input('What is the client {}?'.format(field_name))
    return field


def _get_client():
    cliente={
        'name':_get_client_field('name'),
        'company':_get_client_field('company'),
        'email':_get_client_field('email'),
        'position':_get_client_field('position'),
    }
    return cliente

def _get_client_name():
    client_name = None
    while not client_name:
        client_name = input('What is the client name=')
        if client_name == 'exit':
            client_name=None
            break
    if not client_name:
            sys.exit()
    return client_name

def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*'*50)
    print('What do you want to do today?')
    print('[L]ist client')
    print('[U]pdate client')   
    print('[C]reate client')
    print('[D]elete client')
    print('[S]earch client')

if __name__ == '__main__':
    
    _print_welcome()
    command= input()
    command=command.upper()
    if command == 'C':
        cliente=_get_client()
        create_client(cliente) 
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'U':
        client_name = _get_client_name()
        update_client(client_name)
        list_clients()
    elif command=='D':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)
        if found:
            print('The Client is in the client\'s list')
        else:
            print('The client {} is not in our client\'s list'.format(client_name))
    else:
        print('Invalid Command')

el reto anterior

import sys


clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software Engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer',
    },
]


def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print('Client already in client\'s list')


def list_clients():
    print('uid |  name  | company  | email  | position ')
    print('*' * 50)

    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position']))


def update_client(client_id, updated_client):
    global clients

    if len(clients) - 1 >= client_id:
        clients[client_id] = updated_client
    else:
        print('Client not in client\'s list')


def delete_client(client_id):
    global clients

    for idx, client in enumerate(clients):
        if idx == client_id:
            del clients[idx]
            break


def search_client(client_name):
    for client in clients:
        if client['name'] != client_name:
            continue
        else:
            return True


def _get_client_field(field_name, message='What is the client {}?'):
    field = None

    while not field:
        field = input(message.format(field_name))

    return field


def _get_client_from_user():
    client = {
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'email': _get_client_field('email'),
        'position': _get_client_field('position'),
    }

    return client


def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*' * 50)
    print('What would you like to do today?:')
    print('[C]reate client')
    print('[L]ist clients')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


if __name__ == '__main__':
    _print_welcome()

    command = input()
    command = command.upper()

    if command == 'C':
        client = _get_client_from_user()

        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'U':
        client_id = int(_get_client_field('id'))
        updated_client = _get_client_from_user()

        update_client(client_id, updated_client)
        list_clients()
    elif command == 'D':
        client_id = int(_get_client_field('id'))

        delete_client(client_id)
        list_clients()
    elif command == 'S':
        client_name = _get_client_field('name')
        found = search_client(client_name)

        if found:
            print('The client is in the client\'s list')
        else:
            print('The client: {} is not in our client\'s list'.format(client_name))
    else:
        print('Invalid command')

Ready for practice.

Mi solución

import sys

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Sofware engineer'
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data engineer'
    }

]


# to do :
# search

def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the client\'s list')


def list_clients():
    global clients
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position']

        ))


def update_client(client_data):
    global clients

    for client in clients:
        if client['name'] == client_data['name']:
            client['company'] = client_data['company']
            client['email'] = client_data['email']
            client['position'] = client_data['position']


def delete_client(client_data):
    global clients

    client_exist = False

    for client in clients:
        if client['name'] == client_data['name'] and client['email'] == client_data['email']:
            clients.remove(client)
            client_exist = True

    if not client_exist:
        print('Clients is not in clients list')


def _build_delete_data():
    client = {
        'name': _get_client_field('name'),
        'email': _get_client_field('email')
    }
    return client


def _build_name():
    client = {
        'name': _get_client_field('name')
    }
    return client


def search_client(client_name):
    global clients
    for client in clients:
        if client['name'] != client_name['name']:
            continue
        else:
            return True


def _print_welcome():
    print('WELCOME TO PLAZTI VENTAS')
    print('*' * 50)
    print('What would you like today')
    print('C - Create Client')
    print('L - List Clients')
    print('U - Update Client')
    print('D - Delete Client')
    print('S - Search Client')


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}?'.format(field_name))

        return field


def _build_client_data():
    client = {
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'email': _get_client_field('email'),
        'position': _get_client_field('position'),
    }

    return client


if __name__ == '__main__':
    _print_welcome()
    command = input()
    command = command.upper()
    if command == 'C':
        create_client(_build_client_data())
        list_clients()
    elif command == 'D':
        delete_client(_build_delete_data())
        list_clients()

    elif command == 'U':
        update_client(_build_client_data())
        list_clients()

    elif command == 'S':
        found = search_client(_build_name())

        if found:
            print('The client is in the client\'s list')
        else:
            print('The client: {} is not in our client\'s list'.format(client_name))
    elif command == 'L':
        list_clients()
    else:
        print('Invalid Command')

Solución:

clients = [
    {
        "name": "Pablo", 
        "company": "Google",
        "email": "[email protected]",
        "position": "Software engineer",
    },
    {
        "name": "Ricardo", 
        "company": "Facebook",
        "email": "[email protected]",
        "position": "Data scientist",
    }
]


def create_client(client):
    global clients
    if client not in clients:
        clients.append(client)
    else:
        print("The client already is in the client's list")


def list_clients():
    global clients
    for idx, client in enumerate(clients):
        print("{uid} | {name} | {company} | {email} | {position}".format(
            uid = idx,
            name = client["name"],
            company = client["company"],
            email = client["email"],
            position = client["position"]
        ))



def delete_client(client_idx):
    global clients
    clidx = int(client_idx)
    if  clidx < len(clients):
        clients.pop(clidx)
    else:
        print("Client is not in client's list")


def search_client(client_name):
    global clients

    for client in clients:
        if client["name"] != client_name:
            continue
        else:
            return True


def update_client(client_idx, updated_client):
    global clients
    clidx = int(client_idx)
    if clidx < len(clients):
        clients[clidx] = updated_client
    else:
        print("Client is not in client's list")


def _welcome():
    print("Welcome to ventas")
    print('*' * 50)
    print("What would you like to do today?")
    print("[C] create client")
    print("[D] delete client")
    print("[U] update client")
    print("[S] search client")

def _get_client_field(field_name):
    field = None

    while not field:
        field = input("What's the client {}?".format(field_name))
    return field

def _get_client_name():
    client_input = None

    while not client_input:
        client_input = input("What's the client name?")
    return client_input

def _get_client_idx():
    client_input = None

    while not client_input:
        client_input = input("What's the client index?")
    return client_input

if __name__ == '__main__':
    _welcome()

    command = input()
    command = command.upper()

    if command == 'C':
        client = {
            "name": _get_client_field("name"),
            "company": _get_client_field("company"),
            "email": _get_client_field("email"),
            "position": _get_client_field("position"),

        }
        create_client(client)
        list_clients()
    elif command == 'D':
        client_idx = _get_client_idx()
        delete_client(client_idx)
        list_clients()
    elif command == 'U':
        client_idx = _get_client_idx()
        print("Type the new client data")
        updated_client = {
            "name": _get_client_field("name"),
            "company": _get_client_field("company"),
            "email": _get_client_field("email"),
            "position": _get_client_field("position"),
        }
        update_client(client_idx, updated_client)
        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)
        if found:
            print("The client is in the client's list")
        else:
            print("The client {} is not in our client's name".format(client_name))
    else:
        print("Invalid command")

Solución al reto anterior:

import sys

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software Engineer'
    },
    {
        'name': 'Ricardo',
        'company': 'Faebook',
        'email': '[email protected]',
        'position': 'Data Engineer'
    }
]


def create_clients(client):
    global clients

    if client not in clients:
        clients.append(client)
        # _add_comma()
    else:
        print('Client already is in the clients\'s list.')


def list_clients():
    global clients

    print('uid | name | company | email | position')
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid=idx, 
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position']
        ))


def update_client(client_idx):
    global clients

    if client_idx < len(clients):
        client = clients[client_idx]
        update = _are_you_sure('update', client)
        if update:
            clients.pop(client_idx)
            new_client = _client_structure()
            clients.insert(client_idx, new_client)
            print('Client: {} was successfully updated.'.format(client['name']))
        else:
            print('The action was canceled')
    else:
        print('Client uid is not on clients list.')


def _are_you_sure(command_name, client):
    command = None

    while not command:
        command = input('Are you sure you wanna {} the client: {}? [y/n]: '.format(command_name, client['name']))
        if command.upper() == 'Y' or command.upper() == 'N':
            break
        else:
            command = None
            print('Invalid command')
    
    if command.upper() == 'Y':
        return True
    elif command.upper() == 'N':
        return False



def delete_client(client_idx):
    global clients

    if client_idx < len(clients):
        client = clients[client_idx]
        delete = _are_you_sure('delete', client)
        if delete:
            clients.pop(client_idx)
            print('Client: {} was deleted successfully.'.format(client['name']))
        else:
            print('The action was canceled')
    else:
        print('Client uid is not in clients list')


def search_client(client_name):
    global clients

    for idx, client in enumerate(clients):
        if client_name != client['name']:
            continue
        else:
            return True

    return False


def _print_welcome():
    print('WELCOME TO PLATZI SALES')
    print('#' * 50)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[L]ist clients')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')
    print('[E]xit')


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}?: '.format(field_name))

    return field


def _client_structure():
    return ({
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'email': _get_client_field('email'),
        'position': _get_client_field('position'),
    })


def _get_client_name():
    client_name = None

    while not client_name:
        client_name = input('What is the client name?: ')

        if client_name == 'exit':
            client_name = None
            break

    if not client_name:
        sys.exit()
    return client_name

if __name__ == '__main__':
    while 1:
        _print_welcome()

        command = input()
        command = command.upper()

        if command == 'C':
            client = _client_structure()
            create_clients(client)
            list_clients()
        elif command == 'L':
            list_clients()
        elif command == 'D':
            client_idx = _get_client_field('uid')
            delete_client(int(client_idx))
            list_clients()     
        elif command == 'U':
            client_idx = _get_client_field('uid')
            update_client(int(client_idx))
            list_clients()   
        elif command == 'S':
            client_name = _get_client_name()
            found = search_client(client_name)
            if found:
                print('The client is in client\'s list')
            else:
                print('The client: {client} is not in our client\'s list.'.format(client=client_name))
        elif command == 'E':
            break
        else:
            print('Invalid command')```

My solution:

import sys
clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software engineer'
    }, 
    {
        'name': 'Ricardo',
        'company': 'Facebook', 
        'email': '[email protected]',
        'position': 'Data engineer'
    }
]

_TYPE_YOUR_CLIENT_NAME = 'What is the client name? '
_TYPE_YOUR_UPDATED_CLIENT_NAME = 'What is the new client name? '
_TYPE_YOUR_CLIENT_TO_DELETE= 'What is the client name you want to delete? '
_TYPE_YOUR_FIELD_TO_UPDATE = 'What is the field to update (name, company, email, position)? '
_TYPE_YOUR_FIELD_VALUE_TO_UPDATE = 'Type your value to update: '


def _create_client (client) :
    global clients
    if client not in clients :
        clients.append(client)
        list_clients()
    else :
        print('Client is already registered')


def _update_client_field (client_to_update, updated_client_field, updated_client_field_value) :
    global clients

    for client in clients :
        if client_to_update == client :
            client[updated_client_field] = updated_client_field_value
            break
    
    list_clients()

def _delete_client (client_name) :
    global clients
    
    client = _get_client(client_name)

    if client != None :
        clients.remove(client)
        print('Client has been removed, this is the new list: ')
        list_clients()
    else :
        print('Client doesn\'t exist')


def _search_client (client_name) :
    return _get_client(client_name)


def _get_client (client_name) :
    for client in clients :
        if client_name in client['name'] :
            return client
    return None


def list_clients () :
    for idx, client in enumerate(clients) :
        print('{uid} | {name} | {company} | {email} | {position}'
        .format(
            uid = idx,
            name = client['name'],
            company = client['company'],
            email = client['email'],
            position = client['position']
        ))


def _get_field_to_update () :
    field_to_update = None

    while not field_to_update :
        field_to_update = input(_TYPE_YOUR_FIELD_TO_UPDATE)
    return field_to_update


def _get_client_field (field_name) :
    field = None
    while not field :
        field = input('What is the client {}?'.format(field_name))
    return field


def _get_client_name (message_to_display) :
    client_name = None
    while not client_name :
        client_name = input(message_to_display)

        if client_name == 'exit' :
            client_name = None
            break

    if not client_name :
        sys.exit()
    return client_name


def _get_client_format (client_name, client_company, client_email, client_position) :
    return {
        'name': client_name,
        'company': client_company,
        'email': client_email,
        'position': client_position
    }

def _get_client_field_value_to_update () :
    value_to_update = None 

    while not value_to_update :
        value_to_update = input(_TYPE_YOUR_FIELD_VALUE_TO_UPDATE)
    return value_to_update


def _print_welcome () :
    print("WELCOME TO PLATZI VENTAS")
    print('*' * 50)
    print('What would you like to do today? ')
    print('[C]reate client ')
    print('[U]pdate client ')
    print('[D]elete client ')
    print('[L]ist clients ')
    print('[S]earch client ')


if __name__ == '__main__' :
    _print_welcome()
    command = input()
    command = command.upper()

    if command == 'C' :
        _create_client(
            _get_client_format(
                _get_client_field('name'),
                _get_client_field('company'),
                _get_client_field('email'),
                _get_client_field('position'))
            )

    elif command == 'D' :
        client_name = _get_client_name(_TYPE_YOUR_CLIENT_TO_DELETE)
        _delete_client(client_name)

    elif command == 'L':
        list_clients()

    elif command == 'U':
        client_name = _get_client_name(_TYPE_YOUR_CLIENT_NAME)
        client_to_update = _get_client(client_name)

        if client_to_update != None :
            field_to_update = _get_field_to_update()
            updated_client_field_value = _get_client_field_value_to_update()
            _update_client_field(client_to_update, field_to_update, updated_client_field_value)
        else : 
            print('Client doesn\'t exist')
    
    elif command == 'S':
        client_name = _get_client_name(_TYPE_YOUR_CLIENT_NAME)
        found = _search_client(client_name)

        if found != None : 
            print('Client is in the client\'s list \nClient: {}'.format(found))
        else : 
            print('Client: {} is not in client\'s list'.format(client_name))

    else :
        print("Comando invalido")

        

Por esta razón es que Python es un lenguaje idóneo para Machine Learning y Data Sciencie?
O qué es lo que hace que el lenguaje sea idóneo para este tipo de aplicaciones?

import sys
import os

clients = [
  {
    'name': 'Pablo',
  'company': 'Google',
  'email': '[email protected]',
  'position': 'Software Engineer',
  },
  {
    'name': 'Ricardo',
    'company': 'Facebook',
    'email': '[email protected]',
    'position': 'Data Engineer',
  },
]


def create_client(client):
  global clients

  if client not in clients:
    clients.append(client)
  else:
    print('Client already in client\'s list')


def list_clients():
  print('uid |  name  | company  | email  | position ')
  print('-' * 50)

  for idx, client in enumerate(clients):
    print('')
    print('{uid} | {name} | {company} | {email} | {position}'.format(
    uid=idx, 
    name=client['name'], 
    company=client['company'], 
    email=client['email'], 
    position=client['position']))


def update_client(clientForm, message='Enter your new {}? '):
  global clients

  for idx, client in enumerate(clients):
    if clientForm == idx:
      clients[idx]['name']  = input(message.format('name'))
      clients[idx]['email'] = input(message.format('email'))
    
    elif clientForm == clients[idx]['name']:
      client['name'] = input(message.format('name'))

    elif clientForm == clients[idx]['email']:
      client['email'] = input(message.format('email'))
    
  else:
    print('Client not in client\'s list')


def delete_client(clientForm):
  global clients

  for idx, client in enumerate(clients):
    if clientForm == idx:
      del clients[idx]
    
    elif clientForm == client['name']:
      del clients[idx]
    
    elif clientForm == client['email']:
      del clients[idx]

    else:
      print('Client not in client\'s list')
      break

def search_client(client_id):
  global clients

  for key, values in enumerate(clients):
    if client != client_name:
      continue
    else:
      return True


def _get_client_field(clientForm, message='What is the client {}? '):
  field = None

  while not field:
    field = input(message.format(clientForm))

  return field


def _get_client_from_user():
  client = {
    'name': _get_client_field('name'),
    'company': _get_client_field('company'),
    'email': _get_client_field('email'),
    'position': _get_client_field('position'),
  }

  return client


def _print_welcome():
  print('       WELCOME TO PLATZI VENTAS')
  print('-' * 50)
  print('      What would you like to do today?:')
  print('')
  print('      [C] Create client')
  print('      [L] List clients')
  print('      [U] Update client')
  print('      [D] Delete client')
  print('      [S] Search client')
  print('')

def _print_by_which():
  print('')
  print('      why field do you want to update?')
  print('')
  print('      [ID] Id')
  print('      [N] Name')
  print('      [E] Email')
  print('')

def method_delete():
  while True:
    _print_by_which()

    command = input('Select an option: ')
    commmad = command.upper()


    if commmad == 'N':
      clientForm = _get_client_field('name')
      delete_client(clientForm)
      list_clients()

    elif commmad == 'ID':
      clientForm = int(_get_client_field('id'))
      delete_client(clientForm)
      list_clients()

    elif commmad == 'E':
      clientForm = _get_client_field('email')
      delete_client(clientForm)
      list_clients()

def _method_update():
  while True:
    _print_by_which()

    command = input('Select an option: ')
    commmad = command.upper()


    if commmad == 'ID':
      clientForm = int(_get_client_field('ID'))
      update_client(clientForm)
      list_clients()

    elif commmad == 'N':
      clientForm = _get_client_field('name')
      update_client(clientForm)
      list_clients()
    
    elif commmad == 'E':
      clientForm = _get_client_field('email')
      update_client(clientForm)
      list_clients()

if __name__ == '__main__':
  os.system('clear')
  _print_welcome()
  
  command = input('Select an option: ')
  command = command.upper()

  if command == 'C':
    client = _get_client_from_user()
    create_client(client)
    list_clients()
  
  elif command == 'L':
    list_clients()

  elif command == 'U':
    _method_update()

    update_client(client_id, updated_client)
    list_clients()

  elif command == 'D':
    _method_delete()

  elif command == 'S':
    client_name = _get_client_field('name')
    found = search_client(client_name)

    if found:
      print('The client is in the client\'s list')

    else:
      print('The client: {} is not in our client\'s list'.format(client_name))
  else:
    print('Invalid command')

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email':'[email protected]',
        'position':'software engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email':'[email protected]',
        'position':'Data engineer',        
    }       
]


EXTENTION_INPUT_TEXT = 'of client'


def create_client(client_name):
    global clients
    if client not in clients:        
        clients.append(client)
    else:
        print('Client already is in the client\'s list')
 
  
def list_clients():        
    for idx, client in enumerate(clients) :
        print('{uid} | {name} | {company} | {email} | {position}'
        .format(
            uid = idx,
            name = client['name'],
            company = client['company'],
            email = client['email'],
            position = client['position']
        ))

def delete_client(client_name):
    for client in clients:
        if client_name == client['name']:
            clients.remove(client)
            print('Client has been removed, the list is updated')
        else:
            print('Client is not in client\'s list')
    

def search_client(client_name):        
    for client in clients:        
        if client_name != client['name']:
            continue
        else:
            return True
                        

def update_client(client_name, updated_name, client_update):   
    for client in  clients:
        print(client['name'])
        if client_name == client['name']:
            client['name'] = client_update['name']
            client['company'] = client_update['company']
            client['email'] = client_update['email']
            client['position'] = client_update['position']
        else:
            print('Client is not in client\'s list')
            
   
    
def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')    
    print('*' * 50)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[L]ist client')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')

def _get_client_field(field_name, extention):
    field = None
    while not field:
        field = input('What is the client {} {}? '.format(field_name, extention))
    
    return field


if __name__ == '__main__':
    _print_welcome()
    command = input()
    command = command.upper()
    if command == 'C':
        client = {
            'name': _get_client_field('name',''),
            'company': _get_client_field('company',''),
            'email': _get_client_field('email',''),
            'position': _get_client_field('position','')
        }
        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'D':
        client_name = _get_client_field('name','')
        delete_client(client_name)
        list_clients()
    elif command == 'U':        
        client_name = _get_client_field('name','')
        client_new = {
            'name' : _get_client_field('name',EXTENTION_INPUT_TEXT),
            'company' : _get_client_field('company', EXTENTION_INPUT_TEXT),
            'email' : _get_client_field('email', EXTENTION_INPUT_TEXT),
            'position' : _get_client_field('position', EXTENTION_INPUT_TEXT)
        }                
        update_client(client_name, client_name, client_new)
        list_clients()
    elif command == 'S':        
        client_name = _get_client_field('name','')
        found = search_client(client_name)
        
        if found:
            print('The client is in the client\'s list')
        else:
            print('The client: {} is not in client\'s list'.format(client_name))
    else:
        print('Invalid command')
        ```

Para los que quieran profundizar mas en la teoría de conjuntos les dejo el sigueinte enlace, atrévanse a aprender conjuntos, les garantizo que desarrolla el pensamiento lógico y por ende te ayuda a resolver problemas de manera mas ordenada (lógica).

es posible que el usuario ingrese el nombre del cliente y poder compararlo con los ya registrados en el diccionario? como seria el programa?

Una n-tupla es una secuencia (o lista ordenada) de n elementos, siendo n un número natural (entero no-negativo). La única 0-tupla es la secuencia vacía. Una n-tupla se define inductivamente desde la construcción de un par ordenado. Las tuplas suelen anotarse listando sus elementos entre paréntesis "{\displaystyle ({\text{ }})}{\displaystyle ({\text{ }})}", separados por comas. Por ejemplo, {\displaystyle (2,7,4,1,7)}{\displaystyle (2,7,4,1,7)} denota una 5-tupla. En ocasiones se usan otros delimitadores, como los corchetes "{\displaystyle [{\text{ }}]}{\displaystyle [{\text{ }}]}" o las angulares "{\displaystyle \langle {\text{ }}\rangle }{\displaystyle \langle {\text{ }}\rangle }".```

idóneo para trabajar con poblaciones

Los conjuntos los podemos ver como los JOIN en los query de SQL.
a.difference(b) es lo mismo que decir LEFT JOIN
b.difference(a) es lo mismo que decir RIGHT JOIN
y si queremos unicamente la intersección osea lo que esta en A y esta en B sería un INNER JOIN.

Saludos

Si tenemos conjuntos no podemos repetir los valores.

podemos añadir elementos a los set con el método add y quitamos con el método remove

Literal y funcional, para los sets, debido a su parecido sintáctico con las listas, tenemos que hacer para menor confusión una declaración de forma funcional.

Los conjuntos o sets, dentro de la programación, surgen de lo que en matemáticas llamamos, teoria de conjunto. Estos, son muy parecidos a las demás estructuras de control y estas las tenemos con otras reglas también, como que no podemos tener elementos repetidos pero si podemos mutarlo arbritariamente.

Tenemos que considerar que las diferentes estructuras de datos, están hechas para motivos y situaciones diferentes, no existe una que sea adaptable para todo.

Para posicionar valores dentro un plano cartesiano, tenemos la tupla, que es de mucha utilidad.

podemos utilizar la funció tuple para crear una tupla y utilizamos este tipo de dato en los casos que tenemos, es cuando queremos regresar más de un valor nuestra función, poniendo dentro de una tupla los valores en el return.

Las tuplas se identifican adecuadamente, debido que tienen valores separados por comas y que estos van contenidos en paréntesis.

IMPORTANTE Si estas utilizando una estructura de datos que sabes que son valores van a ser inmutable es preferible utilizar tuplas por que su tiempo de carga al momento de ejecutar es menor y por ende va a estar mayormente optimizado.

Siempre es importante practicar solamente aprenderemos mediante a la practica.

estupendo, sigamos u.u

Excelente, Gracias

• Las tuplas son iguales a listas, pero son inmutables. Se inicializan con paréntesis y se usa para devolver varios valores en una función.
• En los conjuntos no se pueden repetir los elementos, son mutables. Se inicializan con la función set.