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

Scopes and namespaces

37/49

Lectura

En Python, un name, también conocido como identifier, es simplemente una forma de otorgarle un nombre a un objeto. Mediante el nombre, podemos acceder al objeto. Vamos a ver un ejemplo:

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 32

Preguntas 2

Ordenar por:

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

Solo por incluir algo a lo ya mencionado:

En Python, la palabra clave global permite modificar la variable fuera del alcance actual. Se utiliza para crear una variable global y realizar cambios en la variable en un contexto local.

Reglas de palabra clave global

Las reglas básicas para la palabra clave global en Python son:

  • Cuando creamos una variable dentro de una función, es local por defecto.
  • Cuando definimos una variable fuera de una función, es global por defecto. No tienes que usar la palabra clave global.
  • Utilizamos la palabra clave global para leer y escribir una variable global dentro de una función.
  • El uso de global fuera de una función no tiene efecto

En lo referente a la palabra nonlocal, actúa de manera similar, solo que orientada a lo que sería un alcance de funciones y funciones anidadas, a continuación un ejemplo:

def method():

    def method2():
        # este método no tiene acceso a la 
				# variable value, por cuanto se usa 
				# nonlocal para poder acceder.
        nonlocal value
        value = 100

    # Variable local.
    value = 10
    method2()

Acá otra explicación con ejemplos:
https://www.programiz.com/python-programming/namespace

Para complementar pueden checar esta clase en video del Curso de Introducción al Pensamiento Computacional con Python: https://platzi.com/clases/1764-python-cs/25241-scope-o-alcance/

😄

Deben corregir como se muestra el codigo, se ve muy desorganizado y algunas palabras juntas.

def outer_function():
      b = 20 <------ La variable b se encuentra en el namespace LOCAL
     def inner_func():
	    c = 30 <------ La variable c se encuentra en el namespace LOCAL ANIDADO
a = 10 <------ La variable a se encuentra en el namespace GLOBAL```

¿Entiendo entonces que ‘global’ permite a una función, en cualquier nivel, acceder a variables que han sido declaradas en el scope global y, por otro lado, ‘nonlocal’ le permite a una función anidada ingresar a la variable que se encuentra al igual que ella dentro de determinada función, cierto? Si es así, ¿cuantos niveles puede escalar ‘nonlocal’?

Un ejemplo de esto pueden encontrarlo en la documentación:

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

Vayan haciendo sus modificaciones para ir comprendiendo el comportamiento. Es interesante usar id(spam).
https://docs.python.org/3/tutorial/classes.html

“nonlocal”: Se usa para obtener el scope en funciones con funciones anidadas.
“Global”: Se usa para tener el scope del módulo.

Igualmente me sale desordenado el código 😦

Tengo un duda en el codigo

global some_var_in_other_scope

Some_var_in_other_scope += 1

En este caso no se está modificando la variable “some_var_in_other_scope = 10”, ya que una comienza con mayúsculas y la otra no.

some_var_in_other_scope = 10 
c = 10

def echo(value):
	return value


def outer_function(some_local_name):
	def inner_function(other_local_name):
		# Tiene acceso a la built-in function print y al nombre local some_local_name
		print(some_local_name)
        # También tiene acceso a su scope local
		print(other_local_name)


def some_function():
	global some_var_in_other_scope
	some_var_in_other_scope += 1


def outer_function_2():
    global c
    c = 20
    def inner_function():
        global c
        c = 30
        print('c =',c)

    inner_function()
    print('c =',c)


if __name__  == '__main__':
	a = echo
	a = a('Billy') # 3
	print(a)

	b = outer_function
	print(b(some_var_in_other_scope))

	some_function()
	print(some_var_in_other_scope)


	outer_function_2()
	print('c =',c)```

name o identifier es el nombre que hace referencia a una variable y su contenido en memoria.
scope es el alcance que un objeto tiene para ser llamado.
los keywords global y nonlocal permiten tener acceso a variables que no esten declaradas en el scope local, pero si dentro del módulo.

https://www.youtube.com/watch?v=QVdf0LgmICw

complementa la información dada. (Está en ingles)

Excelente la explicación, y creo que es parte de lo que vamos a estar usando en nuestro día a día!

Scope parte del programa desde donde los namespaces pueden ser accedidos

Es importante saber que cuando usas global dentro de la función estas tomando ese valor global de la variable, y si le realizas cambios estos afectaran a la variable global también.

Por otro lado nonlocal se utiliza sobretodo con funciones anidadas o nested functions, toma una variable definida dentro de la función, la utiliza y si se realizan cambios dentro de la segunda función esta solo afectará a la variable de la función una vez finalizada ya no estará el valor.

Creo que ya habíamos visto este tema antes, pero bueno, me imagino que es para entender mejor los módulos.

global nos permite acceder a variables del módulo, desde cualquier parte del código

nonlocal sirve para acceder a variables de una función anidada desde cualquier otra de sus funciones ascendentes

def method():

    def method2():
        def method3():
            nonlocal value
            value = 100
        method3()
    method2()
    
    print(value)
    value += 1
    print(value)
    
method()   
```python

Chequen esto, es muy interesante, una función puede acceder a cualquier dato que se encuentre en la función padre en su argumento y en su interior. Sin tener que pasarle ese dato como argumento a la función hija 😮

def outer_function(some_local_name):
    def inner_function():
        def innnit_function(some_local_name):
            def inot_function():
                print(some_local_name)
            inot_function()
        innnit_function(some_local_name)
    inner_function()
outer_function('El Pepe')

**Así se imprimirá ‘El pepe’ aunque esté en la última función gracias a que le vamos pasando el argumento desde la función padre: **

def outer_function(some_local_name):
    def inner_function(some_local_name):
        def innnit_function(some_local_name):
            def inot_function(some_local_name):
                print(some_local_name)
            inot_function(some_local_name)
        innnit_function(some_local_name)
    inner_function(some_local_name)
outer_function('El Pepe')

Así no se imprimirá nada:

def outer_function(some_local_name):
    def inner_function():
        def innnit_function():
            def inot_function(some_local_name):
                print(some_local_name)
            inot_function()
        innnit_function()
    inner_function()
outer_function('El Pepe')

IMPORTANTE los espacios en memoria se pueden interpretar como las celdas de espacio que tiene una memeria ram o para pensar mas abstracto el peso total en memoria de la aplicacion o del codigo es de esta manera es como se implementan los algoritmos para optimizar los procesos de carga de un programa por ejemplo pasar de una busqueda secuencial a una busqueda binaria.

Genial!!

def my_function():
    x = 1

    def my_sub_function():
            nonlocal x #gracias a esto digamos que hacemos 'global' pero solo dentro de una funcion
            x = "esto no es 1"
            print(x) #"esto no es 1"

    my_sub_function()
    print(x) # "esto no es 1"


my_function()
print(x) #error

Para tener acceso a una variable con scope global, se debe anteponer la palabra reservada “global” en el escope que se desee usar.

Excelente buena info.

excelenet información

Excelente, gracias