Introducci贸n

1

El Zen de Python

Conjuntos

2

Sets

3

Modificando conjuntos

4

Operaciones con conjuntos

5

Playgrounds: Elimina elementos duplicados usando conjuntos

Comprehensions

6

List Comprehension

7

Dictionary Comprehension

8

Dictionary Comprehension: condition

9

Playgrounds: Crea una lista usando List Comprehension

10

Lists vs. Tuples vs. Sets

Funciones

11

Funciones

12

Funciones: return

13

Par谩metros por defecto y m煤ltiples returns

14

El scope

15

Refactor game

16

Playgrounds: Tienda de Tecnolog铆a

17

Funciones an贸nimas: lambda

18

Higher order function: una funci贸n dentro de otra funci贸n

19

Map

20

Map con diccionarios

21

Reto: map con inmutabilidad

22

Playgrounds: Multiplica todos los elementos por dos

23

Filter

24

Playgrounds: Retorna solo palabras de 4 letras y m谩s

25

Reduce

M贸dulos

26

M贸dulos

27

Mis propios m贸dulos

28

M贸dulos como scripts: __name__ y __main__

29

Paquetes

30

Playgrounds: Calcular la suma de todas las compras

Manipulaci贸n de archivos y errores

31

Iterables

32

Errores en Python

33

Manejo de excepciones

34

Playgrounds: Captura la excepci贸n: ZeroDivisionError

35

Leer un archivo de texto

36

Escribir en un archivo

37

Leer un CSV

38

Playgrounds: Lee un CSV para calcular el total de gastos

Gr谩ficas en Python

39

Creando una gr谩fica

40

Reto: graficando la poblaci贸n de un pa铆s

41

Reto: graficando la poblaci贸n mundial

Pr贸ximos pasos

42

隆Conoce otros proyectos de este curso!

43

Reconoce tu proceso y certif铆cate

44

Toma el Curso de PIP y Entornos Virtuales con Python

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

El scope

14/44
Recursos

Aportes 73

Preguntas 8

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Creo que esto te puede ayudar a entender mejor: Dentro de una funci贸n puede haber variables, las cuales se llaman variables locales. Estas variables locales, se identifican porque est谩n escritas dentro de la definici贸n de la funci贸n; y 煤nicamente funcionan mientras que la funci贸n sea llamada o utilizada. Si vas a llamar a una variable local por fuera de la funci贸n, no servir谩.
Y existen variables globales, que son las que est谩n escritas fuera de una funci贸n. Estas variables si funcionan al ser llamadas sin la funci贸n, porque no est谩n determinadas dentro de la funci贸n.

SCOPE

Scope o Alcance, es cuando una variable solo esta disponible desde donde fue construida y para ello existen dos ambitos, el local y el global.

Scope Local

Cuando una variable es construida dentro de una funci贸n pertenece al 谩mbito local de esa funci贸n y solo se puede usar dentro de esa funci贸n.

def incrementar():
  x = 150
  print(x)

incrementar()
_Produccion:_
150

En este ejemplo el valor a incrementar esta dentro de la funci贸n siendo invocada por x = 150 y su resultado ser谩 150 a esto se le llama 谩mbito local

_Scope Global

A diferencia del Scope Local, el Scope Global esta creada en la parte externa de la funci贸n y esta puede ser utilizada tanto de manera global como local.

y = 150
def incrementar_2():
  print(y)

print(y)
_Producci贸n:_
150

En este caso mi valor y = 150 esta en la parte externa de la funci贸n y es invocada por la funci贸n para mostrar su resultado.

Ahora si tenemos dos variables una global y la otra local con el mismo nombre de variable, Python lo que har谩 es tomar los dos variables por separado siendo una de tipo global (fuera de la funci贸n) y la otra de tipo local (dentro de la funci贸n)

y = 150
def incrementar_2():
  y = 300
  print(y)

incrementar_2()
print(y)
_Producci贸n:_
300
150

En este caso observamos que el 谩mbito global tiene 鈥榶 = 150鈥 y el 谩mbito local tiene 鈥榶 = 300鈥, en donde al imprimir el resultado mostrara primero el 谩mbito local 300 y luego mostrar谩 el resultado del 谩mbito global 150

Truco

Si dentro de una variable global que fue creada esta dentro de un 谩mbito local, podemos utilizar global para que la variable se vuelva de 谩mbito global dentro de la funci贸n.

def incrementar_3():
  global x
  x = 250
  
incrementar_3()
print(x)
_Producci贸n:_
250

Tambi茅n podemos utilizar nuestra palabra global dentro de una funci贸n para remplazar un valor de tipo local a uno global de la siguiente manera:

y = 150
def incrementar_2():
  global y
  y = 300

incrementar_2()
print(y)
_Producci贸n:_
300

Me esta gustando mucho el curso, son cosas 鈥樷榖asicas鈥欌 pero realmente importantes.

Una regla de oro:

Una variable solo esta disponible dentro de la regi贸n donde fue creada

Local Scope

Es la regi贸n que corresponde el 谩mbito de una funci贸n, donde podremos tener una o mas variables, estas van a ser accesibles solo en este bloque de c贸digo y no ser谩n visibles para otros bloques o regiones.

Global Scope

Al escribir una o mas variables en esta regi贸n, estas podr谩n ser accesibles desde cualquier parte del c贸digo, incluido dentro de funciones.

El scope hace referencia al alcance de las variables en el programa. As铆 pues, una variable est谩 disponible solo en la regi贸n en la que se crea.

  • Local scope. Este tipo de alcance lo tienen las variables declaradas al interior de una estructura, como una funci贸n, y pueden ser empleadas 煤nicamente al interior de la misma.
  • Enclosing Scope. Tambi茅n conocido como Non-local Scope, se refiere a variables definidas en funciones anidadas; estas variables no son locales pero tampoco globales.
  • Global scope. Variables creadas en el cuerpo principal del c贸digo de Python y que pueden ser accedidas desde cualquier scope, global o local.
  • Built-in scope. Cuando una variable no se encuentra en ninguno de los scope anteriores, Python empieza a buscar en el built-in scope, el cual cubre todas las palabras reservadas del lenguaje. Pueden ser llamadas en cualquier lugar sin necesidad de ser definidas:

