Definición de variables de Python y conversión de tipos de datos

variable

definición de variable

• Sintaxis básica:变量名 = 值

• El nombre de la variable es para adjuntar una etiqueta al objeto para su acceso. El proceso de vincular un nombre al objeto también se llama asignación. El símbolo de asignación "="

  Los nombres de las variables deben personalizarse para cumplir con las reglas de denominación de identificadores.

• En Python, no es necesario declarar el nombre de la variable y su tipo por adelantado . Puede crear varios tipos de variables de objeto asignando valores directamente.

  Una variable se crea cuando se le asigna un valor por primera vez y se puede usar directamente cuando aparece nuevamente.

• Python es un lenguaje de programación fuertemente tipado

  Aunque no es necesario declarar explícitamente las variables y sus tipos antes de su uso, Python es un lenguaje fuertemente tipado. El intérprete de Python inferirá automáticamente el tipo de variable basándose en la expresión en el lado derecho del operador de asignación. creada, una variable conservará su tipo anterior a menos que el tipo de variable se modifique o elimine explícitamente.

• Python es un lenguaje de tipo dinámico y los tipos de variables pueden cambiar en cualquier momento.

• Python adopta un método de administración de memoria basado en valores: si a diferentes variables se les asigna el mismo valor, solo hay una copia de este valor en la memoria y varias variables apuntan a la misma dirección de memoria.

  El proceso de ejecución de la declaración de asignación es: primero calcule el valor de la expresión en el lado derecho del signo igual, luego busque una ubicación en la memoria para almacenar el valor y finalmente cree una variable y apunte a esta dirección de memoria.

  Las variables en Python no se almacenan directamente, sino que almacenan la dirección de memoria o la referencia del valor. Es por eso que los tipos de variables se pueden cambiar en cualquier momento.

• Python tiene administración automática de memoria. Para los valores a los que no apunta ninguna variable, Python los elimina automáticamente.

  Python realiza un seguimiento de todos los valores y elimina automáticamente los valores a los que la variable ya no apunta. Por lo tanto, los programadores de Python generalmente no necesitan pensar demasiado en la administración de la memoria.

  Sin embargo, sigue siendo un buen hábito utilizar explícitamente el comando del para eliminar valores innecesarios o cerrar explícitamente recursos a los que ya no es necesario acceder, y también es una de las cualidades básicas de un buen programador.

• Mecanismo de persistencia de cadenas de Python:

  • Cuando la longitud de la cadena es 0 o 1, el mecanismo residente se utiliza de forma predeterminada;

  • Cuando la longitud de la cadena es mayor que 1 y la cadena solo contiene letras mayúsculas y minúsculas, números y guiones bajos (_), se utiliza el mecanismo residente;

  • Para números enteros entre [-5256], Python reside de forma predeterminada;

  • Las cadenas residen sólo en tiempo de compilación, no en tiempo de ejecución. Python es un lenguaje interpretado, pero de hecho, su intérprete también puede entenderse como un compilador, que es responsable de traducir el código Python a código de bytes, que es un archivo .pyc;

  • Cadena obtenida por multiplicación

    • Si la longitud del resultado es <= 20 y la cadena solo contiene números, letras mayúsculas y minúsculas y guiones bajos, se admite la persistencia.
    • Longitud >20, no admite permanencia.

    El propósito de este diseño es proteger el archivo .pcy para que no se haga demasiado grande debido al código de error.

Reglas de nomenclatura de variables (identificadores)

• El primer carácter del nombre de la variable debe ser un guión bajo, letras en inglés u otros caracteres Unicode . El nombre de la variable puede contener guiones bajos, letras en inglés, números u otros caracteres Unicode.

  Por ejemplo, _abc, r_1 son nombres de variables legales, pero 2abc, precio$ no lo son.

  Nota:

  • No se puede empezar con un número
  • Las variables que comienzan con un guión bajo tienen un significado especial en Python. Las variables ordinarias generalmente no comienzan con un guión bajo, lo que no significa que no puedan comenzar con un guión bajo.

• Los nombres de las variables no pueden tener espacios ni puntuación (corchetes, comillas, comas, barras diagonales, barras invertidas, dos puntos, puntos, signos de interrogación, etc.)

• Los nombres de las variables distinguen estrictamente entre mayúsculas y minúsculas . Por ejemplo, Abc y abc son dos variables diferentes.

