Básicos del Lenguaje

1

Guía de instalación y conceptos básicos

2

Archivos y slides del curso práctico de Python

3

IMPORTANTE: Instalando Ubuntu Bash en Windows para facilitarte el seguimiento del curso desde Windows.

4

¿Qué es la programación?

5

¿Por qué programar con Python?

6

Operadores matemáticos

7

Variables y expresiones

8

Presentación del proyecto

9

Funciones

10

Usando funciones en nuestro proyecto

11

Operadores lógicos

12

Estructuras condicionales

Uso de strings y ciclos

13

Strings en Python

14

Operaciones con Strings en Python

15

Operaciones con strings y el comando Update

16

Operaciones con strings y el comando Delete

17

Operaciones con strings: Slices en python

18

For loops

19

While loops

20

Iterators and generators

Estructuras de Datos

21

Uso de listas

22

Operaciones con listas

23

Agregando listas a nuestro proyecto

24

Diccionarios

25

Agregando diccionarios a nuestro proyecto

26

Tuplas y conjuntos

27

Tuplas y conjuntos en código

28

Introducción al módulo collections

29

Python comprehensions

30

Búsquedas binarias

31

Continuando con las Búsquedas Binarias

32

Manipulación de archivos en Python 3

Uso de objetos y módulos

33

Decoradores

34

Decoradores en Python

35

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

36

Programación orientada a objetos en Python

37

Scopes and namespaces

38

Introducción a Click

39

Definición a la API pública

40

Clients

41

Servicios: Lógica de negocio de nuestra aplicación

42

Interface de create: Comunicación entre servicios y el cliente

43

Actualización de cliente

44

Interface de actualización

45

Manejo de errores y jerarquía de errores en Python

46

Context managers

Python en el mundo real

47

Aplicaciones de Python en el mundo real

Conclusiones finales

48

Python 2 vs 3 (Conclusiones)

Clases bonus

49

Entorno Virtual en Python y su importancia: Python en el mundo real

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Usando funciones en nuestro proyecto

10/49
Recursos

Aportes 94

Preguntas 15

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Mi código del ejercicio

clients = 'Pablo, Ricardo' #creamos el string

def create_client(client_name):
	global clients  #Utilizamos global para definir que la variable es la globarl, es decir la que definimos con pablo y ricardo
	_add_coma() #ejecutamos la funcion _add_coma para agregar una coma y un espacio 
	clients += client_name  #adicionamos el nuevo string



def _add_coma():  #el nombre de la función comienza con un guión bajo para establecer que será una funcion privada
	global clients
	clients +=", " #se agrega una coma y un espacio al string para separar los nuevos valores


def list_clients(): #función que muestra la lista de clientes
	global clients
	print (clients) #imprimimos el string clientes


if __name__ == '__main__': #funcion main
	print("Primer lista")
	list_clients() #Listamos los clientes
	print("****************************************************")
	create_client('Fernando') #ejecutamos la funcion crear cliente
	print("Lista despues de ejecutar la función create_client()")
	list_clients() #Volvemos a ejecutar la funcion listar clientes 

	print("****************************************************")
	print ('Funcion lambda')
	#Funcion lambda
	"""
	Se trata de crear funciónes de manera rápida, just in time, sobre la marcha, para prototipos 
	ligeros que requieren únicamente de una pequeña operación o comprobación. Por lo tanto, 
	toda funcioón lambda también puede expresarse como una convencional (pero no viceversa)
	f = lambda argumentos: resultado
	"""
	f = lambda x,y: x+y
	print (f('Hola, soy una función... ','lambda :)'))

	
input() #En este caso la usamos para pausar la ejecución del programa hasta presionar la tecla enter

¿Qué archivo trabajamos en la clase anterior? No se nos dejó ninguno…

Como vengo de otros lenguajes, y entiendo la importancia de escribir correctamente el código (especialmente en python) me encontré con la herramienta llamada pylint (que me ha gustado bastante, cada vez que la ejecuto me saca como 10 errores XD). Por acá dejo mi código de acuerdo a las indicaciones de pylint

#!/usr/bin/env python
"""
New project
"""

def create_client(name, clients):
    """
    Summary: \n
    \t Creates and add a new client to the client list \n
    Arguments: \n
    \t name (str) : Name of the new client \n
    \t clients (str) : List of clients \n
    """
    clients += name
    return clients


