Instrucciones básicas de Python (Parte 1)

Insertar descripción de la imagen aquí

Instrucciones básicas de Python

constantes y expresiones
Variables y tipos
Comentario
de entrada y salida
operador
Declaraciones condicionales
Bloques de sangría y código.
Pase de declaración vacío
declaración de bucle
- 1. mientras bucle
- 2. para bucle

constantes y expresiones

print(1 + 2 - 3)
print(1 + 2 * 3)
print(1 + 2 / 3)

resultado de la operación

0
7
1.6666666666666665

printEs una Pythonfunción incorporada
que puede utilizar + - * / ( ) otros operadores para realizar operaciones aritméticas. La multiplicación y la división se calculan primero, seguidas de la suma y la resta.
No puede haber espacios o múltiples espacios entre los operadores y los números. Pero generalmente es habitual escribir un espacio

Una expresión en esta forma 1 + 2 - 3se llama expresión en un lenguaje de programación. El resultado de la expresión se llama valor de retorno de la expresión.
Este 1 , 2 , 3tipo se llama constante literal + - * / y este tipo se llama operador u operador.

Nota : C / C++Los estudiantes que estén familiarizados con esto pueden pensar que 2 / 3el resultado es 0(la parte decimal está truncada), pero Pythonel resultado obtenido es un decimal, lo que está más en línea con la intuición del uso diario.

Variables y tipos

1. ¿Qué es una variable?

En Python, las variables son identificadores que se utilizan para almacenar valores de datos. Estos identificadores pueden ser una combinación de letras, números y guiones bajos, pero deben seguir algunas reglas de nomenclatura. Por ejemplo, los nombres de las variables no pueden comenzar con números, no pueden contener espacios, etc. Las variables en Python se escriben dinámicamente, lo que significa que no es necesario declarar el tipo de datos de la variable por adelantado, Python determinará automáticamente su tipo en función del valor asignado a la variable.

Aquí hay un ejemplo simple de variable de Python:

x = 10  # 创建一个整数类型的变量x并赋值为10
name = "John"  # 创建一个字符串类型的变量name并赋值为"John"
is_student = True  # 创建一个布尔类型的变量is_student并赋值为True
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2 #创建一个浮点数类型的变量total并赋值为四个小数的方差

Las variables en Python tienen algunas diferencias significativas en comparación con C:

Escritura dinámica : en C, es necesario especificar explícitamente el tipo de datos de una variable al declararla, mientras que en Python, el tipo de datos de una variable se determina automáticamente por el valor que se le asigna. Esto hace que Python sea más flexible y conciso.
No se requiere declaración : en C, debe declarar explícitamente una variable antes de usarla, pero esto no es necesario en Python. Puede asignar un valor directamente a una variable y Python lo creará automáticamente.
No se requiere punto y coma : en C, las declaraciones generalmente terminan con punto y coma, mientras que Python usa sangría para representar bloques de código y no requiere punto y coma.
Tipos de datos más avanzados : Python tiene muchos tipos de datos avanzados integrados, como listas, diccionarios, conjuntos y tuplas, que hacen que el procesamiento de estructuras de datos complejas en Python sea más conveniente.
Recolección de basura : Python tiene mecanismos automáticos de administración de memoria y recolección de basura, lo que elimina la necesidad de administrar manualmente la asignación y liberación de memoria.

En general, Python es más conciso y más fácil de aprender que el lenguaje C, pero en algunos casos se puede sacrificar algo de rendimiento. Al elegir un lenguaje de programación, existen compensaciones basadas en las necesidades del proyecto y los requisitos de rendimiento.

Nota:
x,name,is_student,total Todas son variables.
**En Python, representan operaciones de exponenciación, ** 2es decir, encontrar cuadrados.

2. Sintaxis de variables

2.1 Definir variables

a = 10

La declaración para crear una variable es muy simple, donde

aes el nombre de la variable. Cuando creamos muchas variables, podemos usar sus nombres para distinguirlas. Es el
=operador de asignación, lo que significa colocar =los datos de la derecha en =el espacio de la izquierda.

