.. raw:: html
7. Bibliotecas y Módulos
========================
7.1 Biblioteca básica
---------------------
Hay algunas funciones y clases que se pueden usar directamente en la
biblioteca estándar. Proporcionan servicios básicos para los programas
de Berry, por lo que también se denominan bibliotecas básicas. Las
funciones y clases de la biblioteca básica están visibles en el ámbito
global (perteneciente al ámbito integrado), por lo que se pueden
utilizar en cualquier lugar. No defina variables con el mismo nombre que
las funciones o clases en la biblioteca base. Si lo hace, será imposible
hacer referencia a las funciones y clases en la biblioteca base.
7.1.1 Función integrada
~~~~~~~~~~~~~~~~~~~~~~~
Función ``print``
^^^^^^^^^^^^^^^^^
**Ejemplo**
.. code:: python
print(...)
**Descripción**
Esta función imprime los parámetros de entrada en el dispositivo de
salida estándar. La función puede aceptar cualquier tipo y cualquier
número de parámetros. Todos los tipos imprimirán su valor directamente,
y para una instancia, esta función verificará si la instancia tiene un
método ``tostring()``, y si lo hay, imprimirá el valor de retorno de la
instancia llamando al método ``tostring()``, de lo contrario, imprimirá
la dirección de la instancia.
.. code:: python
print('Hola mundo!') # Hola mundo!
print([1, 2, '3']) # [1, 2, '3']
print(print) #
Función ``input``
^^^^^^^^^^^^^^^^^
**Ejemplo**
.. code:: python
input()
input(prompt)
**Descripción**
La función ``input`` se usa para ingresar una línea de cadena de
caracteres desde el dispositivo de entrada estándar. Esta función puede
usar el parámetro ``prompt`` como un indicador de entrada, y el
parámetro ``prompt`` debe ser de tipo cadena. Después de llamar a la
función ``input``, los caracteres se leerán desde el búfer del teclado
hasta que se encuentre un carácter de nueva línea.
.. code:: python
input('por favor ingrese una cadena:') # por favor ingrese una cadena:
La función ``input`` no regresa hasta que se presiona la tecla “Enter”,
por lo que el programa queda “atascado” y no es un error.
Función ``type``
^^^^^^^^^^^^^^^^
**Ejemplo**
.. code:: python
type(valor)
- *valor*: parámetro de entrada (se espera obtener su tipo).
- *valor devuelto*: una cadena que describe el tipo de parámetro.
**Descripción**
Esta función recibe un parámetro de cualquier tipo y devuelve el tipo
del parámetro. El valor devuelto es una cadena que describe el tipo del
parámetro. La siguiente tabla muestra los valores de retorno
correspondientes a los principales tipos de parámetros:
================= ============== ================= ==============
Tipo de parámetro Valor devuelto Tipo de parámetro Valor devuelto
================= ============== ================= ==============
Nil ``’nil’`` Integer ``’int’``
Real ``’real’`` Boolean ``’bool’``
Function ``’function’`` Class ``’class’``
String ``’string’`` Instance ``’instance’``
puntero nativo ``’ptr’``
================= ============== ================= ==============
.. code:: python
type(0) # 'int'
type(0.5) # 'real'
type('hello') # 'string'
type(print) # 'función'
Función ``classname``
^^^^^^^^^^^^^^^^^^^^^
**Ejemplo**
.. code:: python
classname(objeto)
**Descripción**
Esta función devuelve el nombre de clase (cadena) del parámetro. Por lo
tanto, el parámetro debe ser una clase o instancia, y otros tipos de
parámetros devolverán ``nil``.
.. code:: python
classname(list) # 'list'
classname(list()) # 'list'
classname({}) # 'map'
classname(0) # nil
Función ``classof``
^^^^^^^^^^^^^^^^^^^
**Ejemplo**
.. code:: python
classof(objeto)
**Descripción**
Devuelve la clase de un objeto de instancia. El parámetro ``objeto``
debe ser una instancia. Si la función se llama con éxito, devolverá la
clase a la que pertenece la instancia; de lo contrario, devolverá
``nil``.
.. code:: python
classof(list) # nil
classof(list()) #
classof({}) #
classof(0) # nil
Función ``str``
^^^^^^^^^^^^^^^
**Ejemplo**
.. code:: python
str(valor)
**Descripción**
Esta función convierte los parámetros en cadenas y los devuelve. Las
funciones ``str`` pueden aceptar cualquier tipo de parámetros y
convertirlos. Cuando el tipo de parámetro es una instancia, verificará
si la instancia tiene un método ``tostring()``, si lo hay, se usará el
valor de retorno del método; de lo contrario, la dirección de la
instancia se convertirá en una cadena.
.. code:: python
str(0) # '0'
str(nil) # 'nil'
str(list) # 'list'
str([0, 1, 2]) # '[0, 1, 2]'
Función ``number``
''''''''''''''''''
.. code:: python
number(valor)
**Descripción**
Esta función convierte la cadena o el número de entrada en un tipo
numérico y lo devuelve. Si el parámetro de entrada es un número entero o
real, devuelve directamente. Si es una cadena de caracteres, intenta
convertir la cadena de caracteres en un valor numérico en formato
decimal. El número entero o real se juzgará automáticamente durante la
conversión. Otros tipos devuelven ``nil``.
**Ejemplo**
.. code:: python
number(5) # 5
number('45.6') # 45.6
number('50') # 50
number(list) # nil
Función ``int``
'''''''''''''''
.. code:: python
int(valor)
**Descripción**
Esta función convierte la cadena o el número de entrada en un número
entero y lo devuelve. Si el parámetro de entrada es un número entero,
regresa directamente, si es un número real, descarta la parte decimal.
Si es una cadena, intenta convertir la cadena en un número entero en
decimal. Otros tipos devuelven ``nil``. Cuando el tipo de parámetro es
una instancia, verificará si la instancia tiene un método ``toint()``,
si lo hay, se utilizará el valor de retorno del método.
**Ejemplo**
.. code:: python
int(5) # 5
int(45.6) # 45
int('50') # 50
int('0x10) # 16 - literal hexadecimal es válido
int(list) # nil
Función ``real``
''''''''''''''''
.. code:: python
real(valor)
**Descripción**
Esta función convierte la cadena o el número de entrada en un número
real y lo devuelve. Si el parámetro de entrada es un número real,
devolverá directamente, si es un número entero, se convertirá en un
número real. Si es una cadena, intenta convertir la cadena en un número
real en decimal. Otros tipos devuelven ``nil``.
**Ejemplo**
.. code:: python
real(5) # 5, type(real(5)) →'real'
real(45.6) # 45.6
real('50.5') # 50.5
real(list) # nil
Función ``bool``
''''''''''''''''
.. code:: python
bool(valor)
**Descripción**
Esta función convierte la cadena o el número de entrada en un valor
booleano y lo devuelve.
La conversión sigue las siguientes reglas:
- ``nil``: convertido a ``falso``.
- **Entero**: cuando el valor es ``0``, se convierte en ``falso``, de
lo contrario, se convierte en ``verdadero``.
- **Número real**: cuando el valor es ``0.0``, se convierte en
``falso``, de lo contrario, se convierte en ``verdadero``.
- **Cadena**: cuando el valor es "" (cadena vacía) se convierte en
``falso`` de lo contrario, se convierte en ``verdadero``.
- **Comobj** y **Comptr**: cuando el puntero interno es ``NULL`` es
convertido a ``falso``, de lo contrario se convierte a ``verdadero``.
- **Instancia**: si la instancia contiene un método ``tobool()``, se
utilizará el valor de retorno del método, de lo contrario, se
convertirá en ``verdadero``.
- Todos los demás tipos: convierte a ``verdadero``.
**Ejemplo**
.. code:: python
bool() # false
bool(nil) # false
bool(false) # false
bool(true) # true
bool(0) # false
bool(1) # true
bool("") # false
bool("a") # true
bool(3.5) # true
bool(list) # true
bool([]) # true
bool({}) # true
# avanzado
import introspect
bool(introspect.toptr(0)) # false
bool(introspect.toptr(0x1000)) # true
Función ``size``
''''''''''''''''
.. code:: python
size(valor)
**Descripción**
Esta función devuelve el tamaño de la cadena de entrada. Si el parámetro
de entrada no es una cadena, se devuelve 0. La longitud de la cadena se
calcula en bytes. Esta función también funciona para instancias de
``list`` y ``map`` y devuelve el número de elementos.
**Ejemplo**
.. code:: python
size(10) # 0
size('s') # 1
size('string') # 6
size([1,2]) # 2
size({"a":1}) # 1
Función ``super``
'''''''''''''''''
.. code:: python
super(objeto)
**Descripción**
Esta función devuelve el objeto principal de la instancia. Cuando crea
una instancia de una clase derivada, también creará una instancia de su
clase base. Se requiere la función ``super`` para acceder a la instancia
de la clase base (es decir, el objeto principal).
Consulte el capítulo 6 sobre el comportamiento mágico de
``super(objeto)`` al llamar a un supermétodo.
**Ejemplo**
.. code:: python
class mi_lista: lista end
l = mi_lista() # classname(l) -->'mi_lista'
sl = super(l) # classname(sl) -->'lista'
Función ``assert``
''''''''''''''''''
.. code:: python
assert(expresión)
assert(expresión, mensaje)
**Descripción**
Esta función se utiliza para implementar la función de aserción. La
función ``assert`` acepta un parámetro. Cuando el valor del parámetro es
``false`` o ``nil``, la función activará un error de aserción; de lo
contrario, la función no tendrá ningún efecto. Cabe señalar que incluso
si el parámetro es un valor equivalente a ``false`` en operaciones
lógicas (por ejemplo, ``0``), no generará un error de aserción. El
parámetro ``mensaje`` es opcional y debe ser una cadena. Si se utiliza
este parámetro, la información de texto proporcionada en ``message`` se
mostrará cuando se produzca un error de aserción; de lo contrario, se
mostrará el mensaje predeterminado “``Assert Fail``”.
**Ejemplo**
.. code:: python
assert(false) # aserción fallida!
assert(nil) # aserción fallida!
assert() # aserción fallida!
assert(0) # aserción fallida!
assert(false,'mensaje de aserción del usuario.') # mensaje de aserción.
assert(true) # pasa
Función ``compile``
'''''''''''''''''''
.. code:: python
compile(cadena)
compile(cadena, 'string')
compile(nombre_archivo, 'file')
**Descripción**
Esta función compila el código fuente de Berry en una función. El código
fuente puede ser una cadena o un archivo de texto. El primer parámetro
de la función ``compile`` es una cadena, y el segundo parámetro es una
``'cadena'`` o ``'archivo'``. Cuando el segundo parámetro es
``'cadena'`` o no hay un segundo parámetro, la función ``compile``
compilará el primer parámetro como código fuente. Cuando el segundo
parámetro es ``'file'``, la función ``compile`` compilará el archivo
correspondiente al primer parámetro. Si la compilación es exitosa,
``compile`` devolverá la función compilada; de lo contrario, devolverá
``nil``.
**Ejemplo**
.. code:: python
compile('print(\'Hola mundo!\')')() # Hola mundo!
compile('test.be','file')
Clase ``list``
~~~~~~~~~~~~~~
``list`` es un tipo incorporado, y define un contenedor de
almacenamiento secuencial que admite la lectura y escritura de
subíndices. Es similar a las matrices en otros lenguajes de
programación. La obtención de una instancia de la clase ``list`` se
puede construir usando un par de corchetes: ``[]`` generará una
instancia vacía de ``list``, y ``[expr, expr, ...]`` generará una
``list`` ejemplo con varios elementos. También se puede instanciar
llamando a la clase ``list``: ejecutar ``list()`` obtendrá una instancia
vacía de ``list``, y ``list(expr, expr, ...)`` devolverá una instancia
con varios elementos.
Método ``list`` (Constructor)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Inicializa el contenedor ``list``. Este método puede aceptar de 0 a
múltiples parámetros. La instancia ``list`` generada cuando se pasan
múltiples parámetros tendrá estos parámetros como elementos, y el orden
de disposición de los elementos es coherente con el orden de disposición
de los parámetros.
Método ``tostring``
^^^^^^^^^^^^^^^^^^^
Serializa la instancia de ``list`` en una cadena y la devuelve. Por
ejemplo, el resultado de ejecutar ``[1, [], 1.5].tostring()`` es
``'[1, [], 1.5]''. Si el contenedor``\ list\` se refiere a sí mismo, la
posición correspondiente utilizará puntos suspensivos en lugar del valor
específico:
.. code:: python
l = [1, 2]
l[0] = l
print(l) # [[...], 2]
Método ``concat``
^^^^^^^^^^^^^^^^^
Convierte cada elemento de la lista en cadenas y la concatena usando la
cadena proporcionada.
.. code:: python
l = [1, 2, 3]
l.concat() # '123'
l.concat(", ") # '1, 2, 3'
Método ``push``
^^^^^^^^^^^^^^^
Agrega un elemento al final del contenedor ``list``. El prototipo de
este método es ``push(valor)``, el parámetro ``valor`` es el valor que
se agregará, y el valor agregado se almacena al final del contenedor
``list``. La operación de agregar aumenta el número de elementos en el
contenedor ``list`` en 1. Puede agregar cualquier tipo de valor a la
instancia de ``lista``.
Método ``insert``
^^^^^^^^^^^^^^^^^
Inserta un elemento en la posición especificada del contenedor ``list``.
El prototipo de este método es ``insert(indice, valor)``, el parámetro
``indice`` es la posición a insertar, y ``valor`` es el valor a
insertar. Después de insertar un elemento en la posición ``indice``,
todos los elementos que originalmente comenzaron desde esta posición se
moverán hacia atrás un elemento. La operación de inserción aumenta el
número de elementos en el contenedor ``list`` en 1. Puede insertar
cualquier tipo de valor en el contenedor ``list``.
Supongamos que el valor de una instancia de ``lista`` ``l`` es
``[0, 1, 2]``, e insertamos una cadena ``'cadena'`` en la posición 1, y
necesitamos llamar a ``l.insert(1, 'cadena')``. Finalmente, el nuevo
valor de ``lista`` es ``[0, 'cadena', 1, 2]``.
Si el número de elementos en un contenedor ``list`` es *S*, el rango de
valores de la posición de inserción es {*i* ∈ ℤ : − *S* ≤ *i* < *S*}.
Cuando la posición de inserción es positiva, indexa hacia atrás desde el
principio del contenedor ``list``; de lo contrario, indexa hacia
adelante desde el final del contenedor ``list``.
Método ``remove``
^^^^^^^^^^^^^^^^^
Quita un elemento del contenedor. El prototipo de este método es
``remove(indice)``, y el parámetro ``indice`` es la posición del
elemento a eliminar. Después de eliminar el elemento, el elemento detrás
del elemento eliminado avanzará un elemento y la cantidad de elementos
en el contenedor se reducirá en 1. Al igual que el método ``insert``, el
método ``remove`` también puede usar índices positivos o negativos.
Método ``item``
^^^^^^^^^^^^^^^
Obtiene un elemento en el contenedor ``list``. El prototipo de este
método es ``item(indice)``, el parámetro ``indice`` es el índice del
elemento a obtener, y el valor de retorno del método es el elemento en
la posición del índice. ``list`` El contenedor admite múltiples métodos
de indexación:
- Índice entero: El valor del índice puede ser un número entero
positivo o un entero negativo. Si el índice es negativo, es relativo
al final de la lista; es decir, ``-1`` indica el último elemento de
la lista. El valor de retorno de ``item`` es el elemento en la
posición del índice. Si la posición del índice excede el número de
elementos en el contenedor o está antes del elemento 0, el método
``item`` devuelve ``nil``.
- Índice ``list``: Utilizando una lista de enteros como índice,
``item`` devuelve una ``lista``, y cada elemento en el valor devuelto
``lista`` es un elemento correspondiente a cada índice entero en el
parámetro ``lista``. los el valor de la expresión
``[3, 2, 1].item([0, 2])`` es ``[3, 1]``. Si una tipo de elemento en
el parámetro ``lista`` no es un número entero, entonces el el valor
en esa posición en el valor de retorno ``lista`` es ``nil``.
- Índice ``range``: Usando un rango de enteros como índice, ``item``
devuelve una ``lista``. El valor devuelto almacena los elementos
indexados de la ``lista`` desde el límite inferior hasta el límite
superior del parámetro ``range``. Si el índice excede el rango de
índice de la ‘lista’ indexada, el retorno value ``list`` usará
``nil`` para llenar la posición más allá del índice.
Método ``setitem``
^^^^^^^^^^^^^^^^^^
Establece el valor de la posición especificada en el contenedor. El
prototipo de este método es ``setitem(indice, valor)``, ``indice`` es la
posición del elemento a escribir y ``valor`` es el valor a escribir.
``indice`` es el valor de índice entero de la posición de escritura. Las
posiciones de índice fuera del rango de índice del contenedor harán que
``setitem`` no se ejecute.
Método ``size``
^^^^^^^^^^^^^^^
Devuelve el número de elementos en el contenedor, que es la longitud del
contenedor. El prototipo de este método es ``size()``.
Método ``resize``
^^^^^^^^^^^^^^^^^
Restablece la ``lista`` a la longitud del contenedor. El prototipo de
este método es ``resize(count)``, y el parámetro ``count`` es la nueva
longitud del contenedor. Al usar ``resize`` para aumentar la longitud
del contenedor, el nuevo elemento se inicializará en ``nil``. El uso de
``resize`` para reducir la longitud del contenedor descartará algunos
elementos al final del contenedor. P.ej:
.. code:: python
l = [1, 2, 3]
l.resize(5) # Expansion, l == [1, 2, 3, nil, nil]
l.resize(2) # Reduce, l == [1, 2]
Método ``iter``
^^^^^^^^^^^^^^^
Devuelve un iterador para recorrer el contenedor ``list`` actual.
Método ``find``
^^^^^^^^^^^^^^^
Similar a ``item`` o ``list[idx]``. La única diferencia es que si el
índice está fuera de rango, ``find`` devuelve ``nil`` en su lugar o
genera una excepción.
Método ``reverse``
^^^^^^^^^^^^^^^^^^
Cambia la lista en el lugar e invierte el orden de los elementos.
También devuelve la lista resultante.
Clase ``map``
~~~~~~~~~~~~~
La clase ``map`` es un tipo de clase incorporado que se utiliza para
proporcionar un contenedor desordenado de pares clave-valor. Dentro del
intérprete de Berry, ``map`` usa la tabla Hash para su implementación.
Puede utilizar pares de llaves para construir un contenedor ``map``. El
uso de un par de llaves vacías ``{}`` generará una instancia de ``map``
vacía. Si necesita construir una instancia de ``map`` que no esté vacía,
use dos puntos para separar la clave y el valor, y use un punto y coma
para separar varios pares clave-valor. Por ejemplo, ``{0: 1, 2: 3}``
tiene dos pares clave-valor (0,1) y (2,3). También puede obtener una
instancia de ``map`` vacía llamando a la clase ``map``.
Método ``map`` (Constructor)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Inicializa el contenedor ``map``, este método no acepta parámetros.
Ejecutar ``map()`` obtendrá una instancia de ``map`` vacía.
.. _método-tostring-1:
Método ``tostring``
^^^^^^^^^^^^^^^^^^^
Serializa ``map`` como una cadena y regresa. La cadena serializada es
similar a la escritura literal. Por ejemplo, el resultado de ejecutar
``'str': 1, 0: 2`` es ``"'str': 1, 0: 2"``. Si el contenedor ``map`` se
refiere a sí mismo, la posición correspondiente utilizará puntos
suspensivos en lugar del valor específico:
.. code:: python
m = {'map': nil,'texto':'hola'}
m['map'] = m
print(m) # {'texto':'hola','map': {...}}
.. _método-insert-1:
Método ``insert``
^^^^^^^^^^^^^^^^^
Inserta un par clave-valor en el contenedor ``map``. El prototipo de
este método es ``insert(llave, valor)``, el parámetro ``llave`` es la
clave a insertar, y ``valor`` es el valor a insertar. Si el ``map``
clave que se va a insertar existe en el contenedor, se actualizará el
par clave-valor original.
.. _método-remove-1:
Método ``remove``
^^^^^^^^^^^^^^^^^
Elimina un par clave-valor del contenedor ``map``. El prototipo de este
método es ``remove(llave)``, y el parámetro ``llave`` es la clave del
par clave-valor que se eliminará.
.. _método-item-1:
Método ``item``
^^^^^^^^^^^^^^^
Obtiene un valor en el contenedor ``map``. El prototipo de este método
es ``item(llave)``, el parámetro ``llave`` es la clave del valor a
obtener, y el valor de retorno del método es el valor correspondiente a
la clave.
.. _método-setitem-1:
Método ``setitem``
^^^^^^^^^^^^^^^^^^
Establece el valor correspondiente a la clave especificada en el
contenedor. El prototipo de este método es ``setitem(clave, valor)``,
``clave`` es la clave del par clave-valor a escribir, y ``valor`` es el
valor a escribir. Si no hay un par clave-valor con la clave ``clave`` en
el contenedor, el método ``setitem`` fallará.
.. _método-size-1:
Método ``size``
^^^^^^^^^^^^^^^
Devuelve el número de pares clave-valor del contenedor ``map``, que es
la longitud del contenedor. El prototipo de este método es ``size()``.
Método ``contains``
^^^^^^^^^^^^^^^^^^^
Devuelve ``true`` booleano si se encuentra un par clave-valor
coincidente en el contenedor ``map``; de lo contrario, ``false``. El
prototipo de este método es ``contains(llave)``.
.. _método-find-1:
Método ``find``
^^^^^^^^^^^^^^^
Devuelve el valor correspondiente a la clave especificada en el
contenedor. El prototipo de este método es ``find(llave)`` o
``find(llave, valor_defecto)``, ``llave`` es la clave del par
clave-valor al que se accederá, y ``valor_defecto`` es el valor
predeterminado devuelto si la clave no se encuentra. Si no se especifica
ningún valor predeterminado, se devuelve ``nil`` en su lugar.
Clase ``range``
~~~~~~~~~~~~~~~
La clase se usa para representar un intervalo cerrado entero. Utilice el
operador binario ``..`` para construir una instancia de ``range``. Los
operandos izquierdo y derecho del operador deben ser números enteros.
Por ejemplo, ``0..10`` significa el intervalo entero [0,10] ∩ ℤ.
Si no especifica el rango alto, se establece en ``MAXINT``. Ejemplo:
``imprimir(0..) # (0..9223372036854775807)``
Por lo general, hay dos formas de recorrer una lista:
.. code:: python
l = [1,2,3,4]
for e:l print(e) end # 1/2/3/4
for i:0..size(l)-1 print(l[i]) end # 1/2/3/4
Clase ``bytes``
~~~~~~~~~~~~~~~
Los objetos ``bytes`` se representan como matrices de bytes
hexadecimales. El constructor ``bytes`` toma una cadena de Hex y
construye el búfer en memoria.
Ejemplo:
.. code:: python
b = bytes()
print(b) # bytes('')
b = bytes("1155AA") # secuencia de bytes 0x11 0x55 0xAA
size(b) # 3 = 3 bytes
b[0] # 17 (0x11)
b[0] = 16 # asigna el primer byte
print(b) # bytes('1055AA')
Método ``bytes`` (Constructor)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Inicializar una matriz de bytes. Hay varias opciones.
**Opción 1: valor vacío**
``bytes()`` crea una nueva matriz de bytes vacía.
``tamaño(bytes()) == 0``.
No hay límite en el tamaño de una matriz de bytes, excepto la memoria
disponible. Se asigna un búfer interno y se reasigna en caso de que el
anterior fuera demasiado pequeño. El búfer inicial es de 36 bytes, pero
puede preasignar un búfer más grande (o más pequeño) si sabe de antemano
el tamaño necesario.
De manera similar, el búfer se reduce automáticamente si se usa menos
del tamaño necesario.
.. code:: python
b = bytes(4096) # 4096 bytes preasignados
**Opción 2: valor inicial**
Si el primer argumento es una “cadena”, se analiza como una lista de
valores hexadecimales. Puede agregar un segundo argumento opcional para
preasignar un búfer más grande.
.. code:: python
b = bytes("BEEF0000")
print(b) # bytes('beef0000')
b = bytes("112233", 128) # preasignar 128 bytes internamente
print(b) # bytes('112233')
**Opción 3: tamaño fijo**
Si el tamaño proporcionado es negativo, el tamaño de la matriz es fijo y
no se puede reducir ni aumentar.
.. code:: python
b = bytes(-8)
print(b) # bytes('0000000000000000')
b = bytes("AA", -4)
print(b) # bytes('AA000000')
b = bytes("1122334455", -4)
atributo_error: tamaño del objeto en bytes es fijo y no se puede cambiar el tamaño
**Opción 4: asignación de memoria**
**Precaución, use con mucho cuidado**
En este modo, la matriz de bytes se asigna a una región específica de la
memoria. Debe proporcionar la dirección base como ``comptr`` y el
tamaño. El tamaño siempre se fija, ya sea positivo o negativo. Esta
función es **peligrosa** ya que puede acceder a cualquier ubicación de
la memoria, lo que provoca un bloqueo si la ubicación está protegida o
no es válida. Usar con cuidado.
En este caso, ``b.ismapped()`` devuelve ``true`` indicando un búfer de
memoria mapeado. En todos los demás casos, ``b.ismapped()`` devuelve
``falso``. Esto se usa típicamente para saber si Berry asignó el búfer o
no, y si los subelementos deben desasignarse explícitamente.
Ejemplo:
.. code:: python
import introspect
def f() return 0 end
addr = introspect.toptr(f)
print(addr) #
b = bytes(addr, 8)
print(b) # bytes('F8EAFE3F24000000')
# este ejemplo muestra los primeros 8 bytes del objeto de función en la memoria
.. _método-size-2:
Método ``size``
^^^^^^^^^^^^^^^
Devuelve el número de bytes en la matriz de bytes
.. code:: python
b = bytes("1122334455")
b.size() # 5
size(b) # 5
.. _método-tostring-2:
Método ``tostring``
^^^^^^^^^^^^^^^^^^^
Muestra una forma legible por humanos la matriz de bytes en hexadecimal.
Por defecto, muestra solo los primeros 32 caracteres. Puede solicitar
más caracteres agregando un argumento int con la cantidad máxima de
bytes que desea convertir. ``tostring`` se usa internamente cuando se
imprime un objeto. ``print(b)`` es equivalente a
``print(b.tostring())``. Es diferente de ``asstring``, que convierte una
matriz de bytes en el objeto de cadena de bajo nivel equivalente sin
ninguna codificación.
.. code:: python
b = bytes("1122334455")
b.tostring() # 'bytes(\'1122334455\')'
b = bytes()
b.resize(64) # redimenciona a 64 bytes
b.tostring() # 'bytes(\'0000000000000000000000000000000000000000000000000000000000000000...\')'
b.tostring(500) # 'bytes(\'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\')'
Método ``tohex``
^^^^^^^^^^^^^^^^
Convierte la matriz de bytes en una cadena hexadecimal, similar a la
devuelta por ``tostring()`` pero sin decoradores.
.. code:: python
b = bytes("1122334455")
b.tohex() # '1122334455'
Método ``fromhex``
^^^^^^^^^^^^^^^^^^
Actualiza el contenido de la matriz de bytes a partir de una nueva
cadena hexadecimal. Esto permite cargar una nueva cadena hexadecimal sin
asignar un nuevo objeto de bytes.
.. code:: python
b = bytes("1122334455")
b.fromhex("AABBCC") # bytes('AABBCC')
Método ``clear``
^^^^^^^^^^^^^^^^
Vuelve a poner la matriz de bytes en vacío
.. code:: python
b = bytes("1122")
b.clear()
print(b) # bytes()
.. _método-resize-1:
Método ``resize``
^^^^^^^^^^^^^^^^^
Reduce o expande la matriz de bytes para que coincida con el tamaño
especificado. Si se expande, se agregan bytes NULL (0x00) al final del
búfer.
.. code:: python
b = bytes("11223344")
b.resize(6)
print(b) # bytes('112233440000')
b.resize(2)
print(b) # bytes('1122')
Métodos de concatenación ``+`` y ``..``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Puede usar ``+`` para concatenar dos listas de ``bytes``, creando un
nuevo objeto ``bytes``. ``..`` cambia la lista en su lugar y se puede
usar para agregar un objeto ``int`` (1 byte) o ``bytes``
::
b = bytes("1122")
c = bytes("3344")
d = b + c # b y c no cambian
print(d) # bytes('11223344')
print(b) # bytes('1122')
print(c) # bytes('3344')
e = b..c # ahora b ha cambiado
print(e) # bytes('11223344')
print(b) # bytes('11223344')
print(c) # bytes('3344')
Método de acceso a bytes ``[]``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Puede acceder a bytes individuales como enteros, para leer y escribir.
Los valores que no están en el rango de 0 a 255 se cortan
silenciosamente.
.. code:: python
b = bytes("010203")
print(b[0]) # 1
# índices negativos cuentan desde el final
print(b[-1]) # 3
# fuera de los límites genera una excepción
print(b[5]) # index_error: índice de bytes fuera de rango
b[0] = -1
print(b) # bytes('FF0203')
b[1] = 256
print(b) # bytes('FF0003')
Método de acceso de rango ``[]``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Puede usar el descriptor de acceso ``[]`` con un rango para obtener una
sublista de ``bytes``. Si un índice es negativo, se toma del final de la
matriz.
Esta construcción no se puede usar como un *lvalue*, es decir, no se
puede empalmar como ``b[1..2] = bytes("0011") # no permitido``.
.. code:: python
b = bytes("001122334455")
print(b[1..2]) # bytes('1122')
# elimina los primeros 2 bytes
print(b[2..-1]) # bytes('22334455')
# eliminar los últimos 2 bytes
print(b[0..-3]) # bytes('00112233')
# se permite el sobreimpulso
print(b[4..10]) # bytes('4455')
# índices invertidos devuelven una matriz vacía
print(b[5..4]) # bytes('')
Los métodos estándar ``item`` y ``setitem`` se implementan y se asignan
de forma transparente al operador ``[]``.
Método ``copy``
^^^^^^^^^^^^^^^
Crea una nueva copia nueva del objeto ``bytes``. Se asigna un nuevo
búfer de memoria y se duplican los datos.
.. code:: python
b = bytes("1122")
print(b) # bytes('1122')
c = b.copy()
print(c) # bytes('1122')
b.clear()
print(b) # bytes('')
print(c) # bytes('1122')bytes('1122')
Métodos ``get, geti``
^^^^^^^^^^^^^^^^^^^^^
Lea un valor de 1/2/4 bytes de cualquier desplazamiento en la matriz de
bytes. El modo estándar es little endian, si se especifica un tamaño
negativo habilita big endian. ``get`` devuelve valores sin signo,
mientras que ``geti`` devuelve valores con signo.
::
b.get(, ) -> objeto de bytes
Si el desplazamiento está fuera de rango, se devuelve ``0`` (no se
genera ninguna excepción).
Ejemplo:
.. code:: python
b = bytes("010203040506")
print(b.get(2,2)) # 1027 - 0x0403 read 2 bytes little endian
print(b.get(2,-2)) # 772 - 0x0304 read 2 bytes big endian
print(b.get(2,4)) # 100992003 - 0x06050403 - little endian
print(b.get(2,-4)) # 50595078 - 0x03040506 - big endian
b = bytes("FEFF")
print(b.get(0, 2)) # 65534 - 0xFFFE
print(b.geti(0, 2)) # -2 - 0xFFFE
Métodos ``set, seti``
^^^^^^^^^^^^^^^^^^^^^
Similar a ``get`` y ``geti``, permite establecer un valor de 1/2/4 bytes
en cualquier desplazamiento. ``seti`` usa números enteros con signo,
``set`` no tiene signo (en realidad, no hace la diferencia).
Si el desplazamiento está fuera de rango, no se realiza ningún cambio
(no se genera ninguna excepción).
::
bytes.set(, , )
Método ``add``
^^^^^^^^^^^^^^
Este método agrega valor de 1/2/4 bytes (little endian o big endian) al
final del búfer. Si el tamaño es negativo, el valor se trata como big
endian.
::
b.add(, )
Ejemplo:
.. code:: python
b = bytes("0011")
b.add(0x22, 1)
print(b) # bytes('001122')
b.add(0x2233, 2)
print(b) # bytes('0011223322')
b.add(0x22334455, 4)
print(b) # bytes('001122332255443322')
b.add(0x00)
print(b) # bytes('00112233225544332200')
b.clear()
b.add(0x0102, -2)
print(b) # bytes('0102')
b.add(0x01020304, -4)
print(b) # bytes('010201020304')
Método ``asstring``
^^^^^^^^^^^^^^^^^^^
Convierte un búfer de bytes en una cadena. El búfer se convierte tal
cual sin ninguna consideración de codificación. Si el búfer contiene
caracteres NULL, la cadena se truncará.
.. code:: python
b=bytes("3344")
print(b.asstring()) # '3D'
Método ``fromstring``
^^^^^^^^^^^^^^^^^^^^^
Convierte un búfer de bytes en una cadena. El búfer se convierte tal
cual sin ninguna consideración de codificación. Si el búfer contiene
caracteres NULL, la cadena se truncará.
.. code:: python
b=bytes().fromstring("Hola")
print(b) # bytes('48656C6C6F')
Métodos de manipulación de bits ``setbits, getbits``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Puede leer y escribir a nivel de subbytes, especificando de qué bit a
qué bit. El desplazamiento está en bits, no en bytes. Agregue el número
de bytes \* 8.
::
b.setbits(, , )
b.getbits(, )
Codificación en base64, método ``tob64``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Convierte una matriz de bytes en una cadena base64.
.. code:: python
b = bytes('deadbeef0011')
s = b.tob64()
print(s) # 3q2+7wAR
Decodificación en base64, método ``fromb64``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Convierte una cadena base64 en una matriz de bytes.
.. code:: python
s = '3q2+7wAR'
b = bytes().fromb64(s)
print(b) # bytes('DEADBEEF0011')
Métodos ``getfloat`` y ``setfloat``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Similar a ``get/set``, permite leer o escribir un valor en coma flotante
de 32 bits.
::
b.getfloat()
b.getfloat(, )
.. code:: berry
b = bytes("00000000")
b.getfloat(0) # 0
b.setfloat(0, -1.5)
print(b) # bytes('0000C0BF')
b.getfloat(0) # -1.5
Método ``_buffer``
^^^^^^^^^^^^^^^^^^
**Característica avanzada**: devuelve la dirección del búfer en la
memoria, para usar con código C.
.. code:: berry
b = bytes('1122')
b._buffer() #
Método ``_change_buffer``
^^^^^^^^^^^^^^^^^^^^^^^^^
**Característica avanzada**: funciona solo para búferes mapeados (es
decir, ``b.ismapped() == true``), permite reasignar el búfer a una nueva
dirección de memoria. Esto permite reutilizar el objeto bytes() sin
reasignar una nueva instancia.
.. code:: berry
# este ejemplo usa la asignación de punteros, use con mucho cuidado
b1 = bytes("11223344")
b2 = bytes("AABBCCDD")
b1._buffer() #
b2._buffer() #
# ahora creamos c como un búfer asignado de 4 bytes a la dirección de b1
c = bytes(b1._buffer(), 4)
print(c) # bytes('11223344') -- asignado a b1
c._buffer() #
# cambiemos un byte para probarlo
c[0] = 254
print(c) # bytes('FE223344')
print(b1) # bytes('FE223344') -- b1 ha cambiado
# reasignar c al mapa b2
c._change_buffer(b2._buffer())
print(c) # bytes('AABBCCDD')
c._buffer() #
Módulos de expansión
--------------------
Módulo JSON
~~~~~~~~~~~
JSON es un formato ligero de intercambio de datos. Es un subconjunto de
JavaScript. Utiliza un formato de texto que es completamente
independiente del lenguaje de programación para representar datos. Berry
proporciona un módulo JSON para proporcionar soporte para datos JSON. El
módulo JSON solo contiene dos funciones, “cargar” y “volcar”, que se
utilizan para analizar cadenas JSON y multiplicar objetos Berry y
serializar un objeto Berry en texto JSON.
Función ``load``
^^^^^^^^^^^^^^^^
.. code:: python
load(text)
**Descripción**
Esta función se usa para convertir el texto JSON de entrada en un objeto
Berry y devolverlo. Las reglas de conversión se muestran en la Tabla 1.1
. Si hay un error de sintaxis en el texto JSON, la función devolverá
``nil``.
============= =====================
**Tipo JSON** **Tipo Berry**
============= =====================
``nulo`` ``nil``
``número`` ``entero`` o ``real``
``cadena`` ``cadena``
``matriz`` ``lista``
``objeto`` ``mapa``
============= =====================
*Tabla 9: Reglas de conversión de tipo JSON a tipo Berry*
**Ejemplo**
.. code:: python
import json
json.load('0') # 0
json.load('[{"nombre": "liu", "edad": 13}, 10.0]') # [{'nombre':'liu','edad': 13}, 10]
Función ``dump``
^^^^^^^^^^^^^^^^
.. code:: python
dump(objectp, ['formato'])
**Descripción**
Esta función se usa para serializar el objeto Berry en texto JSON. Las
reglas de conversión para la serialización se muestran en la Tabla 10 .
================= =============
**Tipo berry** **Tipo JSON**
================= =============
``cero`` ``nulo``
``entero`` ``número``
``verdadero`` ``número``
``lista`` ``matriz``
``mapa`` ``objeto``
``mapa`` Clave de ``cadena``
otro ``cadena``
================= =============
*Tabla 10: Reglas de conversión de tipo Berry a tipo JSON*
**Ejemplo**
.. code:: python
import json
json.dump('string') #'"string"'
json.dump('string') #'"string"'
json.dump({0:'item 0','list': [0, 1, 2]}) #'{"0":"item 0","list":[0,1,2]}'
json.dump({0:'item 0','list': [0, 1, 2],'func': print},'format')
#-
{
"0": "item 0",
"list": [
0,
1,
2
],
"func": ""
}
-#
Módulo matemático
~~~~~~~~~~~~~~~~~
Este módulo se utiliza para proporcionar soporte para funciones
matemáticas, como las funciones trigonométricas y las funciones de raíz
cuadrada de uso común. Para usar el módulo matemático, primero use la
instrucción ``import math``. Todos los ejemplos de esta sección asumen
que el módulo se ha importado correctamente.
Constante ``pi``
^^^^^^^^^^^^^^^^
El valor de Pi *π* es un tipo de número real, aproximadamente igual a
3.141592654.
**Ejemplo**
.. code:: python
math.pi # 3.14159
Función ``abs``
^^^^^^^^^^^^^^^
.. code:: python
abs(valor)
**Descripción**
Esta función devuelve el valor absoluto del parámetro, que puede ser un
número entero o un número real. Si no hay parámetros, la función
devuelve ``0``, si hay varios parámetros, solo se procesa el primer
parámetro. El tipo de retorno de la función ``abs`` es un número real.
**Ejemplo**
.. code:: python
math.abs(-1) # 1
math.abs(1.5) # 1.5
Función ``ceil``
^^^^^^^^^^^^^^^^
.. code:: python
ceil(valor)
**Descripción**
Esta función devuelve el valor redondeado hacia arriba del parámetro, es
decir, el valor entero más pequeño mayor o igual que el parámetro. El
parámetro puede ser un número entero o un número real. Si no hay
parámetros, la función devuelve ``0``, si hay varios parámetros, solo se
procesa el primero. El tipo de retorno de la función es un número real.
**Ejemplo**
.. code:: python
math.ceil(-1.2) # -1
math.ceil(1.5) # 2
Función ``floor``
^^^^^^^^^^^^^^^^^
.. code:: python
floor(valor)
**Descripción**
Esta función devuelve el valor redondeado hacia abajo del parámetro, que
no es mayor que el valor entero máximo del parámetro. El parámetro puede
ser un número entero o un número real. Si no hay parámetros, la función
devuelve ``0``, si hay varios parámetros, solo se procesa el primero. El
tipo de retorno de la función es un número real.
**Ejemplo**
.. code:: python
math.floor(-1.2) # -2
math.floor(1.5) # 1
Función ``sin``
^^^^^^^^^^^^^^^
.. code:: python
sin(valor)
**Descripción**
Esta función devuelve el valor de la función seno del parámetro. El
parámetro puede ser un número entero o un número real, y la unidad son
los radianes. Si no hay parámetros, la función devuelve ``0``, si hay
varios parámetros, solo se procesa el primer parámetro. El tipo de
retorno de la función es un número real.
**Ejemplo**
.. code:: python
math.sin(1) # 0.841471
math.sin(math.pi * 0.5) # 1
Función ``cos``
^^^^^^^^^^^^^^^
.. code:: python
cos(valor)
**Descripción**
Esta función devuelve el valor de la función coseno del parámetro. El
parámetro puede ser un número entero o un número real en radianes. Si no
hay parámetros, la función devuelve ``0``, si hay varios parámetros,
solo se procesa el primero. El tipo de retorno de la función es un
número real.
**Ejemplo**
.. code:: python
math.cos(1) # 0.540302
math.cos(math.pi) # -1
Función ``tan``
^^^^^^^^^^^^^^^
.. code:: python
tan(valor)
**Descripción**
Esta función devuelve el valor de la función tangente del parámetro. El
parámetro puede ser un número entero o un número real, en radianes. Si
no hay parámetros, la función devuelve ``0``, si hay varios parámetros,
solo se procesa el primero. El tipo de retorno de la función es un
número real.
**Ejemplo**
.. code:: python
math.tan(1) # 1.55741
math.tan(math.pi / 4) # 1
Función ``asin``
^^^^^^^^^^^^^^^^
.. code:: python
asin(valor)
**Descripción**
Esta función devuelve el valor de la función arco seno del parámetro. El
parámetro puede ser un número entero o un número real. El rango de
valores es [−1,1]. Si no hay parámetros, la función devuelve ``0``, si
hay varios parámetros, solo se procesa el primero. El tipo de retorno de
la función es un número real y la unidad es radianes.
**Ejemplo**
.. code:: python
math.asin(1) # 1.5708
math.asin(0.5) * 180 / math.pi # 30
Función ``acos``
^^^^^^^^^^^^^^^^
.. code:: python
acos(valor)
**Descripción**
Esta función devuelve el valor de la función de arco coseno del
parámetro. El parámetro puede ser un número entero o un número real. El
rango de valores es [−1,1]. Si no hay parámetros, la función devuelve
``0``, si hay varios parámetros, solo se procesa el primero. El tipo de
retorno de la función es un número real y la unidad es radianes.
**Ejemplo**
.. code:: python
math.acos(1) # 0
math.acos(0) # 1.5708
Función ``atán``
^^^^^^^^^^^^^^^^
.. code:: python
atan(valor)
**Descripción**
Esta función devuelve el valor de la función arco tangente del
parámetro. El parámetro puede ser un número entero o un número real. El
rango de valores es [−∞,+∞]. Si no hay parámetros, la función devuelve
``0``, si hay varios parámetros, solo se procesa el primero. El tipo de
retorno de la función es un número real y la unidad es radianes.
**Ejemplo**
.. code:: python
math.atan(1) * 180 / math.pi # 45
Función ``sinh``
^^^^^^^^^^^^^^^^
.. code:: python
sinh(valor)
**Descripción**
Esta función devuelve el valor de función de seno hiperbólico del
parámetro. Si no hay parámetros, la función devuelve ``0``, si hay
varios parámetros, solo se procesa el primer parámetro. El tipo de
retorno de la función es un número real.
**Ejemplo**
.. code:: python
math.sinh(1) # 1.1752
Función ``cosh``
^^^^^^^^^^^^^^^^
.. code:: python
cosh(valor)
**Descripción**
Esta función devuelve el valor de la función coseno hiperbólico del
parámetro. Si no hay parámetros, la función devuelve ``0``, si hay
varios parámetros, solo se procesa el primero. El tipo de retorno de la
función es un número real.
**Ejemplo**
.. code:: python
math.cosh(1) # 1.54308
Función ``tanh``
^^^^^^^^^^^^^^^^
.. code:: python
tanh(valor)
**Descripción**
Esta función devuelve el valor de la función tangente hiperbólica del
parámetro. Si no hay parámetros, la función devuelve ``0``, si hay
varios parámetros, solo se procesa el primero. El tipo de retorno de la
función es un número real.
**Ejemplo**
.. code:: python
math.tanh(1) # 0.761594
Función ``sqrt``
^^^^^^^^^^^^^^^^
.. code:: python
sqrt(valor)
**Descripción**
Esta función devuelve la raíz cuadrada del argumento. El parámetro de
esta función no puede ser negativo. Si no hay parámetros, la función
devuelve ``0``, si hay varios parámetros, solo se procesa el primero. El
tipo de retorno de la función es un número real.
**Ejemplo**
.. code:: python
math.sqrt(2) # 1.41421
Función ``exp``
^^^^^^^^^^^^^^^
.. code:: python
exp(valor)
**Descripción**
Esta función devuelve el valor de la función exponencial del parámetro
en función de la constante natural *e*. Si no hay parámetros, la función
devuelve ``0``, si hay varios parámetros, solo se procesa el primero. El
tipo de retorno de la función es un número real.
**Ejemplo**
.. code:: python
math.exp(1) # 2.71828
Función ``log``
^^^^^^^^^^^^^^^
.. code:: python
log(valor)
**Descripción**
Esta función devuelve el logaritmo natural del argumento. El parámetro
debe ser un número positivo. Si no hay parámetros, la función devuelve
``0``, si hay varios parámetros, solo se procesa el primero. El tipo de
retorno de la función es un número real.
**Ejemplo**
.. code:: python
log(valor)
Función ``log10``
^^^^^^^^^^^^^^^^^
.. code:: python
log10(valor)
**Descripción**
Esta función devuelve el logaritmo del parámetro en base 10. El
parámetro debe ser un número positivo. Si no hay parámetros, la función
devuelve ``0``, si hay varios parámetros, solo se procesa el primero. El
tipo de retorno de la función es un número real.
**Ejemplo**
.. code:: python
math.log10(10) # 1
Función ``deg``
^^^^^^^^^^^^^^^
.. code:: python
deg(valor)
**Descripción**
Esta función se utiliza para convertir radianes en ángulos. La unidad
del parámetro es radianes. Si no hay parámetros, la función devuelve
``0``, si hay varios parámetros, solo se procesa el primero. El tipo de
retorno de la función es un número real y la unidad es un ángulo.
**Ejemplo**
.. code:: python
math.deg(math.pi) # 180
Función ``rad``
^^^^^^^^^^^^^^^
.. code:: python
rad(valor)
**Descripción**
Esta función se utiliza para convertir ángulos a radianes. La unidad del
parámetro es el ángulo. Si no hay parámetros, la función devuelve ``0``,
si hay varios parámetros, solo se procesa el primero. El tipo de retorno
de la función es un número real y la unidad es radianes.
**Ejemplo**
.. code:: python
math.rad(180) # 3.14159
Función ``pow``
^^^^^^^^^^^^^^^
.. code:: python
pow(x, y)
**Descripción**
El valor de retorno de esta función es el resultado de la expresión *x*
\ *y*\ , que es el parámetro ``x`` elevado a ``y``. Si los parámetros
no están completos, la función devuelve ``0``, si hay parámetros
adicionales, solo se procesan los dos primeros parámetros. El tipo de
retorno de la función es un número real.
**Ejemplo**
.. code:: python
math.pow(2, 3) # 8
Función ``srand``
^^^^^^^^^^^^^^^^^
.. code:: python
srand(valor)
**Descripción**
Esta función se utiliza para establecer la semilla del generador de
números aleatorios. El tipo del parámetro debe ser un número entero.
**Ejemplo**
.. code:: python
math.srand(2)
Función ``rand``
^^^^^^^^^^^^^^^^
.. code:: python
rand()
**Descripción**
Esta función se utiliza para obtener un número entero aleatorio.
**Ejemplo**
.. code:: python
math.rand()
Módulo de tiempo
~~~~~~~~~~~~~~~~
Este módulo se utiliza para proporcionar funciones relacionadas con el
tiempo.
Función ``time``
^^^^^^^^^^^^^^^^
.. code:: python
time()
**Descripción**
Devuelve la marca de tiempo actual. La marca de tiempo es el tiempo
transcurrido desde Unix Epoch (1 de enero de 1970 00:00:00 UTC), en
segundos.
.. _función-dump-1:
Función ``dump``
^^^^^^^^^^^^^^^^
.. code:: python
dump(ts)
**Descripción**
La marca de tiempo de entrada ``ts`` se convierte en un ``map`` de
tiempo, y la correspondencia clave-valor se muestra en la siguiente
tabla:
+----------+----------+----------+----------+----------+----------+
|**clave** | **valor**| **clave**| **valor**| **clave**| **valor**|
+==========+==========+==========+==========+==========+==========+
| `` | Año | ``' | Mes | ` | Día |
| 'year'`` | (desde | month'`` | (1-12) | `'day'`` | (1-31) |
| | 1900) | | | | |
+----------+----------+----------+----------+----------+----------+
| `` | Hora | ` | Puntos | ` | Segundos |
| 'hour'`` | (0-23) | `'min'`` | (0-59) | `'sec'`` | (0-59) |
+----------+----------+----------+----------+----------+----------+
| ``'we | Semana | | | | |
| ekday'`` | (1-7) | | | | |
+----------+----------+----------+----------+----------+----------+
*Tabla 11: La relación clave-valor del valor de retorno de la función
``time.dump``*
Función ``clock``
^^^^^^^^^^^^^^^^^
.. code:: python
clock()
**Descripción**
Esta función devuelve el tiempo transcurrido desde el inicio de la
ejecución del intérprete hasta que se llama a la función en segundos. El
valor de retorno de esta función es del tipo “real” y su precisión de
tiempo está determinada por la plataforma específica.
Módulo de cadena (string)
~~~~~~~~~~~~~~~~~~~~~~~~~
El módulo ``cadena`` proporciona funciones de procesamiento de cadenas.
Para usar el módulo de cadena, primero use la instrucción
``import string``. Todos los ejemplos de esta sección asumen que el
módulo se ha importado correctamente.
Función ``count``
^^^^^^^^^^^^^^^^^
::
string.count(s, sub[, inicio[, fin]])
Cuenta el número de ocurrencias de la subcadena en la cadena s. Busque
desde la posición entre ``inicio`` y ``fin`` de ``s`` (el valor
predeterminado es 0 y tamaño(s)).
Función ``split``
^^^^^^^^^^^^^^^^^
::
string.split(s, pos)
Divide la cadena s en dos subcadenas en la posición ``pos`` y devuelve
la lista de esas cadenas.
::
string.split(s, sep[, num])
Divide la cadena s en subcadenas dondequiera que ocurra sep, y devuelve
la lista de esas cadenas. Dividir como máximo un número de veces (el
valor predeterminado es string.count(s, sep)).
Función ``find``
^^^^^^^^^^^^^^^^
::
string.find(s, sub[, inicio[, fin]])
Compruebe si la cadena s contiene la subcadena sub. Si se especifican el
inicio y el final (el valor predeterminado es 0 y el tamaño(s)), se
buscarán en este rango.
Función ``hex``
^^^^^^^^^^^^^^^
::
hex(numero)
Convertir número a cadena hexadecimal.
Función ``byte``
^^^^^^^^^^^^^^^^
::
byte(s)
Obtiene el valor del código del primer byte de la cadena s.
Función ``char``
^^^^^^^^^^^^^^^^
::
char(numero)
Convierte el número usado como código en un carácter.
Función ``format``
^^^^^^^^^^^^^^^^^^
::
string.format(fmt[, args])
Devuelve una cadena formateada. El patrón que comienza con ‘%’ en la
plantilla de formato fmt será reemplazado por el valor de [args]:
%[flags][fieldwidth][.precision]type
+----+-----------------------------------------------------------------+
| Ti | Descripción |
| po | |
+====+=================================================================+
| %d | Entero decimal |
+----+-----------------------------------------------------------------+
| %o | Entero octal |
+----+-----------------------------------------------------------------+
| %x | Entero hexadecimal en minúsculas |
+----+-----------------------------------------------------------------+
| %X | Entero hexadecimal en mayúsculas |
+----+-----------------------------------------------------------------+
| %x | Entero octal en minúsculas |
+----+-----------------------------------------------------------------+
| %X | Entero octal en mayúsculas |
+----+-----------------------------------------------------------------+
| %f | Punto flotante en la forma [-]nnnn.nnnn |
+----+-----------------------------------------------------------------+
| %e | Punto flotante en exp. forma [-]n.nnnn e [+|-]nnn, mayúsculas |
| %E | si %E |
+----+-----------------------------------------------------------------+
| %g | Punto flotante como %f si −4 < exp. ≤ precision, sino como %e; |
| %G | mayúsculas si %G |
+----+-----------------------------------------------------------------+
| %c | Carácter que tiene el código pasado como entero |
+----+-----------------------------------------------------------------+
| %s | Cadena sin ceros incrustados |
+----+-----------------------------------------------------------------+
| %q | Cadena entre comillas dobles, con caracteres especiales |
| | escapados |
+----+-----------------------------------------------------------------+
| %% | El carácter ‘%’ (escapado) |
+----+-----------------------------------------------------------------+
+------+---------------------------------------------------------------+
| Tipo | Descripción |
+======+===============================================================+
| - | Justificación a la izquierda, el valor predeterminado es |
| | justificación a la derecha |
+------+---------------------------------------------------------------+
| + | antepone el signo (se aplica a los números) |
+------+---------------------------------------------------------------+
| ( | Antepone signo si es negativo, de lo contrario espacio |
| espa | |
| cio) | |
+------+---------------------------------------------------------------+
| # | Agrega “0x” antes de %x, fuerza el punto decimal; para %e, |
| | %f, deja ceros finales para %g |
+------+---------------------------------------------------------------+
+------------+---------------------------------------------------------+
| Ancho de | Descripción |
| campo y | |
| precisión | |
+============+=========================================================+
| n | Pone al menos n caracteres, rellena con espacios en |
| | blanco |
+------------+---------------------------------------------------------+
| 0n | Pone al menos n caracteres, teclado izquierdo con ceros |
+------------+---------------------------------------------------------+
| .n | Usa al menos n dígitos para números enteros, redondee a |
| | n decimales para punto flotante o no más de n |
| | caracteres. para cadenas |
+------------+---------------------------------------------------------+
Módulo ``os``
~~~~~~~~~~~~~
El módulo OS proporciona funciones relacionadas con el sistema, como
funciones relacionadas con archivos y rutas. Estas funciones están
relacionadas con la plataforma. Actualmente, los códigos de estilo
Windows VC y POSIX se implementan en el intérprete de Berry. Si se
ejecuta en otras plataformas, no se garantiza que se proporcionen las
funciones en el módulo del sistema operativo.
[COMPLETAR]
Módulo ``global``
~~~~~~~~~~~~~~~~~
El módulo ``global`` proporciona una forma de acceder a las variables
globales a través de un módulo. El compilador Berry comprueba que existe
un global al compilar el código. Sin embargo, hay casos en los que los
globales se crean dinámicamente por código y aún no se conocen en tiempo
de compilación. El uso del módulo ``global`` da total libertad para
acceder a variables globales estáticas o dinámicas.
Acceder a un global es simplay hecho con ``global.`` para leer y
escribir. También puede usar la sintaxis especial ``global.(nombre)`` si
``nombre`` es una variable que contiene el nombre del global como
cadena.
Ejemplo:
.. code:: berry
> import global
> a = 1
> global.a
1
>
> b
syntax_error: stdin:1: 'b' no declarado (primer uso en esta función)
> global.b = 2
> b
2
> global.b
2
> var nombre = "b"
> global.(nombre)
2
Llamar a ``global()`` devuelve la lista de todos los nombres globales
actualmente definidos (los componentes integrados no están incluidos).
.. code:: berry
> import global
> a = 1
> global.b = 2
> global()
['_argv', 'b', 'global', 'a']
``global.contains( -> bool`` proporciona una manera fácil de
saber si un nombre global ya está definido.
.. code:: berry
> import global
> global.contains("g")
false
> g = 1
> global.contains("g")
true
Módulo ``introspect``
~~~~~~~~~~~~~~~~~~~~~
El módulo ``introspect`` proporciona primitivas para acceder
dinámicamente a variables o módulos. Usar con ``import introspect``.
``introspect.members(objeto: clase o módulo o instancia o nil) -> lista``
devuelve la lista de nombres de miembros para la ``clase``,
``instancia`` o ``módulo``. Tenga en cuenta que no incluye miembros
virtuales potenciales creados a través de ``member`` y ``setmember``.
``introspect.members()`` devuelve la lista de variables globales (sin
incluir las incorporadas) y es equivalente a ``global()``
``introspect.get(objeto: clase o instancia o módulo, nombre:cadena) -> cualquiera``
e
``introspect.set(objeto: clase o instancia o módulo, nombre:cadena, valor:cualquiera) -> nil``
permite leer y escribir cualquier miembro por su nombre.
``introspect.get(o, "a")`` es equivalente a ``oa``,
``introspect.set(o, "a", 1)`` es equivalente a ``oa = 1``. También hay
una sintaxis alternativa: ``o.("a")`` es equivalente a ``oa`` y
``o.("a) = 1`` es equivalente a ``oa = 1``.
``introspect.module(nombre:cadena) -> any`` es equivalente a
``import nombre`` excepto que no crea la variable global o local, sino
que devuelve el módulo. Esta es la única manera de cargar un módulo con
un nombre dinámico, ``import nombre`` solo toma un nombre estático.
``introspect.toptr(addr:int) -> comptr`` convierte un número entero en
un puntero comptr. ``introspect.fromptr(addr:comptr) -> int`` hace lo
contrario y convierte un puntero en un int. Advertencia: usar con
cuidado. En plataformas donde ``int`` y ``void*`` no tienen el mismo
tamaño, estas funciones seguramente darán resultados inutilizables.
``introspect.ismethod(f:function) -> bool`` comprueba si la función
proporcionada es un método de una instancia (tomando a sí mismo como
primer argumento) o una función simple. Esto se usa principalmente para
evitar un error común de pasar un método de instancia como callback,
donde debe usar un cierre que capture la instancia como
``/ -> self.do()``.
Módulo ``solidify``
~~~~~~~~~~~~~~~~~~~
Este módulo permite solidificar el bytecode de Berry en flash. Esto
permite ahorrar RAM ya que el código está en ROM. Esto lo convierte en
una buena alternativa a las funciones nativas de C.
Ver 8.4 Solidificación