if __name__ == '__main__':
    CLIENTS = 'pablo,ricardo'
    print(CLIENTS)
    CLIENTS = create_client(',david', CLIENTS)
    print(CLIENTS)

Lo que sucedes es que no reconoce la variable con la que debe de trabajar, es aca donde entra el concepto de variables globales, locales, ya que en el caso de realizar el

def create_client(client_name)
	clients += client_name

la funcion supone que dentro de ella existe una variable local llamada clients, claro esta que este error solo ocurre cuando tratamos de manipular es decir asignar, reasignar, cambiar el valor de la variable, ya que si mostramos un print clients esto se motraria sin ningun error.

clients = 'pablo,ricardo,'

def create_client(client_name):
	#clients += client_name
	print(clients)


if __name__ == '__main__':
	create_client( "wil")
	#print(clients)```
Porque a la funcion add_comma la comenzaste con ‘_’ que significa?

El error que aparece es:

Traceback (most recent call last):
  File "functions.py", line 13, in <module>
    main()
  File "functions.py", line 9, in main
    create_client('Barbara')
  File "functions.py", line 6, in create_client
    clients += client
UnboundLocalError: local variable 'clients' referenced before assignment```

La clase comienza diciendo que retomemos el archivo anterior y la clase anterior se hablo de sumar dos numero y no fue en un archivo

Para los que usan Vim, les dejo el .vimrc del profe:
https://github.com/jdaroesti/linux-conf/blob/master/.vimrc

Tiene algunas configuraciones y plugins que agregue al mio.

No entendí, ¿qué error debe generarme?

Obtuve:

pablo, ricardodavid

Note que si en la funcion:

print_Client():

no se agrega la variable

global clients

igual funciona, alguien sabe porque?

Alguien puede orientarme sobre de donde sale la lista y mas aun de donde sale el proyecto platzi ventas? siguen hablando del proyecto y no se de donde salió. Saludos

Codigo final

clients = 'pablo,ricardo,'


def create_client(client_name):
    global clients
    clients += client_name
    _add_comma()


def list_clients():
    global clients

    print(clients)


def _add_comma():
    global clients

    clients += ','


if __name__ == '__main__':
    list_clients()

    create_client('david')

    list_clients()

Buenas, porque se anade el _ al principio de ciertas funciones? y que significa estas instrucciones como por ejemplo name, cual es la definicion de estas?

¿Cual es la diferencia entre usar el keyword global para clients y poner clients dentro de la funcion: list_clients(clients)? Se que funcionan diferente pero es una duda que me incomoda.

Con este código:
clients = 'pablo, ricardo, ’

def create_client(client_name):

clients += client_name

if name == ‘main’:
clients += ‘david’

print(clients)

Me regresa esto:
D:\EjerciciosPython>main.py
pablo, ricardo, david

Si me funciona, ¿esta mal?

no entendí para que sirve ??

if name=‘main’:
create_client(‘David’)
print(clients)

No me quedo claro el concepto de funciones lambda en este video, así que tuve que buscar por internet más información acerca de lo que es una función lambda en python y me encontré con un concepto diferente a lo que se ve en el video, en fin creo que hay que cambiarle el título y agregar otro material donde se explique que es una función lambda!

Hola comunidad!

Por sí les sirve, para trabajar en el vim con número de línea y colores y los espacios en lugar del tab.

<
$ echo set number >> ~/.vimrc
$ echo syntax on >> ~/.vimrc
$ echo set tabstop=4 >> ~/.vimrc
$ echo set autoindent >> ~/.vimrc
$ cat ~/.vimrc
set number
syntax on
set tabstop=4
set autoindent
>

Tengo varias dudadas, no he podido avanzar en este curso:

no entiendo esta parte del código

if name == ‘main_’:
clients += 'david’
print(clients)

Muy desprolijo en la clase que creo el archivo main.py lo creo sobre un entorno que el ya había creado con una estructura donde ya esta el proyecto completo. pero en ningún momento explico esa parte.

<h1>Este es mi código funcionando, espero les sirva.</h1>
clients = 'pablo,ricardo,'


def create_client(client_name):
    global clients
    clients += client_name

def list_clients():
    global clients

    print(clients)

def _add_coma():
  global clients 
  clients += ','


if __name__== '__main__':
    list_clients()

    create_client('Nico')

    list_clients()

El error del que habla cuando empieza a escribir el código es de nombre de variable no encontrado. Esto es así, porque la variable clients es interna de la función y como se esta realizando una asignación con operador de suma, el lenguaje asume que es una reasignación sobre esa variable que de hecho no ha sido asignada aun. Cuando se utiliza el global se accede al espacio en memoria que le pertenece a clients, por tanto la reasignación se hace posible.


clients = "Pablo, Ricardo,"


def create_client(client_name):
    global clients

    clients += new
    _add_comma()
    clients += client_name


def list_clients():
    global clients

    print(clients)


def _add_comma():
    global clients

    clients += ","


# inicio del programa
if __name__ == "__main__":
    list_clients()

    new = str(input("ingresa otro cliente: "))
    create_client("David")

    list_clients()```