Nota: Los nombres de las variables deben seguir ciertas reglas.

Reglas estrictas (deben seguirse)

Los nombres de las variables constan de números, letras y guiones bajos.

Los números no pueden empezar.

Los nombres de variables no pueden repetir "palabras clave".

Los nombres de las variables distinguen entre mayúsculas y minúsculas. num y Num son dos nombres de variables diferentes.

Reglas suaves (recomendadas a seguir)

Utilice palabras descriptivas en los nombres de las variables para expresar la función de la variable tanto como sea posible.

Un nombre de variable puede estar compuesto por varias palabras, no importa si es más largo, pero el significado debe ser claro.

Cuando el nombre de la variable contiene varias palabras, se recomienda utilizar "nombramiento en caso de camello", de esta forma totalCount, personInfoexcepto la primera palabra, las primeras letras de las palabras restantes están en mayúscula.

En matemáticas, las variables generalmente se representan con letras simples inglesas o letras latinas como x, y, z. Sin embargo, esto no se recomienda en programación, la razón es que en programación generalmente se crean muchas variables al mismo tiempo en un programa. Si solo se usa una sola letra para representarlo, cuando hay demasiadas variables, es difícil recordar qué variable hace qué, lo que trae ciertas dificultades al mantenimiento del programa, por lo que recomendamos usar nombres claramente descriptivos para representar el propósito de La variable.

2.2 Usando variables

Leer el valor de una variable.

a = 10
print(a)

Modificar el valor de una variable

a = 20
print(a)

En Python, la modificación de variables también utiliza la operación =, que no parece ser significativamente diferente de definir variables .
Por supuesto, también puede asignar el valor de una variable a otra variable.

a = 10
b = 20
a = b
print(a)
print(b)

3. Tipo de variable

El tipo entero (int), el tipo de punto flotante (float), el tipo de cadena (str) y el valor lógico (bool) de Python tienen algunas diferencias con los tipos correspondientes en lenguaje C :

Tipo entero (int):
- Los tipos de enteros en Python son dinámicos y no es necesario especificarlos. Python determinará automáticamente su tipo en función del valor asignado a la variable.
- El tipo entero de Python puede representar números enteros de cualquier tamaño sin un límite de rango fijo, lo que se denomina "enteros de precisión arbitraria".
- En C, el tamaño de los tipos de enteros depende del compilador y la plataforma y, por lo general, tiene un número fijo de bits y un rango.
En Python, los tipos de números enteros pueden representar números enteros muy grandes sin preocuparse por problemas de desbordamiento. Por ejemplo:
```
x = 1234567890123456789012345678901234567890
print(x)
print(type(x))
```
Este número puede causar problemas de desbordamiento o de precisión en C, pero no hay problema en Python.
```
1234567890123456789012345678901234567890
<class 'int'>
```
Tipo de punto flotante (flotante):
- Los tipos de coma flotante en Python también son dinámicos y no requieren una especificación de tipo explícita.
- Python utiliza el estándar de punto flotante de doble precisión (IEEE 754), que normalmente admite de 15 a 17 dígitos de precisión decimal.
- En C, el tamaño y la precisión de los tipos de punto flotante dependen del compilador y la plataforma, y pueden ser números de punto flotante de precisión simple o doble.
El tipo de coma flotante de Python tiene doble precisión y puede representar valores decimales, por ejemplo:
```
y = 3.14159265358979323846
print(y)
print(type(y))
```
Este número de coma flotante tiene suficiente precisión en Python para representar una aproximación de π. En C, la precisión del punto flotante depende del compilador y la plataforma y puede no ser lo suficientemente precisa.
```
3.141592653589793
<class 'float'>
```
Tipo de cadena (cadena):
- El tipo de cadena de Python es una cadena Unicode, lo que significa que puede representar caracteres de la mayoría de los conjuntos de caracteres del mundo, incluidos caracteres ASCII y no ASCII.
- Las cadenas de Python son inmutables, lo que significa que una vez creadas, su contenido no se puede modificar.
- En C, las cadenas suelen ser matrices de caracteres, terminan en nulo y se pueden modificar.
El tipo de cadena de Python puede contener una variedad de caracteres, incluidos caracteres Unicode. Esto lo hace muy conveniente cuando se trabaja con datos de texto en diferentes conjuntos de caracteres, por ejemplo:
```
name = "李雷"
print(name)
print(type(name))
```
Esta es una cadena que contiene caracteres chinos y Python puede manejarla fácilmente. En C, el manejo de caracteres Unicode puede ser más complicado y requiere el uso de funciones de conversión de caracteres anchos o Unicode.
```
李雷
<class 'str'>
```