Es importante resaltar que si se da el mismo nombre a variables dentro y fuera de una funci贸n, Python reconocer谩 dichas variables como 2 variables diferentes como scope diferenciado: uno global y otro local:

price = 100 # Global

def increment():
  # price = price + 10 # UnboundLocalError: local variable 'price' referenced before assignment

  price = 200 # Local

  price = price + 10
  
  return price

price_2 = increment()
print(price_2) # 210
print(price) # 100

Si se retornan varios valores y queremos ignorar alguno que no vayamos a usar con _

val1, _, val3 = funReturn3Values()

La verdad es que es un concepto complejo de entender pero con el tiempo se va comprendiendo mejor. Se usa MUCHO en el backend y es usado en Ciencias de Datos.
Pretendo darle mucho protagonismo en mi futura caja de herramientas de pythonista:

prince = 100 # global

def scope():
  prince = 200 # funcion
  prince += 10
  return prince


print(prince) # global
prince_2 = scope()
print(prince_2) # funcion

Un video para complementar la clase:
https://www.youtube.com/watch?v=nKefMgHBNh0

Cuando necesitamos hacer un llamado de una variable global dentro del entorno local como lo es el de la funci贸n, la palabra global antes del nombre de la funcion, resuelve el 鈥淯nboundLocalError鈥:

price = 200 #Variable global

def increment():
    global price #Llama la funcion Global
    print(price)
    price = price + 30
    print(type(price))
    
increment()

Muy buena la clase y los aportes son excelente, para variar un poco, este es mi aporte:


Local Scope


Son todas la variables, tuplas, lista, diccionarios, etc. Que est谩n dentro de una funci贸n y solo se pueden trabajar con ellas en esa misma funci贸n. Si tratamos de llamar una variable de una funci贸n fuera de la misma nos dar谩 error porque solo existe en el contexto de la funci贸n.


Gobla Scope


Son todas la variables, tuplas, lista, diccionarios, etc. Que est谩n fuera de una funci贸n y con las cuales se pueden llamar y trabajar desde cualquier parte del c贸digo sin problema.


Nota Importante


La programaci贸n es como leer un libro, se inicia de arriba hacia abajo y de izquierda a derecha. Es decir, si tenemos una funci贸n que trabaja con una variable global scope pero la funci贸n ha sido declarada antes de la variable nos dar谩 un error. Por ejemplo:

def level_up_damage(damage):
    return damage + 5

damage = 10 # global scope

print(level_up_damage())

Aqui tenemos una variable global scope llamada damage, que tiene un valor de 10. Tenemos una funci贸n llamada level_up_damage que suma 5 puntos a damage; Aunque damage es una global scope y se puede usar en cualquier funci贸n, se debe declarar primero antes de usarla sino nos dar谩 este error:

 File "D:\Document\pythonZen\13_scope.py", line 26, in <module>
    print(level_up_damage())
          ^^^^^^^^^^^^^^^^^
  File "D:\Document\pythonZen\13_scope.py", line 24, in level_up_damage
    return damage + 5
           ^^^^^^
NameError: name 'damage' is not defined

NameError: name 鈥榙amage鈥 is not defined
驴Porqu茅 ocurre esto? Por lo mencionado anteriormente que la programaci贸n es como un libro.


Ahora bien, de lo siguiente que voy a aportar es que hay lenguajes como js en los cuales puedes hacer el codigo y luego si declaras las variables sin problemas, no estoy seguro pero supongo que es as铆. Pero en Python no funciona, sino declaras primero las cosas no funcionan.

Tengo 19 a帽os, me duele la cabeza, pero aqui sigo intentando aprender, ya termine el de fundamentos de python y tengo el certificado, voy a por este

