601 lines
10 KiB
Markdown
601 lines
10 KiB
Markdown
|
|
## Trabajar con celdas y rangos
|
|
|
|
---
|
|
|
|
### **address**
|
|
|
|
Referencia por dirección.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
rango = hoja['C10:D15']
|
|
|
|
app.debug(celda)
|
|
app.debug(rango)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **doc**
|
|
|
|
Devuelve el documento padre.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
rango = hoja['A1:C5']
|
|
|
|
doc = rango.doc
|
|
app.debug(doc)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **in**
|
|
|
|
Verificar si un rango esta dentro de otro.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['C5']
|
|
rango = hoja['A1:E10']
|
|
|
|
resultado = celda in rango
|
|
app.debug(resultado)
|
|
|
|
celda = hoja['C50']
|
|
resultado = celda in rango
|
|
app.debug(resultado)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **iter**
|
|
|
|
Iterar cada celda de un rango.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
rango = hoja['B10:C15']
|
|
|
|
for celda in rango:
|
|
app.debug(celda)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **position**
|
|
|
|
Referencia por posición.
|
|
|
|
Para celdas: `HOJA[fila,columna]`
|
|
|
|
Para rangos: `HOJA[fila_inicial:fila_final, columna_inicial:columna_final]`
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
# ~ Cell A10
|
|
celda = hoja[9,0]
|
|
|
|
# ~ Range A1:C10
|
|
rango = hoja[0:10,0:3]
|
|
```
|
|
|
|
!!! tip "Atención"
|
|
|
|
Recuerde que las filas y columnas empiezan en cero, por lo que `fila_final` y la `columna_final` deben de ser la fila y columna deseada más 1.
|
|
|
|
<br>
|
|
|
|
### **selection**
|
|
|
|
Referencia por selección actual.
|
|
|
|
```py
|
|
seleccion = app.active.selection
|
|
app.debug(seleccion)
|
|
```
|
|
|
|
!!! tip "Atención"
|
|
|
|
Recuerde que la selección actual pueden ser varias cosas diferentes.
|
|
|
|
<br>
|
|
|
|
## Propiedades
|
|
|
|
---
|
|
|
|
### **address**
|
|
|
|
Devuelve la dirección de la celda como una estructura: `com.sun.star.table.CellAddress`
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['A1']
|
|
if celda.is_cell:
|
|
app.debug(celda.address)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **back_color**
|
|
|
|
Devuelve o aplica el color de fondo del rango.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
rango = hoja['A1:E10']
|
|
rango.back_color = 'red'
|
|
```
|
|
|
|
<br>
|
|
|
|
### **current_region**
|
|
|
|
Devuelve la región actual.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['A1']
|
|
rango = celda.current_region
|
|
app.debug(rango)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **data**
|
|
|
|
Alias de `data_array` al obtener los datos. Al establecer los datos, si es un rango se comporta como `data_array`, pero si es una celda, se autoajusta al tamaño de los datos.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
datos = (
|
|
(1, 'Uno'),
|
|
(2, 'Dos'),
|
|
(3, 'Tres'),
|
|
)
|
|
|
|
celda.data = datos
|
|
app.debug(celda.current_region.data)
|
|
```
|
|
|
|
!!! warning "Cuidado"
|
|
|
|
Siempre valide que haya suficientes celdas libres para los datos para evitar sobreescribirlos.
|
|
|
|
<br>
|
|
|
|
### **data_array**
|
|
|
|
Devuelve o establece los datos de un rango. Es un alias de `DataArray`.
|
|
|
|
```py
|
|
rango = app.active.selection
|
|
|
|
datos = rango.data_array
|
|
app.debug(datos)
|
|
rango.data_array = datos
|
|
```
|
|
|
|
!!! warning "Cuidado"
|
|
|
|
El tamaño de los datos, debe ser **exactamente** del tamaño del rango destino. De lo contrario obtendrá un error.
|
|
|
|
<br>
|
|
|
|
### **date**
|
|
|
|
Devuelve o establece el contenido de la celda como fecha.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
celda.date = app.dates.date(1974, 1, 15)
|
|
app.debug(type(celda.date), celda.date)
|
|
```
|
|
|
|
```
|
|
20/08/2022 18:38:53 - DEBUG - <class 'datetime.date'> 1974-01-15
|
|
```
|
|
|
|
<br>
|
|
|
|
### **datetime**
|
|
|
|
Devuelve o establece el contenido de la celda como fecha y tiempo.
|
|
|
|
```python
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
celda.datetime = app.dates.datetime(1974, 1, 15, 10, 11, 12)
|
|
app.debug(type(celda.datetime), celda.datetime)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **dict**
|
|
|
|
Devuelve o establece los datos como diccionarios. Automáticamente ajusta el rango al tamaño de los datos.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
|
|
datos = (
|
|
{'No': 1, 'Nombre': 'Ingrid'},
|
|
{'No': 2, 'Nombre': 'Sophia'},
|
|
{'No': 3, 'Nombre': 'Scarlette'},
|
|
)
|
|
|
|
celda.dict = datos
|
|
app.debug(celda.current_region.dict)
|
|
```
|
|
|
|
!!! warning "Consejo"
|
|
|
|
Siempre valide que haya suficientes celdas libres para los datos para evitar sobreescribirlos, a menos que eso sea lo que realmente quiera.
|
|
|
|
<br>
|
|
|
|
### **error**
|
|
|
|
Si la celda tiene una formula con error, devuelve el número de error.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
celda.value = '=RAND()/0'
|
|
app.debug(celda.error)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **float**
|
|
|
|
Devuelve o establece el contenido de la celda como valor.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
celda.float = 12345
|
|
app.debug(celda.type, celda.float)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **formula**
|
|
|
|
Devuelve o establece la formula de la celda.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
celda.formula = '=RAND()'
|
|
app.debug(celda.type, celda.formula)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **formula_array**
|
|
|
|
Devuelve o establece los datos de un rango. Es un alias de `FormulaArray`.
|
|
|
|
```py
|
|
rango = app.active.selection
|
|
|
|
datos = rango.data_array
|
|
app.debug(datos)
|
|
datos = rango.formula_array
|
|
app.debug(datos)
|
|
rango.formula_array = datos
|
|
```
|
|
|
|
!!! tip "Consejo"
|
|
|
|
**data_array** devolverá los resultados de las celdas con formulas. **formula_array** devolverá las formulas en dichas celdas.
|
|
|
|
<br>
|
|
|
|
### **is_cell**
|
|
|
|
Verdadero (True) si el objeto es de una celda.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['A1']
|
|
app.debug(celda.is_cell)
|
|
|
|
rango = hoja['A1:C5']
|
|
app.debug(rango.is_cell)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **is_range**
|
|
|
|
Verdadero (True) si el objeto es de un rango.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['A1']
|
|
app.debug(celda.is_range)
|
|
|
|
rango = hoja['A1:C5']
|
|
app.debug(rango.is_range)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **len**
|
|
|
|
Devolver el tamaño del rango en filas y columnas.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
rango = hoja['A1:E100']
|
|
filas = len(rango)
|
|
columnas = rango.len_columns
|
|
app.debug(filas, columnas)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **name**
|
|
|
|
Devuelve la dirección de la celda o rango como texto.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['A1']
|
|
app.debug(celda.name)
|
|
|
|
rango = hoja['A1:C5']
|
|
app.debug(rango.name)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **next_free**
|
|
|
|
Devuelve la siguiente celda libre después de la región actual.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
|
|
celda_libre = celda.next_free
|
|
app.debug(celda_libre)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **range_address**
|
|
|
|
Devuelve la dirección del rango como una estructura: `com.sun.star.table.CellRangeAddress`
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
rango = hoja['A1:C5']
|
|
if rango.is_range:
|
|
app.debug(rango.range_address)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **range_data**
|
|
|
|
Devuelve la región actual del rango excepto la primer fila.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['A1']
|
|
rango = celda.range_data
|
|
app.debug(rango)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **sheet**
|
|
|
|
Devuelve la hoja padre.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
rango = hoja['A1:C5']
|
|
|
|
hoja = rango.sheet
|
|
app.debug(hoja)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **string**
|
|
|
|
Devuelve o establece el contenido de la celda como texto.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['A1']
|
|
celda.string = 'Maldito Mundo'
|
|
app.debug(celda.type, celda.string)
|
|
|
|
celda = hoja['A2']
|
|
celda.string = 12345
|
|
app.debug(celda.type, celda.string)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **style**
|
|
|
|
Devuelve o aplica el estilo de celda.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
rango = hoja['A1:C5']
|
|
rango.style = 'Good'
|
|
```
|
|
|
|
<br>
|
|
|
|
### **time**
|
|
|
|
Devuelve o establece el contenido de la celda como tiempo.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
celda.time = app.dates.time(10, 11, 12)
|
|
app.debug(type(celda.time), celda.time)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **type**
|
|
|
|
Devuelve el tipo de contenido de la celda: texto, número o formula.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
celda = hoja['A1']
|
|
app.debug(celda.type)
|
|
```
|
|
|
|
!!! tip "Consejo"
|
|
|
|
Asegurese de que la selección siempre sea una sola celda.
|
|
|
|
<br>
|
|
|
|
### **value**
|
|
|
|
Devuelve o establece el valor de la celda, estableciendo el tipo de dato automáticamente.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
celda = hoja['A1']
|
|
celda.value = 'Soy Texto'
|
|
app.debug(celda.type, celda.value)
|
|
|
|
celda = hoja['A2']
|
|
celda.value = 12345
|
|
app.debug(celda.type, celda.value)
|
|
|
|
celda = hoja['A3']
|
|
celda.value = '=RAND()'
|
|
app.debug(celda.type, celda.value)
|
|
|
|
celda = hoja['A4']
|
|
celda.value = app.dates.date(1974, 1, 15)
|
|
app.debug(celda.type, celda.value)
|
|
```
|
|
|
|
```sh
|
|
23/04/2023 19:49:05 - DEBUG - <Enum instance com.sun.star.table.CellContentType ('TEXT')> Soy Texto
|
|
23/04/2023 19:49:05 - DEBUG - <Enum instance com.sun.star.table.CellContentType ('VALUE')> 12345.0
|
|
23/04/2023 19:49:05 - DEBUG - <Enum instance com.sun.star.table.CellContentType ('FORMULA')> =RAND()
|
|
23/04/2023 19:49:05 - DEBUG - <Enum instance com.sun.star.table.CellContentType ('VALUE')> 27044.0
|
|
```
|
|
|
|
<br>
|
|
|
|
## Métodos
|
|
|
|
---
|
|
|
|
### **clear**
|
|
|
|
Limpia el rango. Por default solo borra datos. Mire [API CellFlags][1] para más información.
|
|
|
|
```python
|
|
rango.clear()
|
|
```
|
|
|
|
Para borrar todo.
|
|
```python
|
|
rango.clear(app.ALL)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **len**
|
|
|
|
Devuelve el tamaño en filas y columnas del rango.
|
|
|
|
```py
|
|
hoja = app.active.active
|
|
|
|
rango = hoja['A1:C100']
|
|
filas, columnas = rango.len()
|
|
app.debug(filas, columnas)
|
|
```
|
|
|
|
<br>
|
|
|
|
### **offset**
|
|
|
|
Devuelve la celda inmediata a la derecha en la misma fila.
|
|
|
|
```py
|
|
cell = app.active.active['A1']
|
|
app.debug(cell)
|
|
cell = cell.offset()
|
|
app.debug(cell)
|
|
```
|
|
|
|
```
|
|
23/04/2023 21:22:15 - DEBUG - Cell: $Sheet1.$A$1
|
|
23/04/2023 21:22:15 - DEBUG - Cell: $Sheet1.$B$1
|
|
```
|
|
|
|
Se puede establecer la distancia a la celda a devolver en filas y columnas.
|
|
|
|
```py
|
|
cell = app.active.active['A1']
|
|
app.debug(cell)
|
|
cell = cell.offset(4,2)
|
|
app.debug(cell)
|
|
```
|
|
|
|
```
|
|
23/04/2023 21:24:59 - DEBUG - Cell: $Sheet1.$A$1
|
|
23/04/2023 21:24:59 - DEBUG - Cell: $Sheet1.$C$5
|
|
```
|
|
|
|
<br>
|
|
|
|
### **to_size**
|
|
|
|
Espande el tamaño del rango actual tantas filas y columnas se pasen como argumentos.
|
|
|
|
```py
|
|
cell = app.active.active['A1']
|
|
app.debug(cell)
|
|
cell = cell.to_size(10,5)
|
|
app.debug(cell)
|
|
```
|
|
|
|
```
|
|
23/04/2023 21:30:56 - DEBUG - Cell: $Sheet1.$A$1
|
|
23/04/2023 21:30:56 - DEBUG - Range: $Sheet1.$A$1:$E$10
|
|
```
|
|
|
|
<br>
|
|
|
|
[1]: https://api.libreoffice.org/docs/idl/ref/namespacecom_1_1sun_1_1star_1_1sheet_1_1CellFlags.html |