Python Basics
TIPOS DE DATOS EN PYTHON
Los tipos de datos en C se tienen que declarar por defecto en el caso de Python, esto no es necesario ya que esto se hace de manera automatica.
Una funcion que tiene Python por defecto es type() asi es como se utiliza para ver el tipo de dato de la variable en cuestion.
| Tipo de dato | Descripción | Ejemplo | Mutable |
|---|---|---|---|
| Numéricos | |||
int | Números enteros | 10, -5, 1000 | Inmutable |
float | Números de punto flotante (decimales) | 3.14, -0.001, 2.5 | Inmutable |
complex | Números complejos | 3 + 4j, 1j | Inmutable |
| Secuencias | |||
str | Cadenas de caracteres (texto) | "Hola", 'Python', "123" | Inmutable |
list | Listas (colección ordenada y mutable de elementos) | [1, 2, 3], ["a", "b", "c"] | Mutable |
tuple | Tuplas (colección ordenada e inmutable de elementos) | (1, 2, 3), ("a", "b", "c") | Inmutable |
range | Rangos (secuencia inmutable de números) | range(10), range(2, 8) | Inmutable |
| Mapas | |||
dict | Diccionarios (colección de pares clave-valor) | {"nombre": "Juan", "edad": 30} | Mutable |
| Conjuntos | |||
set | Conjuntos (colección no ordenada y mutable de elementos únicos) | {1, 2, 3}, {"a", "b", "c"} | Mutable |
frozenset | Conjuntos inmutables | frozenset({1, 2, 3}) | Inmutable |
| Booleanos | |||
bool | Valores booleanos (verdadero o falso) | True, False | Inmutable |
| Binarios | |||
bytes | Secuencias inmutables de bytes | b"\\x00\\x01\\x02" | Inmutable |
bytearray | Secuencias mutables de bytes | bytearray(b"\\x00\\x01\\x02") | Mutable |
memoryview | Vista de memoria de un objeto binario | memoryview(b"\\x00\\x01\\x02") | Mutable |
In [1]:
a = 1
type(a)
Out[1]:
int
In [2]:
b = 2.5
type(b)
Out[2]:
float
In [3]:
c = 'Hello'
type(c)
Out[3]:
str
In [4]:
d = False
type(d)
Out[4]:
bool
In [5]:
e = [1,2,3]
type(e)
Out[5]:
list
In [6]:
f = (10,20,30)
type(f)
Out[6]:
tuple
In [7]:
g = {1,2,3}
type(g)
Out[7]:
set
In [8]:
h = {1:10, 2:20, 3:30}
type(h)
Out[8]:
dict
Existen muchas operaciones que se pueden aplicar a un tipo de dato
In [9]:
dir(a)
Out[9]:
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
En Python la intencion de las librerias es unir diferentes paquetes de librerias, para que su instalación sea sencilla y no pierda demasiado tiempo en la instalacion.
Estas herramientas vienen con mas herramientas de las necesarias, por ejemplo cosas que solo se podian hacer con facilidad en matalab.
In [10]:
complex('1+5j')
Out[10]:
(1+5j)
In [11]:
dir(complex())
Out[11]:
['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', 'conjugate', 'imag', 'real']
De esta forma, las operaciones que podemos aplicar a esta son, real, imag, cong
Existen palabras clave reservadas del lenguaje que no pueden ser usadas como nombres de variables, si se intenta hacer uso de ellas puede que ocurra un error de sintaxis
| Palabra Clave | Palabra Clave | Palabra Clave | Palabra Clave |
|---|---|---|---|
False | class | from | nonlocal |
None | continue | global | not |
True | def | if | or |
and | del | import | pass |
as | elif | in | raise |
assert | else | is | return |
async | except | lambda | try |
await | finally | while | |
break | for | with | |
yield |
Mutabilidad de variables
Define si un dato puede ser mutado tras ser inicializado o si siempre mantiene el mismo valor. Los objetos no mutables no permitiran cambios. Los mutables, sin embargo cambiaran sus valores para todas las referencias hacia ellos.
In [12]:
x,y = 1, 4
z = x
print(x,y,z)
1 4 1
In [13]:
z = 7
x,y,z
Out[13]:
(1, 4, 7)
In [14]:
lista = [0,3,4]
copia_lista = lista
copia_lista[2] = 569
print(lista, copia_lista)
[0, 3, 569] [0, 3, 569]
Operadores en General
| Operador Lógico | Descripción | Ejemplo | Resultado |
|---|---|---|---|
and | Verdadero si ambos operandos son verdaderos | True and False | False |
or | Verdadero si al menos uno de los operandos es verdadero | True or False | True |
not | Invierte el valor booleano del operando | not True | False |
| Operador de Comparación | Descripción | Ejemplo | Resultado |
|---|---|---|---|
== | Igual a | 5 == 5 | True |
!= | No igual a | 5 != 10 | True |
> | Mayor que | 10 > 5 | True |
< | Menor que | 5 < 10 | True |
>= | Mayor o igual que | 10 >= 10 | True |
<= | Menor o igual que | 5 <= 10 | True |
is | Identidad de objeto | x is y | True si x e y son el mismo objeto |
is not | No identidad de objeto | x is not y | True si x e y no son el mismo objeto |
| Operador | Descripción | Ejemplo | Resultado |
|---|---|---|---|
+ | Suma | 5 + 3 | 8 |
- | Resta | 10 - 4 | 6 |
* | Multiplicación | 6 * 7 | 42 |
/ | División (flotante) | 15 / 4 | 3.75 |
// | División entera (truncada) | 15 // 4 | 3 |
% | Módulo (resto de la división) | 15 % 4 | 3 |
** | Exponenciación | 2 ** 3 | 8 |
- (unario) | Negación | -5 | -5 |
+ (unario) | Positivo | +5 | 5 |
@ | Multiplicación de matrices | mat1 @ mat2 | Producto matricial |
<< | Desplazamiento a la izquierda (bits) | 10 << 2 | 40 |
>> | Desplazamiento a la derecha (bits) | 10 >> 2 | 2 |
& | AND bit a bit | 10 & 12 | 8 |
\| | OR bit a bit | 10 \| 12 | 14 |
^ | XOR bit a bit | 10 ^ 12 | 6 |
~ | NOT bit a bit | ~10 | -11 |
Enteros
Se pueden separar bloques numericos en literales enteros.
Algunas conversiones que se pueden aplicar para convertir un otro sistema al decimal y viceversa
In [15]:
348_304_345
Out[15]:
348304345
In [16]:
binario = '01010111'
int(binario, base=2)
Out[16]:
87
In [17]:
octal = '61'
int(octal, base=8)
Out[17]:
49
In [18]:
hexadecimal = '2b'
int (hexadecimal, base=16)
Out[18]:
43
Listas¶
Secuencias de elementos de cualquier tipo y sin limite de longitud. El constructor y el tipo de dato es list
In [19]:
a = list([1,2,3,4])
a
Out[19]:
[1, 2, 3, 4]
In [20]:
type(a)
Out[20]:
list
| Operación | Descripción | Ejemplo | Resultado |
|---|---|---|---|
len(lista) | Longitud de la lista | len([1, 2, 3]) | 3 |
lista[índice] | Acceder a un elemento por índice | [10, 20, 30][1] | 20 |
lista[inicio:fin] | Slicing (sublista) | [1, 2, 3, 4, 5][1:4] | [2, 3, 4] |
lista.append(elemento) | Agregar un elemento al final | [1, 2].append(3) | [1, 2, 3] |
lista.extend(otra_lista) | Agregar elementos de otra lista | [1, 2].extend([3, 4]) | [1, 2, 3, 4] |
lista.insert(índice, elemento) | Insertar un elemento en un índice dado | [1, 2].insert(1, 1.5) | [1, 1.5, 2] |
lista.remove(elemento) | Eliminar la primera aparición de un elemento | [1, 2, 2, 3].remove(2) | [1, 2, 3] |
lista.pop(índice) | Eliminar y devolver el elemento de un índice dado | [1, 2, 3].pop(1) | 2 y [1, 3] |
lista.clear() | Eliminar todos los elementos de la lista | [1, 2, 3].clear() | [] |
lista.index(elemento) | Obtener el índice de la primera aparición de un elemento | [10, 20, 30].index(20) | 1 |
lista.count(elemento) | Contar cuántas veces aparece un elemento | [1, 2, 2, 3].count(2) | 2 |
lista.sort() | Ordenar la lista (in-place) | [3, 1, 2].sort() | [1, 2, 3] |
lista.reverse() | Invertir el orden de la lista (in-place) | [1, 2, 3].reverse() | [3, 2, 1] |
lista.copy() | Crear una copia superficial de la lista | [1, 2, 3].copy() | [1, 2, 3] |
lista + otra_lista | Concatenar listas | [1, 2] + [3, 4] | [1, 2, 3, 4] |
lista * n | Repetir la lista n veces | [1, 2] * 3 | [1, 2, 1, 2, 1, 2] |
elemento in lista | Verificar si un elemento está en la lista | 2 in [1, 2, 3] | True |
Nota: Usando la función copy sobre las listas solo se hace una copia superficial, por lo que los elementos mas allas del primer nivel, como puede ser una lista dentro de otra lista, no se copian como copias, sino como referencias. Esto hace que realmente sigan estando enlazadas entre sí, aunque estén en dos variables distintas.
In [21]:
xs = [[1,2,3,4],['Isaac','Kevin'], True]
In [22]:
ys = xs.copy()
xs
Out[22]:
[[1, 2, 3, 4], ['Isaac', 'Kevin'], True]
In [23]:
ys
Out[23]:
[[1, 2, 3, 4], ['Isaac', 'Kevin'], True]
In [24]:
xs[0]
Out[24]:
[1, 2, 3, 4]
In [25]:
xs[0][1]=38928
xs
Out[25]:
[[1, 38928, 3, 4], ['Isaac', 'Kevin'], True]
In [26]:
ys
Out[26]:
[[1, 38928, 3, 4], ['Isaac', 'Kevin'], True]
Sin embargo, si se utiliza una función que copie en profundidad, como copy.deepcopy el problema desaparece.
In [27]:
import copy
yys = copy.deepcopy(xs)
yys
Out[27]:
[[1, 38928, 3, 4], ['Isaac', 'Kevin'], True]
In [28]:
xs
Out[28]:
[[1, 38928, 3, 4], ['Isaac', 'Kevin'], True]
In [29]:
xs[0][2] = 'Coche'
xs
Out[29]:
[[1, 38928, 'Coche', 4], ['Isaac', 'Kevin'], True]
In [30]:
ys
Out[30]:
[[1, 38928, 'Coche', 4], ['Isaac', 'Kevin'], True]
In [31]:
yys
Out[31]:
[[1, 38928, 3, 4], ['Isaac', 'Kevin'], True]
Las listas se pueden concatenar con otras listas, el problema puede agraviarse si se utilizan grandes cantidades de datos, es importante hacer buen uso de la memoria. Para conocer el espacio en memoria, se puede usar la función sys.getsizeof
In [32]:
import sys
sys.getsizeof(yys)
Out[32]:
96
Tuplas¶
Es un tipo se secuencia similar a la lista pero este es inmutable, estas son las operaciones que se pueden realizar, como se observa todads las operaciones son de lectura principalmente
| Operación | Descripción | Ejemplo | Resultado |
|---|---|---|---|
len(tupla) | Longitud de la tupla | len((1, 2, 3)) | 3 |
tupla[índice] | Acceder a un elemento por índice | (10, 20, 30)[1] | 20 |
tupla[inicio:fin] | Slicing (subtupla) | (1, 2, 3, 4, 5)[1:4] | (2, 3, 4) |
tupla.count(elemento) | Contar cuántas veces aparece un elemento | (1, 2, 2, 3).count(2) | 2 |
tupla.index(elemento) | Obtener el índice de la primera aparición de un elemento | (10, 20, 30).index(20) | 1 |
tupla1 + tupla2 | Concatenar tuplas | (1, 2) + (3, 4) | (1, 2, 3, 4) |
tupla * n | Repetir la tupla n veces | (1, 2) * 3 | (1, 2, 1, 2, 1, 2) |
elemento in tupla | Verificar si un elemento está en la tupla | 2 in (1, 2, 3) | True |
In [33]:
tuple([2,3,4])
Out[33]:
(2, 3, 4)
Rangos¶
Otro tipo de secuencias inmutables, su gran ventaja es que son iteradores. Se crean invocando al constructor range.
| Operación/Atributo | Descripción | Ejemplo | Resultado |
|---|---|---|---|
range(fin) | Crea un rango de 0 a fin-1 | range(5) | range(0, 5) |
range(inicio, fin) | Crea un rango de inicio a fin-1 | range(2, 7) | range(2, 7) |
range(inicio, fin, paso) | Crea un rango con un incremento de paso | range(1, 10, 2) | range(1, 10, 2) |
len(rango) | Longitud del rango | len(range(0, 10, 2)) | 5 |
rango[índice] | Acceder a un elemento por índice | range(1, 6)[2] | 3 |
elemento in rango | Verificar si un elemento está en el rango | 3 in range(1, 5) | True |
elemento not in rango | Verificar si un elemento no está en el rango | 6 not in range(1, 5) | True |
rango.start | Obtener el valor inicial del rango | range(2, 8).start | 2 |
rango.stop | Obtener el valor final del rango | range(2, 8).stop | 8 |
rango.step | Obtener el valor del paso del rango | range(1, 10, 3).step | 3 |
In [34]:
# Crear una lista a partir de una rango
lista = list(range(3, 10, 2))
print(lista)
[3, 5, 7, 9]
In [35]:
#Verificar si un numero esata dentro de un rango
rango = range(0, 20, 3)
print(12 in rango)
print(15 in rango)
True True
In [36]:
#En el ciclo for
for i in range(5):
print(i)
0 1 2 3 4
In [37]:
range(0) == range (15,20, -5)
Out[37]:
True
In [38]:
rango = range(0, 24, 2)
rango
Out[38]:
range(0, 24, 2)
In [39]:
8 in rango
Out[39]:
True
7 in rango
In [40]:
rango[3]
Out[40]:
6
In [41]:
rango[7]
Out[41]:
14
In [42]:
rango[-2]
Out[42]:
20
In [43]:
rango[:4]
Out[43]:
range(0, 8, 2)
In [44]:
list(rango[:6])
Out[44]:
[0, 2, 4, 6, 8, 10]
In [45]:
list(rango[3:])
Out[45]:
[6, 8, 10, 12, 14, 16, 18, 20, 22]
In [46]:
list(rango)
Out[46]:
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
Slices¶
Como si se tratara de un pastel podemos seleccionar partes de las tuplas o listas, rango de N elementos y definir tanto el orden como el paso. Estas son las operaciones posibles y algunos ejemplos:
| Operación | Descripción | Ejemplo (lista) | Ejemplo (cadena) | Ejemplo (tupla) | Ejemplo (range) | Resultado |
|---|---|---|---|---|---|---|
len(secuencia) | Longitud de la secuencia | len([1, 2, 3]) | len("Hola") | len((1, 2, 3)) | len(range(5)) | 3, 4, 3, 5 |
secuencia[índice] | Acceder a un elemento por índice | [10, 20, 30][1] | "Python"[0] | (10, 20, 30)[2] | range(5)[3] | 20, "P", 30, 3 |
secuencia[inicio:fin] | Slicing (sub-secuencia) | [1, 2, 3, 4, 5][1:4] | "Python"[1:3] | (1, 2, 3, 4, 5)[1:4] | range(10)[2:5] | [2, 3, 4], "yt", (2, 3, 4), range(2, 5) |
secuencia[inicio:fin:paso] | Slicing con paso | [0, 1, 2, 3, 4, 5][0:5:2] | "Python"[0:6:2] | (0, 1, 2, 3, 4, 5)[0:5:2] | range(10)[0:10:3] | [0, 2, 4], "Pto", (0, 2, 4), range(0, 10, 3) |
secuencia1 + secuencia2 | Concatenar secuencias | [1, 2] + [3, 4] | "Hola" + "Mundo" | (1, 2) + (3, 4) | N/A | [1, 2, 3, 4], "HolaMundo", (1, 2, 3, 4) |
secuencia * n | Repetir la secuencia n veces | [1, 2] * 3 | "Py" * 2 | (1, 2) * 2 | N/A | [1, 2, 1, 2, 1, 2], "PyPy", (1, 2, 1, 2) |
elemento in secuencia | Verificar si un elemento está en la secuencia | 2 in [1, 2, 3] | "y" in "Python" | 2 in (1, 2, 3) | 3 in range(5) | True, True, True, True |
elemento not in secuencia | Verificar si un elemento no está en la secuencia | 4 not in [1, 2, 3] | "z" not in "Python" | 4 not in (1, 2, 3) | 6 not in range(5) | True, True, True, True |
secuencia.index(elemento) | Obtener el índice de la primera aparición de un elemento | [10, 20, 30].index(20) | "Python".index("t") | (10, 20, 30).index(20) | N/A | 1, 2, 1 |
secuencia.count(elemento) | Contar cuántas veces aparece un elemento | [1, 2, 2, 3].count(2) | "Python".count("o") | (1, 2, 2, 3).count(2) | N/A | 2, 1, 2 |
min(secuencia) | Obtener el elemento mínimo | min([3, 1, 4]) | min("cab") | min((3, 1, 4)) | min(range(1, 5)) | 1, "a", 1, 1 |
max(secuencia) | Obtener el elemento máximo | max([3, 1, 4]) | max("cab") | max((3, 1, 4)) | max(range(1, 5)) | 4, "c", 4, 4 |
sum(secuencia) | Sumar los elementos (numéricos) | sum([1, 2, 3]) | N/A | sum((1, 2, 3)) | sum(range(1, 5)) | 6, 6, 10 |
sorted(secuencia) | Devolver una nueva lista ordenada | sorted([3, 1, 4]) | sorted("cab") | sorted((3, 1, 4)) | sorted(range(4, 0, -1)) | [1, 3, 4], ['a', 'b', 'c'], [1, 3, 4], [1, 2, 3, 4] |
reversed(secuencia) | Devolver un iterador inverso | list(reversed([1, 2, 3])) | "".join(reversed("abc")) | tuple(reversed((1, 2, 3))) | list(reversed(range(4,0,-1))) | [3, 2, 1], "cba", (3, 2, 1), [3, 2, 1] |
In [47]:
a = [1,2,3,4,5,6]
a[2], a[4], a[-2]
Out[47]:
(3, 5, 5)
In [48]:
a[3:20]
Out[48]:
[4, 5, 6]
In [49]:
a[1:3:2]
Out[49]:
[2]
In [50]:
a[::]
Out[50]:
[1, 2, 3, 4, 5, 6]
In [51]:
a[::-1]
Out[51]:
[6, 5, 4, 3, 2, 1]
Las secuencias de caracteres, son un caso particular de las secuencias.
Particularidades
- Su unidad mínima es un carácter perteneciente a la tabla Unicode.
- Son secuencias inmutables
- Los caracteres y secuencias son del tipo str
In [52]:
('d', "h", 'salon', "uam")
Out[52]:
('d', 'h', 'salon', 'uam') In [53]:
'aqui tienen una cadena de caracteres formado una oracion'
Out[53]:
'aqui tienen una cadena de caracteres formado una oracion'
In [54]:
dir(str)
Out[54]:
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
| Función | Descripción | Ejemplo | Salida |
|---|---|---|---|
capitalize() | Convierte el primer carácter a mayúscula | "hola mundo".capitalize() | "Hola mundo" |
casefold() | Convierte a minúsculas para comparación sin distinción de mayúsculas/minúsculas | "ßElsa".casefold() | "ßelsa" |
center(width, fillchar) | Centra la cadena en un ancho dado, rellenando con fillchar | "Python".center(10, "*") | "**Python**" |
count(sub, start, end) | Cuenta las apariciones de sub en la cadena | "banana".count("a") | 3 |
encode(encoding, errors) | Codifica la cadena a bytes | "café".encode("utf-8") | b'caf\xc3\xa9' |
endswith(suffix, start, end) | Verifica si la cadena termina con suffix | "Python.py".endswith(".py") | True |
expandtabs(tabsize) | Reemplaza tabulaciones con espacios | "hello\tworld".expandtabs(4) | "hello world" |
find(sub, start, end) | Encuentra la primera aparición de sub, devuelve -1 si no se encuentra | "Python".find("th") | 2 |
format(*args, **kwargs) | Formatea la cadena con argumentos | "{} {}".format("Hello", "World") | "Hello World" |
format_map(mapping) | Formatea la cadena con un diccionario | "Nombre: {nombre}".format_map({"nombre": "Ana"}) | "Nombre: Ana" |
index(sub, start, end) | Encuentra la primera aparición de sub, lanza ValueError si no se encuentra | "Python".index("th") | 2 |
isalnum() | Verifica si la cadena es alfanumérica | "Python123".isalnum() | True |
isalpha() | Verifica si la cadena es alfabética | "Python".isalpha() | True |
isdecimal() | Verifica si la cadena contiene solo caracteres decimales | "123".isdecimal() | True |
isdigit() | Verifica si la cadena contiene solo dígitos | "123".isdigit() | True |
isidentifier() | Verifica si la cadena es un identificador válido | "variable1".isidentifier() | True |
islower() | Verifica si la cadena está en minúsculas | "python".islower() | True |
isnumeric() | Verifica si la cadena contiene solo caracteres numéricos | "123".isnumeric() | True |
isprintable() | Verifica si la cadena es imprimible | "Hello\n".isprintable() | False |
isspace() | Verifica si la cadena contiene solo espacios en blanco | " ".isspace() | True |
istitle() | Verifica si la cadena está en formato de título | "Hello World".istitle() | True |
isupper() | Verifica si la cadena está en mayúsculas | "PYTHON".isupper() | True |
join(iterable) | Une los elementos de un iterable con la cadena como separador | ", ".join(["apple", "banana"]) | "apple, banana" |
ljust(width, fillchar) | Justifica la cadena a la izquierda en un ancho dado | "Python".ljust(10, "*") | "Python****" |
lower() | Convierte la cadena a minúsculas | "PYTHON".lower() | "python" |
lstrip(chars) | Elimina los caracteres iniciales de la cadena | " Python ".lstrip() | "Python " |
maketrans(x, y, z) | Crea una tabla de traducción para translate() | str.maketrans("aeiou", "12345") | {97: 49, 101: 50, 105: 51, 111: 52, 117: 53} |
partition(sep) | Divide la cadena en tres partes usando sep | "apple,banana".partition(",") | ('apple', ',', 'banana') |
replace(old, new, count) | Reemplaza old con new | "banana".replace("a", "o") | "bonono" |
rfind(sub, start, end) | Encuentra la última aparición de sub, devuelve -1 si no se encuentra | "banana".rfind("a") | 5 |
rindex(sub, start, end) | Encuentra la última aparición de sub, lanza ValueError si no se encuentra | "banana".rindex("a") | 5 |
rjust(width, fillchar) | Justifica la cadena a la derecha en un ancho dado | "Python".rjust(10, "*") | "****Python" |
rpartition(sep) | Divide la cadena en tres partes usando la última aparición de sep | "apple,banana,cherry".rpartition(",") | ('apple,banana', ',', 'cherry') |
rsplit(sep, maxsplit) | Divide la cadena desde la derecha | "apple,banana,cherry".rsplit(",", 1) | ['apple,banana', 'cherry'] |
rstrip(chars) | Elimina los caracteres finales de la cadena | " Python ".rstrip() | " Python" |
split(sep, maxsplit) | Divide la cadena en una lista de subcadenas | "apple,banana,cherry".split(",") | ['apple', 'banana', 'cherry'] |
splitlines(keepends) | Divide la cadena en líneas | "Hello\nWorld".splitlines() | ['Hello', 'World'] |
startswith(prefix, start, end) | Verifica si la cadena comienza con prefix | "Python.py".startswith("Py") | True |
strip(chars) | Elimina los caracteres iniciales y finales de la cadena | " Python ".strip() | "Python" |
swapcase() | Intercambia mayúsculas y minúsculas | "PyThOn".swapcase() | "pYtHoN" |
title() | Convierte la cadena a formato de título | "hello world".title() | "Hello World" |
translate(table) | Traduce la cadena usando una tabla de traducción | "hello".translate(str.maketrans("he", "xy")) | "xyllo" |
upper() | Convierte la cadena a mayúsculas | "python".upper() | "PYTHON" |
zfill(width) | Rellena la cadena con ceros a la izquierda | "123".zfill(5) | "00123" |