• No puede utilizar palabras reservadas o palabras clave de Python como nombres de variables

  Nota:

  • Las palabras reservadas o las palabras clave pueden formar parte de los nombres de las variables.
  • Las palabras reservadas y las palabras clave tienen un significado especial en Python. El uso de palabras reservadas o palabras clave como nombres de variables provocará errores de sintaxis.
  • Puede importar el módulo de palabras clave y usar print(keyword.kwlist)la función para ver todas las palabras clave de Python

• No se recomienda utilizar nombres de módulos integrados en el sistema, nombres de tipos o nombres de funciones, así como nombres de módulos importados y sus nombres de miembros como nombres de variables. Esto cambiará su tipo y significado. Puede dir(builtins)ver todos los tipos y módulos integrados y funciones a través de Función

• Convención de nomenclatura de variables :

  • Caso de camello grande: es decir, la primera letra de cada palabra está en mayúscula, por ejemplo: MiNombre
  • Joroba pequeña: escriba en mayúscula la primera letra de la segunda palabra (inclusive) después de esa, por ejemplo: miNombre
  • Guión bajo: por ejemplo: mi_nombre

• Además de las reglas de nomenclatura, Python también tiene algunas convenciones de uso de variables :

  • Las convenciones de variables que comienzan con un guión bajo se utilizan para especificar variables privadas o funciones privadas del módulo (privadas)

    No está disponible fuera del módulo o clase. No puede importar todas las variables del módulo ( from module import *), pero puede from module import _变量名importar variables del módulo individualmente ( ).

    from Person import _abc
    

  • Se acepta que las variables que comienzan con dos guiones bajos son variables privadas de la clase (nota: no pueden terminar con dos guiones bajos al mismo tiempo)

    • Dentro de la clase, las variables de clase subrayadas doblemente, las variables de instancia y los métodos tienen derechos de acceso normales.

    • En la estructura de herencia, las subclases no pueden acceder directamente a las variables de clase y las variables de instancia de la clase base con guiones bajos dobles.

    • En una instancia, no se puede acceder directamente a las variables de clase, las variables de instancia y los métodos con guiones bajos dobles.

      Pero hay una manera de acceder indirectamente:对象名._className__func

        class Student:
          __grade = 0
        
      stu = Student()
        print(stu._Student__grade)
      

  • Los nombres de variables con un guión bajo al principio y al final suelen ser variables del sistema . Por ejemplo _name_,_doc_

  • Los nombres de variables con dos guiones bajos al principio y al final son nombres definidos por el sistema. Estos métodos se activarán para ejecutarse en condiciones específicas y también se pueden llamar manualmente.

    Cada script de Python tiene una propiedad cuando se ejecuta __name__.

    • Si el script se importa como un módulo, __name__el valor de su atributo se establece automáticamente en el nombre del módulo (el nombre del archivo .py).
    • Si el script se ejecuta de forma independiente, __name__el valor de su propiedad se establece automáticamente en__main__

    

    Utilice __name__propiedades para controlar cómo se ejecutan los programas Python . Por ejemplo, si escribe un módulo que contiene una gran cantidad de funciones que pueden ser explotadas por otros programas, pero no desea que el módulo se ejecute directamente, puede agregar el siguiente código al archivo del programa:

    if __name__ == '__main__':    
    	print('Please use me as a module.')
    

    De esta manera, cuando el programa se ejecute directamente, recibirá el mensaje "Utilíceme como módulo". Después de usar la declaración de importación para importarlo como módulo, podrá usar sus clases, métodos, constantes u otros. miembros.

    

sentencia de asignación

Las declaraciones de asignación se utilizan para asignar datos a variables.

Python admite múltiples formatos de declaraciones de asignación: asignación simple, asignación de secuencia, asignación de múltiples objetivos, asignación mejorada, etc.:

• Asignación simple : se utiliza para asignar un valor a una variable (consulte el operador de asignación para obtener más detalles)

• Asignación de secuencia : puede asignar valores a varias variables a la vez (consulte los operadores de asignación para obtener más detalles)

  En una declaración de asignación de secuencia, el lado izquierdo del signo igual son múltiples variables representadas por tuplas o listas, y el lado derecho del signo igual son datos representados por secuencias como tuplas, listas o cadenas. Python asigna datos a variables en secuencia.

• Asignación de múltiples objetivos : se refiere al uso de múltiples signos iguales consecutivos para asignar los mismos datos a múltiples variables (consulte el operador de asignación para obtener más detalles)

• Asignación mejorada : se refiere a una declaración de asignación que combina operadores y asignaciones (consulte operadores de asignación compuesta para obtener más detalles)

  Código de muestra:

  a = 5
  a += 10
  print(a)
  # 输出：15
  

tipo de datos

Los seis tipos de datos principales de Python son los siguientes:

