El scope

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 ‘y = 150’ y el ámbito local tiene ‘y = 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 ‘‘basicas’’ 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

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

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 “UnboundLocalError”:

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 ‘damage’ 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.

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 “scope” (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 “scope” 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 “global” 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.

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 “x” 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 “y” 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 “global” y “nonlocal” 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()

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)

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 = “Hola” # 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 = “Mundo” # Variable local

print(mensaje)

funcion2()

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

texto = “Ejemplo 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, “scope” 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 “scope” (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 “NameError”.

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 “global”, 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

“Un 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 ‘variable_local’ is not defined. Did you mean: ‘variable_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)