clients = 'tomas,juan,'

def create_client(client_name):
    global clients
    clients +=client_name
    _add_comma()


def list_clients():
    global clients
    print(clients)

def _add_comma():
    global clients
    clients +=','

    

if __name__ == '__main__':
    print (clients)

    create_client(input(str('Name: ')))

    list_clients()```

En python3 sí lo corre.

siguiendo la explicacion de las lambda funcion para funciones que tienen solo 1 proposito aqui esta mi codigo

clients = 'pablo, ricardo, '

def insert_name(clients_name):
    global clients
    clients += clients_name + ', '

viewLisClient = lambda: print(clients)


if __name__ == '__main__':
    
    viewLisClient()  

    insert_name('victor')    
    
    viewLisClient()
Pequeña modificacion, para agregar clientes mediante inputs, y algunas pausas al imprimir en la consola. ```python import time clients = 'pablo, ricardo, ' def create_client(): global clients clients += input('add new clients: ') _add_comma() def list_clients(): global clients print(clients) def _add_comma(): global clients clients += ', ' if __name__ == '__main__' : print('current clients list:') list_clients() time.sleep(2) create_client() time.sleep(2) print('new clients list:') print(clients) ```import timeclients = 'pablo, ricardo, ' def create\_client(): global clients clients += input('add new clients: ') \_add\_comma() def list\_clients(): global clients print(clients) def \_add\_comma(): global clients clients += ', ' if \_\_name\_\_ == '\_\_main\_\_' : print('current clients list:') list\_clients() time.sleep(2) create\_client() time.sleep(2) print('new clients list:') print(clients)

Por si no se percataron, lean lamdas.pdf que esta en ‘Archivos de clase’ porque ahora puede resultar algo innecesario y una sintaxis hasta confusa, pero hay veces que es práctico y necesario utilizar funciones como parámetro de otras (composición) de forma dinámica y es mucho más útil y limpio usar esta versión de funciones (anónimas) que las tradicionales con def.

Buena clase

Fácilmente se puede usar + ',' en clients. Pero para practicar variables privadas y llamado de funciones.

Les traigo el código del profesor pero con el uso de la función Input().

clients = 'Gael,Paul,Sebastian' #String con nombres de clientes 


def create_client(client_name): #Se concatena los clientes al string clients
    global clients #Global: sirve para acceder a las variables declaradas fuera de la funcion.
    _add_comma()
    clients += client_name


def list_clients(): #Se muestran los clientes 
    global clients
    print(clients)


def _add_comma(): #Se concatena una coma en el string clients
    global clients 
    clients += ','


if __name__ == "__main__":

    list_clients()
    create_client(input("Cual es tu nombre de cliente -> ")) #INPUT: Sirve para pedir el nombre
    list_clients()

Este fue el error que me sacó cuando no le puse la variable global dentro de la función, una vez invoco la función en la clase principal o condicional
UnboundLocalError: local variable ‘clients’ referenced before assignment

Aqui dejo informacion que me parecio importante con respecto al alcance que puede tener una variable segun donde sea utlizada.

Buen Dato lo de la keyword global OMG.

Debemos usar global porque la preferencia del nombre de variable siempre sera dada a la variable local

Algo que me intriga es porque esta clase tiene como nombre en el link funciones lambda cuando no hablamos de eso nunca en esta clase.

porque usa el guion bajo en name y en main?

Está es mi solución al mismo problema pero con algunos añadidos para que sea legible y comodo de usar!

clients = []

def create_client(client_name):
    global clients
    clients.append(client_name)
    
def _add_comma(user_var):    
    user_var += ", "
    
    return user_var

def run():
    global clients
    
    request = True
    while request == True:
        name:str = input("Please, write client's name: ")
        create_client(name)
        
        request = input("Do you want to continue? Y/N: ")
        request = request.upper()
        
        if request == "Y" or request == "YES":
            request = True
        elif request == "N" or request == "NO":
            request = False
            print("-"*30)
            print("\nOk! Request Completed sucefully")
        else:
            request = False
            print("Stopping...")
        
    names = ""
    for i in clients:
        names += i
        names = _add_comma(names)
    
    print(names)

if __name__ == '__main__':
    run()

si corrió el código, creo que se va buscando de manera automática de ámbito en ámbito: local, global, interno.

estoy usando vs_code si logro ver la ventaja de vim me paso, ya que me molesto la indentacion, ya que no esta de 4 sino de 8 espacios, en fin creo que sería interesante configurar bien vim.


clients = 'pablo,ricardo,'


def create_client(client_name):
    global clients
    clients += client_name
    _add_comma()


def list_clients():
    global clients
    print(clients)


def _add_comma():
    global clients
    clients+=','

if __name__=='__main__':
    list_clients()

    create_client('david')
    
    list_clients()```