En general, los tipos de punto flotante y entero en Python tienen mayor flexibilidad y precisión, mientras que los tipos de cadena tienen mejor compatibilidad e inmutabilidad con Unicode. Estas diferencias hacen que Python sea más conveniente para manejar varios tipos de datos, pero existen compensaciones en el rendimiento, ya que C es generalmente más eficiente en el manejo de los datos subyacentes. Dependiendo de sus necesidades específicas, puede optar por utilizar diferentes idiomas y tipos de datos.

Nota : En Python, no hay diferencia entre una cadena compuesta por comillas simples y una cadena compuesta por comillas dobles 'hello'y "hello"son completamente equivalentes.

Puedes usar la función len para obtener la longitud de una cadena.

a = 'hello'
print(len(a))

producción5

Puedes usar + para concatenar dos cadenas

a = 'hello
b = 'world'
print(a + b)

producciónhelloworld

Aquí está la suma de dos cadenas. No puede sumar cadenas y números enteros/punto flotante.

Valor lógico (bool) :
- El tipo booleano en Python tiene dos valores: Verdadero y Falso.
- Los tipos booleanos se utilizan a menudo para juicios condicionales, como en declaraciones if.
- El tipo booleano de Python distingue entre mayúsculas y minúsculas. Verdadero y Falso deben comenzar con una letra mayúscula. Verdadero y falso en minúsculas no son valores booleanos.

is_true = True
is_false = False

if is_true:
    print("这是True")

if not is_false:
    print("这是False")
print(type(is_true))
print(type(is_false))

producción

这是True
这是False
<class 'bool'>
<class 'bool'>

otro

Además de los tipos anteriores, Pythontambién existen list, tuple, dicttipos personalizados, etc., que los presentaremos por separado más adelante.

4. ¿Por qué hay tantos tipos?

El tipo determina cuánto espacio ocupan los datos en la memoria,
por ejemplo, el tipo flotante ocupa 8 bytes en la memoria.

Las computadoras usan binario para representar datos, es decir, cada bit solo puede representar 0 o 1.
1 bit binario se llama "bit" y 8 bits binarios se llaman "byte" (Byte)
Una variable flotante ocupa 8 bytes de espacio en la memoria, que son 64 bits binarios. Mi computadora tiene 16 GB de espacio de memoria, lo que significa un total de 1024 * 1024 * 1024 * 8 tantos bits binarios.

El tipo en realidad estipula qué tipo de operaciones se pueden realizar en esta variable.
Por ejemplo, int / floatlas variables de tipo pueden realizar + - * /operaciones como,
mientras que strlas variables de tipo solo pueden realizar + (y el comportamiento es la concatenación de cadenas), que no se puede realizar - * /, pero También se pueden utilizar leny realizar otras operaciones.

Resumen: el sistema de tipos en realidad "clasifica" variables. Las variables (datos) del mismo tipo a menudo tienen características y reglas de uso similares

5. Características de tipo dinámico

En Python, el tipo de una variable puede cambiar durante el proceso de "ejecución del programa". Esta característica se llama "escritura dinámica".

a = 10
print(type(a))
a = 'hello'
print(type(a))

Salida :

<class 'int'>
<class 'str'>

Durante la ejecución del programa, el tipo de a es int al principio y luego se convierte en str.
Los lenguajes como C++/Java no permiten tales operaciones. El tipo de una variable se fija después de definirla. Esta característica se llama "tipificación estática".
La escritura dinámica es un arma de doble filo

