Fundamentos de Programación y Python
Fundamentos de Programación con Python para Principiantes
Instalación y Uso Básico de Python en Windows y Mac
Semántica y Sintaxis en Programación Python
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manejo de Cadenas y Operaciones Básicas en Python
Tipos de Datos en Python: Enteros, Flotantes y Booleanos
Dominio de la función `print` en Python: usos y formatos avanzados
Operaciones matemáticas avanzadas en Python: módulo, potencia y más
Entrada de información y manejo de tipos de datos en Python
Colección y Procesamiento de Datos en Python
Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos
Copiar listas en Python sin compartir memoria con slicing
Manejo de Matrices y Tuplas en Python
Matrices en Juegos y Imágenes con Python
Diccionarios en Python: Uso y Manipulación de Datos
Control de Flujo en Python
Estructuras Condicionales en Programación: Uso de If, Else y Elif
Iteración y control de flujo con bucles en Python
Iteradores y Generadores en Python: Uso Eficiente de Memoria
Listas por comprensión en Python: creación y optimización de listas
Funciones y Manejo de Excepciones en Python
Funciones y Parámetros en Python: Crea una Calculadora Básica
Funciones Lambda en Python: Uso y Aplicaciones Prácticas
Recursividad en Python: Factoriales y Serie de Fibonacci
Manejo de Excepciones y Errores en Python
Programación Orientada a Objetos en Python
Programación Orientada a Objetos en Python: Clases y Métodos Básicos
Gestión de Biblioteca con Programación Orientada a Objetos
Herencia y Polimorfismo en Programación Orientada a Objetos
Programación Orientada a Objetos: Implementación de Clases y Herencia
Polimorfismo en Programación Orientada a Objetos
Herencia y Uso de la Función super() en Python
Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python
Lectura y escritura de archivos
Manipulación de Archivos TXT y CSV en Python
Manipulación de archivos CSV con Python: lectura y escritura
Manejo de Archivos JSON en Python para Aplicaciones Web y APIs
Biblioteca estándar de Python
Uso Eficiente de la Biblioteca Estándar de Python
Uso de las librerías OS, Math y Random en Python
Análisis de Datos de Ventas con Python y Statistics
Desarrollo del juego Batalla Naval en Python
Conceptos avanzados de Python
Programación Avanzada en Python: POO, Excepciones y Proyectos
Escritura de Código Pytónico y Buenas Prácticas en Python
Comentarios y Docstrings: Buenas Prácticas en Programación
Tiempo de vida y alcance de variables en Python
Anotaciones de Tipo en Python para Código Más Legible
Validación de Tipos y Manejo de Excepciones en Python
Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones
Decoradores
Decoradores en Python: Extiende Funcionalidades de Funciones
Uso de Decoradores Anidados y con Parámetros en Python
Decoradores en Programación Orientada a Objetos en Python
Métodos y estructura de clases en Python
Uso de Métodos Mágicos en Python
Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases
Ejecutar scripts Python con `if __name__ == '__main__'`
Metaprogramación en Python: Métodos `__new__` y `__init__`
Uso de *args y **kwargs en funciones de Python
Métodos y Atributos Privados y Protegidos en Python
Uso de Property en Python: Getter, Setter y Eliminación de Atributos
Métodos estáticos y de clase en Python
Programación concurrente y asíncrona
Concurrencia y Paralelismo en Python: Técnicas y Librerías Básicas
Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`
Asincronismo en Python con AsyncIO y Corrutinas
Sincronía y Concurrencia en Python: Teoría y Práctica
Creación de módulos y paquetes
Módulos y Paquetes en Python: Reutilización y Organización de Código
Uso de Paquetes y Subpaquetes en Python con Visual Studio Code
Publicación de Paquetes Python en PyPI
Proyecto final
Sistema de Gestión de Reservas en Python Avanzado
Sistema de Gestión de Reservas en Python Avanzado
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Semántica y Sintaxis en Programación Python
3/63Recursos
Comprender los conceptos de semántica y sintaxis es crucial en programación. La semántica da sentido al código, asegurando consistencia y coherencia en las operaciones, mientras que la sintaxis dicta cómo escribir correctamente el código, siguiendo reglas específicas.
¿Qué es la semántica en programación?
La semántica en programación se refiere al significado y consistencia del código. Si trabajamos con números, tanto las entradas como las salidas deben ser números para mantener coherencia. Al nombrar variables, debemos hacerlo de manera lógica y significativa para que el código tenga sentido.
¿Cómo afecta la sintaxis al código?
La sintaxis en programación es el conjunto de reglas que dicta cómo escribir el código correctamente. Cada lenguaje tiene su propia sintaxis, y seguir estas reglas es esencial para evitar errores. Por ejemplo, si iniciamos con un paréntesis, debemos cerrarlo. No hacerlo resultará en errores de sintaxis que el compilador o intérprete señalará.
¿Cómo se manejan errores de sintaxis?
Cuando hay errores de sintaxis, el compilador o el entorno de desarrollo, como Visual Studio Code, nos indicarán dónde está el problema. Por ejemplo, al olvidar cerrar un paréntesis, obtendremos un mensaje de error que señala esta omisión. Corregir estos errores es esencial para que el código se ejecute correctamente.
¿Qué papel juegan las variables en la semántica?
Las variables son contenedores de información y su correcto uso es fundamental para la semántica. Al crear una variable, debemos seguir la sintaxis correcta: nombre de la variable, signo de asignación y el valor. Usar nombres descriptivos y relevantes para las variables asegura que el código sea comprensible y lógico.
¿Qué errores comunes pueden ocurrir con las variables?
- Usar nombres de variables que no reflejan su contenido.
- Intentar utilizar palabras reservadas del lenguaje como nombres de variables.
- Iniciar nombres de variables con números, lo cual no está permitido.
- No declarar una variable antes de su uso, lo que generará errores de tipo NameError.
¿Cómo nombrar correctamente las variables?
- Utilizar nombres descriptivos y significativos.
- Iniciar con letras y seguir con números o caracteres permitidos.
- Evitar palabras reservadas.
- Usar guiones bajos para separar palabras en nombres de variables.
¿Qué sucede al redefinir variables?
Redefinir una variable sobrescribirá su valor anterior. Python ejecuta las líneas de código de arriba hacia abajo y de izquierda a derecha, por lo que el último valor asignado a una variable será el que prevalezca.
¿Cómo evitar errores de semántica al nombrar variables?
Usar nombres de variables que reflejen claramente su propósito. Por ejemplo, si una variable almacena un nombre, debería llamarse nombre y no edad. Esto evita confusiones y asegura que el código sea fácil de entender y mantener.
Aportes 81
Preguntas 9
Ordenar por:
Introducción a los conceptos básicos de programación:
# **Variables**
### Espacios en memoria para almacenar datos
### **Tipos de Datos**
### **Enteros** (`int`): Números sin decimales.
### **Flotantes** (`float`): Números con decimales.
### **Cadenas** (`str`): Texto.
### **Booleanos** (`bool`): `True` o `False`.
Las variables no deben comenzar con números y no se deben usar palabras reservadas como:
* class
* if
* else
* for
Pueden iniciar con `_` o `__` esto se usa mucho simbolizar que son variables de tipo privado.
Algo importante a tener en cuenta es que en python se usa snake\_case para el escribir variables.
Para ilustrar la diferencia, imagina una frase en un idioma:
* **Sintaxis**: La gramática y la estructura de la frase (por ejemplo, "El gato está en el jardín" sigue las reglas gramaticales del español).
* **Semántica**: El significado de la frase (en este caso, que hay un gato en el jardín).
Es decir, mientras la sintaxis se ocupa de cómo se debe escribir el código, la semántica se ocupa de qué hace el código cuando se ejecuta.
**La Sintaxis y la Semántica**
La **sintaxis** y la **semántica** son dos conceptos fundamentales en programación. Estas son sus caracteristicas:
1. **Sintaxis:**
* La **sintaxis** se refiere a la **estructura** de un programa escrito en un lenguaje de programación.
* Describe **cómo se debe escribir** el código para que sea válido según las reglas del lenguaje.
* Los **errores sintácticos** ocurren cuando no seguimos las reglas gramaticales del lenguaje.
* Por ejemplo, si olvidamos cerrar un paréntesis o escribimos mal una palabra clave, estamos cometiendo errores de sintaxis.
2. **Semántica:**
* La **semántica** se relaciona con el **significado** detrás del código.
* Describe **qué debe hacer** el programa y cómo se relacionan las diferentes partes del código para lograr un objetivo.
* Los **errores semánticos** no se detectan en tiempo de compilación, sino en tiempo de ejecución.
* Por ejemplo, si asignamos un valor incorrecto a una variable o realizamos una operación lógica incorrecta, estamos cometiendo errores de semántica.
Sobre la indentación yo imagino que estoy escribiendo una lista de instrucciones para que alguien siga. Si pones todas las instrucciones en una línea continua, sería muy confuso.
En cambio, si agruparas las instrucciones en secciones claras, sería mucho más fácil de entender.
En Python, la indentación hace algo similar: organiza el código en bloques claros. Aquí te explico cómo y por qué se usa la indentación en Python:
1. **Definir Bloques de Código**: La indentación muestra qué líneas de código pertenecen juntas. Por ejemplo, en un bucle o una función, todo el código que está indentado a la misma distancia se considera parte de ese bucle o función.
```python
for i in range(5):
print(i) # Esta línea está indentada y pertenece al bucle
if i % 2 == 0:
print(f"{i} es par") # Esta línea está más indentada y pertenece al 'if'
````def saludar(nombre):`
` print(f"Hola, {nombre}") # Esta línea está indentada y pertenece a la función 'saludar'`
`saludar("Carlos") # Esta línea no está indentada y no pertenece a la función`
1. **Mejorar la Legibilidad**: La indentación hace que el código sea más fácil de leer. Al ver las sangrías, puedes entender rápidamente la estructura del programa y cómo están organizadas las instrucciones.
2. **Requisitos del Lenguaje**: A diferencia de otros lenguajes que usan llaves `{}` para definir bloques de código, Python usa la indentación como su principal manera de organizar el código. Si no indentas correctamente, Python no sabrá qué pertenece a qué bloque y producirá un error.
```js
def saludar(nombre):
print(f"Hola, {nombre}") # Esta línea está indentada y pertenece a la función 'saludar'
saludar("Carlos") # Esta línea no está indentada y no pertenece a la función
```
Recuerda que en Python, la consistencia es clave. Debes usar el mismo número de espacios (o un tabulador) para cada nivel de indentación en todo tu código. Por ejemplo, si decides usar cuatro espacios para indentaciones, usa cuatro espacios en todas partes.
Con una correcta indentación, tu código será más claro y más fácil de mantener.
Si desean hacer un ligero salto de linea dentro de la misma linea utilicen "\n", esto lo usaran mucho en los inputs, cuando hacen preguntas, tambien dependiendo del numero de \n es el numero de saltos que dara y los espacios en blancos tambien recorreran lo que sigue a la derecha.
tambien les puede empezar a servir saber que pueden usar triple comillas para comentar o # y en lugar de correr su archivo .py pueden correrlo desde la terminal
<https://github.com/iecgerman/10002-python>
Chicos, les comparto un recurso para complementar esta clase: <https://youtu.be/LmJUhSK7cpU?si=Vo0g8w80LDzdME7d> Me ayudo mucho a terminar de entender los conceptos que describo a continuación:
#### Definición de variable: Espacio en memoria para almacenar datos
#### ¿Cuáles son los tipos de datos más usados?
#### Números Enteros (`int`): Números sin decimales.
#### Qué normas sintácticas se usan para la definición de variables:
Para definir variables en Python, usa letras de la 'a' a la 'z', de la 'A' a la 'Z', dígitos del '0' al '9' (excepto al inicio), y barras bajas `_`, siguiendo la sintaxis `nombre_variable = valor`.
#### Números Flotantes (`float`): Números con decimales.
#### Cadenas de texto (`str`): Texto.
#### Booleanos (`bool`): `True` o `False`.
Todo bien pero el angulo de la camara desde arriba es un poco molesto .. saludos
Algo muy particular que he descubierto en esta clase, está con el uso de print().
Cuando vas a concatenar, a unir dos variables de texto (string) y usas el operador + o comas, print() va a darte un espacio entre las variables.
Me ha volado al cabeza, pues en otros lenguajes de programación uno debe poner explicitamente el caracter de espacio para que dos variables de texto no se impriman juntas en el print().
Esto es algo particular de python, increíble. En otros lenguajes de programación si debes de poner un espacio por obligación.
No entiendo porque eliminaron el curso de Nicolas Molina , lo estaba tomando y de repente ya no esta , esta bueno que actualicen los cursos pero no deberían eliminar los otros , ya depende del " estudiante" cual curso decide tomar .
Si desean hacer un ligero salto de linea dentro de la misma linea utilicen "\n", esto lo usaran mucho en los inputs, cuando hacen preguntas, tambien dependiendo del numero de \n es el numero de saltos que dara y los espacios en blancos tambien recorreran lo que sigue a la derecha.
tambien les puede empezar a servir saber que pueden usar triple comillas para comentar o # y en lugar de correr su archivo .py pueden correrlo desde la terminal
Ya había tomado el curso básico de Python, pero lo estoy volviendo a tomar de nuevo, y wow, está vez me encanta como están las clases. La forma de explicación es excelente.
Semantica: sentido del código
Sintaxis: la escritura y buenas practicas
Python es un lenguaje extremadamente ordenado, tener cuidado con las identaciones
asignar valores a variables:
Nombre = "Kaneki"
print(Nombre)
Las palabras reservadas son propias de cada lenguaje y no se puede nombrar variables con los nombres de estas
Python es un lenguaje ordenado de arriba a abajo y izquierda a derecha
en plan, si tengo dos variables con el mismo nombre se usara la que se declaro después, mas abajo, como un reemplazo o actualización
Saludo = "hola"
Saludo = "Hi"
Si se imprime se imprimirá hi
Semántica .- Sentido que le damos al código.
Sintaxis .- Manera en la que escribimos y seguimos buenas practicas del código
Python es extremadamente ordena con la identación
Variables, se le puede dar nombre, tipo y el dato que se quiere guardar, la sintaxis es la siguiente nombreVariable = "algo"
class es una palabra reservada en el lenguaje
Python es un lenguaje ordena que se ejecuta de arriba hacia abajo y de izquierda a derecha
Así se deben escribir las variables:
* Están permitidos los guiones bajos para escribir en formato camel\_case
* Están permitidos los guiones bajos al principio
* Están permitidos los números, pero no al principio
* No están permitidos los caracteres especiales como @, #, $, %, &, etc.
* No están permitidos colocar nombres a variables con palabras reservadas de Python como 'print', 'if', 'else'.
La razón por lo que están prohibidos los caracteres especiales, es por que entraría en errores, por ejemplo: primer-nombre, python podría interpretarlo como una resta entre primer y nombre. Lo mismo pasaría si intentaras usar una palbra reservada de python como nombre, por ejemplo: print = "nombre cadena", python creeria que debe ejecutar print en vez de crear una variable.
Les presento el ejemplo que desarrollé para poner en practica la tematica de esta clase
![]()
Si quieres listar las palabras clave que no puedes usar como nombre de variables o funciones utiliza este pequeño script en VSCode (también lo puedes escribir directamente en la shell):
`import keyword`
`print(keyword.kwlist)`
lo que imprimira lo siguiente:
No trates de memorizar las palabras por ahora, conforme avances en el curso iras viendo cada una de estas y su función, dándole contexto a tu memoria y memorizándolas de forma natural (debido a su uso).
Para guardar correctamente tu código Python, es fundamental estructurarlo adecuadamente desde el inicio. Utiliza un entorno virtual con `virtualenv` para cada proyecto. Esto permite mantener las dependencias aisladas y evita conflictos entre bibliotecas. Al crear tu entorno virtual, asegúrate de activarlo antes de instalar paquetes con `pip`.
En cuanto a la organización del código, guarda tus archivos en carpetas relacionadas con el proyecto y utiliza nombres descriptivos. Esto facilita la gestión y el mantenimiento a largo plazo. Además, sigue buenas prácticas de codificación, como comentar tu código y utilizar un control de versiones como Git.
Python es case-sensivite lo cual significa que distingue de mayúsculas y minusculas. Lo pongo ya que existen palabras reservadas que solo se pueden escribir de una cierta forma y de no hacerlo dará un error.
Buenos días, no entendí el realizar operaciones matemáticas en la terminal. ¿Cuál terminal? Yo no tengo esa aplicación de terminal en mi Windows, solo tengo Símbolo de sistema. Y recientemente logré bajar la aplicación Ubuntu. Agradezco la ayuda
**Palabras reservadas en Python y su significado**
A continuación, vamos a ver rápidamente que hace cada una de las palabras reservadas más explícitamente.
**False –** Valor booleano, resultado de operaciones de comparación u operaciones lógicas en Python
**None** – Representa a un valor nulo
**True** – Valor booleano, igual que false, resultado de operaciones de comparación u operaciones lógicas en Python
**\_\_peg\_parser\_\_** – Llamado huevo de pascua, relacionado con el lanzamiento del nuevo analizador PEG no está definido aún. <https://peps.python.org/pep-0617/>
**And** – Operador lógico
**As** – Se utiliza para crear un alias al importar un módulo.
**Assert** – Se utiliza con fines de depuración
**Async** – Proporcionada por la biblioteca ‘asyncio’ en Python. Se utiliza para escribir código concurrente en Python
**Await** – Proporcionada por la biblioteca ‘asyncio’ en Python. Se utiliza para escribir código concurrente en Python
**Break** – Se utiliza en el interior de los bucles for y while para alterar su comportamiento normal
**Class** – Se usa para definir una nueva clase definida por el usuario
**Continue** – Se utiliza en el interior de los bucles for y while para alterar su comportamiento normal
**Def** – se usa para definir una función definida por el usuario
**Del** – Para eliminar un objeto
**Elif** – Se usa en declaraciones condicionales, igual ‘else’ e ‘if’
**Else** – Se usa en declaraciones condicionales, igual ‘elif’ e ‘if’
**Except** – Se usa para crear excepciones, qué hacer cuando ocurre una excepción, igual que ‘raise’ y ‘try’
**Finally** – Su uso garantiza que el bloque de código dentro de él se ejecute incluso si hay una excepción no controlada
**For** – Utilizado para hacer bucles. Generalmente lo usamos cuando sabemos la cantidad de veces que queremos que se ejecute ese bucle
**From** – Para importar partes específicas de un módulo
**Global** – Para declarar una variable global.
**If** – Se usa en declaraciones condicionales, igual ‘else’ y ‘elif’
**Import** – Para importar un módulo
**In –** Para comprobar si un valor está presente en una lista, tupla, etc. Devuelve True si el valor está presente, de lo contrario devuelve False
**Is** – Se usa para probar si las dos variables se refieren al mismo objeto. Devuelve True si los objetos son idénticos y False si no
**Lambda** – Para crear una función anónima
**Nonlocal** – Para declarar una variable no local
**Not** – Operador lógico
**Or** – Operador lógico
**Pass** – Es una declaración nula en Python. No pasa nada cuando se ejecuta. Se utiliza como marcador de posición.
**Raise** – Se usa para crear excepciones, qué hacer cuando ocurre una excepción, igual que ‘except y ‘try’
**Return** – Se usa dentro de una función para salir y devolver un valor.
**Try** – Se usa para crear excepciones, qué hacer cuando ocurre una excepción, igual que ‘raise’ y ‘except
While – Se usa para realizar bucles.
**With** – Se usa para simplificar el manejo de excepciones
**Yield** – Se usa dentro de una función al igual que ‘return’, salvo que ‘yield’ devuelve un generador.
**RESUMEN:**
¿Cuáles son los problemas o errores más comunes en python?
Simple y efectivo!
Las variables son nombres que le damos a ciertos valores en nuestros programas.
Resumen de la clase:
La semántica y la sintaxis son conceptos fundamentales en programación. La **semántica** se refiere al significado de las instrucciones en el código, es decir, lo que el código pretende hacer. Por ejemplo, en Python, si un código suma dos números, la semántica se enfoca en la operación de suma y su resultado.
Por otro lado, la **sintaxis** es la forma correcta en que deben escribirse las instrucciones. En Python, cada instrucción debe seguir reglas específicas, como el uso correcto de paréntesis y la indentación adecuada. Un error en la sintaxis, como olvidar cerrar un paréntesis, generará un error de ejecución.
En resumen, la semántica es el "qué" del código y la sintaxis es el "cómo".
Por que a mi no me deja correr el:
1 print("hola")
1 print("mundo")
Aunque esta bien escrito realmente no hace nada.
Desde Python 3.6 es posible escribir números con guiones bajos (`_`) como separadores visuales, lo que resulta útil en cifras grandes. Por ejemplo, `1_000_000` es equivalente a `1000000`, pero más legible. Esto se hereda de buenas prácticas en lenguajes como Ada y Ruby.
```python
# Ejemplos de uso de guiones bajos para mejorar la lectura
millon = 1_000_000
salario_mensual = 3_500_000
numero_binario = 0b_1010_1100
numero_hexadecimal = 0x_FF_EE_DD
print("Un millón es:", millon)
print("Salario mensual:", salario_mensual)
print("Número binario:", bin(numero_binario))
print("Número hexadecimal:", hex(numero_hexadecimal))
```
La semántica en programación se refiere al significado que se le da al código. Es fundamental porque asegura que el código tenga coherencia y lógica. Por ejemplo, si se trabaja con números, la semántica implica que las entradas y salidas del programa también deben ser números. Sin una correcta semántica, el código puede funcionar sintácticamente, pero no cumplir con su propósito. Es importante para mantener la claridad y la funcionalidad en los programas.
```python
Nombre = "Tu nombre"
Cargo = "Software Development"
print("Nombre :", Nombre,"-", "Cargo:", Cargo)
##print imprimira nombre : - cargo:
```Nombre = "Tu nombre"Cargo = "Software Development"print("Nombre :", Nombre,"-", "Cargo:", Cargo)##print imprimira nombre : - cargo:
# #Lo importante de practicar y experimentar les dejo varios ejemplos de print()
*## Hola mundo Ejemplos*
print('hola Mundo')
## #Imprime variables
nombre = "Leo"
edad = 37
ciudad = "México"
print("Mi nombre es", nombre, "tengo", edad, "años y vivo en", ciudad)
*## Separadores*
print("manzana", "banana", "naranja", *sep*="-")
print(1, 2, 3, *sep*=", ")
*## Especificar el final de línea (end):*
*## Por defecto, print() añade un salto de línea (\n) al final de la salida. Puedes cambiar este comportamiento utilizando el parámetro end.*
print("Esto se imprime en", *end*=" ")
print("la misma línea.")
for i in range(5):
print(i, *end*=", ")
print("fin")
*## Usar cadenas formateadas (f-strings):*
*## Las f-strings (disponibles desde Python 3.6) son una forma concisa y legible de insertar expresiones dentro de cadenas de texto. Se definen prefijando la cadena con una f o F y colocando las expresiones entre llaves*
nombre = "Carlos"
puntuacion = 95
print(f"El estudiante {nombre} obtuvo una puntuación de {puntuacion}.")
print(f"El doble de {puntuacion} es {puntuacion \* 2}.")
*# Usar el método .format():*
*# El método .format() también permite formatear cadenas, aunque es un poco más verboso que las f-strings.*
nombre = "Laura"
profesion = "ingeniera"
print("Mi nombre es {} y soy {}.".format(nombre, profesion))
*# Usando índices*
print("El número {0} al cuadrado es {1}.".format(5, 5\*\*2))
*# Usando nombres de clave*
print("Nombre: {n}, Edad: {e}".format(*n*="Pedro", *e*=25))
*## combinaciones*
productos = \["manzana", "plátano", "uva"]
print("Lista de productos:", \*productos, *sep*=", ", *end*=".\n¡Gracias!")
Los nombres de las variables pueden iniciar en mayúscula o tienen alguna restricción en Python.
En Python, las variables básicas representan los tipos más fundamentales de datos que puedes usar para desarrollar programas. Aquí tienes un desglose de los tipos básicos:
1. **Números**:
* **int**: Enteros, como 10 o -3.
* **float**: Números decimales, como 3.14 o -0.01.
2. **Texto**:
* **str**: Cadenas de texto, como "Hola" o 'Python es divertido'.
3. **Booleanos**:
* **bool**: Valores de verdad, True o False.
4. **Colecciones simples**:
* **list**: Listas, como \[1, 2, 3] o \['a', 'b', 'c'].
* **tuple**: Tuplas, como (10, 20, 30).
Estos tipos son esenciales para programar en Python y puedes verificarlos usando type():
x = 42
print(type(x)) # Salida: \<class 'int'>
El "venv" es una herramienta en Python que permite crear entornos virtuales. Un entorno virtual es un espacio aislado donde puedes instalar paquetes específicos para un proyecto sin afectar otras configuraciones de Python en tu sistema. Esto es útil para gestionar dependencias y evitar conflictos entre proyectos.
En el contexto de la programación y sintaxis, puedes usar "venv" para organizar tus proyectos y asegurarte de que cada uno tenga sus propias librerías y versiones. Para crear un entorno virtual, puedes usar el siguiente comando:
```bash
python -m venv nombre_del_entorno
```
Luego, para activarlo, utiliza:
- En Windows: `.\nombre_del_entorno\Scripts\activate`
- En macOS/Linux: `source nombre_del_entorno/bin/activate`
Esta práctica es fundamental para mantener un entorno limpio y ordenado en tus proyectos de Python.
## Semántica
Describe lo que se debe hacer. Explica lo que significa cada símbolo y cómo se deben intepretar, bien por sí misma o en el contexto de otros símbolos. Es decir, lo que realmente hace cuando se ejecuta.
## Sintáxis
Describe cómo se ve. Indica cómo se utilizan los símbolos para representar elementos y cómo se combinan los símbolos. Es importante conocer cómo se escriben correctamente y cómo poner los elementos para formar una sentencia.
Si no se siguen estas reglas, se generará un error de sintáxis
Un programa puede ser sintácticamente correcto pero semánticamente incorrecto
Un saludo para tod@s, me gustaria saber si a alguien mas le sucedio este error mientras realizaba el paso a paso de este curso, que me puedan informar si lo han solucionado y porque razon me lanza este error de ruta.
Ya he intentado de muchas maneras pero no he logrado solucionarlo y tampoco he podido seguir avanzando en el curso. Agradezco cualquier respuesta.
Aguante PyCharm
**VARIABLES**
They should't start with numbers and reserved words should't be used such as:
* class
* if
* else
* for
They can start with \_ or \_\_, which is often used to symbolize that they are private type variables.
An important thing to keep in mind is that in Python snake\_case is used to write variables.
**Totalmente cierto.**
Tener en cuenta la sintaxis de cada lenguaje de programación en el cual trabajemos
Una buena idea para mini proyectos, basándote en los contenidos de la clase, podría ser crear un programa que gestione un sistema de registro de contactos utilizando listas y diccionarios en Python.
Otra opción sería un simple calculador que realice operaciones matemáticas básicas, aplicando conceptos de semántica y sintaxis. También puedes desarrollar un juego sencillo, como "Adivina el número", que utilice estructuras condicionales.
Sube estos proyectos a tu GitHub para mostrar tu progreso y habilidades.
Después de tantas veces pensándolo, finalmente me decidí por aprender Python de 0 hasta lo máximo con este maravilloso curso!.
```python
saludo = "Hola a todos"
nombre = "Camilo"
print(saludo)
print(nombre)
```
En esta clase se abordaron los conceptos fundamentales de programación y Python, enfatizando la diferencia entre semántica y sintaxis. La semántica se refiere al significado del código y la consistencia en las operaciones, mientras que la sintaxis se refiere a las reglas de escritura. Se discutieron errores comunes de sintaxis, la importancia de la identación en Python, el uso adecuado de variables y nombres, así como las convenciones para nombrarlas. Finalmente, se destacó que Python es un lenguaje ordenado que ejecuta el código de arriba hacia abajo, lo que afecta la interpretación de las variables.
Buenas practicas
* Siempre cerrar los paréntesis.
La identacion (indent) es igual a la sangría.
Sintaxis es igual a la forma correcta que escribimos en Python
Cada lenguaje tiene su sintaxis
**Variables**
Contenedores donde podemos guardar información, a estos contenedores podemos asignarles características como:
* Nombre.
* Tipo.
* Dato.
Al generar una variable no acepta un numero como primera letra.
Pyhton tiene palabras reservadas, si la usas y si se pinta de un color diferente significa que es una de esas palabras.
Python es un lenguaje ordenado, ejecuta de arriba abajo y lo usual es que vaya de izquierda a derecha.
Buen curso y buena profesora.
En la clase se tratan los siguientes conceptos:
1. **Sintaxis y semántica**: Diferencia entre cómo se escribe el código y el significado que tiene.
2. **Variables**: Cómo crear y utilizar variables, así como las reglas para nombrarlas.
3. **Errores comunes**: Identificación de errores de sintaxis, como el "syntax error" y problemas de indentación.
4. **Uso de caracteres y números en variables**: Cómo nombrar variables correctamente y evitar caracteres no permitidos.
Código de ejemplo:
```python
saludo = "Hola"
nombre = "Carli"
print(saludo, nombre)
```
Este código muestra cómo asignar valores a variables y luego imprimirlas.
* **Sintaxis**: Cómo se escribe el código (las reglas y estructura).
* **Semántica**: Qué significa el código (lo que hace cuando se ejecuta)
En Python, la indentación es crucial porque el lenguaje utiliza espacios en blanco para definir la estructura del código, especialmente en bloques como funciones y bucles. Si agregas un espacio extra, Python no puede interpretar correctamente la jerarquía del código, lo que genera un error de indentación. Asegúrate de seguir consistentemente la misma cantidad de espacios o usar tabulaciones para evitar estos errores.
Aunque Python es un lenguaje de programación que funciona en múltiples plataformas, hay algunas diferencias notables cuando lo usas en Linux.
1\. Instalación: En la mayoría de las distribuciones de Linux, Python ya viene preinstalado. Puedes instalar versiones adicionales usando el gestor de paquetes de tu distribución (por ejemplo, apt en Ubuntu).
2\. Administración de paquetes: Generalmente, es más fácil instalar bibliotecas que necesitan compilación, ya que las herramientas de desarrollo de C/C++ suelen estar disponibles. Puedes usar pip y también manejar dependencias con apt u otro gestor de paquetes.
3\. Terminal: La terminal de Linux es muy poderosa y ofrece muchas herramientas de línea de comandos. Es un entorno ideal para desarrolladores y administradores de sistemas.
La Identación es super importante
En Python, los comentarios se hacen con el símbolo `#`. Todo el texto que sigue a este símbolo en la misma línea es ignorado por el intérprete.
Por ejemplo:
```python
# Este es un comentario en Python
print("Hola, mundo") # Comentario al final de la línea
```
Python no usa `//` como en JavaScript.
In Python, variables can hold various data types. Here are the main types:
1. **Integer (**`int`**)**: Whole numbers (e.g., `10`, `-5`).
2. **Float (**`float`**)**: Decimal numbers (e.g., `3.14`, `-0.99`).
3. **String (**`str`**)**: Text or characters, enclosed in quotes (e.g., `"hello"`, `'Python'`).
4. **Boolean (**`bool`**)**: Represents `True` or `False` values.
5. **List (**`list`**)**: Ordered, mutable collection of items (e.g., `[1, 2, 3]`).
6. **Tuple (**`tuple`**)**: Ordered, immutable collection (e.g., `(1, 2, 3)`).
7. **Dictionary (**`dict`**)**: Key-value pairs (e.g., `{"name": "Alice", "age": 30}`).
8. **Set (**`set`**)**: Unordered, unique items (e.g., `{1, 2, 3}`).
Estas son algunas palabras reservadas que no se pueden usar como variables en Python:
`False`, `None`, `True`, `and`, `as`, `assert`, `break`, `class`, `continue`, `def`, `del`, `elif`, `else`, `except`, `finally`, `for`, `from`, `global`, `if`, `import`, `in`, `is`, `lambda`, `nonlocal`, `not`, `or`, `pass`, `raise`, `return`, `try`, `while`, `with`, y `yield`.
`Semántica != Sinataxis`
* **Semántica**: Sentido que le damos al código (como se comporta cuando lo ejecutamos).
* **Sintaxis**: Reglas que definen como escribir código correctamente (uso correcto de paréntesis, comas, llaves, en el caso de python los tabs)
Que buen curso, empece hace algunos años con JS, en el de programacion básica y se nota la calidad en evolución de parte de platzi, en la estructura y detalles que antes se veian implicitamente, hoy te explican con lujo de detalle, felicitaciones
ahi vamos de nuevo¡¡¡¡¡ Jajajaja
Semantica: hace referencia al sentido que le damos al codigo
Sintaxis: la manera en que vamos escribiendo el codigo
Tener cuidado con la identacion, cada lenguaje tiene su propia sintaxis
Notas:
Semantica: sentido del código
Sintaxis: la escritura y buenas practicas
Python es un lenguaje extremadamente ordenado, tener cuidado con las identaciones y/ o espacios
asignar valores a variables:
Nombre = "Kaneki"
print(Nombre)
Las palabras reservadas son propias de cada lenguaje y no se puede nombrar variables con los nombres de estas
Python es un lenguaje ordenado de arriba a abajo y izquierda a derecha
en plan, si tengo dos variables con el mismo nombre se usara la que se declaro después, mas abajo, como un reemplazo o actualización
Saludo = "hola"
Saludo = "Hi"
Si se imprime se imprimirá hi
-python no deja iniciar nombres de variables con números, pero se pueden agregar números después de iniciar con una letra
-se puede usar \_ en cualquier lugar del nombre de la variable
Si yo le cambio el nombre a la variable, por ejemplo, por edad, eso no significa que luego en el print vaya a mostrar la edad. Va a mostrar lo que le hayamos puesto como datos en esa variable. En este caso es un dato de texto entrecomillado, y se trata de mi nombre.
<u>Especial atención a la identación, ósea, la sangría.</u>
***<u>PRINCIPIOS BASICOS EN PYTHON</u>***
1. **VARIABLES** : Son como cajas donde guardamos informacion ejemplo: edad=30 cada variable tiene un tipo (entero, decimal, texto, etc)
2. **TIPOS DE DATOS:** Enteros(int): Numeros sin decimales (ej: 5, 2). Flotantes(Float):Numeros con decimales (ej:3,14) Cadenas(str): Texto (eje: "hola, mundo") Boleanos(bool): valores logicos (true or false)
3. **OPERADORES:** Aritmeticos: +,-, /, //, (division entera), % (modulo) Comparacion: == (igual) , !=(diferente), <,>, <=,>= Logicos: and, or, not.
4. **ESTRUCTURAS DE CONTROL: if, else:** permiten tomar decisiones basadas en condiciones. **for:** Repite un bloque de código un número. determinado de veces. **while:** Repite un bloque de código mientras se cumpla una condición.
5. **FUNCIONES:** Son los bloques de codigo reutilizables que realizan una tarea especifica.
una clase muy ordenada y comprensible
Me gusta mucho la metodología que ocupa Carli para enseñar, es más ordenada y comprensible. Vamos muy bien.
A mi no me aparece el boton de ejecutar en visual studio. Porque es? En la opcion del menu, terminal y luego Run Active File, muestra abajo en terminal la ruta del archivo pero no hace nada mas?
Resumen:
\- La **semántica** en programación se refiere al significado y consistencia del código, asegurando coherencia en las operaciones.
\- La **sintaxis** dicta cómo escribir correctamente el código, siguiendo reglas específicas de cada lenguaje.
\- **Los errores de sintaxis** son señalados por el compilador o entorno de desarrollo y deben corregirse para que el código funcione.
\- **Las variables** son fundamentales para la semántica y deben nombrarse de manera descriptiva y relevante.
\- **Errores comunes con variables** incluyen usar nombres no descriptivos o palabras reservadas, y no declararlas antes de su uso.
\- Para **nombrar correctamente las variables**, use nombres descriptivos, inicie con letras y evite palabras reservadas.
\- **Redefinir una variable** sobrescribe su valor anterior, prevaleciendo el último valor asignado.
\- Para **evitar errores** de semántica, use nombres de variables que reflejen claramente su propósito.
Da error al descargar el contenido
creo que no hay nadie en le mundo que no halla cometido un error de sintaxis en su vida
```js
#Nombres de variables legales:
myvar = "John"
my_var = "John"
_my_var = "John"
myVar = "John"
MYVAR = "John"
myvar2 = "John"
#Nombres de variables ilegales:
2myvar = "John"
my-var = "John"
my var = "John"
#Camel Case
#Cada palabra, excepto la primera, comienza con mayúscula:
myVariableName = "John"
#Pascal Case
#Cada palabra comienza con una letra mayúscula:
MyVariableName = "John"
#Snake Case
#Cada palabra está separada por un guión bajo:
my_variable_name = "John"
```#Nombres de variables legales:myvar = "John"my\_var = "John"\_my\_var = "John"myVar = "John"MYVAR = "John"myvar2 = "John"
\#Nombres de variables ilegales:2myvar = "John"my-var = "John"my var = "John"
\#Camel Case#Cada palabra, excepto la primera, comienza con mayúscula:myVariableName = "John"
\#Pascal Case#Cada palabra comienza con una letra mayúscula:MyVariableName = "John"
\#Snake Case#Cada palabra está separada por un guión bajo:my\_variable\_name = "John"
Yo estoy trabajando con pycharm en ves de visualstudio y si tienes Mac para que no estes picando al botón de run, puedes hacerlo con las teclas control+r.
Sintaxis: Alfabeto latino en nuestro cosa con el que escribimos cosas.
Semántica: El significado que dichas letras como LOHA en cierto orden tienen sentido para nosotros HOLA
Sobre la identacion si me a dado duro en un ejercicio me mostraba error en una linea pero no veía el fallo y era que aunque tenia la identacion tenia un espacio extra y era ese el fallo hasta que lo borre guarde y vi que se soluciono
Semántica y sintaxis esto es parte fundamental de los algoritmos.
# Indentacion es la forma de ordenar las cosas en Python.
```js
Una Caja:
Dentro de la caja
Fuera de la caja
```Una Caja: Dentro de la caja Fuera de la caja
Si eres estudiante, me parece tienes acceso gratis a pyCharm professional
La semántica en programación se refiere al significado de las instrucciones que escribimos. Por ejemplo, si creamos una variable llamada `edad` y le asignamos un valor numérico, la semántica implica que esta variable debe representar la edad de alguien. Si luego intentamos usar esta variable para realizar una operación de texto, como concatenarla con una cadena, estaremos violando el sentido que le hemos dado a la variable. Un código con semántica correcta mantiene la coherencia entre las variables y su propósito.
Muy buena explicación desde los conceptos bases. Mil gracias, dan ganas de seguir con el curso.
Como saber que variables no usar, quise curiosear cuales eran y esto saque .
saludos
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?