Añade espacio para hacer el código "más legible", sería más legible si usara un bendito editor y no vim, que desespero ver a alguien programar en vim, además hay una invonaistenvia en el nivel del curso, explican cosas realmente básicas que no son necesarias pero por otro lado, asumen que las personas ya saben lo suficiente y para seguirle el ritmo de programación. Con Aroesti los timos curso que he tratado de verme ainceramente los dejo pausados, que afán su manera de programar y explicar, puede ser muy bueno en su ambito pero no me parece que este curso esté al nivel de calidad que promete platzi

Se puede utilizar el comando para abrir una terminal paralelo a VIM y así correr el script:

  1. Pulsar la tecla ESC
  2. Escribir :term
  3. ENTER

Posteriormente se abre una terminal.

Espero pueda ayudar a alguien!!

Con las funciones se controla el flujo del programa.

Podemos tener también funciones privadas o auxiliaries.

eso, sigamos aprendiendo u.u

Que programa utiliza que se ve VIM de esa manera en la terminal ??

El Scope o alcance de una variable son importantes a la hora de acceder o modificarla, ya que las variables globales si deseamos modificarlas o utilizarlas dentro de una función debemos utilizar el keyword global + el nombre de la variable.
Es importante tener claro el scope de nuestras variables.

Compañeros en el TAG 1:41 del vídeo no es que no corra el programa (corre y agrega el nombre en la lista), lo que pasa es que cada una de las sentencias se ejecutan a excepción de la función.

Esto ocurre porque la función en ningún momento es llamada y se le pasan los parámetros correspondientes. 😉

Este es el error que me arroja

Traceback (most recent call last):
  File "main.py", line 10, in <module>
    create_client('david')
  File "main.py", line 6, in create_client
    clients += client_name
UnboundLocalError: local variable 'clients' referenced before assignment

Si no colocamos:

global clients

obtenemos el siguiente error:

File "main.py", line 5, in create_client
    clients += client_name
UnboundLocalError: local variable 'clients' referenced before assignment

¿Por qué la función _add_comma() se pone privada?

no entendí para que sirve ??

if name=‘main’:
create_client(‘David’)
print(clients)

Alguien que me explique por favor.

y porque usa el doble guion bajo “__”. que significa.?

No se nos proveyó ni se nos instruyó a hacer ningún archivo la clase anterior.

No tira Error!

clientes = "pablo,andres,"

def crear_client(nombre_cliente):
    clientes += nombre_cliente


if __name__ == "__main__":
    clientes += "david"
    print(clientes)```

El error al usar variables fuera del scoope

UnboundLocalError: local variable ‘clients’ referenced before assignment

En mi caso, corrió sin problemas.

Perfect!!

`

#definimos clientes
clients ='pablo,ricardo,'


#creamos funcion para agregar clientes