Para programas pequeños y medianos, la cantidad de código se puede reducir considerablemente (por ejemplo, escribir un fragmento de código puede admitir varios tipos al mismo tiempo) y para programas grandes, aumenta el costo
de interacción entre módulos. El código proporcionado por el programador A es difícil de entender para el programador B).

Comentario

En Python, hay dos tipos principales de comentarios: comentarios de una sola línea y comentarios de varias líneas. Los comentarios se utilizan para agregar explicaciones o anotaciones al código y no serán ejecutados por el intérprete.

Comentarios de una sola línea: un comentario de una sola línea comienza con un #signo de almohadilla y el siguiente contenido se trata como un comentario hasta el final de la línea. Los comentarios de una sola línea se suelen utilizar para agregar una breve explicación del código.

Ejemplo:

# 这是一个单行注释
x = 5  # 这是赋值语句，将5赋给变量x

Comentarios de varias líneas: no hay comentarios de bloque en Python como en C o C++, pero puedes usar comillas triples '''o """crear una cadena de varias líneas y colocarla en el código para lograr el efecto de un comentario de varias líneas. Aunque esto en realidad crea una cadena, si no la asigna a una variable, será tratada como un comentario.

Ejemplo:

'''
这是一个
多行注释
它实际上是一个多行字符串，但没有分配给变量
'''
print("Hello, World!")

O utilice comillas dobles:

"""
这也是一个
多行注释
"""
print("Hello, World!")

Tenga en cuenta que, aunque se pueden usar cadenas de varias líneas para comentarios de varias líneas, generalmente los desarrolladores prefieren usar comentarios de una sola línea y cadenas de documentación de función/clase/método (cadenas de documentos) para agregar comentarios y documentación.

Ejemplo:

def add(x, y):
    """
    这是一个函数的文档字符串
    它用于计算两个数字的和
    """
    return x + y

Estas cadenas de documentación help()se pueden ver mediante funciones y existen herramientas que pueden generar documentación. En el desarrollo real, las cadenas de documentación son muy útiles para la legibilidad y el mantenimiento del código.

Especificaciones de anotación

Contenido preciso: el contenido de los comentarios debe ser coherente y coincidir con el código, y debe actualizarse de manera oportuna cuando se modifica el código.
Extensión razonable: Las notas no deben ser ni demasiado concisas ni largas.
Utilice chino: Generalmente, las empresas chinas exigen que las notas estén escritas en chino, mientras que las empresas extranjeras son un asunto diferente.
Sea positivo: no incluya energía negativa en los comentarios (como líder SB, etc.).Se dice que salió en las noticias y fue filmado, la operación manual fue divertida.

de entrada y salida

1. Interacción entre programa y usuario.

El programa necesita interactuar con el usuario.

El proceso mediante el cual el usuario transfiere información al programa se llama "entrada" y
el proceso mediante el cual el programa muestra los resultados al usuario se llama "salida".

El método más básico de entrada y salida es la consola: el usuario ingresa algunas cadenas a través de la consola y el programa imprime algunas cadenas a través de la consola.

Cuando PyCharm ejecuta el programa, la ventana que aparece a continuación puede considerarse como una consola.

Insertar descripción de la imagen aquí
El programa cmd que viene con Windows también se puede considerar como una consola.

Insertar descripción de la imagen aquí

El método más común de entrada y salida es una interfaz gráfica.

Por supuesto, Python también se puede utilizar para desarrollar programas con interfaces gráficas, pero el desarrollo de programas gráficos en sí es un tema importante y lo presentaremos en detalle más adelante.

2. Salida a través de la consola.

Por ejemplo, generar una variable de otros tipos.

a = 10
print(a)
b = True
print(b)

producción

10
True

La mayoría de las veces, el contenido que queremos generar es una mezcla de cadenas y variables.

Ejemplo: salida num = 10

num = 10
print(f'num = {
      
      num}')

Úselo f como una cadena de prefijo, llamada f-string
dentro de la cual se puede usar { }para incrustar otra variable/expresión