• Números : int (tipo entero), long (tipo entero largo), complex (número complejo), float (tipo punto flotante), bool (tipo booleano);

  • Tipo entero:

    • Enteros decimales : por ejemplo, 0, -1, 9, 123
    • Entero hexadecimal : se requieren 16 dígitos 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f para representar el número entero, que debe comenzar con 0x . como 0x10, 0xfa, 0xabcdef
    • Entero octal : solo se necesitan 8 dígitos 0, 1, 2, 3, 4, 5, 6, 7 para representar el número entero, que debe comenzar con 0o , como 0o35, 0o11.
    • Entero binario : solo se necesitan dos números 0 y 1 para representar el número entero, que debe comenzar con 0b , como por ejemplo 0b101, 0b100

  • Número de coma flotante:

    • Forma de punto decimal: 0,0, -1,34, -99.
    • Notación científica: 23e4, 78e-4, 3.5E7

  • plural:

    Un número complejo consta de una parte real y una parte imaginaria. En el lenguaje Python, generalmente se representa por a+bj o complejo (a,b), donde a representa la parte real del número complejo, b representa la parte imaginaria. del número complejo, y la parte real a y la parte imaginaria del número complejo b son todos tipos de punto flotante.

• Cadena : "Python", 'Python'

• Lista : [1, 2, 3, 4], [5,6,7, [8,9], 10]

• Diccionario (abreviado como dict) : {1: “estudio”, 2: “Python”}

• Tupla : (1, “shuai”, 2)

• 集合(Conjunto) :{'P', 'y', 't', 'h', 'o', 'n'}

Nota:

• Para otros tipos, excepto los numéricos, el valor correspondiente al índice se puede obtener en forma de nombre de variable [índice].

Conversión de tipo de datos

Referencia: Conversión de tipo de datos en Python

conversión de tipo implícita

Conversión de tipo implícita: autocompletar

Al realizar operaciones con dos tipos diferentes de datos, el tipo de datos inferior (entero) se convierte al tipo de datos superior (punto flotante) para evitar la pérdida de datos.

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo
print("Value of num_new:", num_new)

print("datatype of num_int:", type(num_int))
print("datatype of num_flo:", type(num_flo))
print("datatype of num_new:", type(num_new))

conversión de tipo explícita

Conversión de tipo explícita: requiere el uso de funciones de tipo para convertir

Los resultados de las operaciones de tipo entero y de cadena informarán errores y generarán TypeError. Python no puede usar conversión implícita en este caso. Puede usar funciones predefinidas como int(), float(), str(), etc. para realizar una conversión de tipo explícita.

Funciones integradas para la conversión entre tipos de datos :

• int(x [,base]) : convierte x en un número entero

  # 语法：
  class int(x, base=10)
  # base为进制数，默认十进制，若 x 不符合 base 规则，则报错
  
  # 实例：
  print(int(3.6))
  print(int("1001", 2))
  print(int("0xa", 16))
  

  Nota: La conversión de números de punto flotante a enteros se realiza redondeando hacia abajo, no redondeando

• float(x) : se utiliza para convertir números enteros y cadenas en números de coma flotante

  # 语法：
  float([x])
  # x -- 整数或字符串
  
  # 实例：
  str1 = "3.14"
  str2 = 2
  f1 = float(str1)
  f2 = float(str2)
  print(f1, f2)
  

• bool(x) : convierte el parámetro a un valor booleano

  Si el parámetro es "0" o se omite, se devuelve False; en caso contrario, se devuelve True.

  # 实例：
  print(bool())
  print(bool(0))
  print(bool(1))
  print(bool(1.2))
  print(bool(-1))
  print(bool(-1.1))
  print(bool("a"))
  

• str(x) : convierte el objeto en un formato adecuado para la lectura humana y devuelve el formato de cadena de un objeto.

  # 语法：
  str(object='')
  # 
  
  # 实例：
  s1 = 'python'
  s2 = {
        
        'python': 'python.com', 'google': 'google.com'}
  print(str(s1), str(s2))
  

• repr(x) : convierte el objeto en un formulario para que el intérprete lo lea y devuelve el formato de cadena de un objeto.

  # 语法：
  repr(object)
  
  # 实例：
  s1 = 'python'
  s2 = {
        
        'python': 'python.com', 'google': 'google.com'}
  print(repr(s1), repr(s2))
  

• eval(str) : se utiliza para ejecutar una expresión de cadena y devolver el valor de la expresión

  # 语法：
  eval(expression[, globals[, locals]])
  # expression -- 表达式
  # globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象
  # locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
  
  # 实例：
  x,y = 1,2
  e1 = eval('3 * x')
  e2 = eval('pow(2,3)')
  e3 = eval('y+10')
  print(e1, e2, e3)
  