Hice este este esquema para entender los scope que no s贸lo son aplicables a funciones sino tambi茅n a bloques de c贸digo con condicionales o ciclos ![](https://static.platzi.com/media/user_upload/image-843eb636-e733-47e2-b8be-a96129cbe329.jpg)

La diferencia principal entre return y print en Python es su prop贸sito y c贸mo afectan a la ejecuci贸n del programa.

return en una Funci贸n:

  • Prop贸sito: La declaraci贸n return se utiliza en una funci贸n para devolver un valor calculado por esa funci贸n. Puede devolver un solo valor o una tupla de valores.

  • Efecto en la Ejecuci贸n: Cuando se encuentra una declaraci贸n return en una funci贸n, la funci贸n termina su ejecuci贸n inmediatamente y devuelve el valor especificado. El valor puede ser asignado a una variable cuando se llama a la funci贸n.

    def suma(a, b):
        resultado = a + b
        return resultado
    
    total = suma(3, 4)
    print(total)  # Imprime 7
    
  • Accesibilidad del Valor: Puedes usar el valor devuelto por una funci贸n para realizar operaciones adicionales o para almacenarlo en una variable.

print en Python:

  • Prop贸sito: La funci贸n print se utiliza para mostrar informaci贸n en la consola. No devuelve un valor que pueda ser utilizado por otras partes del programa.

  • Efecto en la Ejecuci贸n: La funci贸n print imprime el valor o los valores proporcionados en la consola, pero no afecta el flujo de ejecuci贸n del programa.

    def saludar(nombre):
        print("Hola, " + nombre)
    
    saludar("Juan")  # Imprime "Hola, Juan"
    
  • Accesibilidad del Valor: print no proporciona un valor que pueda ser utilizado posteriormente en el programa. Simplemente muestra informaci贸n en la consola.

Ejemplo de Distinci贸n:

def cuadrado(x):
    return x**2

def cuadrado_e_imprimir(y):
    print(y**2)

resultado1 = cuadrado(5)
print(resultado1)  # Imprime 25

resultado2 = cuadrado_e_imprimir(5)
print(resultado2)  # Imprime None (el valor devuelto por la funci贸n print)

En este ejemplo, cuadrado devuelve un valor que puede ser utilizado en el programa, mientras que cuadrado_e_imprimir simplemente imprime el resultado en la consola pero no devuelve un valor 煤til. La variable resultado2 contiene None, ya que la funci贸n print no devuelve un valor utilizable.

En resumen, return se utiliza para devolver un valor desde una funci贸n y afecta el flujo de ejecuci贸n, mientras que print se utiliza para mostrar informaci贸n en la consola y no devuelve un valor que pueda ser utilizado por otras partes del programa.

En Python, el t茅rmino 鈥渟cope鈥 (alcance) se refiere a la regi贸n de un programa en la cual una variable es v谩lida y accesible. En otras palabras, el alcance de una variable determina d贸nde puede ser utilizada en el c贸digo. Python tiene dos tipos principales de alcance: el alcance local y el alcance global.

  1. Alcance Local:

    • Un alcance local se refiere al 谩rea dentro de una funci贸n donde una variable es v谩lida.
    • Las variables definidas dentro de una funci贸n tienen un alcance local y solo pueden ser utilizadas dentro de esa funci贸n.
    • Cuando la funci贸n se ejecuta, se crea su propio espacio de nombres local, y las variables definidas dentro de esa funci贸n son visibles solo en ese 谩mbito.
    def ejemplo():
        x = 10  # x tiene alcance local
        print(x)
    
    ejemplo()
    # print(x)  # Esto generar铆a un error, ya que x no es visible fuera de la funci贸n
    
  2. Alcance Global:

    • Un alcance global se refiere al 谩rea fuera de cualquier funci贸n o bloque, donde una variable es v谩lida.
    • Las variables definidas fuera de las funciones o bloques tienen alcance global y son accesibles desde cualquier parte del c贸digo.
    • Si una variable se declara fuera de cualquier funci贸n, es global y puede ser utilizada tanto dentro como fuera de funciones.
    y = 20  # y tiene alcance global
    
    def ejemplo():
        print(y)  # y es visible dentro de la funci贸n
    
    ejemplo()
    print(y)  # y es visible fuera de la funci贸n
    
  3. Reglas de Alcance (LEGB):

    • En Python, la b煤squeda de una variable sigue el principio LEGB:
      • Local (L): Busca primero en el alcance local, es decir, dentro de la funci贸n actual.
      • Enclosing (E): Luego busca en alcances que engloban la funci贸n actual, si la funci贸n est谩 anidada en otras funciones.
      • Global (G): Despu茅s busca en el alcance global, fuera de cualquier funci贸n.
      • Built-in (B): Finalmente, busca en el alcance incorporado, que son nombres predefinidos en Python.
    x = 10  # Alcance global
    
    def exterior():
        y = 20  # Alcance local
        
        def interior():
            z = 30  # Alcance local
            print(x, y, z)
    
        interior()
    
    exterior()
    

    En este ejemplo, interior tiene acceso a las variables en su alcance local, as铆 como a las variables en el alcance de funciones que lo envuelven (exterior y alcance global).

  4. Palabra Clave global:

    • Si necesitas modificar una variable global desde dentro de una funci贸n, puedes usar la palabra clave global.
    global_variable = 50
    
    def modificar_global():
        global global_variable
        global_variable = 100
    
    print(global_variable)  # Imprime 50
    modificar_global()
    print(global_variable)  # Imprime 100
    

Entender el alcance en Python es crucial para evitar errores y para escribir c贸digo m谩s claro y modular. Adem谩s, el manejo adecuado de los 谩mbitos contribuye a la legibilidad y mantenimiento del c贸digo.

El 鈥渟cope鈥 o 谩mbito se refiere a la regi贸n o contexto en el que una variable o nombre es v谩lido y tiene significado dentro de un programa. En Python, como en muchos otros lenguajes de programaci贸n, se definen varios niveles de 谩mbito que determinan d贸nde una variable o funci贸n puede ser utilizada. Los dos 谩mbitos principales en Python son:

  1. 脕mbito Local (Local Scope): Este es el 谩mbito m谩s interno y se refiere a las variables o nombres que est谩n definidos dentro de una funci贸n. Las variables locales solo son accesibles dentro de esa funci贸n y no son visibles fuera de ella. Una vez que la funci贸n termina su ejecuci贸n, las variables locales desaparecen.

    pythonCopy code
    def funcion():
        x = 10  # Variable local
        print(x)
    
    funcion()
    print(x)  # Generar谩 un error, ya que x no es accesible aqu铆
    
    
  2. 脕mbito Global (Global Scope): Este es el 谩mbito exterior a todas las funciones y se refiere a las variables o nombres que est谩n definidos fuera de todas las funciones. Las variables globales son accesibles desde cualquier lugar del programa, tanto dentro como fuera de las funciones.

    pythonCopy code
    x = 10  # Variable global
    
    def funcion():
        print(x)  # La variable global x es accesible aqu铆
    
    funcion()
    print(x)  # Tambi茅n es accesible fuera de la funci贸n
    
    
  • Las variables locales son visibles solo dentro de la funci贸n en la que est谩n definidas. No pueden ser accedidas desde fuera de esa funci贸n.
  • Las variables globales son visibles desde cualquier lugar del programa, incluyendo dentro de funciones.

Es importante tener en cuenta que si tienes una variable local en una funci贸n con el mismo nombre que una variable global, la variable local tendr谩 prioridad dentro de la funci贸n y ocultar谩 la variable global. Sin embargo, si deseas modificar una variable global desde dentro de una funci贸n, debes declararla como 鈥済lobal鈥 dentro de la funci贸n para indicar que est谩s trabajando con la variable global y no creando una nueva variable local con el mismo nombre.

pythonCopy code
x = 10  # Variable global

def modificar_global():
    global x  # Declarando x como global
    x = 20  # Modifica la variable global x

modificar_global()
print(x)  # Imprimir谩 20, ya que la variable global x fue modificada

El uso adecuado de los 谩mbitos es fundamental para evitar confusiones y errores en tu c贸digo, y te permite controlar la visibilidad y el alcance de las variables en tus programas.

El scope o alcance en Python se refiere a la visibilidad y disponibilidad de las variables y objetos en diferentes partes del c贸digo. Existen dos tipos principales de scope en Python:

Scope global: las variables definidas a nivel de m贸dulo, fuera de cualquier funci贸n, son globales y est谩n disponibles y visibles en todo el c贸digo.
Scope local: las variables definidas dentro de una funci贸n solo est谩n disponibles y visibles dentro de esa funci贸n. Se llaman variables locales.
Python aplica las siguientes reglas de resoluci贸n de nombres:

LEGB: Busca nombres en este orden:
Local (funci贸n)
Enclosing (externo)
Global (m贸dulo)
Built-in (integrado)
Las variables globales pueden ser le铆das desde cualquier parte pero si se modifican dentro de una funci贸n se crea una variable local. Para modificar una global dentro de una funci贸n se usa la palabra global.
Los closures recuerdan valores de variables de scopes anteriores incluso cuando se llaman fuera de ese scope.
La palabra nonlocal permite asignar a variables en un scope externo pero no global.
Los m贸dulos permiten dividir las globales en m煤ltiples archivos. Se usan imports para acceder a globales de otros m贸dulos.
En resumen, el scope en Python est谩 determinado por bloques de c贸digo y sangr铆a. Entender la regla LEGB y t茅cnicas como global, nonlocal y closures ayuda a manejar el acceso a variables.

A mi parecer, 茅sta clase est谩 s煤per mal explicada, me he sido un l铆o el seguirla y he tenido que buscar informaci贸n fuera

SCOPE global y local

Creo que Nicol谩s deber铆a de ser un poco m谩s preciso con su manera de explicar, y con sus herramientas. El gr谩fico que aparece en un principio no sirve de nada, y solo le deja dudas a uno. 驴Por qu茅 muestras algo que no vas a explicar, Nicol谩s?

En Python, el alcance de una variable se determina por la posici贸n en la que se define en el c贸digo. Las variables definidas fuera de cualquier funci贸n o bloque de c贸digo se consideran variables globales y son visibles en todo el programa. Por otro lado, las variables definidas dentro de una funci贸n o bloque de c贸digo se consideran variables locales y solo son visibles dentro de esa funci贸n o bloque de c贸digo.

Por ejemplo, si define una variable 鈥渪鈥 en el nivel superior de su programa, esta variable ser谩 global y ser谩 visible en todo el programa:

x = 5

def my_function():
    print(x)

my_function()  # imprime 5

Por otro lado, si define una variable 鈥測鈥 dentro de una funci贸n, esta variable ser谩 local y solo ser谩 visible dentro de esa funci贸n:

def my_function():
    y = 5
    print(y)

my_function()  #imprime 5
print(y) # dara error ya que no se puede acceder a y fuera de la funcion

Es importante tener en cuenta que si una variable con el mismo nombre se define tanto en el 谩mbito global como en el 谩mbito local, la versi贸n local tendr谩 prioridad dentro de la funci贸n o bloque de c贸digo correspondiente, y la versi贸n global seguir谩 siendo visible en el resto del programa.

En Python, existe tambi茅n la posibilidad de utilizar la palabra clave 鈥済lobal鈥 y 鈥渘onlocal鈥 para acceder a variables globales y no locales dentro de una funci贸n.

Para mejor visualizaci贸n

price = 100 #global

def increment():
  price = 200 # local
  result = price + 10
  print(f'Price Local {price}')
  return result

print(f'Price Global {price}')
price_2 = increment()
print(f'Result Local {price_2}')
Price Global 100
Price Local 200
Result Local 210
price = 100 #global

def printp():
  print(price)

printp()

#asignacion nueva en un nuevo contexto # local
def increment():
  price = 200
  price = price +10
  print(price)
  return price
  
# result no se puede usar fuera de este contexto
def increment():
  price = 200
  result = price +10
  print(result)
  return result

# print(result) da un error
print(price)
increment()
Excelente curso , cosas basicas que pasamos por alto y son cruciales para entender la logica de las funciones.
Escope <https://github.com/angel20125/python-2-comprehension-functions-2024> ![](https://static.platzi.com/media/user_upload/clase-14-scope-95797dcc-4469-455a-bc4a-0b845711c568.jpg)
```js import os os.system('clear') print('\n') print('=====') print('Clase 14 Scope de variables') print('=====') print('\n') ''' #resumen ''' print('Caso 1 : Global scope') print('variables globales tienen un alcanze total') print('=====') # - caso 1 print('\n') print('- Caso 1: llamada de una variable global en un contexto local') print('--------') msn_global= 'Hola, ' def saludo(): msn_local='Mundo' print(msn_global + msn_local) saludo() ''' #salida - Caso 1: llamada de una variable global en un contexto local -------- Hola, Mundo ''' # - caso 2 print('\n') print('- Caso 2: a pesar de que una variable se llame igual existen dos contexto diferentes') print('--------') msn_global= 'Hola, ' def saludo (): msn_global ='Este mensaje es un contexto local' print(msn_global) saludo() ''' #salida - Caso 2: a pesar de que una variable se llame igual existen dos contexto diferentes -------- Este mensaje es un contexto local ''' print('\n') print('Caso 2 : Enclosing scope') print('Si una funcion es declarada dentro de otra funcion, las variables que esten en la funci贸n padre ser谩n accesible en la funci贸n hijo') print('--------') #caso - 2 def func_father(): x = 300 def func_son(): print(x) func_son() func_father() ''' #salida Si una funcion es declarada dentro de otra funcion, las variables que esten en la funci贸n padre ser谩n accesible en la funci贸n hijo -------- 300 ''' ```*import* osos.system('clear') print('\n')print('=====')print('Clase 14 Scope de variables')print('=====')print('\n') '''#resumen ''' print('Caso 1 : Global scope')print('variables globales tienen un alcanze total')print('=====') *# - caso 1*print('\n')print('- Caso 1: llamada de una variable global en un contexto local')print('--------')msn\_global= 'Hola, '*def* saludo(): msn\_local='Mundo' print(msn\_global + msn\_local)saludo()'''#salida \- Caso 1: llamada de una variable global en un contexto local--------Hola, Mundo''' *# - caso 2*print('\n')print('- Caso 2: a pesar de que una variable se llame igual existen dos contexto diferentes')print('--------') msn\_global= 'Hola, '*def* saludo (): msn\_global ='Este mensaje es un contexto local' print(msn\_global)saludo()'''#salida- Caso 2: a pesar de que una variable se llame igual existen dos contexto diferentes--------Este mensaje es un contexto local''' print('\n')print('Caso 2 : Enclosing scope')print('Si una funcion es declarada dentro de otra funcion, las variables que esten en la funci贸n padre ser谩n accesible en la funci贸n hijo')print('--------')*#caso - 2def* func\_father(): x = 300 *def* func\_son(): print(x) func\_son() func\_father()'''#salida Si una funcion es declarada dentro de otra funcion, las variables que esten en la funci贸n padre ser谩n accesible en la funci贸n hijo--------300 '''
*El 鈥渟cope鈥 en Python se refiere al espacio de nombres en el que una variable es visible. Hay dos tipos principales de scopes en Python: global y local.* ***Scope Global:*** *Las variables definidas en el cuerpo principal de un archivo de Python son globales y est谩n disponibles en todo el archivo, incluyendo cualquier funci贸n o clase definida en el archivo.* variable\_global = "Soy una variable global" def mi\_funcion(): 聽聽聽聽print(variable\_global)聽 # Puedo acceder a la variable global desde aqu铆 mi\_funcion()聽 # Imprime: Soy una variable global ***Scope Local:*** *Las variables definidas dentro de una funci贸n son locales a esa funci贸n y no est谩n disponibles fuera de la funci贸n.* def mi\_funcion(): 聽聽聽聽variable\_local = "Soy una variable local" 聽聽聽聽print(variable\_local)聽 # Puedo acceder a la variable local desde aqu铆 mi\_funcion()聽 # Imprime: Soy una variable local print(variable\_local)聽 # Error! La variable local no est谩 definida en el scope global ***Uso de la palabra clave global:*** *Si necesitas modificar una variable global desde dentro de una funci贸n, puedes usar la palabra clave global.* variable\_global = "Soy una variable global" def mi\_funcion(): 聽聽聽聽global variable\_global 聽聽聽聽variable\_global = "He sido modificada" 聽聽聽聽print(variable\_global)聽 # Puedo acceder y modificar la variable global desde aqu铆 mi\_funcion()聽 # Imprime: He sido modificada print(variable\_global)聽 # Imprime: He sido modificada
Una funci贸n en Python es como una caja cerrada. Las variables que creas dentro de esa caja (funci贸n) solo existen y son accesibles dentro de esa caja. Fuera de la caja, no puedes ver ni usar esas variables. Este l铆mite donde las variables son accesibles se llama "scope local" o alcance local. As铆 que, cuando trabajas dentro de una funci贸n, est谩s trabajando en un espacio propio y separado del resto del programa.
Yo lo entiendo, haciendo una analogia, de la siguiente manera. 馃彙 Imaginemos que tenemos una casa con jard铆n adelante (sin rejas). Tanto en el jardin como en el interior de la casa hay plantas 馃. La gente que pasa por mi casa puede tomar plantas del jardin, estan disponibles para cualqueira (global scope) pero no del interior de la casa, pues solo acceden a esas plantas (local scope) quienes entren en la casa (variable).

Hola, este es un ejemplo muy bueno que aclara todo

# Variable global
variable_global = "Soy una variable global"

def mi_funcion():
    # Variable local
    variable_local = "Soy una variable local"
    print(variable_local)
    print(variable_global)

mi_funcion()

# Intentando imprimir la variable local fuera de la funci贸n
try:
    print(variable_local)
except NameError:
    print("La variable local no est谩 definida fuera de la funci贸n")

# Imprimiendo la variable global fuera de la funci贸n
print(variable_global)
Lo que he entendido hasta ahora es que hay 'variables locales' que solo tienen validez dentro del contexto de las funciones, pero que si las llamamos por fuera no van a 'existir' porque no est谩n definidas en el contexto global, sin embargo si yo defino una funci贸n en el contexto global puedo utilizarla en 'contextos locales' o funciones si previamente los he definido.
Exelente, pero hay maneras de acceder al Scope global dentro de una funcion: ```python price = 100 def increment(): global price price += 10 increment() print(price) ```
Pensar铆a que este concepto se puede entender mejor utilizando los llamados entre programas que a煤n no hemos visto. Tengo esa duda, hacer los llamados entre los objetos.

Cuando se busca o se utiliza una variable, Python sigue un orden de b煤squeda espec铆fico conocido como 鈥淟EGB鈥 (Local, Enclosing, Global, Built-in). Primero busca en el 谩mbito local, luego en el 谩mbito enclosing (si es una funci贸n dentro de otra funci贸n), despu茅s en el 谩mbito global y, finalmente, en el 谩mbito built-in.

El 'scope' es el alcance de las variable, es decir, desde d贸nde puede acceder a esa variable.

Me parecio interesante el concepto del scope. Espero seguir aprendiendo mas de este curso.

Hello 馃槂

#scope: (alcance:) que alcance tiene una variable- bloque scope, enclosing scope, globla scope y Built - in

price = 100  #es una variable global scope, no tiene nada que ver con la var:price dentro de la funci贸n.
#tener en cuenta los contextos de las variables, tener cuidado como utilizarlas.
result = 500  # es una variable global scope


def increment():
  price = 200  #variable local scope
  result = price = price + 10
  print(result)
  return result


print(price)

price2 = increment()
print(price2 + 10)
print(
    result
)  #sale un error porque esta fuera del contexto de la funci贸n. #Al tener la variable inicializada fuera de la funci贸n el error se iria.

precio = 100 # alcance global

def incrementar ():
print(precio)

print(" el precio es: " ,precio)

precio2 = 200

def incrementar2 ():
precio2 =200
result = precio2 + 10
print(result)
return result
precio2 = incrementar2()
print(precio2)

algunos ejemplos de scope global y local en Python:

Scope Global
msg = 鈥淗ola鈥 # Variable global

def funcion1():
print(msg) # Se puede acceder desde una funci贸n

funcion1()
print(msg) # Tambi茅n disponible en el scope global

Scope Local
def funcion2():
mensaje = 鈥淢undo鈥 # Variable local

print(mensaje)

funcion2()

print(mensaje) # Esto lanzar铆a error, mensaje no existe en el scope global
def funcion3():
global texto

texto = 鈥淓jemplo scope global鈥 # Declaramos la variable global

print(texto)

funcion3()
print(texto) # Se puede acceder desde el scope global

Ejemplo con loop
for x in range(5):
y = x * 2 # y es local al loop
print(y)

print(y) # Esto lanzar铆a error, y solo existe en el scope local del loop
En resumen, las variables globales se definen fuera de las funciones y est谩n disponibles de forma global. Las variables locales se definen dentro de una funci贸n y solo existen en ese scope local.

price = 100

def increment(a):
    price = a + 10
    print(price)

increment(price)

Aqui aprendiste un concepto el cocepto scope, que practicamente es el alcance que tiene una variable dentro del programa.
digamos que podemos entender ahora la estructura de una funcion y el programa principal.
Locales: Variables dentro de la funcion que no se pueden usar por fuera del mismo
Globales: Variables fuera de la funcion por tanto del programa principal que pueden ser usadas en cualquier parte del programa.
esto es clarisimo, pero, tambien hay mas.
tu puedes convertir una variable local en una global usando el termino global o nonlocal = No local, SU USO ES INDIFERENTE usa el que mas te guste, yo usar茅 global.

global variable
variable = "Fui creada como global"

ejemplo pracrico:



def f():
    global num
    num = 3
    print(num)

def g():
    global num
    print(num)

f()
g()

tienes que iniciar la funcion f(), porque esta es la que le da inicio a tu variable y ademas, al termino global

esto significa que puedes usar esta variable dentro de la funcion como tambien fuera de la misma conservando su resultado, si quieres cambiarlo solo debes escribir:


def f():
    global num
    num = 3
    print(num)

def g():
    global num
    num = 2
    print(num)

f()
g()

ahi tienes una nueva idea para mejorar tu codigo.

El scope o alcance es una regi贸n del programa, y el scope de variables se refiere al 谩rea del programa donde las variables del programa pueden ser accedidas despu茅s de haber sido declaradas. De manera general, podemos decir que hay 3 lugares donde las variables pueden ser declaradas: Dentro de una funci贸n o un bloque de c贸digo, las cuales se conocen como variables locales. Fuera de una funci贸n, las cuales se conocen como variables globales. En la definici贸n de par谩metros de una funci贸n, conocidos como par谩metros f

parece ser algo dificil pero uno aprende paso a paso

Platzi tiene un blog de este tema explicandolo a detalle:
https://platzi.com/tutoriales/1764-python-cs/7580-scope-o-alcance-computer-science/

Scope de una funci贸n: piensa que el bloque de instrucciones de una funci贸n y sus variables existen cuando la funci贸n sea llamada, estan dentro una caja negra. Alcance local.

Las variables fuera de las funciones tienen un alcance global.

En Python, 鈥渟cope鈥 se refiere al alcance o 谩mbito de visibilidad de una variable. Define d贸nde en un programa una variable es v谩lida y puede ser accedida.

Existen diferentes niveles de alcance en Python:

  1. Alcance global (Global scope): Las variables declaradas fuera de cualquier funci贸n o clase tienen alcance global. Estas variables pueden ser accedidas desde cualquier parte del programa.

Ejemplo de variable global:

x = 10

def foo():
    print(x)

foo()  # Imprime 10
  1. Alcance local (Local scope): Las variables declaradas dentro de una funci贸n tienen alcance local. Estas variables solo son accesibles dentro de la funci贸n en la que fueron definidas.

Ejemplo de variable local:

def foo():
    y = 20
    print(y)

foo()  # Imprime 20
print(y)  # Generar谩 un error, ya que "y" no est谩 definida fuera de la funci贸n
  1. Alcance de bloque (Block scope): A partir de Python 3.8, se introdujo el concepto de alcance de bloque con la declaraci贸n nonlocal. Permite acceder y modificar variables en bloques anidados, como en el caso de una funci贸n dentro de otra funci贸n.

Ejemplo de variable con alcance de bloque:

def outer():
    x = 10
    
    def inner():
        nonlocal x
        x = 20
        print(x)
    
    inner()  # Imprime 20
    print(x)  # Imprime 20, ya que la variable "x" fue modificada por inner()

outer()

Es importante comprender el alcance de las variables en Python para evitar errores y tener un control adecuado sobre el flujo y el acceso a los datos en un programa.

Es bueno cuando el mismo genera el error. Desde el curso anterior me pregunto si llegara un momento donde optimice mejor el c贸digo de mejores pr谩cticas.

El 鈥渟cope鈥 (alcance) en Python se refiere a la accesibilidad y visibilidad de las variables, funciones y otros objetos en diferentes partes del c贸digo.

  1. El scope determina las partes del c贸digo donde una variable o funci贸n es reconocida y puede ser referenciada.
  2. Python tiene dos tipos principales de scope: scope local y scope global.
  3. El scope local se refiere a las variables que son definidas dentro de una funci贸n y solo pueden ser accedidas desde dentro de esa funci贸n.
  4. El scope global se refiere a las variables que son definidas fuera de todas las funciones y son accesibles desde cualquier parte del c贸digo.
  5. Si se intenta acceder a una variable desde un scope donde no est谩 definida, se producir谩 un error de 鈥淣ameError鈥.

las variables dentro de una funcion, solo viven dentro de una funcion y son llamadas , variables locales, mientras aquellas fuera de la funcion y que puede llamar en cualquier momento son globales

price = 348 # global
result = 200

def increment():
  price = 200
  result = price +10 # Estas variables solo tienen sentido en el trozo de codigo que estemos manejando en ese momento
  print(price)
  return result

print(price)
price_2 = increment()
print(price_2)
print(result)

驴C贸mo acceder a variables globales y modificarlas?

Una variable definida en un Scope Global puede leerse dentro de una funci贸n pero no modificarse. Por ejemplo, esto funciona:

x = 300
def myfunc():
  resultado = x + 10 # S贸lo leemos x
  print(resultado)

myfunc() # 310

Mientras esto no funciona:

x = 300
def myfunc():
  x = x + 10 # Intentamos modificar x
  print(x)

myfunc()
# Traceback (most recent call last):
#   File "/home/runner/Python-202/03_scopes.py",
#     line 16, in <module>
#     myfunc()
#   File "/home/runner/Python-202/03_scopes.py",
#     line 13, in myfunc
#     x = x + 10
# UnboundLocalError: local variable "x"
#     referenced before assignment

Si queremos usar una variable del contexto global podemos usamos 鈥済lobal鈥, en caso de que no exista la variable global entonces python la crea, y as铆 podemos modificarla:

x = 300
def myfunc():
  global x
  x += 10
  print("IN =>", x)

myfunc() # IN => 310
print("OUT=>", x) # OUT => 310

鈥淯n peque帽o ejemplo鈥

No me gust贸 esta clase, ac谩 este video lo explica mejor 鉂わ笍 scope_python

Les comparto un ejemplo que hice. Si ejecutamos este codigo:

variable_global = 1 

def suma():
    variable_local = 0 
    while variable_local < 3:
        variable_local = variable_global + variable_local  #suma la variable local y la variable global
        print(f"variable_global:{variable_global}, Variable_local_1: {variable_local}")
    return variable_local

suma()   #ejecuta la funci贸n

El resultado es:

variable_global:1, Variable_local_1: 1
variable_global:1, Variable_local_1: 2
variable_global:1, Variable_local_1: 3

Ahora bien, si queremos imprimir la variable local fuera de la funci贸n:

variable_global = 1 

def suma():
    variable_local = 0 
    while variable_local < 3:
        variable_local = variable_global + variable_local  #suma la variable local y la variable global
        print(f"variable_global:{variable_global}, Variable_local_1: {variable_local}")
    return variable_local

suma()   #ejecuta la funci贸n

print(f"variable_global:{variable_global}, Variable_local: {variable_local}")

el resultado es:
NameError: name 鈥榲ariable_local鈥 is not defined. Did you mean: 鈥榲ariable_global鈥?

Hola!!! Aqui les dejo mi codigo espero ayude

'''
El scope o alcance de variables
'''
def jumpline():
  print('>' * 25)

  # Esta variable es de alcance local, puedo usarla en cualquier momento
price = 100
print(price)
jumpline()

# Hay variables que estan solo dentro de funciones y su alcance esta limitado
def increment():
  print(price) # Puedo invocar price por que tiene alto alcance
increment()
jumpline()

# Un ejemplo de una variable local, la varible dentro de la funcion, solo existira en la funcion
def increment():
  price = 200
  price = price + 10
  print(price)
  return price

price_2 = increment()
print(price_2)
print(price) # Tiene el valor de 100 por que el valor 200 solo existe dentro de la funcion increment()
jumpline()

def increment():
  price = 200
  result = price + 10
  print(price)
  return result

# print(result) # Va dar error por que result solo esta en la funcion increment()
print(increment())

Es importante tener en cuenta que las variables globales pueden ser modificadas desde dentro de una funci贸n si se utiliza la palabra clave global. Sin embargo, es recomendable evitar su uso ya que puede dificultar la lectura y el mantenimiento del c贸digo. En su lugar, es mejor utilizar argumentos de funci贸n y retornar valores para compartir informaci贸n entre diferentes partes del programa.

En Python, existen dos tipos de 谩mbito de variables: el 谩mbito local y el 谩mbito global.

  1. El 谩mbito local se refiere a las variables que se definen dentro de una funci贸n. Estas variables solo son visibles dentro de la funci贸n y no se pueden acceder desde fuera de ella.
  2. El 谩mbito global se refiere a las variables que se definen fuera de una funci贸n. Estas variables son visibles tanto dentro como fuera de la funci贸n. Sin embargo, si se define una variable con el mismo nombre dentro de una funci贸n, esa variable se considera una variable local y oculta la variable global con el mismo nombre.

Scope

  • Global scope:
    La variable puede ser usada en cualquier bloque de c贸digo dentro del programa

  • **Local scope: **
    La variable solo va a tener sentido dentro del bloque de c贸digo donde fue creada (en este caso dentro de la funci贸n)

# El scope
# https://www.w3schools.com/python/python_scope.asp

'''
Global scope: 
La variable puede ser usada en cualquier bloque de c贸digo dentro del programa
'''
price = 100

'''
Local scope: 
La variable solo va a tener sentido dentro del bloque de c贸digo donde fue creada (en este caso dentro de la funcion)
'''
def increment():
  price = 200
  price = price + 10
  return price


print(price) # Variable Global scope
price_2 = increment() # Retorna el valor de variable Local Scope
print(price_2)

'''
El scope o El alcance

#Hasta donde tiene alcance una variable
que creamos
-Built in
-Global scope
-Enclosing scope
-local scope
'''

precio=100 #global scope
#Esta variable creada tiene contexto
#en todo el codigo

def increment():
    precio=200 #Esto es la solucion para el error de abajo
    precio=precio+1 #Error Error
    #Esta variable creada solo tiene contexto en esta funcion, 
    #por lo que sumarle 1 a algo que no tiene valor no tiene sentido
    print(precio)
    return precio

print(precio)
price_v2=increment()
print(price_v2)

precio=100 
result=200 #Global scope
def incrementv2():
    precio=200 
    result=precio+1 
    #La variable result, solo tiene contexto
    #dentro de esta funcion
    print(result)
    return result

#print(result) Falla

Y qu茅 pasa si quiero utilizar el precio global dentro de la funci贸n? Lo podemos hacer as铆:

price = 100

def increment_2(price=price):
	price = price + 10
	return price

result = increment_2()
print(result) # Obtendr谩s 110 de la suma de price global + 10

Global Scope

Al escribir una o mas variables en esta regi贸n, estas podr谩n ser accesibles desde cualquier parte del c贸digo, incluido dentro de funciones.

Si necesitas que una variable de scope local necesitas utilizar en el scope global, puedes utilizar la propiedad global para la variable

def myfunc():
  global x
  x = 300

myfunc()

print(x) #300

Para cambiar el valor de una variable global dentro de una funci贸n, consulte la variable utilizando la palabra clave global:

x = 300

def myfunc():
  global x
  x = 200

myfunc()

print(x) #200

Scope o alcance, es cuando una variable solo esta disponible desde donde fue construida y para ello existen dos 谩mbitos, el local y el global.

Scope local: Cuando una variables es construida dentro de una funci贸n o un bloque de c贸digo, pertenece al 谩mbito local de esa funci贸n o bloque de c贸digo, solo se puede usar dentro de esa funci贸n o bloque de c贸digo.

Scope global: Pertenece a un todo, esto quiere decir que la variable esta disponible para usarse en cualquier parte del c贸digo, puede ser utilizada de manera global como local.

  • El 谩mbito de una variable en Python se refiere a la zona del c贸digo en la que la variable es accesible. En Python, hay dos tipos de 谩mbito: global y local

  • El 谩mbito global se refiere a las variables que se definen en el nivel m谩s alto del c贸digo (es decir, no dentro de ninguna funci贸n o clase). Estas variables son accesibles desde cualquier parte del c贸digo y se consideran variables globales.

  • El 谩mbito local se refiere a las variables que se definen dentro de una funci贸n o clase. Estas variables solo son accesibles dentro de la funci贸n o clase en la que se han definido y se consideran variables locales.

  • Es importante tener en cuenta que, si quieres acceder a una variable global desde una funci贸n, debes usar la palabra clave global para indicarle al int茅rprete de Python que est谩s accediendo a una variable global y no a una local con el mismo nombre

numero = 100

def aumentar_valor_en_30():
  global numero
  numero += 30
  print(numero)

aumentar_valor_en_30()  

Resumen de la clase y explicaci贸n de por qu茅 en el min 4:45 da error con la variable price:
Al declarar la variable price DENTRO de una funci贸n, le estamos diciendo a nuestro programa que price ser谩 LOCAL (se usar谩 dentro del alcance de la funci贸n).
Y en la l铆nea 4, estamos llamando a nuestra variable local price para sumarle + 10.
El problema es que localmente nunca hemos dado un valor a price localmente y por eso el error:

De hecho replit detecta este error y lo subraya en rojo.
Personalmente, no me gusta repetir nombres de variables para evitar ambiguedades como estas.
Pero fue una buena manera de ense帽ar este error.
Saludos.

SCOPE: (alcance)
Una variable solo esta disponible dentro de la regi贸n donde fue creada
Se refiere al alcance de las variables.

-脕mbito Local:
    Una variable creada dentro de una funci贸n pertenece al 谩mbito local de esa funci贸n y solo se 
    puede usar dentro de esa funci贸n.

-Funci贸n interior de una funci贸n:
    Como se explica en el ejemplo anterior, la variable x no est谩 disponible fuera de la funci贸n,
    pero est谩 disponible para cualquier funci贸n dentro de la funci贸n

-Alcance global:
    Una variable creada en el cuerpo principal del c贸digo Python es una variable global y pertenece
    al 谩mbito global.
    Las variables globales est谩n disponibles desde cualquier 谩mbito, global y local.

-Nombrando Variables:
    Si opera con el mismo nombre de variable dentro y fuera de una funci贸n, Python las tratar谩 como
    dos variables separadas, una disponible en el 谩mbito global (fuera de la funci贸n) y otra
    disponible en el 谩mbito local (dentro de la funci贸n)

-Palabra clave global:
    Si necesita crear una variable global, pero est谩 atascado en el 谩mbito local, puede usar la
    global palabra clave.
    La global palabra clave hace que la variable sea global.
price = 100 # global
result =  200


def increment():
  price = 200
  price = price + 10
  print(price)
  return price

print(price)
price_2 = increment()
print(price_2)
print(result)
""" scope """
x = 123

def suma(x, y):
  res = x + y
  return res

sum = suma(3, 4)
print(sum)
# print(res)

price = 100 # Alcance global

def increment():
price = 200 # Alcance local
result = price + 10
print(price)
return result
print(price)
price_2 = increment()
print(price_2)


Scope

#----------------------- Scope -------------------------

# variable con alcance general
price = 100
print(price)
--> 100

# uso de la variable general en un contexto locals
def increment():
  print(price)
increment()
--> 100

# error al crear una variable local a partir de una general
def increment2():
  price = price + 10
  print(price)

increment2()
--> ERROR

# variable con alcance global
def increment3():
  price = 200
  price = price + 10
  return price

result = increment3()
print(result)
--> 210

# variable local en un contexto general arroja error
def increment4():
  price = 200
  total = price + 10
  return total

print(total)
--> ERROR

Local Scope

  • A variable created inside a function belongs to the local scope of that function, and can only be used inside that function.

  • Example
    A variable created inside a function is available inside that function:

def myfunc():
  x = 300
  print(x)

myfunc()

Global Scope

  • A variable created in the main body of the Python code is a global variable and belongs to the global scope.

  • Global variables are available from within any scope, global and local.

  • Example
    A variable created outside of a function is global and can be used by anyone:

x = 300

def myfunc():
  print(x)

myfunc()

print(x)