Machine Translated by Google

Tarjeta de referencia rápida de Python 2.4 Estilos: palabra clave función/método tipo replace_expression variable módulo literal module_filename
Tipos
basestring1 bool buffer complex dict archivo de excepción float frozenset int list long object set slice
©2005­2007 — Laurent Pointal — Licencia CC [por nc sa] language_syntax Notaciones : f(…)→ valor de retorno [x] para una lista de datos x, (x) para una
tupla de datos x, puede tener x{n}→ n veces x datos. str tuple type unicode xrange
CONTENIDO DE LA TARJETA f(…) no devuelve nada (procedimiento) 1
basestring es una superclase virtual de str y unicode.
Variables de entorno.................................. 1 Opciones Copia de contenedores..................................8
Este documento usa una cadena cuando se pueden aplicar Unicode y str .
de la línea de comandos.................. .............1 Anulación de operaciones de contenedores........ .....
Extensiones de archivos ............................... .....1 8 Secuencias................................................ ....8 Listas Funciones
Palabras clave del idioma ........................... 1 y Tuplas........................................... ...8 Operaciones VARIABLES DEL ENTORNO
Las funciones de constructor de tipos integrados son directamente accesibles en los elementos
Elementos integrados ........ ............................................ en Secuencias.......................8
CAJA DE PITÓNOK 1
sin distinción de mayúsculas y minúsculas en módulo → integrados. __import__ abs apply1 callable chr classmethod cmp forzar compilar delattr dir divmod
1 Tipos.... .................................................... ...1 Indexación.............. ......................................8
PYTHONDEBUG 1 enumerar eval execfile filter getattr globals hasattr hash help hex id input intern2 isinstance issubclass
Funciones.................................................. ...... 1 Operaciones en secuencias mutables ....... ..... 8 asignación de archivos = ­d opción de línea de comando
Declaraciones................................................ ....1 Operaciones de anulación de secuencias ............ PITÓNHOME Modificar las ubicaciones de prefijo de bibliotecas estándar de Python y iter len locales map max min oct open ord pow property range raw_input reduce reload repr inverted
Bloques.................................................. ............ 1 8 Asignaciones (diccionarios) ...................... ....8 prefijo exec. Utilice <prefijo>[:<prefijoexec>]. = ­i opción de línea de round setattr sorted staticmethod sum super unichr vars zip Use f(*args,**kargs) en lugar de
Atajos de asignaciones .......................... 1 Consola Operaciones en asignaciones ........................... 8 PYTHONINSPECCIONAR 1 apply(f,args,kargs).
comandos = ­O opción de línea de comandos Directorios donde Python
y Entrada/Salida Interactiva...........1 Objetos, Nombres Anulación de operaciones de asignación ........... .......8 1
PITÓN OPTIMIZAR busca al importar módulos/paquetes. Separador : (posix) o ; (ventanas).
y Espacios de Nombres...........2 Otras asignaciones .......................................... .8 1
Identificadores.................. ..........................2 juegos.................................................. .......... 8 PITONPATO Bajo Windows use el registro HKLM\Sofware\….
2 No utilice interno.
Objetos y nombres, recuento de referencias... 2 Operaciones con conjuntos ..................................
Objetos mutables/inmutables... ....................2 8 Otras Estructuras de Contenedores, Algoritmos 9 DECLARACIONES
Espacios de nombres................... .................. 2 Array.................................................. ..........9
Constantes, Enumeraciones..........................2 Cola................................ ..........................9 Colas PYTHONSTARTUP Una instrucción por línea1 . Puede continuar en la línea siguiente si una expresión o una cadena no está
Archivo para cargar al comienzo de las sesiones interactivas.
Control de caudal.................................................. 2 prioritarias ...................... ................... 9 Li 1
PYTHONUNBUFERED = ­u opción de línea de comandos = terminada (( [ { """ ''' no cerrada), o con \ al final de la línea.
Condición .................................................... ..2 ordenados calle................................................. .9
PYTHONVERBOSE Si se 1
Bucle.................................................. .............2 Herramientas de iteración................................9 ­v opción de línea de comandos
1 Char # comienza los comentarios hasta el final de la línea.
Salida de funciones/métodos ............................... Fecha & Tiempo.................................................. 9 establece en un valor no vacío.
2 Excepciones. .......................................... 2 Tiempo del módulo. .............................................9
aprobar Declaración nula.
Iterable Protocolo..................................................2 Fecha y hora del módulo. .......................................9 OPCIONES DE LÍNEA DE COMANDO
Módulo timeit ........ .....................................9 Otros afirmar expr[,mensaje] La expresión de comprobación de aserción es
Interpretación / Ejecución.... ................... 2 Definiciones
Módulos.......... ............................... 10 pitón [­dEhiOQStuUvVWx] [­c cmd | ­m mod | archivo | ­] [args] ­d Información de verdadera. del nombre[,…] Eliminar nombre → enlace de objeto. imprimir
y uso de las funciones ................. 2 Parámetros / Valor
Archivos ............... ..........................................10 depuración de salida del analizador.
de retorno ..... ....................2 Funciones [>>obj,][expr[,…][,] Escriba expr en sys.stdout2 . exec
lambda.......................... ........... 2 Objetos Objetos de archivo ......... .....................................10 ­E Ignora las variables de entorno. ­h Imprime la ayuda y
expr [en globales [, locales]] Ejecuta expr en espacios de nombres. fct([expr[,…]],
invocables.................................... .....2 Funciones Archivos de bajo nivel ........ ................................... sale. ­i Forzar eldespués
modo interactivo con solicitud
de la ejecución (incluso
del script).
[ nombre = expr[,…]] Llame a cualquier objeto invocable fct con argumentos
de llamada ..........................................2 Funciones 10 Tubos............... .......................................10
Control..................................................2 Archivos en memoria.... ....................................10 [,*args][,**kwargs]) dados (consulte Definiciones y uso de funciones ­ p2).
Decoradores........ .......................................2 Tipos/ Información de archivos ............ ..........................
­O Optimice el código de bytes generado, elimine las comprobaciones de afirmación .
Clases y Objetos... ...................... 3 Definición de 10 Operaciones de la terminal ............... ......... 11 nombre[,…] = expresión Operador de asignación3 .
clase .............................. ..................3 Creación de ­OO Como ­O y elimina las cadenas de documentación.
Archivos Temporales ....................................... .11 1
Opción de división, arg en [antiguo (predeterminado), advertir, advertir, nuevo]. Múltiples declaraciones en la misma línea usando ; separador ­ evitar si no
Objetos ............................... ............3 Relaciones Manipulaciones de rutas ................................ 11 ­Q argumento

de Clases y Objetos .......................3 Manipulación Directorios ........... ..................................... 11 No importe el módulo de definiciones de site.py. necesario.
2
de Atributos ....... ....... ............... 3 Métodos Archivos especiales..............................................11 ­Calle Advierta el uso inconsistente de tabulación/espacio (salida ­tt con error). Escribir en cualquier objeto especificado siguiendo la interfaz de archivo (método de escritura).
especiales ............................... .........3 Protocolo Copiar, Mover, Quitar.................... 11 Archivos ­tu Escriba un espacio entre las expresiones, el retorno de línea al final de la línea, excepto con un nombre
codificados.................... ...................11 Use salida binaria sin búfer para stdout y stderr.
de descriptores ................................3 Copia de final de la parte
,. izquierda, puede ser una expresión contenedora. Si expr es una secuencia de
­T Forzar el uso de literales Unicode para cadenas.
objetos .......................................3 Serialización ............................... ................12 3
Persistencia................................ .............. 12 ­v Seguimiento de importaciones.
Introspección....... .......................................3
Módulos y Paquetes....... .....................3 Codificaciones Archivos de configuración ............................... ..12 ­V Imprima el número de versión y salga. múltiples valores, puede descomprimirse en múltiples nombres. Puede tener múltiples asignaciones
de origen .......................... ............ 3 Atributos Excepciones................................................12 Clases ­Warg Emitir advertencia para arg "acción: mensaje: categoría: módulo: lineno" del mismo valor en la misma línea: a = b = c = expr.
Especiales.................................... ....3 Parámetros de excepción estándar...........12 ­X Omita la primera línea de la fuente (fuera de las formas no Unix de #!cmd). ­c Otras declaraciones (bucles, condiciones...) introducidas en las partes respectivas.
principales de ejecución/secuencia de comandos........ Advertencias.................... ..........................12 cmd Ejecuta cmd. ­m mod Busca mod de módulo en sys.path y lo ejecuta como script principal. bloques
3 Operadores.................................. .................... 4 Procesamiento de excepciones .................. ........
Prioridad ............................... ......................... 4 12 Codificación ­ Decodificación ........................... 12
file Archivo de secuencia de comandos de Python para ejecutar. A : entre declaraciones define declaraciones dependientes, escritas en la misma línea o escritas en la(s)
Operadores aritméticos ...................... ........... 4 Subprocesos y sincronización ..... .............. 12 siguiente(s) línea(s) con sangría más profunda.
Operadores de comparación .......................... 4 Funciones de enhebrado ............................. 12 sys.argv[1:]. Argumentos de línea de comandos para cmd/file, disponibles en args
Los bloques de declaraciones son simplemente líneas en el mismo nivel de sangría.
Operadores como funciones. .............................4 Hilos................................................. ...13 Exclusión
if x<=0 : devuelve 1 if asin(v)>pi/
Booleanos ............... .............................. 4 Mutua......................................13
Números................. ..........................4 Eventos.... .................................................... 13 4 : a = pi/2 b = ­pi/2 else : a =
EXTENSIONES DE ARCHIVOS
Operadores................ ....................................4 Semáforos...................................................13 asin(v) b = pi/2­a Las
Funciones.............. ...................................... 4 bits Variables de condición .............. ....................13 .py=fuente, .pyc=bytecode, .pyo=bytecode optimizado, .pyd=módulo binario, .dll/.so=biblioteca líneas de continuación
Operaciones de Nivel..................................5 Colas Sincronizadas........................... ... 13 dinámica. .pyw=fuente asociada a pythonw.exe en plataforma Windows, para ejecutar sin abrir una de sentencia no sangría de
Operadores.............. .....................................5 Proceso.................................................. .....13 Proceso consola. cuidado.
Cuerdas........... ..........................................5 Secuencias actual ............................................. 13 Manejo de
de escape..... .......................... 5 cadenas señales ..........................................14 Control de
Unicode............... ..........................5 Métodos y procesos externo simple ..... .........14 Control PALABRAS CLAVE DEL IDIOMA
funciones.................... ...........5 avanzado de procesos externos .........14 Para evitar problemas, configure su editor para usar 4 espacios en lugar de tabulaciones.
Formateo ............................................. ............. 5 Procesamiento de XML......................... ............. 15 Lista de palabras clave en la palabra clave del módulo estándar. y
Constantes.................................. ................6 SAX ­ Impulsado por eventos.................... ....15 as1 afirmar romper clase continuar def del elif más excepto exec finalmente para desde global si importar Accesos directos de tareas a += ba
Expresiones Regulares ............................... ... 6 DOM ­ Árbol en memoria ............................. 16 en es lambda no o pasar imprimir aumentar devolver intentar mientras rendimiento
Localización.................................................. ...6 Bases de datos ......... .................................. 17 Acceso ­= ba *= ba //= ba %= ba
ba ^=
**=bba &= ba |= un / = segundo

Soporte multilingüe......................................7 genérico a bases de datos estilo DBM ...... ...... 17 1

Contenedores....... ..........................................7 no reservado, pero evita redefinirlo.
API de base de datos estándar para bases de un >>= segundo un <<= segundo

Operaciones en Contenedores...... .....................7 datos SQL........ 17 Bulk........................... ............................. 17No redefina estas constantes: Ninguno, Verdadero, Falso.
Evalúe a una vez y asigne a a el resultado del operador antes = aplicado a a y b actuales. Ejemplo:
EDIFICIOS
a%=b ≈ a=a%b
Disponible directamente en todas partes sin importación específica. Definido también en el módulo
CONSOLA Y ENTRADA/SALIDA INTERACTIVA
__builtins__.
imprimir expresión[,…]

1a 1b 1c
Machine Translated by Google

input([prompt]) → evaluación de la entrada del usuario (datos escritos) métodos). Generadores

raw_input([prompt]) → str: entrada del usuario como una cadena sin Los espacios de nombres se pueden anidar, los espacios de nombres internos ocultan nombres Funciones que conservan su estado entre dos llamadas. Devolver valores usando yield. Detenga
formato Manipulación directa (redefinición) de stdin/stdout/stderr a través del módulo sys: sys.stdin idénticos de los espacios de nombres externos. dir([objeto]) → lista: nombres definidos en el espacio la generación mediante un simple retorno o mediante un aumento de StopIteration.
sys. __stdin__ Todos son archivos
sys.stdout
u objetos similares asys.stderr
archivos. Los formularios __xxx__ 1
de nombres del objeto vars([objeto]) → dict2 : identificador:valor del objeto como un espacio de 1) generar generador a partir de la función: gen=generatorfct(args) 2) usar
mantienen el acceso a los flujos
sys.__stdout__
de E/S estándar
sys.__stderr__
originales. nombres1 si el objeto no se especifica, use el espacio de nombres más cercano (locales). no debe valores gen.next() hasta que se genere StopIteration .
1
ser modificado.
2 Generador de expresiones iterables con: (x for x in iterable where cond)
Ctrl­C genera la excepción KeyboardInterrupt . → valor de Operaciones con/en Iterable
Constantes, Enumeraciones Use
_ la ayuda de evaluación de la última expresión ([objeto])
_ para identificadores
mayúsculas y espacios de nombres para de constantes (buena práctica). puede definir Consulte Operaciones en contenedores (p7).
imprimir documentación en línea sys.displayhook → (rw)
agrupar constantes. No se puede evitar la redefinición de nombres globales/locales
fct(value) llamado para mostrar el valor sys.__displayhook__ → copia de Consulte Herramientas de iteración (p9).
(eventualmente se pueden definir espacios de nombres como clases con atributos de
seguridad de la función original de displayhook sys.ps1 → str: intérprete primario INTERPRETACIÓN / EJECUCIÓN
control de acceso, no en el espíritu de Python y el costo de ejecución).
de aviso sys .ps2 → str: mensaje de intérprete secundario (continuación) Consulte
Consulte los módulos de terceros pyenum para obtener un espacio de nombres similar a una enumeración estricta.
el paquete externo ipython para obtener un shell de Python interactivo mejorado. compile(string1,filename,kind2 [,flags3 [,dont_inherit3 ]]) → code object
CONTROL DE FLUJO eval(expression[,globals[,locals]]) → value: evaluación4 de expresión string
4
eval(code_object[,globals[,locals]]) → valor: evaluación exec5 sentencias [en
deglobales[,locales]]
código_objeto
OBJETOS, NOMBRES Y ESPACIOS DE NOMBRES Condición Bucle sentencias cadena1 ejecutadas4 execfile(nombre de archivo[,globales[,locales]]) archivo
si cond : inst nombre de archivo interpretado4
Identificadores para var[,…] en iterable : inst
[ elif cond : inst ] [ else : 1
[ más : insta ] Las declaraciones de varias líneas en el código fuente deben usar \n como nueva línea y deben
Uso: [a­zA­Z_][a­zA­Z0­9_]* Uso inst ]
while cond : inst No ser terminado por una nueva línea.
especial para guión bajo: global no 2
hay 'interruptor' o 'caso'. [ más : insta ] Tipo relativo al contenido de la cadena, 'exec' → secuencia de declaraciones, 'eval' →
implementación,importado
para uso por importación
interno * _xxx detalle
(buena práctica) _xxx de Se puede usar if elif elif… else. expresión única, 'single' → declaración interactiva única.
miembros
__xxx__ normalmente de clasepor
reservado 'privados',
Python Eldefinidos
caso escomo _ClassName__xxx
significativo: This_Name __xxx
!= Salir del bucle con descanso.
3
Puede usar una asignación con Flags y dont_inherit son para declaraciones futuras (ver doc).
THIS_NAME. vinculadas a los casos. Ir a la siguiente iteración con continuar. funciones 4
En el contexto de espacios de nombres globales y locales.
5
Los bloques de bucles solo se ejecutan cuando el Exec es una declaración de idioma, otras son funciones integradas.
bucle sale normalmente (sin interrupción). FUNCIONES DEFINICIONES Y USO
Los objetos y nombres, los datos de conteo de referencia son
Funciones/métodos exit Salir de
objetos escritos (todos los datos), los nombres se vinculan dinámicamente a los objetos. = def fctname([ paramname [ = valor predeterminado ][,…]] [,*args][,**kwargs]) :
función/método con retorno [valor] instrucciones
instrucción de asignación vincular el resultado de la evaluación de la parte derecha con
los nombres/contenedores de la parte izquierda. Ejemplos: Salir del cuerpo del generador con valor de rendimiento new.function(code,globals[,name[,argdefs]]) → función python (ver documentos)
Múltiples valores devueltos utilizando datos de tupla .
Parámetros / Valor de retorno Los
a = 3*c+5 a,b = ("Hola","Mundo") pi,e = 3.14,2.71 x,y,tabz[i] = fct(i) a,b = b,a No se puede ceder dentro de un bloque try/finally.
s = "Hola" parámetros se pasan por referencias a objetos.
Prueba de
Puede modificar valores de tipos de objetos mutables.
Cuando ya no se hace referencia a un objeto (por nombres o contenedores), se destruye ( entonces excepciones : inst No puede modificar valores de tipos de objetos inmutables, como si se pasaran por valor.
se llama a su método __del__ ). excepto [ except_class [ , valor ]] : instante
… Notación * → lista de variables de parámetros anónimos en una tupla.
sys.getrefcount(objeto)→ int: contador de referencia actual del objeto
[ más : insta ] Notación ** → lista de variables de parámetros con nombre en un dict.
El módulo estándar débil ref define herramientas para permitir que los objetos se recopilen
Puede tener una tupla de clases para except_class. No especificar una clase para capturar Valor(es) devuelto(s) con retorno [valor[,…]]
como basura cuando sea necesario y se vuelvan a crear dinámicamente bajo demanda. todas las excepciones. Para valores múltiples, devuelve una tupla. Si no se especifica un valor de retorno o si se alcanza el
Objetos mutables/inmutables Los objetos El bloque se ejecuta de otra manera cuando intenta salir del bloque final de la definición de la función, devuelva el valor Ninguno .
mutables se pueden modificar en su lugar. Los objetos inmutables no se pueden modificar (debe normalmente. intente : inst finalmente : inst El proceso finalmente funciones lambda
crear un nuevo objeto con un nuevo valor). bloquea todas las rutas de ejecución (normal o de excepción).
lambda param[,…] : expresión Funciones
Inmutable : bool, int, long, float, complex, string, unicode, tuple,
conjunto congelado, búfer, rebanada. aumentar clase_excepción[,valor[,retroceso]] aumentar objeto_excepción aumentar Última anónimas definidas en línea. Se devuelve el resultado de la evaluación de la expresión (debe
forma volver a generar la excepción capturada actualmente en un controlador de excepciones. ser una expresión, sin bucle, sin condición).
Mutable : list, set, dict y otros objetos de clase de alto nivel.
La expresión usa valores conocidos en el momento de la definición (excepto para los parámetros).
No hay una definición constante. Simplemente use nombres en mayúsculas para identificar
símbolos que no deben modificarse. Objetos invocables

Espacios de Los objetos que tienen un método __call__ se pueden usar como funciones.
Los métodos vinculados a objetos se pueden usar como funciones: f = o.meth
nombres Lugares donde Python encontró nombres. Protocolo iterable callable(x) → bool: test x callable with x(…)
Espacio de nombres incorporados → nombres del módulo __builtins__, ya
disponible. Protocolo genérico y simple que permite iterar sobre cualquier colección de datos.
funciones de llamada
Espacio de nombres global → nombres definidos a nivel de módulo (sangría cero). Los objetos de clase que definen __iter__ o __getitem__ son iterables (directamente utilizables en
[nombre=] fctname([expr[,…]][,name=expr[,…][,*args][,**args])
bucles for ). __iter__(self) → iterador en sí mismo iter(objeto) → iterador en objeto iterable
Espacio de nombres local → nombres definidos en métodos/funciones. del Parámetros anónimos pasados en la declaración de orden de parámetros.
iter(invocable,centinela) → iterador que devuelve valores invocables() hasta enumerar
nombre elimina el nombre existente del espacio de nombres (elimina la vinculación de Se pueden omitir los parámetros que tienen un valor predeterminado.
centinela(iterable)→ iterador que devuelve tuplas (índice,valor) de iterable
objetos) globals() → dict: identificador→valor del espacio de nombres global locales() → dict: Notación * → pasa la lista de variables de parámetros anónimos en una tupla.
identificador→valor del espacio de nombres local Ámbito actual → nombres directamente Notación ** → pasa la lista de variables de parámetros con nombre en un dict.
Control de funciones
utilizables. Se buscó en locales, luego locales de definiciones adjuntas, luego globales, luego
Interfaz de objetos de iteradores
incorporados. sys.getrecursionlimit()→ int: límite de recurrencia actual para funciones
Nombre fuera del alcance → use la notación de atributo con puntos xy (quizás xyzt)... donde next(self)→ next item1 sys.setrecursionlimit(limit) establecer límite de recurrencia para funciones
x es un nombre visible dentro del alcance actual. __iter__(self)→ objeto iterador en sí mismo
1 Decoradores
Cuando llegue al final de la colección, genere la excepción StopIteration en las llamadas
Espacio de nombres de clase → nombres definidos en una clase (miembros de clase). Pegue el código (funciones) llamado en el momento de las definiciones de funciones y métodos,
subsiguientes (es decir, el iterador solo se puede usar una vez en una colección).
Espacio de nombres de objetos → nombres utilizables con la notación object.name (atributos, devuelva la función/método final (generalmente con código de ajuste).

2a 2b 2c
Machine Translated by Google
1
@ nombredecorador [( argumentos_decorador )] […] def Si no devuelve un objeto classref, se llama a object.__init__ con initargs. Ejemplo de atributos de introspección
fct(argumentos_fct):… Nota: ¡las clases también son objetos!
@dec1 @dec2(argumentos) @dec3 def fct(…):… fct = Reparto de objetos __base__ → lista: clases principales de una clase __slots__
def fct(…):… Me dec1(dec2(args)(dec3(fct)))) → tupla: nombres de atributos de objetos permitidos1 de una clase __class__ → clase/
__repr__(self)→ str: pidió repr(self) y `self` __str__(self) → str: pidió str(self) y print
self __coerce__(self,other) → value, pidió coerce(self,other) tipo: clase de objeto __dict__ → dict: atributos definidos (espacio de nombres del objeto)
gusta Consulte la página PythonDecoratorLibrary en python.org Wiki para ver algunas de una instancia __doc__ → cadena: cadena de documentación de un paquete , módulo, clase,
definiciones de decoradores.
función → str: definición de objeto nombre de una función __name__
Clave hash de objeto
TIPOS/CLASES Y OBJETOS Todos los datos
__hash__(self)→ int: código hash de 32 bits para el objeto, usado para hash(obj) y comparación rápida __file__ → cadena: ruta del módulo cargado .pyc, .pyo o .pyd Lista de nombres de
son objetos tipificados que se basan en clases. tipo(o) → tipo: de claves de mapeo de dictado ­ implementación predeterminada usa hash(id(self)) 1
atributos permitidos. Uso desaconsejado.
objeto de tipo de o Los tipos de módulos estándar definen objetos
de tipo para tipos incorporados. Acceso a los atributos
MÓDULOS Y PAQUETES
Definición de clase
Véase también "Protocolo de descriptores" infra.
class classname [(parentclass[,…])] : varname = expr Archivo gabuzo.py módulo gabuzo.
__getattr__(self,name)→ valor, llamado para atributos no definidos __getattribute__(self,
varname definido en el espacio de nombres classname def metname(self[,…]): Directorio kramed/ con un archivo __init__.py paquete kramed.
nombre)→ value, siempre llamado __setattr__(self, name, value) llamado para
define métodos como funciones Admite herencia múltiple. Puede heredar de la Puede tener subpaquetes (subdirectorios que tienen el archivo __init__.py ).
obj.name=value __delattr__(self, name) llamado para del obj.name __call__(self, *args,
clase incorporada. Buscado en el PATH de Python.
**kwargs)→ value, llamado para obj(…)
RUTA Python actual almacenada en la lista sys.path . Contiene directorios y rutas de archivos .zip.
Heredar al menos de la clase base del objeto => Python 'nueva clase de estilo'.
Construido a partir de la ubicación de los módulos Python estándar, la variable de entorno
El primer parámetro de los métodos es el objeto de destino, el nombre propio de uso estándar .
Método estático / Método de clase PYTHONPATH, el directorio del módulo principal proporcionado en la línea de comando, los datos
Acceda a los miembros de la clase a través del nombre de la clase, a los miembros del objeto a través de sí mismo.
Use decoradores estándar (ver Decoradores p2). clase ClassName : especificados en las líneas de los archivos .pth que se encuentran en el directorio de inicio de Python y
Este documento considera que usa una nueva clase de estilo (heredando del objeto).
@staticmethod def nombremétodo(…): … @classmethod def los datos especificados en el registro en Windows .
new.classobj(name,baseclasses,dict) → nueva clase (ver documentos)
nombremétodo(classref,…): … Lista actual de módulos cargados almacenados en el mapa sys.modules (el módulo principal está bajo la
new.instancemethod(fct,instance,class) → nuevo método: vinculado a la instancia no es Ninguno, ver
clave __main__). módulo de importación [ como alias ] [,...] del módulo nombre de importación [ como
documentos
alias ] [,...] del módulo importar * recargar (módulo) el módulo se vuelve a cargar (pero las referencias
metaclase existentes aún se refieren al contenido del módulo antiguo) nuevo.módulo (nombre [ ,doc]) → nuevo objeto
La definición de clase crea un nuevo tipo. Se puede hacer 'a mano' con: x = type('classname', de módulo.
Protocolo de descriptores
( parentclass ,[…]),{varname:expr[,…]} def metname(self[,…]):
Los descriptores son objetos de atributos que controlan el acceso a los valores de los atributos.
Deben definir algunos de los siguientes métodos:
x.metname = metname Esto
__get__(self,obj,ownerclass)→ valor de atributo para obj __set__(self,obj,value)
permite la creación de una clase de metaclase (clase que construye otra clase). La importación puede usar la ruta del paquete (por ejemplo, desde la importación de codificación.alias …).
modificar atributo en obj, establecer valor __delete__(self,obj) eliminar atributo de
Importación directa desde un paquete de definiciones de uso del archivo __init__.py .
Creación de objetos obj obj In estos métodos self es el objeto descriptor, y obj es el objeto de destino cuyo
Mucho cuidado con import * ya que los nombres importados anulan los nombres ya definidos.
= ClassName(initargs…) atributo se manipula.
En caso de excepción durante la inicialización, el objeto se destruye al salir del código de inicio
Para limitar los nombres de sus módulos exportados y visibles por importación *, defina el módulo global
(el contador de referencia llega a cero). new.instance(class[,dict]) → objeto: crea una nueva
Propiedades __all__ con la lista de nombres exportados (o use nombres globales _xxx).
instancia de clase sin llamar al método __init__ , dict son los atributos iniciales del objeto Clases y
Un descriptor para vincular directamente métodos/funciones para controlar el acceso a los
objetos Relaciones isinstance(obj,classinfo) → bool: prueba el tipo de objeto de tipo/clase classinfo
atributos. Use la propiedad de tipo incorporada con argumentos de inicio. class MyClass : nombre Consulte la función incorporada __import__ y los módulos imp, ihooks.
issubclass( aclass,aparent) → bool: prueba la misma clase o relación principal. Prefiere del atributo = propiedad (captador, definidor, eliminador, descripción) __import__(nombre_módulo[, globales[,locales[,lnameslist]]])
isinstance() a type() para la verificación de tipos.
Codificaciones de origen
Cada argumento inicial está predeterminado en Ninguno (es decir, indefinido). Consulte PEP 263. Declare la codificación de los archivos de origen en la primera o segunda línea en
Asignación de objetos de un comentario especial. # ­*­ codificación: encoding_name ­*­ Si no se especifica, Python usa el
Los métodos de la clase principal no se llaman automáticamente si se anulan en la subclase; valor sys.getdefaultencoding() (consulte los módulos sitecustomize.py y user.py).
copia solo referencias duplicadas. Para realizar una copia superficial de un objeto (construir uno nuevo con
deben llamarse explícitamente si es necesario.
los mismos valores, haciendo referencia al mismo contenido), o para realizar una copia profunda de un
Llame a los métodos principales a través de la superfunción :
objeto (contenido de referencia de copia profunda), consulte los métodos y funciones de copia de objetos
super(ThisClass,self).methodname(self,args…) Es importante especificar la codificación de sus módulos, ya que las cadenas u"…" la utilizan para
en la copia de módulo estándar . copy.copy(objeto)→ valor: copia superficial del objeto
O a la antigua, a través del espacio de nombres de la clase construir correctamente los literales Unicode.
copy.deepcopy(objeto[[,memo],_nil])→ valor: copia profunda del objeto
principal: ParentClass.methodname(self,args…) 1
Atributos especiales → str:
1
Manipulación de atributos objeto.nombre Params memo y nil se usan en copia profunda recursiva, su valor predeterminado nombre del módulo, '__main__' para la línea de comandos llamada script __name__
= valor setattr(objeto,nombre,valor) atributo los valores son Ninguno y lista vacía. __file__ → cadena: nombre de ruta del módulo compilado cargado
del objeto establecido en valor objeto.nombre → valor del atributo del objeto Protocolo de copia
PARÁMETROS PRINCIPALES DE EJECUCIÓN / SCRIPT
getattr(objeto,nombre[,predeterminado])→ valor del atributo del objeto del
__copy__(self)→ valor: copia superficial de sí mismo, llamada por copy.copy(…)
objeto.nombre delattr( objeto, nombre) atributo de objeto eliminado El módulo 'principal' es el módulo llamado a través de la línea de comandos (o ejecutado por shell con la
__deepcopy__(self,memo)→ valor: copia profunda de sí mismo, llamada por copy.deepcopy(…)
primera línea de script #! /bin/env python).
Los parámetros de la línea de comandos están disponibles en sys.argv (una lista de python).
Para copiar, los objetos también pueden definir el protocolo de decapado (ver Archivos ­
Al final del módulo, podemos tener: if
Métodos especiales Otros Serialización ­ p12), en lugar de __copy__ y __deepcopy__.
__name__=='__main__': # código principal #
métodos __xxx___ anulables especiales se enumeran en las secciones respectivas. Introspección Más generalmente llamar a una función
'principal': mainfunction(sys.argv[1:]) # o en módulos lib,
allá de esta documentación. Se definen muchos atributos __xxx___ , algunos se pueden escribir (ver otros
Object Life documentos). ejecutar código de prueba/demostración ...

__new__(classref,initargs…)→ objeto de tipo classref, ya inicializado1 __init__ (self,initargs…) Consulte la inspección del módulo estándar para manipular estos datos.
La ejecución sale después de la última instrucción del módulo principal (en subprocesos múltiples,
llamado para inicializar el objeto con initargs __del__ (self) llamado cuando el objeto será destruido
espere también el final de los subprocesos que no son demonios), a menos que se fuerce el modo interactivo.

3a 3b 3c
Machine Translated by Google

Puede forzar la salida llamando a sys.exit(code), lo que genera una excepción SystemExit ; Operadores como funciones Los long(expr[,base=10]) → long: conversión de expr
consulte Proceso actual ­ Salir (p13). operadores también se definen como funciones en el módulo de operador estándar . Tipos de punto flotante incorporados: flotante (como C doble), complejo (las partes
reales e imaginarias son flotantes). float(expr) → float: representación de expr
OPERADORES Comparación
complejo(x[,y]) → complejo: número: x+yj [x+]yj → complejo: número, ej: 3+4j ­8.2j
Trate con la aritmética, la lógica booleana, el nivel de bits, la indexación y el corte. lt(a,b) = __lt__(a,b) le(a,b) = ne(a,b) = __ne__(a,b) ge(a,b) c.real → float: real parte del número complejo c.img → float: parte imaginaria del número
__le__(a,b) eq(a,b) = = __ge__(a,b) gt(a,b) = complejo c.conjugate() → complejo: conjugado del número complejo (real,­img)
Prioridad
__eq__(a,b) __gt__(a,b)
1 ( a ,[...
a ), ... ] { a : 6x+ 11 x < yx <= yx > yx >= yx == yx != yx <> yx
` ` Lógico / Booleano
b , ... } … yx ­ y es yx no es yx en sx no en s
not_(o) = __not__(o) verdad(o) y_(a,b) = __y__(a,b) o_(a,b) =
Máximo int entero en sys.maxint.
12 no x __o__(a,b) xor(a,b) = __xor__(a,b)
2 s [ yo ] s [ yo : j ] 7 x<<yx Conversiones automáticas entre tipos numéricos.
>> y es_(a,b)
s . atributo f ( ... ) Conversiones automáticas de int a long cuando el resultado desborda max int.
no_es(a,b)
3+x­x~x 8xey 13 x e y Conversiones directas de/a cadenas de/a int, long… a través de constructores
Aritmética de tipos.
4 x ** año 9x ^ 14 x o y
abs(o) = __abs__(o) truediv(a,b) = __truediv__(a,b) floordiv(a,b) = Tipo Decimal definido en el módulo estándar decimal.
5 x * yx / yx % y y10x | _ y 15 argumentos lambda : expr Matrices de almacenamiento compactas de tipo fijo base en matriz de módulos estándar.
suma(a,b) = __sum__(a,b) __floordiv__(a,b) neg(o) = __neg__(o) pos(o) =
Operadores aritméticos Se sub(a,b) = __sub__(a,b) mul(a,b) __pos__(o) pow(a,b) = __poder__(a,b) Operadores
pueden definir para cualquier tipo de datos. = __mul__(a,b) div( a,b) = 1
­x +x x+y xy x*y x/y x%y Con división 1
x//yimportada 2
x**y 2
__div__(a,b) mod(a,b) = 1
de __futuro__ , / es división verdadera (1/2→0.5), y // es división de piso (1//2→0) . De
Sobreescritura aritmética
__mod__(a,b) lo contrario, para números enteros / sigue siendo una división de piso. % es el operador
__add__(self,other) → valor: llamado para sí mismo + otro Nivel de bits 2
restante, ** es el operador de elevación de potencia (igual que pow).
__sub__(self,other) → valor: llamado para sí mismo ­ otro
lshift(a,b) = __lshift__(a,b) rshift(a,b) = Funciones
__mul__(self,other) → valor: llamado para sí mismo * otro
__rshift__(a,b) inv(o) = invertir(o) = Algunas funciones incorporadas.
__div__(self,other) → valor: llamado1 para uno mismo / otro
__truediv__(yo,otro) → valor: llamado2 para uno mismo / otro __inv__(o) = __invertir__(o) abs(x) → valor absoluto de x
__floordiv__(yo,otro) → valor: llamado para uno mismo // otro __mod__(uno Secuencias divmod(x,y) → (x/y,x%y) oct(entero)
mismo,otro) → valor: llamado para uno mismo % other __divmod__(self,other) → str: representación octal del número entero hex(entero) → str:
concat(a,b) = __concat__(a,b) contiene(a,b)
→ valor: llamado para divmod(self,other) __pow__(self,other) → value: llamado representación hexadecimal del número entero Representación funciones de
= __contiene__(a,b) cuenta(a,b) indexOf(a,b)
para self ** other __nonzero__(self)→ value: llamado para nonzero(self) formateo en cadenas Formateo (p5) y Localización (p6).
repite(a,b) = __repetir__(a,b ) ) setitem(a,b,c) =
__neg__(self) → valor: llamado para ­self __pos__(self) → valor: llamado para __setitem__(a,b,c) getitem(a,b) = __getitem__(a,b)
+self __abs__(self) → valor: llamado para abs(self) __iadd__(self,other) Funciones Matemáticas
delitem(a,b) = __delitem__(a,b) setssegmento(a,b,
llamado para self += other __isub__(self,other) llamado para uno mismo ­= Funciones/datos estándar de coma flotante en el módulo matemático estándar .
c,v) = __setslice__(a,b,c,v) obtieneslice(a,b,c) =
otro __imul__(yo, otro) llamado para uno mismo *= otro __idiv__(yo, otro)
__getslice__(a,b,c) delslice(a,b,c) = acos(x) → float: ángulo en radianes para el valor de x coseno: [­1…1] →[0…π]
llamado1 para uno mismo /= otro __itruediv__(yo, otro) llamado2 para uno
__delslice__(a,b,c) asin(x) → float: ángulo en radianes para el valor de x seno: [­1…1] →[­π /2…+π/2]
mismo /= otro __ifloordiv__(yo, otro) llamado por uno mismo //= otro __i
atan(x) → float: ángulo en radianes para el valor de la tangente x: [­∞…∞] →]­π/2…+π/
mod__(self,other) llamado por uno mismo %= otro __ipow__(self,other)
2[ atan2(x,y) → float: randians ángulo para el valor de la tangente x/y ceil(x) → float: valor
llamado por uno mismo **= otro
integral más pequeño >= x cos(x) → float: valor del coseno para el ángulo en radianes x
Pruebas de tipo cosh(x) → float: valor del coseno hiperbólico para el ángulo en radianes x exp(x) ) →
Estas funciones deben considerarse como no fiables. float: exponencial de x = ex fabs(x) → float: valor absoluto de x floor(x) → float: mayor
esMappingType(o) esNumberType(o) esSequenceType(o) valor integral <= x fmod(x,y) → float: modulo = resto de x/y freexp (x) → (float,int): (m,y)
1 sin / 2
con de __futur__ división de importación m mantisa de x, y exponente de x — donde x=m*2y ldepx(x,i) → float: x multiplicado por
Los operadores binarios __xxx__ también tienen formas __rxxx__, llamados cuando el objeto de 2 elevado a i potencia: x * 2i log(x) → float: logaritmo neperiano de x log10(x) → float:
destino está en el lado derecho. Búsqueda de atributos y logaritmo decimal de x modf(x) → (float{2}): (f,i) f parte fraccionaria con signo de x, i con
Operadores de comparación Los elementos attrgetter(attr) → fct: where fct(x)→x.attr signo parte entera de
operadores pueden comparar cualquier tipo de datos. itemgetter(item) → fct: where fct(x)→x[item]
Compara valores con < <= > >= == != <>.
Probar la identidad de los objetos con is y not is (comparar con id(obj)). BOOLEANOS
Se permite la composición directa de comparadores en expresiones: x<y<=z>t. Falso: Ninguno, cero números, contenedores vacíos. Falso → 0.
Función incorporada cmp(o1,o2) → ­1 (o1 < o2), 0 (o1 == o2), 1 (o1 > o2) Verdadero: si no falso. Verdadero
X
Anulación de la comparación → 1. bool(expr) → Verdadero |
Falso Lógico no : no expr Lógico pow(x,y) → float: x elevado a la potencia y (x y )
__lt__(uno mismo, otro)→ bool1 : llamado para uno mismo < otro
y : expr1 y expr2 Lógico o : expr1 o sin(x) → float: valor del seno para el ángulo en radianes
__le__(uno mismo, otro)→ bool1 : llamado para uno mismo <=
expr2 Lógico y y o usar evaluación x sinh(x) → float: valor del seno hiperbólico para el ángulo en radianes x
otro __gt__(uno mismo, otro)→ bool1 : llamado para uno mismo >
de ruta corta. sqrt(x) → float: raíz cuadrada de x (√x) tan(x) → float: valor de la tangente
otro __ge__(uno mismo, otro ) )→ bool1 : llamado para uno mismo
>= otro __eq__(yo, otro)→ bool1 : llamado para uno mismo == Bool Cast Overriding para el ángulo en radianes x tanh(x) → float: valor de la tangente hiperbólica
otro __ne__(yo, otro)→ bool1 : llamado para uno mismo != otro y para el ángulo en radianes x pi → float: valor de π (pi=3.1415926535897931) e
__nonzero__(self) → bool: probar el objeto en sí mismo1
para uno mismo <> otro 1 → float: valor de base de logaritmos neperianos (e=2.7182818284590451)
Si __nonzero__ no está definido, mire __len__, de lo contrario, el objeto es verdadero.
__cmp__(self,other)→ int: llamado por self comparado con otro,
self<otro→valor<0, self==otro→valor=0, self>otro→valor>0 NÚMEROS El módulo cmath proporciona funciones similares para números complejos .
1
Cualquier valor utilizable como valor booleano, o un valor NotImplemented si no se Tipos de enteros integrados: int (como C long), long (entero ilimitado) Números al azar
puede comparar con ese otro tipo. int(expr[,base=10]) → int: conversión de expr Funciones de aleatorización en módulo aleatorio estándar . Funciones del módulo

4a 4b 4c
Machine Translated by Google

use un generador de tipo aleatorio oculto y de estado compartido (distribución uniforme). __irshift__(self,other) llamado por uno mismo >>= otro La mayoría de los métodos de cadena también están disponibles como funciones en el módulo
de cadena estándar . s.capitalize() → cadena con el primer carácter en mayúscula 1
INSTRUMENTOS DE CUERDA

Funciones también disponibles como métodos de objetos aleatorios . seed([x]) s.center(ancho[,fillchar]) → cadena centrada s.count(sub[,start[,end]]) → int: contar sub
inicializa el generador de números aleatorios random()→ float: valor "Hola" entre comillas simples o "Hola" entre comillas dobles . ocurrencias s.decode([codificación [,errores]]) → unicode: texto decodificado ­ ver codificaciones
aleatorio en [0.0, 1.0[ randint(a,b)→ int: valor aleatorio en [a, b] uniform(a, b)→ Use comillas triples [simples | dobles] para cadenas de varias líneas: """Hola, (p12) s.encode([codificación[,errores]]) → str: texto codificado ­ ver codificaciones (p12)
float : valor aleatorio en [a, b[ getrandbits(k)→ long: con k bits aleatorios ¿cómo está?""" s.endswith(suffix[,start[, end]]) → bool: texto de prueba que finaliza s.expandtabs([tabsize]) →
randrange([start,]stop[,step])→ int: valor aleatorio en range(start, stop, step) cadena con tabulaciones reemplazadas por espacios s.find(sub[,start[,end]]) → int/­1:
choice(seq) → valor: elemento aleatorio de la secuencia secuencial Las cadenas son inmutables (una vez creada, una cadena no se puede modificar en su lugar). compensación de sub s. index(sub[,start[,end]]) → int: desplazamiento de sub ­ puede generar
shuffle(x[,rndfct]) elementos de x reordenados aleatoriamente usando rndfct() muestra(población,k)→ ValueError s.isalnum() → bool: cadena no vacía con todos los caracteres alfanuméricos s.isalpha()
lista: k elementos aleatorios de la polución Distribuciones aleatorias alternativas: Las cadenas pueden contener datos binarios, incluidos caracteres nulos (caracteres de código 0). → bool: cadena no vacía con todos alfabético chars1 s.isdigit() → bool: cadena no vacía con todos
betavariante(alfa,beta) , expovariable(lambd), gammavariante(alfa,beta), gauss(mu,sigma), Las cadenas son secuencias, consulte Indexación (p8) para la indexación de caracteres los dígitos chars1 s.islower() → bool: cadena no vacía con todos los chars1 inferiores s.isspace()
(segmentación) y otras operaciones. chr(código)→ str: cadena de un carácter ord(char)→ int: → bool: cadena no vacía con todos los espacios chars1 s.istitle () → bool: cadena no vacía con
lognormvariante(mu, sigma), normalvariante(mu,sigma), vonmisesvariante(mu,kappa),
código str(expr)→ str: representación textual legible de expr ­ si está disponible `expr` → str: 1
paretovariante(alfa), weibullvariante(alfa, beta). palabras en mayúsculas1 s.isupper() → bool: cadena no vacía con todos los caracteres superiores1
representación textual legible de expr ­ si está disponible repr( expr)→ str: representación textual
s.join(seq) → cadena: seq[0]+s+seq [1]+s+…+seq[n­1] s.ljust(width[,fillchar]) → cadena de texto
evaluable de expr ­ si está disponible
alineada a la izquierda2 s.lower() → cadena de texto rebajada1 s.lstrip([chars]) → cadena de texto
con encabezado chars2 eliminado s.replace(old,new[,count]) → cadena con count firsts old
reemplazada por new s.rfind(sub[,start[,end]]) → int/­1: última compensación de sub s.rindex
Secuencias de escape \a ­ (sub[,start[end]])→ int: último desplazamiento de sub ­ puede generar ValueError
Generador aleatorio alternativo Clase WichmannHill . campana \b ­ retroceso \e ­ escape \v ­ tabulador vertical s.rjust(width[,fillchar]) → texto de cadena alineado a la derecha2 s.rsplit([sep[,maxsplit]])→ [ string]:
Manipulación directa del generador: getstate(), setstate(state), jumpahead(n). \f ­ salto de página \n ­ nueva línea \' ­ comilla simple \" ­ palabras más a la derecha delim. by sep2 s.rstrip([chars]) → cadena con los caracteres finales2
\r ­ retorno de carro \t ­ pestaña comilla doble \\ ­ barra eliminados s.split([sep[,maxsplit]]) → [string]: palabras delimitadas por sep2 s.splitlines([keepends])
En el módulo os, consulte: horizontal invertida \ooo ­ char por → [string]: lista de líneas de texto s.startswith(suffix[,start[,end]]) → bool: texto de prueba que
os.urandom(n) → str: n bytes aleatorios adecuados para uso criptográfico valor octal ooo \xhh ­ char por valor comienza s.strip([chars]) → cadena de texto con los caracteres iniciales y finales eliminados
Otros módulos de matemáticas hexadecimal hh \<nueva línea> ­ continuar cadena s.swapcase() → cadena con mayúsculas y minúsculas conmutado1 s.title() → cadena con palabras
en la línea siguiente. en mayúsculas1 s.translate(table[,deletechars]) → cadena: limpiado, convertido3 s.upper() →
Matriz avanzada, algoritmos y procesamiento de números en módulos de terceros como
cadena superior1 s.zfill(witdh) → cadena: cadena prefijada con ceros para que coincida ancho
numpy (evolución de numarray / Numeric), gmpy (aritmética de multiprecisión), DecInt, scipy, Y para cadenas Unicode: \uxxxx ­
pyarray, … char unicode por valor xxxx hexadecimal de 16 bits.
\Uxxxxxxxx: carácter unicode por valor xxxxxxxx hexadecimal de 32 bits.
Ver sitios SciPy, BioPython, PyScience,…
\N{nombre} : caracteres Unicode por nombre en la base de datos Unicode.
Lanzamientos de números anulando Mantenga los caracteres de escape \ prefijando los literales de cadena con una r (o R) ­ para cadenas
__int__(self) → int: llamado para int(self) __long__(self) → 'sin procesar' (nota: no puede terminar una cadena sin procesar con \).
long: llamado para long(self) __float__(self) → float: llamado para Cadenas Unicode 2

float(self) __complex__(self) → complex: llamado for complex(self) Citado como para str, pero con un prefijo u (o U) antes de la cadena: u"Voiçi"
__oct__(self) → str: llamado para oct(self) __hex__(self) → str: llamado para U"""Une bonne journée en
hex(self) __coerce__(self,other) → value: llamado para coerce(self,other) perspectiva."""
Puede mezclar los prefijos de cadenas r (o R) y u (o U).
Debe definir la codificación de su archivo fuente para que Python sepa cómo convertir sus cadenas
OPERACIONES A NIVEL DE BITS
literales fuente en cadenas Unicode internas. unichr(código) → unicode: cadena de un char 1
Depende de la configuración regional para cadenas de 8 bits.
ord(unicode char) → int: código unicode unicode(objeto[,codificación[,errores]]) → unicode: unicode 2
Los caracteres/separador/relleno predeterminados son espacios.
Trabaja con datos int y long . sys.maxunicode → int: código unicode máximo=fct(compilar opción de tiempo) 3
Para la tabla str debe haber una cadena de 256 caracteres; consulte string.maketrans().
Operadores ~x Para Unicode no se eliminan caracteres, y la tabla debe ser un mapa de ordinales Unicode
→ bits invertidos de x x^y → a ordinales Unicode.
bit a bit exclusivo o en x e y x&y → bit a bit y en Información de caracteres Unicode
Formateo Use
x e y x|y → bit a bit o en x e y x<<n → x Módulo unicodedata contiene información sobre caracteres Unicode el operador % entre la cadena de formato y los argumentos: string%args La cadena de
desplazado a la izquierda por n bits (ceros propiedades, nombres. formato contiene %[(nombre)][bandera][ancho][.precisión]código Si no, use %(nombre)… →
insertado) x>>n → x desplazado a la derecha por n bits buscar(nombre) → unicode: char unicode de su nombre args = valor único o tupla de valores .
(ceros insertados) nombre(unichr[,predeterminado]) → str: nombre unicode ­ puede generar ValueError Si usa %(nombre)… → args = mapeo con nombre como claves.
Manipulaciones de estructuras binarias en la estructura del módulo estándar. decimal(unichr[,predeterminado]) → int: valor decimal ­ puede generar ValueError Para el mapeo, los argumentos pueden ser un objeto con el método __getitem__ ; consulte
Mapeo y manipulación de estructuras binarias avanzadas en módulos de terceros: ctypes, xstruct, digit(unichr[ ,predeterminado]) → int: valor de dígito ­ puede generar ValueError Anulación de operaciones de mapeo (p8).
pyconstruct, … numeric(unichr[,default]) → float: valor numérico ­ puede generar ValueError categoría(unichr) → str: Formatear códigos de caracteres
categoría general unicode de char bidireccional(unichr) → str: bidir categoría de char, puede ser
Anulación de nivel de bits d firmado ent. decimal: ­324 o octal sin firmé int. decimal: ­324 u decimal sin
combinación de cadenas vacías (unichr) → str/0: clase de combinación canónica de char como entero
__y__(uno mismo, otro) → valor: para uno mismo y otros east_asian_width(unichr) → str: ancho del este asiático reflejado (unichr) → int: propiedad reflejada signo: 774 x hexa sin signo: f3a e float. signo 6953 X hexadecimal sin signo:
__o__(uno mismo, otro) → valor: para uno mismo | otro punto de experiencia : ­3.256e­12 f F3A E float. punto de experiencia :
en texto bidi, 1 si reflejado else 0 descomposición(unichr) → str: mapeo de descomposición, puede
__xor__(yo,otro) → valor: para uno mismo ^ otro __lshift__(yo,otro)
→ valor: estar vacío str normalize(form, unistr) → str: forma normal de cadena ­ forma en 'NFC', flotante. punto diciembre : ­0.0000032 g como ­3.256E­12 F flotante. punto diciembre :
para uno mismo << otro __rshift__(yo,otro) → valor: para uno mismo carácter e o fc (1 carácter str o código) r ­0.0000032 G como E o F % %% → %
>> otro __invert__(yo) → valor: para ~self __iand__(yo,otro) llamado formato de objeto como repr(objeto) s formato
para uno mismo &= otro __ior__(yo,otro) llamado para uno mismo |= 'NFKC', 'NFD', 'NFKD' de objeto como str(objeto)
otro __ixor__(yo,otro) llamado para uno mismo ^= otro unidata_version → str: versión de la base de datos Unicode utilizada
__ilshift__(yo,otro) llamado para uno mismo <<= otro Plantillas Con
Métodos y funciones
Desde funciones integradas (ver también funciones oct y hexadecimales para números enteros a cadena. Objetos de plantilla. Utilice la sintaxis de $ común: $$ single $; $nombre o ${nombre}
cadenas): len(s) → int: número de caracteres en la cadena valor para nombre.
5a 5b 5c
Machine Translated by Google

tmpl = string.Template(template_string) expr+ coincide con 1 o más repeticiones de expr (tanto como sea posible) expr? Coincidencia y búsqueda
tmpl.substitute(mapping[,**kwargs]) → string: plantilla llena coincide con 0 o 1 expr expr*? coincide como expr* pero con la menor cantidad
Puede usar funciones re , o compilar expresiones en objetos SRE_Pattern y usar sus métodos.
tmpl.safe_substitute(mapping[,**kwargs]) → string: plantilla llena tmpl.template → string Can posible de expr+? coincide como expr+ pero con la menor cantidad posible de expr??
subclass Template para construir su propia plantilla (ver doc, fuentes). partido como expr? pero la menor cantidad posible expr{m} emparejar m Ver Opciones de bandera arriba para parámetros de banderas.
repeticiones de expr expr{[m],[n]} emparejar de m a n repeticiones de expr, faltando buscar (patrón, cadena [, banderas]) → MatchObject/Ninguno: escanear a través de la cadena para
Véase también formateador de módulos. m por defecto a 0 encontrar subcadenas que coincidan con el patrón coincidencia (patrón, cadena [, banderas]) →
Envase MatchObject/Ninguno: intente hacer coincidir la cadena con el patrón dividido (patrón, cadena
y falta n por defecto a infinite expr{[m], [ ,maxsplit=0])→ [cadena]: dividir cadena por ocurrencias de patrón ­ si se especifica maxsplit, el resto
El módulo textwrap tiene una clase TextWrapper y funciones de herramienta. tw =
[n]}? emparejar como expr{[m],[n]} pero tan pocos como sea posible [conjunto] se coloca en el último elemento de la lista findall(patrón,cadena[,flags])→ [cadena]/[(cadena)] : encontrar
textwrap.TextWrapper([…]) → nuevo envoltorio de texto usando parámetros nombrados como valores de
emparejar un carácter en el conjunto definido por: → al principio, invertir la definición del patrón de coincidencia de subcadenas que no se superpongan ­ eventualmente coincidencias vacías ­
atributos correspondientes tw.width → int: longitud máxima de líneas envueltas (predeterminado 70) ^
conjunto xy → caracteres de x a y \x → ver Escape secuencias para cadenas devolver la lista de tuplas si el patrón tiene grupos ,string[,count=0])→ string: reemplazar el patrón de
tw.expand_tabs → bool: reemplazar tabs por text.expandtabs() (Verdadero predeterminado )
(p5) \­ , \] → caracteres ­ y ] (­ y ] al principio coinciden con ­ y ] caracteres) x → coincidencia de subcadenas por repl ­ repl como cadena puede contener referencias anteriores1 a la
tw.replace_whitespace → bool: reemplaza cada espacio en blanco por espacio ( Verdadero predeterminado)
char x (incluidos otros metacaracteres re) exprA|exprB coincide con exprA o subcadena identificada ­ repl como fct(MatchObject) devolver cadena de reemplazo ­ el patrón puede
tw.initial_indent → cadena: anteponer a la primera línea envuelta (predeterminado '') tw.subsequent_indent exprB, ruta corta evaluación (expr) emparejar expr ycoincidencia
crear un grupo numerado
[i][L][m][s][u][x]) (al menos uno de iLmsux char) de grupo vacía(? ser RE_Pattern object subn(pattern,repl ,string[,count=0])→ (string,int): igual que sub, el segundo
→ cadena: anteponer a otras líneas envueltas (predeterminado '' ) tw.fix_sentence_endings → bool: elemento es el recuento de sustituciones escape(string)→ string: no alfanuméricos b ackslashed Si
intente separar oraciones por dos espacios (predeterminado False) tw.break_long_words → bool: rompa
necesita reutilizar un patrón, compílelo una vez para todos. pat = re.compile(patrón[,flags])→ objeto
palabras más largas que el ancho (predeterminado True) tw.initial_indent → string: anteponga a la primera
RE_Pattern pat.match(string[,pos[,endpos]]) → igual que la función de coincidencia
línea ajustada (predeterminado '') tw .wrap(texto) → [cadena]: lista de líneas de texto, cada una con una pat.search(string[,pos[,endpos]]) → mismo como función de búsqueda pat.split(string[,maxsplit=0])→
longitud máxima de ancho ­ sin nueva línea final tw.fill(texto) → cadena: texto completo, líneas envueltas
cadena, modifique los indicadores de opciones para toda la expresión; consulte las opciones de igual que la función split pat.findall(string[,pos[,endpos]])→ igual que findall function2
usando líneas nuevas Dos funciones convenientes usan TextWrapper temporal , construido usando named pat.finditer(string[,pos[,endpos ]])→ igual que finditer function2 pat.sub(repl,string[,count=0])→ igual que
ILMSUX (?:expr) haga coincidir expr pero no cree un grupo (?P<nombre>expr) haga coincidir expr
parámetros correspondientes a los atributos. wrap(text[,width=70[,…]]) → [string] fill(text[,width=70[,…]]) sub function pat.subn(pattern,repl,string[,count=0])→ igual que subn function pat. flags → int: flags usados
y cree un grupo numerado y nombrado (nombre
→ string dedent(text) → string: elimina los espacios en blanco uniformes al principio de las líneas de texto en tiempo de compilación pat.pattern → string: patrón usado en tiempo de compilación pat.groupindex →
debe ser un identificador Python válido)
(?P=nombre) coincide con el texto que coincide con el nombre del grupo anterior (? dict: mapeo de nombres de grupos a números de grupos
#texto) no coincide, el texto es solo un comentario (?=expr) coincide si coincide
con expr pero no consume entrada (?!expr) coincide si no coincide con expr pero 2

no consume entrada (?<=expr) coincide si la posición actual está inmediatamente 2

precedida por una coincidencia para el patrón de longitud fija expr (?<!expr) coincide si la posición 2

actual no está inmediatamente precedido por un partido

constantes para patrón de longitud fija expr

La cadena de módulo estándar proporciona varias constantes (no las modifique, se usan en funciones de (?(num/name)yesexpr[|noexpr]) intente hacer coincidir yesexpr si el grupo num/name existe, de lo
manipulación de cadenas) y algunas funciones de cadena no están disponibles como métodos. contrario intente hacer coincidir noexpr

Secuencias de escape
letras_ascii → str: caracteres en minúsculas y mayúsculas ascii_lowercase
\n \nn número de grupo de match3 n (nn) donde primero n≠0 \ooo
→ str : caracteres en minúsculas az ascii_uppercase → str: caracteres en
\0o carácter de match3 con valor octal ooo (0o) Varias funciones/métodos devuelven objetos MatchObject . m.expand(plantilla)→
mayúsculas AZ digits → str: 0­9 caracteres de dígitos decimales hexdigits
\A coincide solo al comienzo de la cadena \b cadena: hacer sustitución de barra invertida en la plantilla (como submétodo ) usando valores de grupos
→ str: 0­9a­fA­F letras de caracteres de dígitos hexadecimales → str:
coincide con 3 cadena vacía al principio o al final de una palabra 1+2 de objetos de coincidencia m.group([grupo[,…]])→ cadena/(cadena): subgrupos de la coincidencia a
caracteres en minúsculas y mayúsculas minúsculas → str: minúsculas az
1 \B coincide con una cadena vacía que no está al principio o al final de una palabra partir de números
chars1 octdigits → str: 0­7 dígitos octales caracteres puntuación → str:
1+2 \d coincide con el dígito decimal de la clase char [0­9] o nombres
caracteres ascii considerados como puntuación en la configuración regional
\D coincide con la clase de caracteres que no son dígitos m.groups([predeterminado=Ninguno])→ (cadena): todos los subgrupos del partido ­ por defecto da acceso
de C printable → str: caracteres imprimibles en mayúsculas → str:
[^0­9] \s coincide con los espacios en blanco de la clase de caracteres [\t\n\r\f\v] a los subgrupos que no están en el partido m.groupdict([predeterminado=Ninguno])→ dict:
mayúsculas AZ chars1 espacios en blanco → str: caracteres de espacios en blanco (spc,
\S coincide con la clase de caracteres que no son espacios en blanco [^ nombre→subgrupo: todos los subgrupos con nombre de la coincidencia ­ da acceso predeterminado a los
tabulador, cr, lf, ff, vt) capwords(s) → str: split → capitalize → join maketrans(from,to) → tabla
\t\n\r\f\v] \w coincide con la clase de caracteres alfanuméricos [a­zA­Z0­9_] subgrupos que no están en la coincidencia m.start([group=0])→ int: índice de inicio de la subcadena
de traducción utilizable en str.translate ­ from y to deben tener la misma longitud Definición
\W coincide con la clase de caracteres no alfanuméricos [^a­zA­Z0­9_] coincidente por grupo, ­1 si el grupo existe pero no en la coincidencia m.end([group =0])→ int: índice del
depende de la configuración regional.
\Z coincide con el final de la final de la subcadena que coincide con el grupo, ­1 si el grupo existe pero no coincide m.span([group=0])→
cadena \a \b \f \n \r \t \v \x \\ igual que los escapes de cadena \c para otros (int{2}): valores de los métodos de inicio y finalización para el grupo m.pos → int: valor pos del método de
caracteres c, coincide con el carácter c búsqueda/coincidencia m.endpos → int: valor final de la posición del método de búsqueda/coincidencia
1 1
m.lastindex → int/Ninguno: índice del último grupo de captura coincidente m.lastgroup → cadena/Ninguno:
Depende de la bandera UNICODE.
2 nombre del último grupo de captura coincidente m.re → RE_Pattern: patrón utilizado para producir el objeto
Depende de la bandera LOCALE.
Expresiones regulares 3 de coincidencia m.string → cadena: cadena utilizada en la coincidencia/búsqueda para producir el objeto
Cuando está fuera de la definición de clase char ([…])
El módulo estándar tiene un potente motor de expresiones regulares. Consulte CÓMO de expresiones de coincidencia
regulares en http://www.amk.ca/python/howto/regex/. Opciones de marca

Utilice la notación r"…" de cadena sin formato . IGNORECASE (I) : expresión que no distingue entre mayúsculas y minúsculas, no depende de la configuración regional.
Ver también proyectos externos pyparsing, PLY (Python Lex­Yacc), tpg (Toy Parser Generator)… LOCALE (L) : hacer que \w \W \b \B dependa de la configuración regional.
MULTILINE (M) : ^ y $ coinciden con el principio/final de la cadena y las líneas. De lo contrario, ^ y $ 1
Referencias anteriores extendidas a \g<groupnum> y \g<groupname>.
Expresiones coinciden solo con el principio y el final de la cadena. 1
Usando parte de la cadena entre pos y endpos.
DOTALL (S) : hacer . coincide con cualquier carácter, incluida la nueva línea. Si no, nueva línea
Metacaracteres : . ^$*+?{ []\| ( ), puede usar \ escape. El grupo número 0 corresponde a la coincidencia completa.
excluido.
. } coincide con cualquier carácter excepto una nueva línea (incluida la nueva línea con la opción Localización
UNICODE (U) : hacer \w \W \b \B dependiente de unicode.
DOTALL ) La configuración regional del módulo estándar proporciona un servicio de configuración regional posix
VERBOSE (X) : ignora los espacios en blanco y realiza # comentarios iniciales (excepto cuando el espacio
^ coincide con el inicio de la cadena (y el inicio de las líneas con la opción MULTILINE ) (internacionalización). setlocale(categoría[,locale]) → configuración actual/nueva: si se especifica la
y # se escapan o están en la clase char).
$ coincide con el final de la cadena (y el final de las líneas con la opción MULTILINE ) configuración regional (como cadena o como tupla(código de idioma, codificación)), modifique la
expr* coincide con 0 o más repeticiones de expr (tanto como sea posible) configuración regional para

6a 6b 6c
Machine Translated by Google

categoría y devuelve una nueva ­ si no se especifica la configuración regional o Ninguna, llave uso del valor nl_langinfo() lngettext(singular,plural,n)→ string: como ngettext(), usando la codificación preferida
devuelve la configuración regional actual ­ no es segura para subprocesos localeconv()→ dict: ERA_D_FMT usable como formato para strftime() para fecha con era hasta 100 dngettext(domain,singular,plural,n)→ string: como ngettext(), buscando en el dominio
base de datos de convenciones locales nl_langinfo(opción)→ cadena: información específica de ALT_DIGITS valores que representan 0 a 99 especificado. ldngettext(domain,singular,plural,n)→ string: como dngettext(), usando la codificación
la configuración regional ­ no disponible en todos los sistemas ­ las opciones pueden varía según preferida. Generalmente está vinculado a gettext.gettext, y las cadenas traducibles se escriben
localeconv claves
los sistemas: vea las opciones p7 getdefaultlocale([envvars])→( código de idioma, codificación): en las fuentes usando _('thestring'). Ver documentos para ejemplos de uso.
intente determinar la configuración de configuración regional predeterminada getlocale([category])→ clave que
configuración actual de LC_* para la categoría ­ categoría predeterminada en LC_CTYPE ­ para el símbolo_moneda punto_decimal significa Símbolo de moneda local para valores monetarios . _
código de idioma y ancoding puede ser None getpreferredencoding([do_setlocale])→ str: codificación frac_dígitos Carácter de punto decimal para números.
preferida por el usuario para datos de texto ­ establezca do_setlocale en False para evitar una posible Número de dígitos fraccionarios utilizados en el formato
llamada a setlocale() normalize(localename)→ código de configuración regional normalizado para local de valores monetarios . [int]: posiciones relativas API basada en clases
localename ­ utilizable con setlocale() ­ devuelve localename si la normalización falla agrupamiento de 'miles_sep' en números. CHAR_MAX en la agrupación de
La forma recomendada. El módulo gettext define una clase Traducciones, que se ocupa de los
resetlocale([categoría]) restablece la configuración regional para la categoría a la configuración parada final. 0 al final repite el último grupo.
archivos de traducción .mo y admite cadenas str/unicode . find(domain[,localedir[,languages[,all]]])→
predeterminada ­ categoría predeterminada a LC_ALL strcoll(s1,s2)→ int: comparar dos cadenas ­
str/None: .mo nombre de archivo para traducciones (buscar en localedir/language/LC_MESSAGES/
seguir la configuración LC_COLLATE ­ devolver 0 si s1==s2, < 0 si s1<s2 , > 0 si s1>s2 int_curr_symbol Símbolo de moneda internacional de valores monetarios .
domain.mo) translation(domain[,localedir[,languages[ ,class_[,fallback[,codeset]]]]]) →Traducciones:
strxfrm(cadena)→ cadena: cadena de transformación para formato de comparación con
objeto de la clase class_ (predeterminado en GNUTranslations, el constructor toma el objeto de
reconocimiento de configuración regional (formato, valor [, agrupación ] ) punto, + agrupación si es int_frac_digits Número de dígitos fraccionarios utilizados en el formato
archivo como parámetro) ­ si es verdadero, permite devolver NullTranslations si no se encuentra
verdadero) str(float)→ cadena: convertir float ­ seguir la configuración LC_NUMERIC (punto decimal) internacional de valores monetarios . mon_decimal_point Punto
ningún archivo .mo, el valor predeterminado es falso (aumentar IOError) : conjunto de caracteres
atof(string)→ float: convertir cadena en float ­ seguir la configuración LC_NUMERIC atoi(string)→ int: decimal utilizado para valores monetarios . mon_agrupación
de cambio de conjunto de códigos utilizado para codificar cadenas traducidas
convertir cadena a entero ­ siga la configuración LC_NUMERIC CHAR_MAX → constante simbólica Equivalente a 'agrupación', utilizado para valores monetarios .
utilizada por localeconv() función en
_
mon_thousands_sep Separador de grupo utilizado para valores monetarios . n_cs_precedes
Verdadero si el símbolo de moneda precede a los valores monetarios negativos , falso si lo
sigue.
Traducciones nulas

n_sep_by_space Verdadero si hay un espacio entre el símbolo de moneda NullTranslations es una clase base para todas las traducciones. t.__init__([fp])
y el valor monetario negativo . inicializar traducciones: fp es un objeto de archivo ­ llame a _parse(fp) si no es Ninguno t._parse(fp)
n_sign_posn Posición de signo negativo para valores monetarios1 . nada: las subclases anulan para leer datos del archivo t.add_fallback(fallback ) agregar respaldo
Categorías
signo_negativo Símbolo utilizado para anotar un valor monetario negativo . utilizado si no se encuentra la traducción de un mensaje Defina los métodos gettext, lgettext, ngettext,
LC_CTYPE → tipo de carácter ­ comportamiento de cambio de
lngettext como en la API base. Y defina los métodos especiales ugettext y ungettext que devuelven
mayúsculas y minúsculas LC_COLLATE → clasificación de cadenas ­ funciones strcoll() p_cs_precede Verdadero si el símbolo de la moneda precede a los cadenas Unicode (otras formas devuelven cadenas str codificadas ). Devolver el mensaje traducido,
y strxfrm() LC_TIME → formato de tiempo ­ time.strftime() valores monetarios positivos , falso si lo sigue. reenviando a respaldo si está definido. Anulado en subclases. t.info()→ devolver el atributo _info
LC_MONETARY → formateo de valores monetarios ­ opciones de localeconv() p_sep_by_space Verdadero si hay un espacio entre el símbolo de moneda protegido t.charset()→ devolver el atributo _charset protegido t.output_charset()→ devolver el atributo
LC_MESSAGES → visualización de mensajes ­ os.strerror() ­ no para mensajes de Python y el valor monetario positivo . _output_charset protegido (que define la codificación utilizada para devolver los mensajes traducidos)
LC_NUMERIC → formato de números ­ format(), atoi(), atof() y str() de este módulo (no modifique el p_sign_posn Posición de signo positivo para valores monetarios1 . t.set_output_charset(charset) establecer el atributo _output_charset t .install([unicode]) enlazar
formato normal de números de Python) self.ugettext() en Unicode (predeterminado en falso)
signo_positivo Símbolo utilizado para anotar un valor monetario positivo .
LC_ALL → todas las configuraciones regionales: se utiliza para cambiar/recuperar la configuración regional para todas

las categorías nl_langinfo opciones miles_sep Carácter utilizado entre grupos de dígitos en números.
llave nl_langinfo() valor uso nombre de
1
CONJUNTO DE CÓDIGOS
codificación de caracteres usable como formato para Valores posibles: 0=moneda y valor entre paréntesis, 1=el signo debe preceder al valor y al
D_T_FMT strftime() para hora y fecha usable como formato para strftime() para símbolo de la moneda, 2=el signo debe seguir al valor y al símbolo de la moneda, 3=el signo
D_FMT fecha usable como formato para strftime() para hora usable como debe preceder inmediatamente al valor, 4=el signo debe seguir inmediatamente al valor, LC_MAX= _ en el espacio de nombres incorporado a self.gettext() o

T_FMT formato para strftime() para hora en am/ formato pm nada especificado en esta configuración regional.
Traducciones GNU
T_FMT_AMPM
Soporte multilingüe La clase GNUTranslations (subclase de NullTranslations) se basa en archivos GNU gettext y .mo.
nombre
DAY_7 nombre abreviado del día n del
de día n de la ­semana
la semana primero­ ABDAY_1…
el primer díael
esdía
domingo DAY_1…
es domingo Módulo estándar gettext para servicios de internacionalización (I18N) y localización (L10N), basado
ABDAY_7 MON_1… MON_12 nombre del mes n nombre abreviado del en GNU gettext API + interfaz superior. Consulte los documentos para obtener explicaciones sobre Los identificadores de mensajes y los textos están forzados a Unicode.
mes n ABMON_1…
el uso de herramientas. El atributo _info protegido contiene traducciones de mensajes.
API básica Traducción para metadatos de retorno de cadena vacía (ver doc).
Defina los métodos gettext, lgettext, ugettext, ngettext, lngettext, ungettext como en la interfaz
bindtextdomain(dominio[,localedir])→ str: directorio delimitado ­ enlazar dominio a directorio localedir NullTranslations : las mismas reglas para los valores devueltos (str/unicode). Las traducciones
ABMON_12 si se especifica (usado al buscar archivos .mo) bind_textdomain_codeset(dominio[,codeset])→
RADIXCHAR de los mensajes se buscan en el catálogo, luego, si están definidas, en reserva, y si no se
carácter de base (punto decimal/coma/…) carácter enlace de conjunto de códigos: enlazar dominio a conjunto de códigos si se especifica ­ cambiar encuentra ninguna traducción, se devuelve el mensaje en sí (para n... métodos, devuelve formas
THOUSEP separador para miles expresión regular (¡de la biblioteca xxgettext() devolvió cadenas que codifican dominio de texto ([dominio]) → dominio global: establecer singulares si n=1 más formas plurales).
SÍEXPR C!) utilizable para respuesta sí expresión regular (¡de la biblioteca C!) dominio global si se especifica y no
Ninguno
NOEXPR utilizable para respuesta no símbolo de moneda, precedido por ­ si debe
gettext(mensaje)→ cadena: traducción localizada del mensaje, basada en el dominio global CONTENEDORES
CRNCYSTR aparecer antes del valor , por + si debe aparecer después del valor, por .
actual, el idioma y el directorio local, generalmente con alias como espacio de nombres local _ en Tipo de contenedores básicos:
si debe reemplazar el carácter radix era ­ generalmente no definido ­ igual lgettext(mensaje)→ cadena: como gettext(), usando la codificación preferida dgettext(dominio, ­secuencias (colecciones ordenadas): lista, tupla, str, cualquier iterable,... ­mappings (clave/
que el formato Estrftime()
en strftime()
paraaño
fecha
en yera
hora
utilizable
con eracomo formato para mensaje) → cadena: como gettext(), buscando en el dominio especificado.
ERA valor no ordenado): dict... ­conjuntos (colecciones no ordenadas): set, frozenset...
ldgettext(dominio,mensaje)→ cadena: como dgettext(), usando la codificación preferida
ngettext(singular,plural,n)→ cadena: como gettext(), pero considere formas plurales (vea
ERA_AÑO Python y GNU gettext docs) 7b Operaciones sobre Contenedores
ERA_D_T_FMT Para cadenas, los elementos son caracteres. Para las asignaciones, los elementos son
claves. elemento en contenedor → bool: elemento de prueba contenedor1 elemento no
en contenedor → bool: elemento de prueba contenedor1

7a 7c
Machine Translated by Google
para var en el contenedor: … iterar var sobre los elementos del contenedor índices de artículos Operaciones en asignaciones
len(contenedor) → int: contar el número de elementos en el contenedor2 ­norte ­n+1 ­n+2 … ­2 ­1 Consulte Operaciones en contenedores (p7) también, teniendo en cuenta las operaciones en
max(contenedor) → valor: el elemento más grande en el contenedor min(contenedor) claves. d[clave]→ valor para clave1 d[clave]=valor establece d[clave] al valor del d[clave]
→ valor: el elemento más pequeño en el contenedor sum( contenedor) → valor: 0 1 2 … n­2 n­1
elimina d[clave] de d d.fromkeys(iterable[,valor=Ninguno]) → dict: con claves de iterable y todas
1
suma de elementos (los elementos deben ser compatibles con el número) con el mismo valor d.clear() elimina todos los elementos de d d.copy() → dict: santificar copia
1 e1 e2 e3 …artículo… es­1 es
Para cadenas, pruebe si expr es una subcadena de secuencia. de d d.has_key(k)→ bool: prueba de presencia de clave ­ igual que k en d d .items()→ list: copia
2
El contenedor debe proporcionar el método de longitud directa, sin generador. 0 1 2 3 … n­2 n­1 norte
de la lista de d de pares (clave, elemento) d.keys()→ list: copia de la lista de d de claves
Copiar contenedores d.update(otherd) copiar otros pares en d d.update(iterable) copiar pares (clave,valor) en d
­norte ­n+1 ­n+2 ­n+3 … ­2 ­1 d.update(**kwargs) copiar pares nombre=valor en d d.valores()→ lista: copia de la lista de
Los constructores de contenedores predeterminados crean un nuevo contenedor con referencias
a objetos existentes (copia superficial). Para duplicar contenido también, use la copia de módulo índices de corte valores de d d.get(clave,defval)→ valor : d[clave] si clave d, sino defval
estándar. Consulte Copiar objetos (p3). d.setdefault(clave[,defval=Ninguno]) → valor: si clave d establece d[clave]=defval, devuelve
Objetos de
d[clave] d.iteritems()→ iterador sobre pares (clave, valor) d.iterkeys()→ iterador sobre claves
Anulación de operaciones de contenedores división Define objetos de rango de índice, utilizables en notación [] . d.itervalues()→ iterador sobre valores d.pop(key[,defval]) → valor: del clave y devuelve el valor
__len__(self)→ int: llamado para len(self) slice([start,]stop[,step])→ objeto de corte slice.indices(len)→ (int{3}): correspondiente. Si no se encuentra la clave, se devuelve defval si se proporciona; de lo contrario,
__contains__(self,item)→ bool: llamado para item [not] in self También puede anular el (start,stop,stride) se genera KeyError d.popitem() → elimina y devuelve un par arbitrario (clave, valor) de d
protocolo iterable en contenedores. Conjuntos ordenados de datos indexados desde 0. Los miembros inician, detienen, avanzan.

SECUENCIAS Rebanadas extendidas

La notación de múltiples rebanadas, que corresponde a una selección en datos
Las secuencias son colecciones ordenadas: str, unicode, list, tuple, buffer, xrange, array.array…
multidimensionales, se puede escribir usando una notación como [am:n]. , x:y:z , la
cualquier clase de usuario que defina la interfaz de secuencias, o cualquier dato iterable.
: , : se
notación de puntos suspensivos : , usar
, puede comopara
[ a , llenar
x:y:z ,varios
... , sectores que faltan,

Listas y tuplas Lista m:n]. Ver documentos.

de tipos incorporados y secuencias de almacenamiento de tuplas de cualquier objeto.
La notación de tres puntos... se reemplaza internamente por el objeto Ellipsis .
Las listas son mutables, las tuplas son inmutables.
Declarar una lista: [elemento[,…]] Operaciones en secuencias mutables Las secuencias
Declarar una tupla: (elemento[,…]) mutables (por ejemplo, lista) se pueden modificar en su lugar. 1
Si la clave no existe, genera la excepción KeyError .
Notas: [] lista vacía ;() tupla vacía; (elemento,) tupla de un elemento. lista(objeto) → Puede usar la indexación de secuencia mutable en la parte izquierda de la asignación para modificar
Anulación de operaciones de asignación
lista: nueva lista (transmitida desde objeto/duplicado existente) tupla(objeto) → tupla: nueva sus elementos: seq[index]=expr ; seq[inicio:detener]=expr ; seq[start:stop:step]=expr
seq.append(item) agregar elemento al final de la secuencia seq.extend(otherseq) concatenar __getitem__(self,key)→ valor para key, llamado para self[key]
tupla (transmitida desde objeto/duplicado existente) range([start,]stop[,step])→ [int] : lista,
otherseq al final de la secuencia seq.count(expr) → int: número de elementos expr en secuencia __setitem__(self,key,value) establecer valor para key, llamado para
progresión aritmética de enteros xrange1([start,]stop[,step]) → xrange: objeto que genera
seq.index(expr[,start[,stop]])→ int: primer índice del elemento expr seq.insert(índice,elemento) self[key]=value __delitem__(self,key,value) remove value for key, llamado
progresión aritmética de enteros A menos que se use una secuencia como clave de mapeo, o
elemento insertado en el índice seq.remove(expr) elimina el primer elemento expr de secuencia para del self[key]
se asegure de que son datos inmutables, prefiera lista a tupla.
seq .pop([índice]) → elemento: elimina y devuelve el elemento en el índice (predeterminado ­1)
seq.reverse() elementos invertidos en su lugar seq.sort([cmp][,key][,reverse]) elementos También puede anular operaciones de contenedores y operaciones de objetos.
1 ordenados in situ ­ cmp : comparación personalizada fct(a,b), retval <0 o = 0 o >0 ­ clave : nombre Otras asignaciones Para
Úselo en lugar de rango para evitar crear listas enormes solo para indexar.
del atributo de los elementos a comparar ­ inversa : bool del seq[índice] eliminar elemento de la las asignaciones en disco, consulte la estantería de módulos estándar y los módulos de
Operaciones en Secuencias Ver
secuencia del seq[inicio :stop[:step]] eliminar elementos de la secuencia base de datos.
Operaciones en Contenedores (p7) también. seq1 +
Para asignaciones ordenadas, consulte los módulos de terceros OrderedDict.
seq2 → concatenación de seq1 y seq2 * n → concatenación
concatenación
dede
secuencia
secuencia
duplicada
duplicada
n veces
n veces
secuencia
n* secuencia → CONJUNTOS

Colecciones desordenadas de artículos únicos. Los conjuntos congelados son inmutables una vez
invertido(secuencia)→ iterador a través de la secuencia en orden inverso
creados.
sorted(sequence[,cmp[,key[,reverse]]])→ list: nueva lista, elementos ordenados de iterable ­ ver
set([iterable]) → set: usando valores de iterable
list.sorted() filter1(fct,sequence) → list: nueva lista donde fct(item) es True. Use None fct para una Operaciones de anulación de secuencias
frozenset([iterable]) → frozenset: usando valores de iterable Operaciones en
prueba booleana en elementos __getitem__(self,index2)→ valor: elemento en el índice, llamado por self[index]
__setitem__1(self,index2,value) establecer elemento en el índice como valor, llamado por Conjuntos Ver Operaciones en Contenedores (p7) también. s.issubset(otros)→
el
map1(fct,secuencia,…)→ lista: nueva lista donde el i­ésimo elemento es fct(i artículos de self[index]=valor __delitem__1(self,index2) eliminar elemento en el índice, llamado para del bool: probar s otros s.issuperset(otros)→ bool: probar otros ss
secuencia(s)) reduce(fct,secuencia[,inicializador])→ valor: fct aplicado self[índice] s.add(elemento) añadir elemento al conjunto s.remove(elemento) eliminar
acumulativamente a los elementos de la secuencia, f(f(… f(f(f(inicializador,a),b),c,…) elemento del conjunto1 s. clear() elimina todos los elementos de (no forzen)
zip1(secuencia,…)→ lista: lista de tuplas, la i­ésima tupla contiene los i­ésimos elementos 1
Solo para secuencias mutables. conjunto s.intersección(otros)→ conjunto: s ∩ otros s & otros → conjunto: s ∩
2 otros s.union(otros) → conjunto: s otros s | otros → conjunto: s otros
de cada secuencia El índice de parámetros puede ser un segmento [inicio, detención, paso]: reemplace el antiguo
__getslice__, __setslice__, __delslice__. s.diferencia(otros) → conjunto: [x / x s y x otros] s ­ otros → conjunto: [x / x s
1
Consulte Herramientas de iteración (p9) como reemplazo (evite crear una nueva lista). También puede anular las operaciones aritméticas __add__ (concatenación) y __mul__ y x otros] s.diferencia_simétrica(otros) → conjunto: [x / x s xor x otros]
(repetición), operaciones de contenedores y operaciones de objetos.
Indexación
Use la sintaxis de índice [i] y segmento [i:j[:paso]] . Índices de base cero. Índices negativos que MAPAS (DICCIONARIOS)
indexan desde el final. El paso predeterminado es 1, puede usar pasos negativos.
Dict de tipo incorporado . Almacenar pares clave:valor.
Índices de subsecuencias entre elementos. l = {}
Declarar un diccionario: { clave : valor [,…]} dict()→
[e1,e2,e3,…,en­2,en­1,en] l[ 0]→ e1
dict: diccionario vacío (como {}) dict(**kwargs)→ dict:
l[0:n]→[e1,e2,e3,…,en­2,en­1l[:]→[e1,e2,e3,…,en­2,en­1,en]
,en] l[1]→ e2 l [­2]→ en­1
de parámetros nombrados y sus valores dict(iterable)→ dict: from ( clave, valor) por s ^ otros → conjunto: [x / x s xor x otros]
l[i:]→[ei +1,ei+2,ei+3,…,en­1,en] l [­1]→ en l[:i]→[e1,e2,…,ei­2,ei­1,ei]
dict iterable (otherdict) → dict: duplicado para otro (primer nivel) s.copy()→ establecer: copia superficial de
s s.update(iterable) agrega todos los valores de iterable a s
1
Genera KeyError si el objeto no está en el conjunto.
El conjunto de resultados tiene el mismo tipo que el objeto s (conjunto/congelado).

8a 8b 8c
Machine Translated by Google

OTRAS ESTRUCTURAS DE CONTENEDORES , ALGORITMOS heap, push newitem accept2dyear → [rw] bool: acepta valores de año de dos dígitos (verdadero predeterminado),
nlargest(n,iterable)→ lista: n mayor de iterable nsmallest(n,iterable)→ modificable a través del entorno var PYTHONY2K altzone → int: compensación (pos/neg)
En general, los contenedores siguen los modismos de Python, puede usar: len(cont), cont[i], lista: n elementos más pequeños de iterable en segundos de DST en relación con UTC, en segundos, use solo si la luz del día es verdadera luz del
para el elemento en cont:… día → int: ≠0 si se define una zona horaria DST timezone → int: desplazamiento (pos/neg) en segundos
Lista ordenada
Formación de la zona horaria local (no DST) tzname → (str{2}): nombres de la zona horaria local (no DST, DST )
El módulo estándar bisect mantiene las listas ordenadas (a través de un algoritmo de bisección básico).
La matriz de módulos estándar proporciona una matriz eficiente de tipos básicos. Utiliza bisect_left(list,item[,lo[,hi]])→ int: índice para insertar el elemento en la posición ordenada más a la
almacenamiento compacto para elementos del mismo tipo. izquierda1 bisect_right(list,item[,lo[,hi]])→ int: índice para insertar el elemento en la posición ordenada
Funciones
Tipo Códigos C más a la derecha1 bisect(…) alias para bisect_right(…) insort_left(list,item[,lo[,hi]]) insertar
n tc py tipo n tc py tipo C elemento en la posición ordenada más a la izquierda insort_right(list,item[,lo[,hi]]) insertar elemento asctime([t=2 ])→ str: crea una cadena de tiempo local a partir de t (tuple_time o struct_time) clock()→
tipo 1 'b'
en posición ordenada más a la derecha insort(…) alias para insort_right(…) float: tiempo del procesador en segundos, para una medición precisa del tiempo relativo
signado char int 1 'c' char 2 'h' signado 1 'B' char int sin signo 2 'u' unicode char 1
calle
short int 2 'i' signado int 4 'l' signado unicode
ctime([secs=2 ])→ str: construir cadena de tiempo local desde float_time segundo
long int 4 'f' float float 2 'H' int corto sin signo
En t 1
gmtime([secs=2 ])→ struct_time: convertir float_time a UTC struct_time localtime([secs=2 ])→
2 'I' sin signo int largo Con listado previamente ordenado. struct_time: convertir float_time a DST struct_time mktime(t)→ float_time: convertir DST t (tuple_time
4 'L' sin signo largo largo 8 'd' doble flotante Herramientas de iteración o struct_time) a float_time ­ puede generar OverflowError o ValueError sleep(secs) ejecución
El módulo estándar itertools proporciona algunos iteradores prácticos. cadena (iterable suspendida durante segundos (float_delay) veces, tal vez menos (captura de señal), puede ser más
n=tamaño en bytes, tc=código de tipo de carácter a usar [,...]) → iterador sobre elementos de varios iterables cuenta ([inicio]) → iterador sobre (proceso/ programación de subprocesos) strftime (formato [, t = 2 ]) → str: cadena de tiempo de
Funciones enteros desde el inicio (predeterminado 0) ciclo (iterable) → iterador ciclando sobre compilación de t (tuple_time o struct_time) usando cadena de formato (tabla debajo) ­ puede
elementos iterables dropwhile (predicatefct, iterable) → iterador sobre elementos de generar ValueError strptime (cadena [, formato]) → struct_time: cadena de análisis usando el formato
array(tc,[iterable]) → array: con código de tipo tc, inicializado desde iterable a.typecode → str:
iterable donde predicatefct(elemento) es falso groupby(iterable[,keyfct])→ iterador sobre (valor de tiempo 1 : puede generar ValueError time () → float_time: hora UTC actual tzset () restablece
código de tipo de un dato a.itemsize → int: tamaño en bytes de un dato a.append(expr)
clave, grupo1 de elementos donde keyfct(elemento)=valor clave), keyfct predeterminado es las reglas de conversión de tiempo de acuerdo con la variable de entorno
agregar elemento expr a final de a.extend(array) agregar elementos de otra matriz
identidad ifilter(predicado,iterable)→ iterador sobre elementos de iterable donde predicatefct(item)
a.count(expr) → int: número de elementos de expr a.index(expr) → int: primer índice del
es verdadero ­ Ninguno de los elementos de filtro de predicado es verdadero
elemento de expr a.insert(index,expr) elemento expr insertado en el índice a.remove(expr)
ifilterfalse(predicate,iterable)→ iterador sobre elementos de iterable donde predicatefct(item) es
elimina el primer elemento expr a.pop([index]) → valor: devuelve y elimina el elemento en TZ ­ solo unix, ver documentos
falso ­ Ninguno de los elementos de filtro de predicado es falso imap(función,iterable[ ,…]) →
el índice (predeterminado ­1) a.reverse() los elementos de la matriz están invertidos 1
iterador sobre la función (elementos en el mismo índice de iterables2 ), ninguna función devuelve Formato predeterminado "%a %b %d %H:%M:%S %Y". Los valores faltantes predeterminados son
a.buffer_info() → (int{2}): información de almacenamiento actual (dirección, cantidad de
elementos de tuplas islice (iterable, [inicio,] parada [, paso]) → iterador sobre elementos en los (1900, 1, 1, 0, 0, 0, 0, 1, ­1)
elementos) a.byteswap() intercambiar bytes de elementos de matriz a.fromfile(f,n) 2
índices de slice3 de iterable, None stop sube para finalizar izip(iterable[,…])→ iterador sobre Param secs predeterminado a la hora actual, param t predeterminado a la hora local actual.
agregar n elementos leídos desde un archivo binario real f1 a.tofile(f) escribe todos los
tupla(elementos en el mismo índice de iterables) re peat(object[,count])→ iterador que devuelve el
elementos en un archivo binario real f a.fromlist(lista) extiende el arreglo desde los valores
objeto una y otra vez, hasta contar veces (predeterminado a infinito) starmap(function,iterable)→ Cadenas de formato de tiempo
en la lista a.tolist() → lista: elementos en una lista a.fromstring(s) extiende el arreglo de valores
iterador sobre función(*tuple item from iterable) takewhile(predicatefct,iterable)→ iterador sobre %a Nombre abreviado del día de la %A Nombre completo del día de la semana1 .
en búfer binario s (cadena) a.tostring() → str: elementos en representación binaria a.fromunicode(s)
elementos de iterable donde predicatefct(item) es verdadero tee(iterable[,n]) → n iteradores semana1 . %b Nombre abreviado del %B Nombre del mes
extender ' matriz u' a partir de datos en unicode agitando a.tounicode() → unicode: convierte la
independientes del mismo iterable
matriz 'u' en una cadena unicode mes1 . %c Representación adecuada de completo1 . %d Día del mes [01,31].
fecha y hora1 .
%H Hora [00,23]. %j %I Hora [01,12]. %m
Día del año [001,366]. Mes [01,12]. %p AM o
4 %M Minuto [00,59]. PM1 .
, por defecto n=2
1 %S Segundo [00,61]. %w %U Año semana [00,53] (basado en domingo).
El grupo de artículos se usa internamente; debe guardarlo como lista si es necesario después
Día de la semana [0,6] (0=domingo). %x %W Año semana [00,53] (basado en lunes).
1
iteración actual.
Si hay menos elementos de los necesarios, obtenga los disponibles y luego genere EOFError. 2 Representación de fecha adecuada1 . %X Representación de tiempo apropiada1 . %y Año
Deténgase al final del iterable más corto.
Los métodos antiguos de lectura y escritura fueron reemplazados por fromfile y tofile. 3
Los parámetros de sector no pueden ser negativos. [00,99]. %Y Año (con siglo).
4
Cola No use iterables fuera de los iteradores creados en T. %Z Nombre de zona horaria (sin caracteres si %% Literal % char.
no existe ninguna zona horaria).
Las colecciones de módulos estándar proporcionan gestión de colas. deque([iterable])→ FECHA Y HORA 1
deque: inicializado desde iterable q.append(x) agrega x al lado derecho de deque Representación del idioma local.
q.appendleft(x) agrega x al lado izquierdo de deque q.clear() elimina todos los Tiempo del módulo
elementos de deque q.extend(iterable) extiende el lado derecho de deque con El tiempo de módulo estándar define funciones y datos comunes. Fecha y hora del módulo
elementos iterables q.extendleft(iterable) extiende el lado izquierdo de deque con El módulo estándar datetime tiene herramientas para aritmética de fecha/hora, extracción y
Datos de fecha y hora
elementos iterables q.pop() → item: extrae y devuelve el elemento del lado derecho de
manipulación de datos.
dequeue q. popleft() → elemento: extrae y devuelve el elemento desde la cola del lado izquierdo • float_time = float que contiene segundos de 'epoch' (1 de enero de 1970 en Unix ­ ver gmtime(0)), con Define la clase: timedelta, time, date, datetime, [tzinfo].
q.rotate(n) rotar deque desde n pasos, a la derecha si n>0, a la izquierda si n<0 También puede precisión de subsegundos en la parte decimal. • tuple_time = tupla que contiene 9 int (ver tabla). •
tiempo del módulo
usar operaciones estándar en secuencias: len( q), invertido(q), copy.copy(q), copy.deepcopy(q), struct_time = tupla/objeto con atributos int (ver tabla).
item in q, q[­1] y serialización a través del protocolo de decapado. Módulo estándar timeit tiene funciones para medir el tiempo de procesamiento del código. Se puede
# atributo valor # atributo valor usar en scripts (ver documentos) o directamente en la línea de comandos: python ­mtimeit [­n N] [­r
En t 0…61 N] [­s S] [­t] [­c] [­h] [statement [ …]] ­n N / ­­number=N ejecutar declaración N veces ­r N / ­­repeat=N
0 tm_año 1 5 tm_sec 6
1…12 0…6 (lunes=0) ­s S / ­­setup=S ­t / ­­time ­c / ­­clock ­v / ­ ­verbose ­h / ­­ayuda
tm_mon 2 tm_wday 7
1…31 0…366 repetir el temporizador N veces
Colas de prioridad tm_mday 3 tm_yday 8
0 (no) (predeterminado 3) ejecutado S una vez inicialmente
tm_hour 4 0…23 tm_isdst
Heapq del módulo estándar . Estructura una lista como una cola de prioridad. 1 (sí) ( pase predeterminado ) usar time.time() (predeterminado
tm_min 0…59
heapify(x) transforma lista x en heap heappush(heap,item) inserta elemento en ­1 (desconocido) excepto Windows) usar time.clock() (predeterminado en
heap heappop(heap)→ item: extrae y devuelve el elemento más pequeño del montón Windows) imprimir resultados de tiempo sin procesar; puede
heapreplace(heap,newitem)→ item: extrae y devuelve el elemento más pequeño desde • float_delay = float que contiene segundos, con precisión de subsegundos.
repetir la opción imprimir ayuda y salir
el DST es la hora local, UTC es la hora universal (GMT).

9a 9b 9c
Machine Translated by Google
Otros módulos fsync(fd) obliga a que se escriban los búferes del sistema operativo de En Windows, el nombre de la etiqueta permite identificar diferentes asignaciones en el mismo archivo
El calendario del módulo estándar tiene funciones para crear calendarios. bajo nivel ftruncate(fd,longitud) trunca el descriptor de archivo a la longitud máxima (Unix) (predeterminado en Ninguno).

Consulte también el módulo de terceros mxDateTime. En Unix, indicadores: MAP_PRIVATE (copia en escritura privada para procesar) o MAP_SHARED

Banderas abiertas
(predeterminado). Y prot (máscara de protección de memoria): PROT_READ o PROT_WRITE, por
ARCHIVOS
defecto es PROT_READ|PROT_WRITE. Si usa los parámetros prot+flags, no use el parámetro de acceso.
Constantes definidas en el módulo os , use OR bit a bit (x|y|z) para mezclarlas.
Las operaciones de archivo normales usan objetos de archivo de Python (u objetos similares a archivos con la
O_RDONLY → solo lectura mm.close() el archivo mmap ya no se puede usar
misma interfaz). Algunas funciones manipulan directamente los nombres de las rutas de los archivos (cadenas).
O_WRONLY → solo escritura mm.find(string[,start=0])→ int: offset / ­1 mm.flush([offset,size])
Las funciones que asignan controladores de sistema operativo de bajo nivel (principalmente aquellos en el
O_RDWR → lectura/escritura escribe los cambios en el disco mm.move(dest ,src,count) copiar
módulo de sistema operativo estándar ) usan descriptores de archivo numéricos (fd también conocido como
O_APPEND → agrega cada escritura al final O_CREAT datos en el archivo mm.read([tamaño])→ str: bloque de datos leídos del
fileno).
→ crea un nuevo archivo (elimina el existente) 1
archivo mmap mm.read_byte()→ str: siguiente byte del archivo mmap1 mm.readline()→
Los datos sin procesar usan el tipo str (pueden contener cualquier valor de byte de datos, incluido 0).
O_EXCL → con O_CREAT, falla si existe el archivo (Unix)
str: siguiente línea leída del archivo, el final de la línea no se elimina1
Objetos de archivo
O_TRUNC → restablecer archivo existente a tamaño cero mm.resize(newsize) redimensionador de archivo mmap grabable mm.seek(offset[,wherece=0]) modifica
El tipo de archivo estándar es un archivo integrado. Define el protocolo de archivo de Python. O_DSYNC → xxxxxx (Unix) la posición actual en el archivo mmap ­ de donde: 0 desde el inicio, 1 desde actual, 2 desde final mm.size()→
Cree un archivo: archivo (nombre de archivo [, modo = 'r' [, tamaño de buf]]) → objeto de archivo O_RSYNC → xxxxxx (Unix) int: longitud del archivo del sistema operativo real mm.tell() → int: posición actual en el archivo mmap
Indicadores de modo (combinables): 'r' leer, 'w' escribir nuevo, 'a' escribir agregar, '+' actualizar, 'b' binary1 , O_SYNC → retorno de IO cuando los datos se escriben físicamente (Unix) mm.write(cadena) datos escritos en mmapfile1 mm.write_byte(byte) cadena de datos de un carácter
'U' universal newline2 . O_NDELAY → regresar inmediatamente (no bloquear a la persona que llama durante IO) (Unix) (byte) escritos en un archivo mmap Los métodos similares a archivos usan y mueven la posición de búsqueda
Tamaño del búfer: 0 sin búfer, 1 línea con búfer, >1 alrededor de ese tamaño. O_NONBLOCK → igual que O_NDELAY (Unix) del archivo.
Open() es un alias para file() O_NOCTTY → el archivo del dispositivo terminal no puede convertirse en proceso tty (Unix)
1
El modo de texto predeterminado intenta interpretar las secuencias de nueva línea en el archivo. O_BINARY → no procesar el final de las líneas (cf+lf from/to cr) (Windows) 1
2
Elija automáticamente la secuencia de nueva línea en CR o LF o CR+LF adaptado
O_NOINHERIT → xxxxxx (Windows)
1
de archivo/a plataforma.
O_SHORT_LIVED → xxxxxx (Windows)
Métodos y funciones Información de archivos
O_TEMPORAL → xxxxxx (Windows)

f.close() archivo vaciado y ya no se puede usar f.fileno() → int: O_RANDOM → xxxxxx (Windows) Las funciones para establecer/obtener información de archivos están en os y en el módulo os.path , algunas en

descriptor de archivo de bajo nivel (fd) f.flush() búferes escritos O_SECUENCIAL → xxxxxx (Windows) el módulo shutil . Los indicadores de constantes se definen en el módulo de estadísticas estándar .

en el archivo en el disco f.isatty() → bool: el archivo indicador es un O_TEXT → xxxxxx (Windows)

Algunas funciones que acceden a los datos del entorno del proceso (por ejemplo, el directorio de
terminal f.read([tamaño]) → str: bloque de datos leídos del archivo Tubería
trabajo actual) están documentadas en la sección Proceso. os.access(ruta,modo)→ bool: probar el
f.readline() → str: siguiente línea leída del archivo, final de línea Para la redirección de procesos estándar mediante tuberías, consulte también Control de procesos externo
acceso a la ruta con el modo usando real uid/gid ­ modo en F_OK, R_OK, W_OK, X_OK os.F_OK → modo
eliminado f.readlines() → [cadena]: lista de todos líneas leídas del archivo, final de las líneas simple (p14). os.pipe() → ((int{2}){2}): crea un par (fdmaster,fdslav) de fd (lectura, escritura) para una tubería
de acceso para probar la existencia de la ruta os.R_OK → modo de acceso para probar ruta legible
eliminadas f.seek(offset[,wherece=0]) modifica la posición actual en el archivo ­ de donde: 0 desde el inicio, 1 os.mkfifo(ruta[,modo=0666]) crea con nombre ruta de la tubería ­ modo enmascarado con umask ­ no lo abra
os.W_OK → modo de acceso a la ruta de prueba escribible os.X_OK → modo de acceso a la ruta de prueba
desde el actual, 2 desde el final f.tell() → int: actual posición en el archivo f.write(string) datos escritos en el (Unix)
archivo f.writelines(listofstrings) datos escritos en el archivo (sin agregar final de línea) for line in f :… ejecutable os.chmod(ruta,modo) cambiar el modo de ruta ­ modo usar constantes stat.S_*

iterar línea sobre líneas de f Método antiguo xreadlines reemplazado por iteración en el objeto de archivo.
Utilice las funciones os en los descriptores de archivos.

Archivos en memoria

Archivos de búfer de memoria os.chown(ruta, uid, gid) cambiar propietario y grupo de ruta (Unix) os.lchown(ruta, uid, gid)
cambiar propietario y grupo de ruta ­ no seguir enlaces simbólicos (Unix) os.fstat(fd) → int: estado del
Para un acceso directo optimizado a líneas aleatorias en archivos de texto, consulte el módulo linecache. Utilice los módulos estándar StringIO y cStringIO para crear objetos similares a archivos que almacenen datos
descriptor de archivo os.fstatvfs(fd)→ statvfs_result: información sobre el sistema de archivos que contiene
en la memoria. f = StringIO.StringIO()
el descriptor de archivo (Unix) os.stat(ruta)→ objeto de estructura estadística: información del sistema de
Atributos
archivos (Unix) os.lstat(ruta)→ objeto de estructura estadística: información del sistema de archivos (Unix) ­
Construya un archivo como en la memoria.
f.closed → bool: el archivo del indicador ha sido cerrado f.encoding no seguir los enlaces simbólicos os.stat_float_times([nuevo valor])→ bool: probar/establecer el tipo de datos
f.write(string) datos escritos en el archivo f.…otros
→ str/None: codificación del contenido del archivo f.name → str: de las marcas de tiempo de la función estadística ­ evitar establecer un nuevo valor os.statvfs(ruta)→
métodos de escritura de archivos… f.getvalue() → str:
nombre del archivo f.newlines → str/tupla de str/None: caracteres de statvfs_result: información sobre sistema de archivos que contiene la ruta (Unix) os.utime(ruta,veces)
datos actuales escritos en el archivo f.close() archivo que ya no se
nueva línea encontrados f.softspace → bool: indicador para usar espacio blando con impresión en establecer tiempos de acceso y modificación de la ruta del archivo ­ veces=(ahora,mhora) (números) ­
puede utilizar, búfer libre cStringIO es un compilado ( más eficiente)
archivo veces=Ninguna usar la hora actual os.fpathconf(fd,nombre) → str / int: información de configuración del sistema
versión de StringIO para escribir.
sobre el archivo al que hace referencia el descriptor de archivo ­ consulte la documentación de la plataforma y
Archivos de bajo nivel El argumento opcional permite crear archivos de memoria para leer también. f =
la variable pathconf_names ­ nombre str o int (Unix) os.pathconf(ruta,nombre)→ str / int: información de
Las funciones básicas de bajo nivel están en el módulo estándar os. cStringIO.StringIO([cadena]) f.read([tamaño]) → str: bloque de datos leídos de 'archivo' (cadena) f.…
configuración del sistema sobre el archivo al que hace referencia el descriptor de archivo; consulte la
Cuidado con los conflictos con elementos integrados con el nombre os.open . otros métodos de lectura de archivos…
documentación de la plataforma y la variable pathconf_names : nombre str o int (Unix) os.pathconf_names →
open(path,flags[,mode=0777])→ int (fd): abre la ruta del archivo ­ ver flags infra ­ modo enmascarado con dict: nombre → índice: nombres aceptados por pathconf y fpathconf → índice correspondiente en el host
umask Archivos asignados a la memoria (nivel de SO) ( Unix) os.path.exists(ruta)→ bool: probar la ruta existente ­ sin enlaces simbólicos rotos os.path.lexists(ruta)→
fdopen(fd[,mode[,bufsize]]) → archivo: crea un archivo conectado a fd ­ mode y bufsize como para el modo El módulo estándar mmap administra archivos mapeados en memoria, utilizables como objetos similares a bool: probar la ruta existente ­ permitir enlaces simbólicos rotos os.path.getatime(ruta)→ float_time: last hora de
integrado open()+ debe comenzar con r o w o un dup(fd)→ int (fd) : descriptor de archivo duplicado fd archivos y como objetos mutables similares a cadenas. acceso de la ruta os.path.getmtime(path)→ float_time: hora de la última modificación de la ruta
dup2(fd,fd2)→ int (fd): descriptor de archivo duplicado fd en fd2, cerrando previamente fd2 si es necesario Para construir un mapa de memoria: os.path.getctime(path)→ float_time: hora de creación (ventanas) o última
close(fd) cerrar descriptor de archivo read(fd,n)→ str: leer como la mayoría de n bytes del archivo fd: devuelve mm = mmap.mmap(fileno,length[,tagname[,access]]) [windows] mm =
una cadena vacía si se alcanza el final del archivo mmap.mmap(fileno,length[,flags[,prot[,access]]]) [ unix]
Use un descriptor de archivo os (de os.open() o de fileno() del objeto de archivo ) para un archivo
abierto para actualizar.
Longitud especifica la cantidad de bytes para mapear. En Windows, el archivo puede extenderse a
write(fd,str)→ int: escribe str en el archivo fd ­ devuelve el número de bytes realmente escritos lseek(fd,pos,how) esa longitud si es más corto, no puede estar vacío y 0 corresponde a la longitud máxima del archivo.
establece la posición del descriptor del archivo ­ cómo: 0 desde el inicio, 1 desde el actual, 2 desde el final
fdatasync( fd) vaciar los datos del archivo en el disco; no fuerce la actualización de los metadatos (Unix) Acceso (parámetro de palabra clave): ACCESS_READ (solo lectura), ACCESS_WRITE (escritura
simultánea, predeterminado en Windows) o ACCESS_COPY (copia en escritura).

10 a 10b 10c
Machine Translated by Google

tiempo de modificación (unix) de la ruta S_IRUSR → 00400 el usuario puede leer altsep → str: carácter alternativo utilizado para separar los componentes del nombre de la
os.path.getsize(ruta)→ int: tamaño en bytes del archivo de la ruta S_IWUSR → 00200 el usuario puede ruta extsep → str: carácter utilizado para separar el nombre del archivo base de la extensión
os.path.isabs(ruta)→ bool: prueba absoluta os.path.isfile(ruta)→ bool: escribir S_IXUSR → 00100 el usuario puede pathsep → str: carácter convencional para separar diferentes rutas
prueba del archivo regular (siga los enlaces simbólicos) os.path.isdir(ruta)→ bool: ejecutar S_IRWXG → 00070 el grupo puede leer+escribir+ejecutar Directorios
pruebe el directorio existente (siga los enlaces simbólicos) os.path.islink(ruta)→ bool: pruebe S_IRGRP → 00040 el grupo puede leer S_IWGRP → 00020 el
os.listdir(ruta)→ [str]/[unicode]: lista de nombres en el directorio de ruta ­ sin
el enlace simbólico os.path.ismount(ruta)→ bool: pruebe el punto de montaje grupo puede escribir S_IXGRP → 00010 el grupo puede ejecutar . y .. ­ orden arbitrario ­ tipo de cadena de ruta → tipo de cadena de
os .path.samefile(path1,path2)→ bool: la prueba se refiere al mismo archivo real (unix, S_IRWXO → 00007 todos puede leer+escribir+ejecutar S_IROTH
elemento os.mkdir(ruta[,modo=0777]) crear ruta de directorio ­ modo enmascarado con umask
macos) os.path.sameopenfile(f1,f2)→ bool: la prueba de archivos abiertos se refiere al → 00004 todos pueden leer S_IWOTH → 00002 todos pueden escribir
mismo archivo real (unix, macos) os .path.samestat(stat1,stat2)→ bool: las tuplas de S_IXOTH → 00001 todos pueden ejecutar operaciones de terminal os.makedirs(ruta[,modo=0777]) crear ruta de directorio, recursivamente ­ modo enmascarado con
estadísticas de prueba se refieren al mismo archivo (unix, macos) shutil.copymode(srcpath,dstpath) os.openpty()→ (int{2}): par abierto de pseudo­terminal1 umask ­ no manejar ruta UNC de Windows os.rmdir(ruta) eliminar ruta de directorio
copiar bits de permiso de archivo normal shutil.copystat(srcpath,dstpath) copiar archivo (fdmaster,fdslave)= (pty,tty) (Unix) os.ttyname(fd)→ str: dispositivo os.removedirs(ruta) eliminar directorios, recursivamente os.walk(top[,topdown=True [,onerror=None]])→
normal bits de permiso y horas de último acceso y modificación
terminal asociado a fd (Unix) os.isatty(fd)→ bool: el descriptor del iterable: ir a través de los directorios debajo de top, para cada directorio producir tupla(dirpath, dirnames,
archivo de prueba es similar a tty (Unix) os.tcsetpgrp(fd ,pg) establecer filenames) ­ onerror=fct(os. error) ­ consulte los documentos os.path.walk(path,visit,arg) call
el ID del grupo de procesos asociado con el terminal fd (Unix) visit(arg,dirname,names) for dirs rooted at path ­ puede modificar nombres (lista de archivos) para
os.tcgetpgrp(fd)→ int: grupo de procesos asociado con el terminal fd (Unix) influir en walk, puede preferir usar os. caminar

Estructuras de estadísticas

stat_result es devuelto por las funciones stat y lstat , utilizable como una tupla y como objeto con
atributos: atributo 0 st_mode 1 st_ino 2 st_dev 3 st_nlink 4 st_uid 5 st_gid 6 st_size 7 st_atime 8 Archivos especiales
Consulte también los módulos estándar tty y pty. Para control de interfaz de usuario en terminal
# st_mtime 9 st_ctime uso
de texto , ver curses del paquete estándar y sus submódulos. os.link(src,dst) crear enlace duro llamado dst que haga referencia a src (Unix)
bits de protección
os.symlink(src,dst) crear enlace simbólico llamado dst que apunte a src (Unix) os.readlink(ruta)→
número de inodo
str: ruta señalada a por enlace simbólico os.mknod(ruta[,modo=0666,dispositivo]) crear nodo FS
número de dispositivo Archivos temporales
(archivo, archivo especial de dispositivo, canalización con nombre) ­ modo = permisos | nodetype:
de enlaces duros ID de Utilice el módulo de archivos temporales estándar . Define varias funciones para hacer la vida más
fácil y segura. tipo de nodo en S_IFREG, S_IFREG, S_IFCHR, S_IFBLK y S_IFIFO definido en el módulo de
usuario del propietario
estadísticas os.major(dispositivo) → int: número principal del dispositivo sin procesar
Archivo temporal ([modo = 'w + b' [, tamaño de buf = ­1 [, sufijo [, prefijo [, dir]]]]]) →
ID de grupo del propietario os.minor(dispositivo) → int: número menor del dispositivo sin procesar os.makedev(principal ,menor)
archivo / archivo similar: archivo temporal ­ eliminado al cerrar ­ no necesariamente visible en el
tamaño del archivo, en bytes componer dispositivo sin formato a partir de números mayores y menores
archivo ­system ­ dir y prefijo como para mkstemp
hora del acceso más reciente
NamedTemporaryFile([mode='w+b'[,bufsize=­1[,suffix[,prefix[,dir]]]]]) → file/file­like: like TemporaryFile ­
hora de la modificación de contenido más reciente
archivo visible en el sistema de archivos mkstemp([suffix[,prefix[,dir[,text]]]])→ (int,str): (fd,path) del
hora del cambio de metadatos más reciente en Unix, hora de nuevo archivo temporal ­ sin condición de carrera ­ solo el creador puede leer/ escritura ­ sin bit Copiar, mover, eliminar os.remove (ruta)
creación en Windows st_blocks número de bloques asignados
ejecutable ­ no se elimina automáticamente ­ modo binario a menos que se especifique texto búsqueda: eliminar la ruta del archivo (no el directorio) os.rename (src, dst)
para el archivo (Unix) st_blksize tamaño del bloque del sistema de archivos (Unix)
no se elimina automáticamente gettempdir() → str: directorio predeterminado para archivos temporales cambiar el nombre de src a dst ­ en el mismo sistema de archivos ­ puede eliminar el archivo dst
st_rdev st_rsize st_creator código del creador del archivo (MacOS) st_type gettempprefix() → str: prefijo de nombre de archivo predeterminado para archivos temporales Otras existente os.renames (antiguo, nuevo) cambie el nombre de antiguo a nuevo, recursivamente:
tipo de dispositivo si es un dispositivo inodo (Unix)
funciones en tempfile y módulos os se conservan para la compatibilidad del código, pero se consideran intente crear directorios intermedios os.unlink (ruta) elimine la ruta del archivo (no el directorio):
tamaño de la bifurcación de recursos, en bytes (MacOS) no lo suficientemente seguras. También tempdir y datos de plantilla en tempfile , que no deben usarse lo mismo que eliminar El módulo estándar shutil proporciona funciones de alto nivel en archivos y
directamente. directorios. copyfile(src,dst) copiar el contenido del archivo normal ­ sobrescribir destino2 .
código de tipo de archivo (MacOS)
copyfileobj(fsrc,fdst[,length=16kb]) copia el contenido del objeto similar a un archivo por bloques
statvfs_result es devuelto por las funciones fstatvfs y statvfs , utilizable como una tupla (use índices de de tamaño de longitud (<0=un trozo) copy(src,dst) copia el contenido del archivo normal a file/
variables statvfs ) y como un objeto con atributos: atributo 0 f_bsize 1 f_frsize 2 f_blocks 3 f_bfree 4 directory2 ­ en caso de El directorio usa el mismo nombre base que src ­ sobrescribe el destino ­
f_bavail 5 f_files 6 f_ffree 7 f_favail nodos libres disponibles para no superusuario 8 banderas f_flag : copia los bits de permiso. copy2(src,dst) igual que copiar + copiar las horas de último acceso y
# consulte la página delíndice
manualvar de host statvfs() 9 f_namemax uso
F_NAMEMAX longitud modificación copytree(src,dst[,symlinks=False]) copiar recursivamente el árbol de directorios ­
Manipulaciones de rutas Las
máxima del nombre de archivo
F_BSIZE sistema de archivos preferido tamaño de el destino debe ser nuevo ­ los archivos copiados a través de la copia ­ si los enlaces simbólicos son
funciones de manipulación de rutas se encuentran en el módulo os.path estándar .
F_FRSIZE bloque sistema de archivos fundamental falsos, copie el contenido de los archivos de enlaces simbólicos, de lo contrario , simplemente cree
support_unicode_filenames → bool: unicode utilizable para nombres de archivo abspath(ruta)→ 2
.
F_BLOQUES tamaño de bloque número total de bloques en el enlaces simbólicos . ,dst) mover recursivamente un archivo o un árbol de directorios; puede
str: nombre de ruta absolutizado normalizado nombrebase(ruta)→ str: parte del nombre de
F_BGRATIS sistema de archivos número total de bloques libres renombrar o copiar.1
archivo de la ruta commonprefix(pathlist) → str: prefijo de ruta común más largo (char­by­char)
F_BAVAIL bloques gratuitos disponibles para no superusuarios
dirname (ruta)→ str: nombre del directorio del nombre de la ruta join(ruta[,…])→ str: concatenar
número total de nodos de archivo
F_ARCHIVOS los componentes de la ruta normcase(ruta)→ str: normalizar la ruta case para la plataforma (ver
número total de nodos de archivos libres
F_FGRATIS doc) normpath(ruta)→ str: normalizar la ruta ( // /./ /../), en windows /→ \ realpath(ruta)→ str: ruta
F_FAVIL canónica (eliminar enlaces simbólicos) (unix) split(ruta)→ (str{2}): dividir en (cabeza, último
F_BANDERA componente de nombre de ruta) splitdrive(ruta)→ (str{2}): dividir en (unidad, final) splitext(ruta)→ 1
(str{2}): dividir en (raíz, ext) Puede generar la excepción shutil.Error .
2
Los parámetros src y dst son nombres de rutas de archivos.
Constantes estadísticas
Archivos codificados
Definido en el módulo de estadísticas estándar .
Los códecs de módulo estándar tienen funciones y objetos para procesar archivos codificados de
S_ISUID → xxxx forma transparente (utilizados internamente como archivos Unicode). codecs.open (nombre de
Datos de ruta específicos del
S_ISGID → xxxx archivo, modo [, codificación [, errores [, almacenamiento en búfer]]]) → objeto EncodedFile similar
S_ENFMT → xxxx host sys.getfilesystemencoding() → str: nombre de la codificación utilizada por el sistema para los
a un archivo con códecs de codificación / decodificación transparentes. EncodedFile (archivo,
nombres de archivo Los siguientes datos están en os y en os.path. curdir → str: cadena utilizada
S_ISVTX → xxxxx entrada [, salida [, errores]]) → archivo­ como envoltorio alrededor del archivo, decodificar desde la
S_IREAD → 00400 el usuario puede leer para hacer referencia al directorio actual pardir → str: cadena utilizada para hacer referencia al
codificación de entrada y codificar para codificación de salida códecs.BOM → str: alias para
S_IWRITE → 00200 el usuario puede escribir directorio principal sep → str: char utilizado para separar los componentes del nombre de la ruta
BOM_UTF16 códecs.BOM_BE → str: alias para BOM_UTF16_BE
S_IEXEC → 00100 el usuario puede ejecutar
S_IRWXU → 00700 el usuario puede leer+escribir+ejecutar
11a 11b 11c
Machine Translated by Google

códecs.BOM_LE → str: alias para BOM_UTF16_LE rp.write(fileobject) escribir datos de configuración en el archivo RuntimeError ― (prefiere definir subclases ad­hoc).
códecs.BOM_UTF8 → str: '\xef\xbb\xbf' códecs.BOM_UTF16 rp.remove_option(sección,opción)→ bool: devuelve True si existiera tal opción ­ puede generar NotImplementedError
→ str: alias para BOM_UTF16_LE o BOM_UTF16_BE códecs.BOM_UTF16_BE → str: NoSectionError rp.remove_section(section)→ bool: devuelve True si existiera tal sección SyntaxError IndentationError
'\xfe\xff' códecs.BOM_UTF16_BE → str: códecs '\xff\ xfe'.BOM_UTF32 → str: alias para rp.optionxform(option)→ str: forma interna normalizada de la opción Interfaz normal
códecs BOM_UTF32_LE o BOM_UTF32_BE.BOM_UTF32_BE → str: códecs TabError
'\x00\x00\xfe\xff'.BOM_UTF32_LE → str : ' \xff\xfe\x00\x00 ' SystemError : un error... en Python.
TypeError
cp.get(sección,opción[,sin procesar[,vars]])→ cadena: valor para la opción en la sección ­ % de
ValueError ― buen tipo, pero mal valor.
interpolación expandida a menos que raw sea verdadero ­ vars es un dict de valores predeterminados Advertencia de
Consulte Codificación ­ Decodificación (p12) para obtener detalles sobre la codificación y los errores.
adicionales ­ los nombres de expansión de referencia son procesados por optionxform() para hacer
Publicación por entregas UnicodeError : superclase de advertencias (ver Advertencias más adelante)
coincidir cp.items(section[,raw[,vars]])→ [(name,value)]: para la sección dada ­ raw y vars como en get()
UserWarning
Los módulos estándar pickle y cPickle (velocidad de hasta 1000x) tienen soporte para la
PendingDeprecationWarning
serialización de datos de jerarquías de objetos.
Interfaz segura DeprecationWarning SintaxisWarning
Consulte la documentación de Python.
Véase también marshal del módulo (lectura/escritura de datos de Python en formato sp.set(sección,opción,valor) establecer cadena de valor para sección y opción RuntimeWarning Advertencias Las

binario independiente de la plataforma, pero puede romper el formato entre versiones). advertencias deben ser subclases de la
Excepciones
El módulo estándar clase raíz de advertencia .
(Excepción)
de persistencia deja de lado el uso del protocolo de decapado para almacenar objetos en archivos Error
DBM (consulte la página 17) y acceder a ellos a través de una interfaz similar a un diccionario con Error de sintáxis El módulo de advertencias estándar controla el procesamiento de las excepciones de advertencia.
claves como str. open(filename[,flag[,protocol[,writeback[,binary]]]])→ objeto similar a un diccionario NoSectionError warn(mensaje[,categoría[,stacklevel]]) warn_explicit(mensaje,categoría,nombre de
­ marcar como anydbm.open (p17), predeterminado en 'c' ­ protocolo predeterminado en 0 (formato DuplicateSectionError archivo,lineno[,módulo[,registro]]) showwarning(mensaje,categoría,nombre de archivo,lineno[,archivo])
ascii) ­ reescritura: almacena en caché las entradas en la memoria y las vuelve a escribir en el momento Error de encabezado de sección faltante formatwarning(mensaje,categoría, filename,lineno)
del cierre; el valor predeterminado es Falso: el binario está en desuso, use el protocolo. NoOptionError filterwarnings(acción[,mensaje[,categoría[,módulo[,lineno[,agregar]]]]]) resetwarnings()
Error de interpolación sys.warnoptions
InterpolationDepthErrorInterpolationDepthError
Archivos de configuración InterpolationMissingOptionErrorInterpolationMissingOptionError
Módulo estándar ConfigParser. Utiliza archivos .INI estándar para almacenar datos de Error de sintaxis de interpolación
Procesamiento de excepciones
configuración:
Para obtener un formato de archivo similar que admita subsecciones anidadas, consulte el
[sección] Los valores pueden contener referencias de %(name)s que se sys.exc_info()→ (tipo, valor, rastreo) para la excepción actual 1 sys.exc_clear()
nombre:valor analizador de configuración ConfigObj . Para usuarios de Windows, el módulo estándar _winreg.
pueden expandir usando valores en la misma sección o en los valores información relacionada con la excepción actual borrada sys.excepthook → (rw) fct (tipo,
nombre=valor predeterminados # y ; iniciar líneas de comentarios. Para configuraciones de archivos de texto, puede usar herramientas XML y ver también analizadores
valor, rastreo) llamado para excepciones no detectadas sys. __excepthook__ → copia de
YAML de terceros como PyYaml.
seguridad de la función original de excepthook sys.tracebacklimit → int: (rw) niveles
El módulo define 3 clases de configuración con diferentes niveles de acceso a datos: RawConfigParser EXCEPCIONES máximos de rastreo impreso, <=0 para ninguno
ConfigParser SafeConfigParser
Excepciones estándar definidas en el módulo de excepciones y disponibles en el alcance actual.
1
O (Ninguno,Ninguno,Ninguno) si no se ejecuta ninguna excepción.
Todas las excepciones deben ser subclases de la clase raíz de excepciones . El seguimiento del módulo estándar tiene herramientas para procesar y formatear esta
rp=RawConfigParser([predeterminados]) → RawConfigParser
Utilice excepciones estándar si su significado corresponde a sus errores. información.
cp=ConfigParser([predeterminados]) → ConfigParser
Excepciones estándar de subclase cuando sea necesario.
sp=SafeConfigParser([predeterminados]) → SafeConfigParser En los tres
CODIFICACIÓN ­ DECODIFICACIÓN
constructores, los valores predeterminados son una sentencia de opción:valor para la Clases de excepción estándar Excepción
expansión de referencias. StopIteration : siguiente () del iterador, no hay Los códecs de módulos estándar brindan soporte básico para codificar/descodificar datos. Esto se
MAX_INTERPOLATION_DEPTH → int: profundidad recursiva máxima para get() cuando el parámetro más valor. usa para la codificación de caracteres, pero también para la compresión de datos (zip, bz2) o la
sin procesar es falso DEFAULTSECT → str: nombre de la sección predeterminada SystemExit ― sys.exit() llamado representación de datos (uu, hex).
StandardError ― excepciones integradas Consulte Cadenas Unicode (p5), Codificaciones de origen (p3).
ArithmeticError : errores aritméticos. Consulte funciones, clases y constantes para la codificación de archivos en Archivos codificados
Interfaz sin procesar
Error de punto flotante (p11).
rp.defaults()→ dict: valores predeterminados para la expansión de referencias OverflowError Módulo codificaciones.aliases.
rp.sections()→ [string]: lista de secciones en la configuración (sin DEFAULT) ZeroDivisionError
HILOS Y SINCRONIZACIÓN
rp.add_section(section) agregar una nueva sección ­ puede generar
AssertionError ― aseverar cond[,message] falló.
DuplicateSectionError rp.has_section( sección)→ bool: prueba si la sección existe ­ no Los subprocesos de Python utilizan subprocesos nativos. Un mutex global (el GIL) bloquea
AttributeError : error al establecer/obtener atributo.
puedo probar DEFAULT rp.options(sección)→ [cadena]: lista de opciones en la sección los datos del intérprete durante la ejecución de las instrucciones virtuales de Python (se
EnvironmentError : error del sistema host: consulte el atributo de la tupla arg
rp.has_option(sección,opción)→ bool: prueba si la sección y la opción existen rp.read( [nombre de IOError desbloquea durante la E/S o el cálculo largo en código nativo). Verifique que el cambio de
archivo]/nombre de archivo) → [nombre de archivo]: intente cargar los datos de configuración de los OSError subprocesos y el procesamiento de la señal se realicen a intervalos regulares. sys.getcheckinterval()→
1
archivos (continúe si falla) ­ devuelva los nombres de los archivos cargados rp.readfp(fp[,nombre de int: intervalo de verificación de cambio de hilo actual sys.setcheckinterval(intervalo) establecer
WindowsError : códigos de error de Windows.
archivo]) cargue los datos de configuración del archivo/ rp similar a un archivo .get(sección,opción)→ intervalo de verificación de cambio de hilo1
EOFError ― fin de archivo con input() o raw_input().
str: valor de la opción rp.getint(sección,opción)→ int: convertir el valor de la opción en int 1
Expresado en número de instrucciones virtuales de Python.
ImportError
rp.getfloat(sección,opción)→ float: convertir el valor de la opción en float rp.getboolean(sección,
KeyboardInterrupt : interrupción del usuario (Ctrl­C). Funciones de subprocesamiento
option)→ bool: forzar el valor de la opción a bool ­ True es cadenas 1 sí true on ­ False es cadenas 0
LookupError Utilice el subprocesamiento de módulo de alto nivel estándar que proporciona varias clases:
no false off ­ puede generar ValueError rp.items(section)→[(name,value)]: opciones en la sección
IndexError : índice de secuencia inexistente. Subproceso, local (para almacenamiento local de subprocesos), Evento, Bloqueo y RLock
rp .set(s) sección, opción, valor) establecer la opción en el valor de cadena en la sección ­ puede
KeyError : clave de asignación inexistente. (mutex), Semáforo y BoudedSemaphore, Temporizador.
generar NoSectionError
MemoryError El subprocesamiento del módulo también proporciona
NameError : nombre inexistente en el ámbito actual. funciones: activeCount()→ int: número de subprocesos actualmente activos
UnboundLocalError : referencia a una variable local no asignada. subproceso actual()→ Subproceso: subproceso actual en ejecución
ReferenceError : intente acceder al objeto descartado de referencia débil. enumerar()→ [Subproceso]: lista de subprocesos activos

12a 12b 12c

Machine Translated by Google
settrace(func) función de seguimiento de instalación llamada antes de que los subprocesos Programador de eventos de propósito general sys.exit([arg=0]) sale a través de una excepción SystemExit (puede ser catch) ­ arg es el código de
ejecuten métodos setprofile(func) función de perfil de instalación llamada antes de que los subprocesos salida os._exit(n) sale sin limpieza os.abort() sale a través de una señal SIGABRT (la señal puede
El módulo sched proporciona una herramienta de este tipo, adaptable a sus necesidades (la
ejecuten métodos El subproceso de módulo estándar admite la gestión de subprocesos de bajo nivel. unidad de "tiempo" es suya). sc = sched.scheduler(timefunc,delayfunc) → planificador: timefunc ser manejado)
Utilice los módulos dummy_thread y dummy_threading en plataformas sin subprocesos múltiples. devuelve números que miden el tiempo, delayfunc(n) espera n tiempo (la misma unidad que la salida
de timefunc) ­ típicamente sc = sched.scheduler(time.time,time.sleep) Los siguientes códigos de salida están definidos en os (Unix):
Hilos sc .enterabs(hora,prioridad,acción,argumentos) → evtid: programar un nuevo evento, llamará a la Comando No hay error

La clase threading.Thread se usa para crear una nueva ruta de ejecución en el proceso actual. Debe acción(*argumentos) a la hora sc.enter(retraso,prioridad,acción,argumentos)→ evtid: programar un EX_USO EX_OK utilizado incorrectamente
llamarse con argumentos de palabra clave. Especifique el código del subproceso con un parámetro de nuevo evento, llamará action(*args) after delay sc.cancel(evtid) eliminar evento programado ­ EX_DATAERR datos de entrada incorrectos
destino invocable o reemplazando el método de ejecución (recuerde llamar al __init__ heredado en las puede generar RuntimeError sc.empty()→ bool: probar si la cola de eventos del programador está EX_NOINPUT usuario desconocido de entrada no disponible/inaccesible
subclases), proporcione argumentos en args y kwargs (tuple y dict), asigne un nombre para identificar vacía sc.run() ejecutar eventos programados en su horario de programación ­ ver documentos EX_NOUSER
el subproceso ­ grupo actualmente no utilizado (Ninguno). th = threading.Thread(group,target,name,args,kwargs) EX_NOHOST host desconocido
th.start() iniciar actividad de subproceso (en otro subproceso) th.run() código de subproceso a EX_UNAVAILABLE servicio requerido no disponible
ejecutar ­ llamar al destino si no se anula th.join( [tiempo de espera]) esperar a que finalice o transcurra EX_SOFTWARE error interno
el tiempo de espera (float_delay, predeterminado en Ninguno para infinito) th.getName()→ str: nombre Semáforos EX_OSRR Falta el
asociado del subproceso th.setName(nombre) establecer el nombre asociado del subproceso (nombre EX_OSFILE no archivo OS error/inaccesible
Las clases threading.Semaphore y threading.BoundedSemaphore proporcionan un semáforo
inicial establecido por clase) th.isAlive()→ bool: subproceso de prueba activo (iniciado y ejecutado() no puede crear salida
Error EX_CANTCREAT
simple para el conteo de recursos (sin/con verificación de contador). sem = threading.Semaphore([value=1])
terminado) th.isDaemon()→ bool: subproceso de prueba tiene indicador de daemon
semáforo con contador inicial sem = threading.BoundedSemaphore([value]) sem.acquire([blocking])→ EX_IOERR durante la E/S del archivo
th.setDaemon(daemonic) establecer indicador de demonio de subproceso ­ debe llamarse antes de bool/None: adquiere el semáforo (consume un recurso). bloqueo no especificado: espera y retorno EX_TEMPFAIL error temporal
iniciar . Indicador inicial heredado de la creación del hilo. El proceso de Python sale solo después de la Ninguno ; bloqueo verdadero: esperar y devolver verdadero ; bloqueo falso: no espere (pruebe) y EX_PROTOCOL intercambio de protocolo ilegal/inválido/no entendido permisos insuficientes
última finalización del subproceso no demonio.
devuelva Verdadero/Falso sem.release() libere el semáforo (un recurso gratis) Problema de (permisos sin archivo)
EX_CONFIG configuración EX_NOPERM
datos faltantes
EX_NO FOUND

Variables de condición Puede instalar funciones de salida (para salida normal) con el módulo atexit.
Un subproceso no puede ser eliminado o pausado externamente por otro subproceso. register(func[,*args[,**kargs]]) función de registro que se llamará con args y kargs Las funciones
Class threading.Condition permite que los subprocesos compartan el estado (datos)
Almacenamiento local de subprocesos registradas se llaman en orden inverso al registro.
protegidos a través de un bloqueo. Importante: las variables de condición (bloqueo) deben
Los valores de los atributos de clase threading.local son subprocesos locales. adquirirse al llamar a esperar, notificar o notificar a todos. Consulte la documentación de Python.
Se omite cuando el proceso finaliza por una señal, un error interno o un os._exit.
Subclasifique o utilícelo como un espacio de nombres. cond = threading.Condition([lock]) construye una nueva variable de condición, usa el bloqueo
tlsdata = roscado.local() tlsdata.x = 1 proporcionado por el usuario (Lock o RLock) o crea una nueva RLock cond.acquire(*args)→ valor:
adquiere cond. variedad bloquear, devolver el valor lock.acquire() Variables de entorno

Threading de clase de environ → dict: variables de entorno ­ modificación llame a putenv si es compatible
cond.release() liberar cond. variedad lock getenv(varname[,default=None])→ str: valor de variable de entorno putenv(varname,value) establecer
subproceso de inicio retrasado . El temporizador es una subclase de subproceso que se ejecuta
cond.wait([tiempo de espera]) espera hasta que se notifique o se agote el tiempo de espera; el variable de entorno ­ afecta el subproceso iniciado más tarde ­ puede causar fugas de memoria (ver
efectivamente después de un intervalo específico desde su inicio. t =
tiempo de espera es un float_delay (predeterminado en Ninguno = bloqueo infinito). Liberar cond. documentación de la plataforma)
threading.Timer(interval,function,args=[],kwargs={}) t.cancel() el temporizador nunca se ejecutará;
variedad bloquear y esperar una notificación/tiempo de espera y luego volver a adquirir el bloqueo.
no debe estar ejecutándose Algunas funciones también en os.path :
cond.notify() activa un subproceso en espera (si lo hay). cond.notifyAll() activa todos los
Cree un temporizador que ejecutará la función con argumentos args y argumentos de palabra clave expanduser(ruta)→ str: ruta con la inicial "~" o "~user" reemplazada expandvars(string)→
subprocesos en espera.
kwargs, después de que hayan pasado los segundos del intervalo. str: cadena con $name o ${name} variable de entorno reemplazada
Exclusión mutua El módulo de colas sincronizadas
Queue proporciona una cola de clase para almacenar datos en una cola FIFO sincronizada y dos
Las clases threading.Lock y threading.RLock proporcionan exclusión mutua entre Directorio, Archivos, Terminal
clases de excepción Full y Empty. En el modo de bloqueo, la cola completa bloquea a los
subprocesos. El bloqueo no permite que un subproceso vuelva a adquirir un bloqueo que ya posee, Consulte también Consola y entrada/salida interactiva (p1) y Archivos ­ Operaciones de terminal
productores y la cola vacía bloquea a los consumidores (en el modo sin bloqueo generan excepciones).
RLock sí lo hace (bloqueo de reentrada). lock = threading.Lock() lock = threading.RLock() (p11). chdir(ruta) cambia el directorio de trabajo actual a la ruta fchdir(fd) cambia el directorio
Se puede construir otra organización con subclases (consulte la fuente para conocer los métodos
lock.acquire([blocking])→ bool/None: adquiere el bloqueo. bloqueo no especificado: espera y retorno de trabajo actual para que esté representado por el descriptor de archivo getcwd()→ str: directorio de
internos). q = queue.Queue(maxsize) construye una nueva cola ­ cola infinita si maxsize<=0
Ninguno ; bloqueo verdadero: esperar y devolver verdadero ; bloqueo falso: no espere (intente) y trabajo actual getcwdu()→ unicode: directorio de trabajo actual chroot(ruta) cambiar procesar la
q.qsize()→ int: tamaño de la cola ­ en el momento de la llamada q.empty()→ bool: prueba si el tamaño
devuelva Verdadero/Falso lock.release() desbloquear un bloqueo adquirido previamente Debe liberar raíz del sistema de archivos a la ruta (Unix) umask(máscara)→ int: establecer el umask numérico
de la cola es 0 ­ en el momento de la llamada q.full()→ bool: prueba si el tamaño de la cola es máximo ­
un bloqueo al mismo tiempo que se adquirió. actual y devolver el anterior ctermid()→ str: nombre de archivo del terminal de control (Unix)
en el momento de la llamada q.put(elemento[,bloque[,tiempo de espera]]) poner el elemento en la cola
getlogin()→ str: nombre del usuario que inició sesión controlando terminales (Unix)
­ el bloque puede ser verdadero/falso, tiempo de espera puede ser Ninguno/float_delay. Puede generar
la excepción Queue.Full . q.put_nowait(item) igual que put(item,False) q.get([block[,timeout]])→ item:
eliminado de la cola ­ el bloque puede ser verdadero/falso, el tiempo de espera puede ser Ninguno/
Buena práctica para adquirir/liberar bloqueos en bloques try/finally . float_delay ­ puede aumentar Queue.Empty excepción q.get_nowait() igual que get(False)
Para mutex entre procesos portátil, consulte el módulo glock.py de terceros .
Eventos Usuario, proceso, ID de grupo

Class threading.Event es un indicador de sincronización con un mecanismo de bloqueo de pid: id de proceso, gid: id de grupo, uid: id de usuario
subprocesos para esperar el indicador. evt = threading.Event() nuevo evento, con el indicador getpid()→ int: pid actual getegid()→ int: gid efectivo (Unix)
PROCESO
interno establecido en False evt.isSet()→ bool: valor del indicador interno del evento evt.set() setegid(egid) establecer proceso gid efectivo (Unix)
establecer el indicador interno del evento en verdadero ­ desbloquear subprocesos en espera Proceso actual geteuid()→ int : uid efectivo (Unix) seteuid(euid) establecer
evt.clear( ) establezca el indicador interno del evento en False evt.wait([timeout]) espere a que El módulo estándar os tiene herramientas para obtener información y manipular el proceso actual y su proceso uid efectivo (Unix) getgid()→ int: real gid (Unix)
el indicador interno del evento sea verdadero: el tiempo de espera es un float_delay (predeterminado entorno. setgid(gid) establecer proceso gid (Unix) getgid()→ int:
en Ninguno = bloqueo infinito) proceso actual' uid (Unix) setuid(uid) establecer el uid actual
saliendo
del proceso (Unix)
Normalmente, el proceso de Python sale cuando no hay más subprocesos que no sean demonios en
ejecución.

13a 13b 13c

Machine Translated by Google

setregid(rgid,egid) establecer proceso gid real y efectivo (Unix) setreuid(ruid,euid) SIG_IGN → 1: ignorar la función del controlador de señal p.stderr → archivo/Ninguno: salida de error del proceso secundario si se captura p.pid
establecer proceso uid real y efectivo (Unix) getpgrp()→ int: gid actual (Unix) NSIG → int: número de señal más alto +1 → int: ID de proceso del proceso secundario p.returncode → int/Ninguno: código de
getgroups()→ [int] : lista de gid asociados suplementarios (Unix) setgroups(groups) retorno del proceso secundario (Ninguno si no está terminado) ­ en Unix ­N para subproceso terminado
El módulo también define los números de señal (ejemplos de Posix: la definición del tiempo de ejecución
lista de conjuntos de gid asociados suplementarios (Unix) setpgrp() sistema de depende de la plataforma): interrupción del teclado de desconexión del proceso de control o terminal por señal N Use el módulo de subproceso cuando sea posible (interfaz más limpia y simple, consulte
llamadas function1 (Unix) getppid()→ int: pid del padre (Unix) setsid() sistema de SUSCRÍBETE los documentos para ver ejemplos). Véase también expectativa de módulo externo.
llamadas function1 (Unix) getpgid(pid)→ int: id del grupo de procesos del id del proceso SEGUIR
pid (0=actual) (Unix) getsid(pid) llamar al sistema function1 (Unix) setpgid(pid,pgrp) SIGQUIT solicitud de salida del teclado instrucción ilegal Control de procesos externo avanzado
establecer el grupo de pid del proceso en pgrp1 (Unix) SEÑAL SIGABRT abortar señal de parada
Consulte las siguientes funciones del módulo os .
error de coma flotante SIGKILL la señal KILL SIGSEGV
execl(ruta,[arg[,…]]) execle(ruta,[arg[,…]],env)
SIGFPE referencia de memoria no válida
execlp(archivo,[arg[,…]]) execlpe(archivo,[arg[,…]], env)
SIGPIPE escribir sin lector SIGALRM temporizador de
1
execv(ruta,argumentos) execve(ruta,argumentos,env)
Vea el manual para la semántica. alarma transcurrido SIGTERM señal de terminación
execvp(archivo,argumentos) execvpe(archivo,argumentos,env)
SIGUSR1 señal de usuario 1 SIGUSR2 señal de usuario
Horarios, Prioridad
2 SIGCHLD hijo terminado/detenido SIGCONT continuar
times()→ (ut,st,cut,cst,ert): (float_delay{5}): hora del usuario, hora del sistema, hora del usuario de proceso (si está parado)
los niños, hora del sistema de los niños, tiempo real transcurrido agradable(incremento)→ int:
proceso renice ­ devolver nueva amabilidad (Unix)
Con exec… el nuevo programa reemplaza el proceso actual (fct no regresa). Las versiones 'p' usan
Memoria
PATH para localizar el archivo ejecutable. Las versiones 'e' usan un dict env para configurar un nuevo
plock(op) bloquear segmentos de programa en la memoria ­ ver <sys/lock.h> para valores de entorno de programa. Las versiones 'l' usan un argumento posicionado, las versiones 'v' usan una lista
operación (Unix) SIGSTOP proceso de detención
de argumentos variables. spawnl(modo,ruta,[arg[,…]])→ int spawnle(modo,ruta,[arg[,…]],env) → int
SIGTSTP solicitud de detención desde el teclado SIGTTIN
Información del anfitrión spawnlp(modo,archivo,[arg[,…]])→ int spawnlpe(modo,archivo,[arg[,…]],env) → int spawnv(modo,ruta,args)
lee en tty mientras está en segundo plano SIGTTOU escribe
→ int spawnve(modo,ruta,args,env) → int spawnvp(modo,archivo,args) → int spawnvpe(mode,file,args,env)
strerror(code)→ str: mensaje de error para el código de error uname()→ en tty mientras está en segundo plano → consulte la
→ int Con spawn… se crea un nuevo proceso. Versiones 'lpev' como para exec….
tuple: identificación del sistema operativo actual, (sysname, nodename, release, version, … documentación de su plataforma (señal de man 7 en Linux).
machine) (Unix reciente)
Las funciones para enviar señales están en el módulo os :
sys.byteorder → str: orden de bytes nativo del host grande o pequeño sys.winver kill(pid,sig) matar proceso pid con señal sig (Unix) killpg(pgid,sig)
→ str: número de versión para claves de registro (Windows) sys.platform → str: matar proceso grupo pgid con señal sig (Unix)
identificador de plataforma (por ejemplo, linux2)
Control de procesos externo simple
Los siguientes datos están en os y en os.path. defpath →
Usar subproceso de módulo estándar. Envuelve la creación y el control de procesos externos en
str: ruta de búsqueda para os.exec*p*() y os.spawn*p*() si el entorno PATH no está definido Si el modo es P_NOWAIT o P_NOWAIT0, devuelve el pid secundario (Unix) o el identificador del
objetos Popen . Las excepciones de procesos secundarios generadas antes de la ejecución se
vuelven a generar en el proceso principal, las excepciones tendrán el atributo child_traceback proceso (Windows). Si el modo es P_WAIT, espere la finalización del hijo y devuelva su código de
linesep → str: carácter(es) de fin de línea para la plataforma devnull salida (>0) o su señal de eliminación (<0). En el modo Windows puede ser P_DETACH (igual que
(cadena).
→ str: ruta del archivo del dispositivo nulo P_NOWAIT pero el nuevo proceso se separó de la consola del proceso de llamada) o P_OVERLAY
Nota: las herramientas de subproceso nunca llamarán a /bin/sh implícitamente.
Información de Python (se reemplaza el proceso actual). fork()→ pid: bifurcar un proceso hijo, devolver 0 en hijo, pid hijo en
PIPE → ­1: valor constante utilizado para Popen stdin stdout stderr params
padre (Unix) forkpty()→ (int{2}): (pid,fd): bifurcar usando un nuevo pseudo­terminal para hijo ­ pid es 0
sys.builtin_module_names → (str): nombres de los módulos compilados en el intérprete call(*args,**kwargs)→ int: ejecutar el comando con argumentos, esperar a que se complete,
en child, child pid en parent ­ fd pseudo­terminal master end (Unix) startfile(ruta) abra la ruta del
sys.copyright → str: copyright del intérprete sys.hexversion → int: versión de Python con un devolver el código de retorno ­ envoltorio conveniente alrededor del objeto Popen
archivo como si hubiera hecho doble clic en explorer (Windows) system(cmd)→ valor: ejecutar string
dígito por byte sys.version → str: versión del intérprete + compilación + compilador sys.dllhandle
Utilice objetos Popen como herramientas de control de cmd en subshell ­ generalmente devuelve (pid/status) (Unix) o estado (Windows) espera()→ (int{2}):
→ int: identificador de la DLL de Python (Windows) sys.executable → str: nombre del binario
procesos: p = Popen(args,bufsize=0,executable=Ninguno,stdin=Ninguno,stdout=Ninguno, (pid,status) espera la finalización de un proceso secundario (Unix) ­ estado=0xZZTT donde ZZ=código
ejecutable del intérprete sys.prefix → str: prefijo de directorio para archivos de Python
stderr=Ninguno, preexec_fn=Ninguno,close_fds=False,shell=False,cwd=Ninguno, de salida, TT=número de señal waitpid(pid,opciones)→ (int{2}): (pid,status) (Unix): pid>0 espera por
independientes de la plataforma sys.api_version → int: versión de Python C API sys. version_info
env=Ninguno,universal_newlines=False,startupinfo=Ninguno,creationflags=0) args es una cadena/lista un proceso específico, pid=0 espera por cualquier hijo en el grupo de procesos, pid=­1 esperar a
→ (int{3},str,int): (major, minor, micro, releaselevel, serial) ­ lanzamiento en alfa, beta, candidato,
de cadenas ["comando","arg1","arg2",...] bufsize como para archivo/abrir funciones ejecutables cualquier hijo del proceso actual, pid<­1 esperar a cualquier proceso en el grupo de procesos ­opción
final
se pueden usar para proporcionar el comando en lugar de args[0] stdin, stdout y stderr pueden pid en WNOHANG, WCONTINUED, WUNTRACED status=0xZZTT donde ZZ=código de salida,
ser PIPE para capturar el archivo y comunicarse con el subproceso se llama a preexec_fn justo TT=número de señal
antes de la ejecución del proceso secundario close_fds bool fuerza el cierre de los archivos
heredados del subproceso, excepto 0
Manejo de señal Señal
de módulo estándar . Consulte el documento para conocer las reglas generales sobre el uso de señales
1y2
en Python.
Los manejadores de señales son invocables f(signalnum,stackframe). shell bool forzar la ejecución del comando a través de la cadena shell cwd waitpid(pid,opciones)→ (int{2}): (pid,status) (Windows): pid es cualquier identificador de proceso (>0) ­
especificar el directorio de trabajo para configurar el subproceso iniciar el diccionario del opción ignorada ­ estado=0xZZ00 donde ZZ=código de salida
alarm(time)→ float_delay: tiempo restante de la alarma anterior ­ solicitar un nuevo SIGALRM en entorno especificar las variables de entorno para el subproceso universal_newlines traducir
Extracción de información de estado
segundos de tiempo ­ cancelar el anterior ­ time≠0 (Unix) alarm(0)→ float_delay: tiempo restante todas las líneas nuevas a \n (como el modo U para los archivos) startupinfo y las banderas de
de la alarma anterior ­ cancelar la alarma anterior (Unix) getsignal( signalnum)→ fct: controlador de creación son información opcional para la creación de procesos en Windows p.poll()→ int/ WCOREDUMP(status)→ bool: proceso de prueba generado core­dump (Unix)
señal actual o SIG_IGN o SIG_DFL o Ninguno (controlador no instalado desde Python) pause() Ninguno: verifique la finalización del proceso secundario, devuelva el atributo de código de WIFCONTINUED(status)→ bool: proceso de prueba continuado desde una parada de control de trabajo
proceso de suspensión hasta que se recibe una señal (Unix) signal(signalnum,handler)→ fct: controlador retorno (Unix)
anterior para la señal (como getsignal) ­ instale un nuevo controlador (tal vez SIG_IGN o SIG_DFL WIFSTOPPED(status)→ bool: proceso de prueba detenido (Unix)
también) ­ solo se puede llamar en el hilo principal p.wait()→ int: esperar a que finalice el proceso secundario, devolver el atributo de código de retorno WIFSIGNALED(status)→ bool: prueba salió en señal (Unix)
p.communicate(input=None)→ (stdout,stderr): enviar datos (cadena de entrada) a stdin, leer datos desde WIFEXITED(status)→ bool: el proceso de prueba salió a través de la llamada al sistema exit(2) (Unix)
stdout/stderr hasta el final ­de archivo, espera que el proceso finalice, devuelve valores de lectura: la WEXITSTATUS(status)→ int: si se sale a través de exit(2), devuelve el parámetro de salida (Unix)
lectura de datos se almacena en la memoria p.stdin → archivo/Ninguno: entrada estándar del proceso WSTOPSIG(status)→ int: señal de haber detenido el proceso (Unix)
Se definen las siguientes constantes de señal: chil si se captura p.stdout → archivo/Ninguno: salida estándar del proceso chil si se captura WTERMSIG(status)→ int: señal de haber salido del proceso (Unix)
SIG_DFL → 0: función de controlador de señal predeterminada

14a 14b 14c

Machine Translated by Google
Tuberías en proceso 1
Nombres de características en xml.sax.handler como feature_xxx. Interfaz del controlador DTDH
2
Tres funciones disponibles en el módulo popen2 (y en el módulo os donde los valores de retorno Nombres de propiedades en xml.sax.handler como property_xxx. Definido en xml.sax.handler. Sus métodos son controladores llamados cuando el analizador
stdin/stdout están invertidos). popen2(cmd[,bufsize[,modo]])→ (archivo{2}): (stdout,stdin): ejecutar Interfaz de fuente de entrada necesita trabajo relativo a DTD. dh = MyDTDHandler() → Objeto de subclase DTDHandler
cmd como subproceso popen3(cmd[,bufsize[,modo]])→ (archivo{3} ): (stdout,stdin,stderr): ejecutar cmd dh.notationDecl(name,publicId,systemId) declaración de notación
Proporcione la fuente de datos para el
como subproceso popen4(cmd[,bufsize[,mode]])→ (archivo{2}): stdout_stderr,stdin): ejecutar cmd dh.unparsedEntityDecl(name,publicId,systemId,ndata) declaración de entidad no analizada
analizador. isrc.setPublicId(id) establecer el identificador
como subproceso Donde bufsize es tamaño de búfer para conductos de E/S, y el modo es 'b' (flujos
público isrc.getPublicId() → unicode: identificador público
binarios) o 't' (flujos de texto, predeterminado). Param cmd es una cadena que se pasa a os.system ;
isrc.setSystemId(id) establecer el identificador del sistema
en Unix, puede ser una secuencia de cadenas que se pasan directamente al programa sin la intervención
isrc.getSystemId() → unicode: identificar el sistema Interfaz EntityResolver
del shell.
isrc.setEncoding(encoding) establecer la codificación ­ debe ser una cadena aceptable para una Definido en xml.sax.handler. Sus métodos son controladores llamados cuando el analizador
declaración de codificación XML; se ignora si InputSource contiene el flujo de caracteres necesita una resolución de entidad externa. er = MyEntityResolver() → Objeto de interfaz
isrc.getEncoding() → str/None (si se desconoce) isrc.setByteStream(bytefile) set input byte stream: se EntityResolver er.resolveEntity(publicId,systemId) → str/InputSource: devolución predeterminada
ignora si InputSource contiene el flujo de caracteres isrc. getByteStream() → flujo de bytes systemId Excepciones definidas en el módulo xml.sax .
isrc.setCharacterStream(charfile) establecer flujo de caracteres (Unicode) isrc.getCharacterStream()
En Unix, el módulo popen2 también define la clase Popen3 (utilizada en las funciones popen2 y → flujo de caracteres
popen3 ) y la clase Popen4 (utilizada en la función popen4 ): Popen3(cmd[,capturestderr[,bufsize]])→
Popen3: cmd: str shell command, captudestderr: bool ( falso por defecto)
SAXException(mensaje[,excepción])
Interfaz del localizador
Popen4(cmd[,bufsize])→ Popen4 Los objetos SAXParseException(msg,exception,locator) ― XML no válido
Popen3 y Popen4 tienen los siguientes atributos: p.poll()→ int: código de Las instancias de Locator proporcionan estos métodos: SAXNotRecognizedException(msg[,exception])
retorno secundario o ­1 si el elemento secundario no finaliza p.wait()→ int: código loc.getColumnNumber() → int: número de columna donde finaliza el evento actual loc.getLineNumber() SAXNotSupportedException(mensaje[,excepción])
de retorno secundario p.fromchild → archivo: salida del niño (stdout y stderr para → int: número de línea donde finaliza el evento actual loc.getPublicId() → str: identificador público
Interfaz del controlador de errores
Popen4) p.tochild → archivo: entrada al niño p.childerr → archivo: salida de error del niño si del evento actual loc. getSystemId() → str: identificador del sistema del evento actual
Definido en xml.sax.handler. Sus métodos son controladores llamados cuando
se solicita más Ninguno (Ninguno para Popen4) p.pid → int: pid del proceso secundario
Interfaz de atributos analizador detecta un error. Sus parámetros de excepción obtienen objetos
SAXParseException . eh = MyErroHandler() → Objeto de interfaz ErrorHandler
También implemente el protocolo de asignación de partes (copiar(), obtener(), has_key(), eh.error(exception) error recuperable ­ el análisis continuará si el método
elementos(), claves() y valores()). ai.getLength() → int: número de atributos ai.getNames() → regresa
Ver también comandos de módulos (Unix). [unicode]: nombres de atributos ai.getType(name)→ tipo de nombre de atributo ­ normalmente
'CDATA' ai.getValue(name)→ unicode: valor de nombre de atributo eh.fatalError(excepción) error irrecuperable: el análisis debe detenerse eh.warning(excepción)
PROCESAMIENTO XML
advertencia menor: el análisis continuará si el método regresa
Varios módulos para procesar XML están disponibles. Algunos con interfaces estándar SAX y DOM,
otros con más interfaces Pythonic. AtributosInterfaz NS Utilidades SAX
Consulte también el paquete de extensión PyXML de terceros .
También implemente la interfaz de atributos . Definido en xml.sax.saxutils.
SAX ­ Impulsado por eventos
ansi.getValueByQName(nombre)→ unicode: valor del nombre calificado del atributo escape(datos[,entidades]) → str: & < > escapado ­ escape de otras entidades reemplazando cadenas de
Funciones base en módulo xml.sax .
ansi.getNameByQName(nombre)→ (unicode{2}): (espacio de nombres, nombre local) para el nombre mapeo (claves) por identificadores correspondientes unescape(datos[,entidades]) → str: &amp; &lt; &gt;
make_parser([parser_list]) → XMLReader: construido a partir del primer analizador disponible calificado ansi.getQNameByName(par de nombres)→ unicode: nombre calificado para (espacio de sin escape: elimina el escape de otras entidades reemplazando los identificadores de mapeo (claves)
parse(filename_or_stream,content_handler[,error_handler]) analizar el documento usando el nombres , localname) ansi.getQNames()→ [unicode]: nombres calificados de todos los atributos por las cadenas correspondientes quoteattr(datos[,entidades]) → str: como escape + cadena de comillas
primer analizador disponible parseString(string,content_handler[,error_handler]) analizar la para usar como valor de atributo prepare_input_source(fuente[,base]) → InputSource: la fuente es una
cadena usando el primer analizador disponible cadena , similar a un archivo o InputSource ­ la base es una cadena de URL ­ devuelve InputSource
Interfaz del controlador de contenido para el analizador
Interfaz de lector XML
Definido en xml.sax.handler. Sus métodos son controladores llamados cuando
Definido en xml.sax.xmlreader. p =
El analizador encuentra estructuras
xml.sax.make_parser() → objeto XMLReader p.parse(fuente) XML. ch = MyContentHandler() → Objeto de subclase ContentHandler Class XMLGenerator es un ContentHandler que escribe eventos SAX en un documento XML (es
analizar completamente la fuente ­ la fuente es el nombre de archivo o URL o archivo como o ch.setDocumentLocator(locator) establecer el localizador para el origen de los eventos del documento decir, reproduce el documento original).
InputSource­ flujos de bytes de entrada (no flujos de caracteres) p.getContentHandler() → ch.startDocument() comienzo del documento ch.endDocument() final del documento XMLGenerator([out[,encoding]]) → controlador de contenido: como un archivo, por defecto en
ContentHandler: el actual p.setContentHandler(handler) establecer el controlador de contenido ch.startPrefixMapping(prefix,uri) inicio de una asignación de espacio de nombres de prefijo­URI; sys.stdout ­ codificación por defecto en 'iso­8859­1'
actual p.getDTDHandler() → DTDHandler: el actual p.setDTDHandler(handler) establecer el consulte el documento ch.endPrefixMapping(prefix) final de una asignación de espacio de nombres La clase XMLFilterBase es un evento de paso predeterminado, se puede subclasificar para
controlador DTD actual p.getEntityResolver() → EntityResolver: el actual p.setEntityResolver(handler) de prefijo­URI ch.startElement(name,attrs) inicio de un elemento ­ modo sin espacio de nombres ­ modificar eventos sobre la marcha antes de que los controladores de aplicaciones los
establecer el solucionador de entidades actual p.getErrorHandler() → ErrorHandler: el actual attrs tiene una interfaz de atributos (puede reutilizarse ­ copiar datos) ch.endElement(name) final de procesen.
p.setErrorHandler(handler) establecer el controlador de errores actual p.setLocale(locale) un elemento ­ modo sin espacio de nombres ch.startElementNS(name,qname,attrs) inicio de un XMLFilterBase(base) → filtro de eventos
establecer la configuración regional para errores y advertencias p.getFeature(featurename) → elemento ­ modo de espacio de nombres ­ el nombre es (uri,localname) ­ qname es un nombre XML sin
Características y propiedades
configuración actual para feature1 p.setFeature(featurename,value) establecer función en valor procesar ­ attrs tiene una interfaz AttributesNS (se puede reutilizar ­ copiar datos) ­ qname puede ser
p.getProperty(propertyname) → configuración actual para property2 p.setProperty(propertyname,value) definidas en xml.sax.handler. No des su valor, sino su significado. feature_namespaces1 → Verdadero:
Ninguno (sobre prefijos de espacio de nombres de características) ch.endElementNS(nombre,qnombre)
establecer propiedad en valor final de un elemento ­ modo de espacio de nombres ch.characters(contenido ) datos de caracteres realiza el procesamiento del espacio de nombres. Falso: no hay procesamiento de espacios de
­ el contenido es str o unicode ch.ignorableWhitespace(espacio en blanco) espacios en blanco nombres (por lo que no hay prefijos de espacios de nombres). feature_namespace_prefixes1 →
ch.processing Instrucción (objetivo, datos) instrucción de procesamiento ch.skippedEntity (nombre) Verdadero: informa los nombres y atributos con prefijos originales utilizados para las declaraciones de
entidad no procesada espacios de nombres. feature_string_interning1 → Verdadero: interna todos los nombres (elementos,
prefijos, atributos, URI de espacios de nombres, nombres locales). feature_validation1 → Verdadero:
También hay una interfaz de subclase IncrementalParser con: p.feed(data) procesar informar todos los errores de validación. feature_external_ges1 → Verdadero: incluye todas las

una parte de los datos p.close() asumir el final del documento, verificar la buena entidades externas generales (texto). feature_external_pes1 → Verdadero: incluye todas las entidades
formación, limpiar p.reset() después de cerrar, preparar un nuevo análisis de parámetros externos, incluido el subconjunto de DTD externo.

15a 15b 15c

Machine Translated by Google

all_features → lista de todas las características lista de nodos atributo

property_lexical_handler → controlador de extensión opcional para eventos léxicos (como comentarios). Una secuencia de nodos, utilizable como una secuencia de Python (quizás modificable tras la Subclase de nodo.
property_declaration_handler → controlador de extensión opcional para eventos relacionados con DTD implementación). o.length → int: número de nodos en la secuencia o.item(i) → Nodo/Ninguno: enésimo o.nodeType → ATTRIBUTE_NODE o.name
que no sean notaciones y entidades no analizadas. property_dom_node1 → nodo DOM visitado (si es elemento en la lista → unicode: (ro) nombre completo del atributo ­ puede tener dos puntos o.localName
un iterador DOM) al analizar, de lo contrario, nodo DOM raíz. property_xml_string → fuente de cadena
→ unicode: (ro) nombre del atributo ­ parte después de los dos puntos o.prefix →
literal del evento actual (propiedad de solo lectura). all_properties → lista de todos los nombres de unicode: (ro) prefijo del atributo ­ parte antes dos puntos: puede estar vacío NamedNodeMap
propiedades Tipo de Documento
Subclase de nodo.
o.nodeType → DOCUMENT_TYPE_NODE o.publicId Un mapeo de nodos: utilizable experimentalmente como un mapeo de Python. o.length → int:
→ unicode/None: identificador público para subconjunto externo de DTD o.systemId → unicode/ longitud de la lista de atributos o.item(index) → Attr: atributo en el índice ­ orden arbitrario pero
1 None: identificador de sistema URI para subconjunto externo de DTD o.internalSubset → unicode/None: consistente
solo se puede leer durante el análisis (y modificarse antes).
subconjunto interno completo del documento ­ sin corchetes Comentario
DOM ­ Árbol en memoria Definido en
xml.dom. Dos funciones para registrar/acceder a los procesadores DOM y algunas constantes. Subclase de nodo. No puede tener subnodo. o.nodeType
o.name → unicode/None: nombre del elemento raíz (como se indica en DOCTYPE) o.entities
→ NamedNodeMap/None: definición de entidades externas o.notations → NamedNodeMap/ → COMMENT_NODE o.data → unicode: contenido del
registerDOMImplementation(name,factory) registre la implementación de DOM comentario, sin <!­­ y ­­>
None: definición de notaciones
factory getDOMImplementation([nombre[,características]]) → Implementación de Texto
Documento
DOM ­ el nombre puede ser Ninguno ­ puede encontrar el nombre en env. var PYTHON_DOM ­
Subclase de nodo. Subclases de Node. No puede tener subnodo. Parte de texto en un elemento. o.nodeType →
características es [(nombre de característica, versión),…]
o.nodeType → DOCUMENT_NODE TEXT_NODE o.data → unicode: contenido de texto

EMPTY_NAMESPACE → ningún espacio de nombres asociado con un nodo o.documentElement → Elemento: elemento raíz del documento
XML_NAMESPACE → espacio de nombres de prefijo xml XMLNS_NAMESPACE o.createElement(tagName)→ Elemento: nuevo1 elemento nodo CDATASección
→ URI de espacio de nombres para declaraciones de espacios de nombres: definición de especificación de o.createElementNS(namespaceURI,tagName)→ Elemento: nuevo1 elemento nodo con espacio de Subclases de Node. No puede tener subnodo. sección CDATA en un
nivel 2 de DOM XHTML_NAMESPACE → URI del espacio de nombres XHTML (XHTML 1.0) nombres ­ tagName puede tener prefijo o .createTextNode(datos) → Elemento: nuevo1 nodo de
documento, puede tener múltiples nodos CDATASection para un CDATA. o.nodeType →
texto que contiene datos o.createComment(datos) → Elemento: nuevo1 nodo de comentario que
CDATA_SECTION_NODE o.data → unicode: contenido de CDATA
contiene datos o.createProcessingInstruction(objetivo,datos) → Elemento: nuevo nodo de instrucciones
DOMImplementation
1
de procesamiento que contiene destino y nodo de atributos de datos
impl.hasFeature(característica,versión) → bool: prueba de característica admitida en una implementación Instrucción de procesamiento
1
o.createAttribute(name) → Elemento: nuevo Subclases de Node. No puede tener subnodo. Representa una instrucción de procesamiento en el
Nodo o.createAttributeNS(namespaceURI,qualifiedName) → Elemento: nuevo nodo de atributo con
1
documento XML; esto hereda de la interfaz Node y no puede tener nodos secundarios. o.nodeType →
espacio de nombres ­ tagName puede tener prefijo o.getElementsByTagName(tagName) → PROCESSING_INSTRUCTION_NODE o.target → unicode: (ro) procesamiento del contenido de la
Definida en xml.dom, la clase Node es padre de las clases de nodos de componentes XML.
NodeList: busca todos los descendientes (búsqueda profunda) que tengan tipo tagName instrucción hasta el primer espacio en blanco o.data → unicode: (ro) procesamiento del contenido de la
o.getElementsByTagNameNS(namespaceURI,localName) → NodeList: busque todos los instrucción después del primer espacio en blanco Excepciones
o.nodeType → int: (ro) en ELEMENT_NODE, ATTRIBUTE_NODE, TEXT_NODE,
descendientes (búsqueda profunda) que tengan namespaceURI y localName (parte después del
CDATA_SECTION_NODE, ENTITY_NODE, PROCESSING_INSTRUCTION_NODE, COMMENT_NODE,
prefijo)
DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE o.parentNode → Node/Ninguno:
(ro) ­ Ninguno para los nodos Attr o.attributes → NamedNodeMap /Ninguno: atributos de objetos para Python asigna códigos de error DOM a excepciones.
1
elementos, de lo contrario Los nuevos nodos son independientes: debe insertarlos/asociarlos en/a
Constantes de códigos DOM Excepción
Ninguno partes del documento.
DOMSTRING_SIZE_ERR DomstringSizeErr
o.previousSibling → Nodo/Ninguno: (ro) nodo anterior en los hijos de los padres o.nextSibling → Elemento
HIERARCHY_REQUEST_ERR JerarquíaSolicitudErr
Nodo/Ninguno: (ro) siguiente nodo en los hijos de los padres o.childNodes → [Nodo]: (ro) lista de Subclase de nodo. IndexSizeErr
INDEX_SIZE_ERR
subnodos o.firstChild → Nodo/Ninguno: (ro) primer subnodo o.lastChild → Nodo/Ninguno: (ro) último
o.nodeType → ELEMENT_NODE INUSE_ATTRIBUTE_ERR InuseAttributeErr
subnodo o.localName → unicode/Ninguno: (ro) nombre de elemento sin prefijo de espacio de
o.tagName → unicode: nombre de tipo de elemento ­ con espacio de nombres puede contener dos INVALID_ACCESS_ERR Error de acceso no válido
nombres o.prefix → unicode/Ninguno: (ro) elemento prefijo de espacio de nombres ­ puede ser una
puntos INVALID_CHARACTER_ERR Error de carácter no válido
cadena vacía o Ninguno o.namespaceURI → unicode/Ninguno: (ro) URI asociado al espacio de nombres Error de modificación no válida
o.getElementsByTagName(tagName) → NodeList: busque todos los descendientes INVALID_MODIFICATION_ERR
del elemento o.nodeName → unicode/Ninguno: (ro) uso especificado en las subclases o.nodeValue → InvalidStateErr
(búsqueda profunda) que tengan el tipo tagName INVALID_STATE_ERR
unicode/Ninguno: (ro ) uso especificado en las subclases o.hasAttributes() → bool: prueba la existencia
o.getElementsByTagNameNS(namespaceURI,localName) → NodeList: busque todos los ESPACIO DE NOMBRES_ERR Espacio de nombresErr
de cualquier atributo o.hasChildNodes() → bool: prueba la existencia de cualquier subnodo NotFoundErr
descendientes (búsqueda profunda) que tengan el nombrespaceURI y localName (parte después del NOT_FOUND_ERR
o.isSameNode(otro) → bool: prueba otro se refiere al mismo nodo o.appendChild(newChild) → new Child: prefijo) o. getAttribute(attname)→ unicode: valor de atributo o.getAttributeNode(attrname)→ Attr: nodo NOT_SUPPORTED_ERR No admitidoErr
agrega un nuevo nodo secundario al final de los subnodos; devuelve un nuevo elemento secundario de atributo o.getAttributeNS(namespaceURI,localName)→ unicode: valor de atributo NoDataPermitedErr
NO_DATOS_PERMITIDOS_ERR
o.insertBefore(newChild,refChild) → new Child: agrega un nuevo nodo secundario antes de un subnodo o.getAttributeNodeNS(namespaceURI,localName)→ Attr: nodo de atributo o.removeAttribute( attname) NO_MODIFICATION_ALLOWED_ERR NoModificationPermitedErr
existente: al final de los subnodos si refCh ild es None ­ devuelve un nuevo hijo o.removeChild(oldChild) eliminar atributo por nombre: ignorar atributo faltante o.removeAttributeNode(oldAttr)→ Attr: eliminar y SYNTAX_ERR error de sintaxis
→ oldChild: elimina un subnodo, devuélvelo ­ cuando ya no se usa, debe llamar a oldChild.unlink() devolver oldAttr o.removeAttributeNS(namespaceURI,localName) eliminar atributo por espacio de ERROR_DOCUMENTO_ERR Error de documento incorrecto
o.replaceChild(newChild,oldChild) reemplaza el subnodo existente con uno nuevo nombres URI y nombre: ignorar atributo faltante o.setAttribute(attname, value) establecer el valor de la
cadena de atributo o.setAttributeNode(newAttr)→ Attr: establecer el atributo de un nuevo nodo Attr ­ excepción.código → int: código DOM correspondiente a la excepción excepción.msg
→ cadena: mensaje para la excepción
devolver el antiguo
Excepción DOM
DomstringSizeErr ― alcance del límite de implementación
HierarchyRequestErr : insertar en el lugar equivocado
IndexSizeErr ― error de rango de índice
uno
InuseAttributeErr ― El nodo Attr ya se usó en el árbol
o.normalize() unir nodos de texto adyacentes o.setAttributeNodeNS(newAttr)→ Attr: establece el atributo de un nuevo nodo Attr con URI de InvalidAccessErr : parámetro/operación no compatible con el objeto
o.cloneNode(profundo) → Nodo: si es profundo, clonar subnodos también ­ devolver clonar espacio de nombres y nombre local; devuelve uno anterior o.setAttributeNS(namespaceURI,qname,value)→ InvalidCharacterErr ― carácter no válido en el contexto
Attr: establece el valor de la cadena de atributos de un espacio de nombresURI y qname nombre de InvalidModificationErr : no se puede modificar el tipo de nodo
atributo) ­ devuelve el antiguo 16b InvalidStateErr : intente usar un objeto indefinido/inutilizable 16c
16a
Machine Translated by Google

NamespaceErr ― cambio prohibido en el contexto del espacio de nombres atributos (opcional). Marca de tiempo (año, mes, día, hora, minuto, segundo) → objeto para mantener un valor de marca
NotFoundErr ― el nodo no existe en el contexto de referencia NotSupportedErr ― Conexión de tiempo
operación/tipo no compatible con la implementación NoDataAllowedErr ― no hay datos para este DateFromTicks(ticks)→ objeto para contener un valor de fecha de un valor de ticks dado
nodo NoModificationAllowedErr ― no se puede modificar el objeto SyntaxErr ― cadena no válida/ connect(dsn[,usuario[,contraseña[,host[,base de datos]]]])→ Objeto de conexión (interfaz definida
TimeFromTicks(ticks)→ objeto para mantener un valor de tiempo de un valor de ticks dado
como guía) ­ dsn=cadena de nombre de origen de datos cx.errorhandler → fct: (opcional)
ilegal WrongDocumentErr ― impl. no se pueden migrar nodos entre documentos TimestampFromTicks(ticks)→ objeto para contener un valor de marca de tiempo de un valor de ticks dado
controlador para errores de conexión ­ controlador de errores (conexión, cursor/Ninguno, clase de
error, valor de error) ­ el controlador predeterminado completa cx.messages y puede generar
Binario (cadena) → objeto para contener un valor de cadena binaria larga
excepciones cx.messages → [ ( clase de excepción, valor de excepción)]: (opcional) mensajes recibidos
Valores SQL NULL representados por Python Ninguno.
BASES DE DATOS de la base de datos para operaciones con conexión cx .close() terminar la conexión (puede revertirse
si no se confirma) cx.commit() confirmar transacciones pendientes cx.rollback() revertir Tipos de base de datos Códigos
Consulte la wiki de Python.org para obtener una lista de los módulos de interfaz de base de datos.
transacciones pendientes (opcional) cx.cursor()→ nuevo objeto Cursor Cursor de tipo STRING → columna basada en cadenas (CHAR)
Algunas interfaces son para motores de base de datos externos (MySQL, PostgreSQL,
BINARIO → columna binaria larga (LONG, RAW, BLOBs)
BerkeleyDB, SQLite, Metakit…), otras para motores de base de datos Python puros (gadfly,
NÚMERO → columna numérica
ZODB, KirkyBase, Buzhug…).
DATETIME → columna de fecha/hora
Acceso genérico a bases de datos de estilo DBM ROWID → columna de ID de fila (CHAR)
El módulo estándar anydbm es un front­end para algunos módulos DB disponibles: dbhash
(→bsddb→Berkeley DB), gdbm (→GNU dbm), dbm (→unix dbm) y el dumbdbm de respaldo portátil cu.arraysize → int: (RW) número de filas para buscar con fetchmany ­ predeterminado a 1 A GRANEL

lento.
cu.connection → Conexión: (opcional) conexión utilizada por el cursor cu.description → Herramientas
Se accede a los datos almacenados en archivos de estilo DBM a través de una interfaz similar a un
diccionario donde las claves y los valores deben ser str. abierto (nombre de archivo [, bandera [, modo]]) [(name, type_code, display_size, internal_size, precision, scale, null_ok)]/Ninguno: describe Baterías incluidas: pdb (depurador de Python), banco de código con timeit (p9).
→ objeto similar a un diccionario: bandera en 'r' (leer predeterminado), 'w' (escribir), 'c' (crear si no existe), las columnas de resultados cu.errorhandler → fct: (opcional) handler para errores de conexión Imprescindible: pychecker.
'n' (crear nuevo vacío) ­ el modo es el modo unix indicadores de error de creación → tupla de clases de ­ manejador de errores (conexión, cursor, clase de error, valor de error) ­ el controlador Echa un vistazo: pylint, psyco, pyrex, pycount, trace2html, depgraph, cobertura, pycover, Pyflakes,
predeterminado llena cx.messages y puede generar excepciones ­ heredado de la conexión pyreverse, HAP.
excepción de los módulos DB (anydbm.error,...)
cu.lastrowid → int/Ninguno: (opcional) ID de fila de la última columna modificada cu.messages →
Enlaces
[( clase de excepción, valor de excepción)]: (opcional) mensajes recibidos de la base de datos para
Utiliza el módulo whichdb para identificar el módulo DB correcto para el archivo existente.
operaciones con cursor cu.rowcount → int: número de filas producidas/afectadas por la última solicitud Documentos: http://www.python.org/doc/
Para archivos nuevos, utilice el primer módulo de base de datos disponible en el orden de la lista.
­ ­1 o Ninguno si la solicitud no puede tocar las filas cu.rownumber → int/Ninguno: (opcional) índice Preguntas frecuentes Python: http://www.python.org/doc/faq/
Esto es utilizado por el módulo de estantería (ver Persistencia, p12).
basado en 0 del cursor en el conjunto de resultados si está disponible PEP: http://www.python.org/dev/peps/ (Python Enhancement Propuesta)
Los módulos de base de datos pueden tener funciones específicas relacionadas con su backend, consulte los
documentos.
COMO: http://www.amk.ca/python/howto/ Libro de cocina: http://
aspn.activestate.com/ASPN/Python/Cookbook/ Inmersión en: http://www.diveintopython.org/
API DB estándar para bases de datos SQL
Generalmente, los módulos para bases de datos SQL usan la API de base de datos estándar de Python v2 cu.callproc(nombreproc[,parámetros])→ (parámetros) ­ (opcional) llamar al procedimiento almacenado
(definida en PEP249).
en la base de datos ­ los parámetros inout y inout pueden haber sido reemplazados por el procedimiento
Información de la API cu.close()ä cierra el cursor cu.execute(oper[ ,params]) preparar y ejecutar la solicitud DB: params1
es una secuencia o una asignación (consulte la variable de estilo de parámetro del módulo)
apilevel → str: actualmente '1.0' o '2.0' ­ '1.0' si no está definido seguridad de
cu.executemany(oper,params_seq) como ejecutar, con una secuencia de parámetros (para valores
subprocesos → int: nivel de seguridad de subprocesos módulo compartido compartir
# conexiones compartir cursores múltiples) cu.fetchone( )→ (column_value,…) / Ninguno: siguiente fila del resultado de la consulta,
0 No No No Ninguno cuando no hay más datos disponibles
1 Sí No No
2 Sí Sí No
3 Sí Sí Sí
cu.fetchmany([tamaño])→ [(column_value)]: siguiente conjunto de filas del resultado de la consulta,
paramstyle → str: marcador de parámetro para solicitudes lista vacía cuando no haya más datos disponibles; el tamaño predeterminado es cu.arraysize
valor parámetros ejemplo ... ©2005­2007 ­ Laurent Pointal <[email protected]> V0.67 — 2007­4­29 Licencia:
cu.fetchall()→ [(column_value)]: todos filas restantes del resultado de la consulta, lista vacía cuando no hay
'qmark' Estilo de signo de interrogación1 DONDE nombre=? más datos disponibles cu.next()→ (column_value) : (opcional) siguiente fila del resultado de la consulta,
Creative Commons [por nc sa].
'numérico' Numérico, estilo posicional 1 o 2 …DONDE nombre=:1
genera StopIteration cuando no hay más datos disponibles cu.nextset() → True/None: ( opcional) descarta
'nombrado' estilo con nombre2 …DONDE nombre=:nombre PQRC en http://laurent.pointal.org/python/pqrc Referencia rápida
los resultados hasta el siguiente conjunto disponible cu.scroll(valor[,modo]) (opcional) ­ cursor de
'formato' Códigos de formato de impresión ANSI C1 …DONDE nombre=%s de Python larga en http://rgruet.free.fr/ Referencia original de Python en http://
desplazamiento en el conjunto de resultados actual ­ el modo es 'relativo' (predeterminado) o 'absoluto'.
'pyformat Códigos de formato extendido de Python2 … DONDE nombre = % (nombre) s www.python.org/doc
cu.setinputsizes(tamaños) áreas de memoria predefinidas para ejecutar parámetros de operaciones XXX
1
Parámetros como valores posicionales en una secuencia. ­ tamaños=[param_size,…] ­ param_size=Tipo de objeto o int (longitud máxima de un parámetro de
2
Parámetros como valores con nombre en un mapa.
cadena) ­ param_size=Ninguno sin predefinición cu.setoutputsize(tamaño[ ,columna]) establece el
Excepciones tamaño del búfer de columna para obtener columnas grandes (por ejemplo, LONG, BLOB, etc.) mediante
(Error estándar) executeXXX ­ la columna es un índice en el resultado ­ todas las columnas si no se especifica la columna
Advertencia : advertencia importante. Error : cu.__iter__() → Cursor: (opcional) objeto sí mismo
captura general.
InterfaceError : problema con la interfaz (no con la base de datos)
Error de la base de datos

DataError : problema con el procesamiento de datos 1

El método __getitem__ se usa para obtener valores en parámetros, usando la posición o el nombre.
OperationalError : problema durante las operaciones de la base de datos Puede usar tupla o dict... o sus propios objetos de clase con su __getitem__.
Error de integridad
Error interno
Si se definen next y __iter__ , los cursores son iterables.
ProgrammingError : error relacionado con la programación de SQL
Tipos de DB Constructores
Error no admitido
Las clases de excepciones también pueden estar disponibles como objetos de conexión . Fecha (año, mes, día) → objeto para mantener un valor de fecha
Tiempo (hora, minuto, segundo) → objeto para mantener un valor de tiempo
17a 17b 17c