• tupla(s) : convierte una serie iterable (cadena, lista, diccionario, conjunto) en una tupla

  # 语法：
  tuple(iterable)
  
  # 实例：
  l1 = ['python', 'ruby', 'golang', 'java']
  t1 = tuple(l1)
  print(t1)
  

• lista(s) : convierte una tupla o cadena en una lista

  Las tuplas son muy similares a las listas, la diferencia es que los valores de los elementos de las tuplas no se pueden modificar, las tuplas se colocan entre paréntesis y las listas, entre corchetes.

  # 语法：
  list( seq )
  # seq -- 要转换为列表的元组或字符串
  
  # 实例：
  t1 = (123, 'Google', 'Python', 'Taobao')
  l1 = list(t1)
  s1 = "hello"
  l2 = list(s1)
  print(l1, l2)
  

• set(s) : crea un conjunto desordenado de elementos no repetidos, que se puede usar para probar relaciones y eliminar datos duplicados (devolviendo un nuevo objeto de conjunto)

  # 语法：
  set([iterable])，
  
  # 实例：
  l1 = ['a', 'b', 'b', 'c', 'c', 'c']
  s1 = set(l1)
  print(s1)
  

• dict(d) : crea un diccionario

  d debe ser una secuencia de tuplas (clave, valor)

  # 语法：
  dict(**kwarg)
  dict(mapping, **kwarg)
  dict(iterable, **kwarg),
  # **kwargs -- 关键字
  # mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系
  # iterable -- 可迭代对象
  
  # 实例：
  # 传入关键字
  d1 = dict(a='a', b='b', t='t')	
  # 映射函数方式来构造字典
  d2 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
  # # 可迭代对象方式来构造字典
  d3 = dict([('one', 1), ('two', 2), ('three', 3)]) 
  print(d1)
  print(d2)
  print(d3)
  

• complex(real [,imag]) : crea un número complejo con el valor real + imag * j o convierte una cadena o número en un número complejo

  Si el primer parámetro es una cadena, no es necesario especificar el segundo parámetro. .

  # 语法：
  complex([real[, imag]])
  # real -- int, long, float或字符串
  # imag -- int, long, float
  
  # 实例：
  c1 = complex(1, 2)
  c2 = complex(3)
  print(c1,c2)
  

• frozenset(s) : Devuelve un conjunto congelado. Después de congelarlo, no se pueden agregar ni eliminar elementos del conjunto.

  Devuelve un nuevo objeto frozenset.Si no se proporcionan parámetros,se generará una colección vacía de forma predeterminada.

  # 语法：
  frozenset([iterable])
  # iterable -- 可迭代的对象，比如列表、字典、元组等等。
  
  # 实例：
  f1 = frozenset(range(10))
  f2 = frozenset(['h','e','l','l','0'])
  print(f1)
  print(f2)
  

• chr(x) : utiliza un número entero en el rango (256) (es decir, de 0 a 255) como parámetro y el valor de retorno es el carácter ASCII correspondiente al número entero actual.

  # 语法：
  chr(i)
  # i -- 可以是10进制也可以是16进制的形式的数字
  
  # 实例：
  print(chr(0x30), chr(0x31), chr(0x61))   # 十六进制
  print(chr(48), chr(49), chr(97))       # 十进制
  

• ord(x) : la función emparejada de la función chr() (para cadenas ASCII de 8 bits) o la función unichr() (para objetos Unicode)

  Toma un carácter (una cadena de longitud 1) como parámetro y devuelve el valor decimal ASCII correspondiente o el valor Unicode.

  Si el carácter Unicode dado excede el rango de definición de Python, se generará una excepción TypeError.

  # 语法：
  ord(c)
  # c -- 字符
  
  # 实例：
  o1 = ord('a')
  o2 = ord('b')
  o3 = ord('c')
  print(o1,o2,o3)
  

• hex(x) : se utiliza para convertir números enteros decimales a hexadecimal y se expresa en forma de cadena.

  # 语法：hex(x)
  
  # 实例：
  print(hex(255), hex(-42), hex(1), hex(12), type(hex(12)))
  

• oct(x) : convierte un número entero en una cadena octal. La base octal de la versión Python3.x está representada por 0o como prefijo

  # 语法：oct(x)
  # x -- 整数
  
  # 实例：
  o1 = oct(10)
  o2 = oct(20)
  o3 = oct(15)
  print(o1, o2, o3)