def create_cliente (client_name):
    global clients
    clients+=client_name
    _add_comma()

#printeamos clientes
def list_clients():
    global clients
    print clients

#generamos una coma
def _add_comma():
    global clients
    clients+=','
    

if __name__=='__main__':
    
    list_clients()
    create_cliente('roberto')
    list_clients()

Resultado:
pablo,ricardo,
pablo,ricardo,roberto,

Bien desarrollado; sin embargo no se detalla la utilidad puntual de cada Función ni de
if name == ‘main’:

Algunos podrían intuir de qué trata cada parte del desarrollo del código, pero los cien por ciento neófitos, no.

client_before = ["juan ", “samir”, “pedro”]

def created_user():
client_new = []
for x in range(5):
name = input("digita tu nombre: ")
client_new.append(name)
list_client(client_new)

def list_client(client_new):
global client_before
print("clientes anteriores {} ".format(client_before))
new_client(client_new, client_before)

def new_client(client_new, client_before):
new = client_new + client_before
print(“clientes nuevos {}”.format(new))

if name == “main”:

created_user()

El error que se recibe al ejecutar el codigo sin agregar global clients dentro de la funcion es el siguiente

Traceback (most recent call last):
  File ".\main.py", line 14, in <module>
    create_client('david')
  File ".\main.py", line 6, in create_client
    clients += client_name
**++UnboundLocalError: local variable 'clients' referenced before assignment++**
IndentationError: unexpected indent

¿Que configuración de vim usas?

Genial!!

Perdón por lo adelantado de la pregunta, pero todo este proceso se puede compilar en un “.exe” a futuro?

Para lo que comenta David sobre las convenciones de los dos espacios entre funciones, los IDE te lo comentan
PyCharm me colocó:

PEP8: Expected 2 blank lines, found 1
entre la primera funciòn y la segunda, y te lo subraya de color gris, al dar el segundo espacio se quita el subrayado.

¿Porque las variables e funciones se declaran antes que la asignacion: if name == ‘main’?

Ami el código con la variable clients += client_name

Excelente clase! 😄

En vez de crear otra funcion que diga la lista de los clientes hice esto:

clients = 'pablo, ricardo, Facundo, '

def clients_create(client_name):
	global clients
	clients += client_name

	_add_comma()


def _add_comma ():
	global clients
	clients += ', '

if __name__ == '__main__':
	print ("Clientes anteriores:", clients)
	clients_create('David')
	print("Clientes nuevos:", clients)```

Bien o mal

Vaina no podía editar dentro del archivo. Investigue y tocaba digitar “i”.

Estoy modificando el código y me parece más legible y sencillo de entender (si conoces las listas).

clients = ['Pablo', 'Ricardo']

def create_client(client_name):

    global clients # Take global variable clients to use it
    clients.append('client_name') # Add element client_name to the list

if __name__ == '__main__':

    create_client('David')
    # Join the elements of the list using the string ', '
    print(', '.join(clients)) # Pablo, Ricardo, David

def list_clients():
    global clients

    print(clients)


def _add_comma():
    global clients

    clients += ','


if __name__ == '__main__':
    list_clients()
    create_client('Jorge')
    list_clients()

Para aquellos que no saben usar el editor de texto vim, aquí les dejo algunos comandos básicos:
vim entramos al archivo vim
vim [nombre del archivo]: entramos al archivo mediante el editor de texto vim
:q no salimos del editor de texto
:q! salir forzosamente sin guardar
i entramos al modo insertar
esc nos salimos del modo insertar
:w guardar los cambios
:wq guardamos y salimos del editor

No es claro.

A los que se les dificulte usar el editor vim pueden ocupar otro IDE llamandolo antes de ejecutar su archivo.
Por ejemplo VisualEstudioCode tiene una interfaz grafica muy amigable para los que van iniciando en este mundo,
se invoca de la siguiente manera desde terminal

code main.py

Clase Clientes
clients.py

class Clients:
    clients = []

    def list(self):
        print(self.clients)

    def create(self, name):
        self.clients.append(name)

Clase Main

from clients import Clients


def main():
    clients_persons()


def clients_persons():
    list_clients = Clients()

    for x in range(5):
        name = input("Please, enter your name: \n")

        # Add client to list
        list_clients.create(name=name)

    list_clients.list()


if __name__ == '__main__':
    main()

Esto es lo que me arroja el Pycharm sobre clients dentro de la funcion create_client

Unresolved reference ‘clients’ less… (⌘F1)
Inspection info: This inspection detects names that should resolve but don’t. Due to dynamic dispatch and duck typing, this is possible in a limited but useful number of cases. Top-level and class-level items are supported better than instance items

A mi no me lanza errores si no utilizo el GLOBAL CLIENTS

Este video me ha resultado bastante complementario para llevar el curso, https://www.youtube.com/watch?v=chPhlsHoEPo&t=817s

clients = 'Pablo,Ricardo'


def list_clients():
    global clients

    print(clients)


def create_client(client_name):
    global clients

    _add_trailing_comma()
    clients+=client_name



def _add_trailing_comma():
    global clients

    clients+=','


if __name__ == "__main__":
    list_clients()

    create_client('David')

    list_clients()

<clients ="pablo, ricardo, "


def crear_cliente(nombre_cliente):
    global clients
    clients += nombre_cliente
    _crear_coma()   #Aqui se agrega la funcion agregar coma

def listar_clientes(): #Le estamos diciendoq que ordene la lista de clientes
    global clients
    print(clients)

def _crear_coma():  #Se crea esta funcion para agregar coma al final
    global clients
    clients += ", "


if __name__ == "__main__": #Indica el inicio del codigo
    listar_clientes()
    crear_cliente("jorge")
    listar_clientes()>

Ese error se da al intentar usar mal el scope de las variables

Traceback (most recent call last):
  File "c:/Users/Royer/Documents/Python Platzi Curso/CRUD_python/platzi-ventas/main.py", line 10, in <module>    
    create_client('royer')
  File "c:/Users/Royer/Documents/Python Platzi Curso/CRUD_python/platzi-ventas/main.py", line 6, in create_client
    clients += client_name
UnboundLocalError: local variable 'clients' referenced before assignment

En este ejercicio estamos concatenando caracteres:

clients = "Pablo, Ricardo,"

def create_client(client_name):
    global clients

    clients += client_name
    _add_comma()


def list_clients():
    global clients

    print(clients)


def _add_comma():
    global clients

    clients += ","


if __name__ == "__main__":
    create_client("Natalia")
    list_clients()```

Buenos días compañero.

Hasta quí todo muy claro, pero tengo una duda y es con el if por que no declara asi; if name== ‘main’: osea de donde sale name y main ?

clients = ‘pablo,ricardo,’

def create_client (client_name):
global clients
clients += client_name
_add_coma ()

def list_clients():
global clients

def _add_coma():
global clients
clients += ‘,’

if name== ‘main’:

list_clients()
print (clients)
create_client ('David')
list_clients()
print (clients)

Implementado, sigamos aprendiendo…

Scope o name space.

De esta forma es mas facil

def create_client(name):
    global  clients
    clients += f" ,{name}"```

Saludos amigos les comparto el codigo de la clase con algunos comentarios utiles para entender mejor:

clients = 'pablo, ricardo, '

def create_clieant(client_name):
    global clients#Asigna a la variable poderla trabajar dentro de la funcion
    clients += client_name
    _add_comma()

def list_clients():
    global clients
    print(clients)

def _add_comma():
    global clients
    clients +=','

if __name__ == '__main__':
    list_clients()#Antes
    create_clieant('Zero')
    list_clients()#Despues```

Les comparto el cogido de la clase:
.

'''
A Pythobn Project to develop a CRUD(create, read, update, delete)
'''

clients = 'pablo, ricardo, '

# Función que añade un nuevo cliente a la variable clients
def create_client(client_name):
    global clients              # La función global aumenta el alcance de la función y permite 
                                # utilizar     la variable clients
    clients += client_name
    _add_comma()


# Función que imprime la lista de clientes
def list_clients():
    global clients
    print(clients)


# Creación de función privada que será auxiliar para separar por comas los nombres
def _add_comma():
    global clients
    clients += ', '


if __name__ == '__main__':
    create_client('david')
    list_clients()


clients = 'pablo,ricardo,'


def create_client(client_name):
    global clients
    clients += client_name
    _add_comma()


def _add_comma():
    global clients

    clients += ','


if __name__ == '__main__':
    create_client('david')
    print(clients)