¿Cuál es la diferencia entre los métodos de lista de Python adjuntar y extender?

¿Cuál es la diferencia entre los métodos de lista? append() y extend()?

preguntado Oct 31 '08, 03:10

20 Respuestas

append: Agrega un objeto al final.

x = [1, 2, 3]
x.append([4, 5])
print (x)

te dio: [1, 2, 3, [4, 5]]


extend: Extiende la lista agregando elementos del iterable.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

te dio: [1, 2, 3, 4, 5]

Respondido 06 Oct 19, 18:10

Cuál es la diferencia entre extend y simplemente usando el operador de suma - en el ejemplo anterior, x = x + [4, 5]? - Rohan

De hecho hay un gran diferencia - x + [4, 5] le da una nueva lista asignada a x - x.extend() muta la lista original. Explico mi respuesta aquí abajo. - Aaron Hall ♦

@AaronHall @Rohan pero es lo mismo que x += [4,5]. - Astitva Srivastava

@AstitvaSrivastava En realidad, creo que extender es más rápido en términos de código de bytes - Vía Láctea90

La palabra clave al usar append is Objeto. Si intentas usar extend y pasas en un diccionario, agregará el clavey no todo el hash hasta el final de la matriz. - Antonio

append agrega un elemento a una lista, y extend concatena la primera lista con otra lista (u otra iterable, no necesariamente una lista).

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']

Respondido el 04 de Septiembre de 19 a las 16:09

¡buena respuesta! Simple y comprensible - Dionysis.B

¿Cuál es la diferencia entre los métodos de lista adjuntar y extender?

  • append agrega su argumento como un solo elemento al final de una lista. La longitud de la lista en sí aumentará en uno.
  • extend itera sobre su argumento agregando cada elemento a la lista, extendiendo la lista. La longitud de la lista aumentará sin importar cuántos elementos haya en el argumento iterable.

append

Los programas list.append agrega un objeto al final de la lista.

my_list.append(object) 

Cualquiera que sea el objeto, ya sea un número, una cadena, otra lista u otra cosa, se agrega al final de my_list como una sola entrada en la lista.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Por tanto, tenga en cuenta que una lista es un objeto. Si agrega otra lista a una lista, la primera lista será un solo objeto al final de la lista (que puede no ser lo que desea):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item at the end of the list.

extend

Los programas list.extend El método extiende una lista agregando elementos de un iterable:

my_list.extend(iterable)

Entonces, con extender, cada elemento del iterable se agrega a la lista. Por ejemplo:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Tenga en cuenta que una cadena es iterable, por lo que si extiende una lista con una cadena, agregará cada carácter a medida que itera sobre la cadena (que puede no ser lo que desea):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Sobrecarga del operador, __add__ (+) y __iadd__ (+=)

Ambos + y += los operadores están definidos para list. Son semánticamente similares a extender.

my_list + another_list crea una tercera lista en la memoria, por lo que puede devolver el resultado de la misma, pero requiere que el segundo iterable sea una lista.

my_list += another_list modifica la lista en el lugar (se is el operador in situ, y las listas son objetos mutables, como hemos visto) por lo que no crea una nueva lista. También funciona como extender, ya que el segundo iterable puede ser cualquier tipo de iterable.

No te confundas my_list = my_list + another_list no es equivalente a += - le da una lista nueva asignada a my_list.

Complejidad de tiempo

Anexar tiene complejidad de tiempo constante, O (1).

Extender tiene complejidad de tiempo, O (k).

Iterando a través de las múltiples llamadas a append se suma a la complejidad, haciéndolo equivalente al de extender, y dado que la iteración de extender se implementa en C, siempre será más rápido si tiene la intención de agregar elementos sucesivos de un iterable a una lista.

Rendimiento

Quizás se pregunte qué es más eficaz, ya que append se puede usar para lograr el mismo resultado que extend. Las siguientes funciones hacen lo mismo:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Así que pongámosles el tiempo:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Abordar un comentario sobre horarios

Un comentarista dijo:

Respuesta perfecta, solo extraño el momento de comparar agregando solo un elemento

Haz lo semánticamente correcto. Si desea agregar todos los elementos en un iterable, use extend. Si solo está agregando un elemento, use append.

Bien, creemos un experimento para ver cómo funciona esto a tiempo:

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

Y vemos que hacer todo lo posible para crear un iterable solo para usar extend es una (menor) pérdida de tiempo:

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

Aprendemos de esto que no se gana nada con el uso extend cuando tenemos solo . elemento para agregar.

Además, estos tiempos no son tan importantes. Solo les estoy mostrando para señalar que, en Python, hacer lo semánticamente correcto es hacer cosas que Derecha Way ™.

Es concebible que pueda probar los tiempos en dos operaciones comparables y obtener un resultado ambiguo o inverso. Solo concéntrate en hacer lo semánticamente correcto.

Conclusión

Vemos eso extend es semánticamente más claro, y que puede correr mucho más rápido que append, cuando tiene la intención de agregar cada elemento en un iterable a una lista.

Si solo tiene un solo elemento (no en un iterable) para agregar a la lista, use append.

Respondido 03 Oct 18, 15:10

@Aaron Hall Un pequeño comentario en el algoritmo de sincronización. "extend_one" puede devolver un tiempo "ligeramente incorrecto" porque la creación de una lista también está involucrada. Probablemente sea mejor crear los elementos como variables (ex1 = 0 y ex2 = [0]) y pase estas variables, si quiere ser más estricto. - ilias iliadis

De hecho, respuesta perfecta. ¿Qué pasa con el rendimiento de l1 += l2 vs l1.extend(l2)? - Jean-François T.

@ Jean-FrancoisT .: l1 += l2 y l1.extend(l2) finalmente ejecutar el mismo código (el list_extend Funcionar en listobject.c). Las únicas diferencias son: 1. += reasigna l1 (a sí mismo por lists, pero la reasignación admite tipos inmutables que no son el mismo objeto después), lo que lo hace ilegal si l1 es en realidad un atributo de un objeto inmutable; por ejemplo, t = ([],), t[0] += lst fallaría, mientras t[0].extend(lst) trabajaría. 2. l1 += l2 utiliza códigos de bytes dedicados, mientras que l1.extend(l2) utiliza el método de envío generalizado; Esto hace += más rápido que extend. - ShadowRanger

El hecho de que += debe reasignar l1 significa que, en algunos casos, el despacho más lento de extend se compensa parcial o totalmente al no asignar de nuevo al lado izquierdo. Por ejemplo, si el list es un atributo de un objeto, self.l1 += l2 y self.l1.extend(l2) tener un rendimiento idéntico en mi instalación de Python 3.6, simplemente porque la operación real es más como self.l1 = self.l1.__iadd__(l2), lo que significa que debe realizar un trabajo moderadamente caro STORE_ATTR que self.l1.extend(l2) no tiene que hacerlo. - ShadowRanger

Comparación simple en pruebas locales: para una variable local (por lo que += solo está usando STORE_FAST, que es súper barato), donde el valor agregado es un list con un elemento en él, con la operación repetida 1000 veces, += tomó alrededor de 33 ns en promedio, mientras que extend tomó 78 ns, una diferencia de 45 ns. Si l1 es global (requiere más caro STORE_GLOBAL), la diferencia se reduce a 17 ns. Si l1 es en realidad local.l1 (requiere aún más caro STORE_ATTR), no hay una diferencia significativa entre += y extend (tiempos aproximadamente idénticos; extend a veces gana). - ShadowRanger

append agrega un solo elemento. extend agrega una lista de elementos.

Tenga en cuenta que si pasa una lista para agregar, aún agrega un elemento:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

Respondido 31 Oct 08, 05:10

Agregar vs extender

enter image description here

Con append puede agregar un solo elemento que extenderá la lista:

>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]

Si desea extender más de un elemento, debe usar extender, porque solo puede agregar un elemento o una lista de elementos:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

Para que obtengas una lista anidada

En cambio, con extender, puede extender un solo elemento como este

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

O, de manera diferente, de agregar, extender más elementos de una vez sin anidar la lista en la original (esa es la razón por la que el nombre se extiende)

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

Agregar un elemento con ambos métodos

enter image description here

Tanto agregar como extender pueden agregar un elemento al final de la lista, aunque agregar es más simple.

añadir 1 elemento

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

extender un elemento

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3]

Añadiendo más elementos ... con diferentes resultados

Si usa append para más de un elemento, debe pasar una lista de elementos como argumentos y obtendrá una lista NESTED.

>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]

Con extender, en cambio, pasa una lista como argumento, pero obtendrá una lista con el nuevo elemento que no está anidado en el anterior.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

Entonces, con más elementos, usará extender para obtener una lista con más elementos. Sin embargo, agregar una lista no agregará más elementos a la lista, sino un elemento que es una lista anidada, como puede ver claramente en la salida del código.

enter image description here

enter image description here

contestado el 08 de mayo de 20 a las 11:05

Los siguientes dos fragmentos son semánticamente equivalentes:

for item in iterator:
    a_list.append(item)

y

a_list.extend(iterator)

Este último puede ser más rápido ya que el bucle se implementa en C.

respondido 24 nov., 16:11

Extender es ~ 4 veces más rápido en mi máquina que agregar en un bucle (16us vs 4us para 100 bucles de ceros) - Alex l

extend() probablemente preasigna, mientras que append() probablemente no. - Físico loco

@MadPhysicist: En aras de la integridad, habría ocasiones en las que extend() no puedes preasignar con sensatez, ya que algunos iterables no implementan __len__(), pero como tú, me sorprendería que no lo intente. Parte de la ganancia de rendimiento también proviene de hacer la parte de iteración en C puro en lugar de en Python, como se señala en La respuesta de Aaron. - Soren Björnstad

Los programas append() El método agrega un solo elemento al final de la lista.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

Los programas extend() El método toma un argumento, una lista y agrega cada uno de los elementos del argumento a la lista original. (Las listas se implementan como clases. "Crear" una lista es realmente instanciar una clase. Como tal, una lista tiene métodos que operan en ella).

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

De Sumérgete en Python.

contestado el 21 de mayo de 19 a las 10:05

No se puede extender con solo 6 ya que no es iterable. Y la segunda salida de su ejemplo es incorrecta. 'abc' se agrega como un solo elemento desde que lo pasó a extend como una lista con un elemento ['abc']: [1, 2, 3, 4, 5, 'abc']. Para que su salida de ejemplo sea correcta, cambie la línea abc a: x.extend('abc'). Y quita el x.extend(6) o cámbielo a x.extend([6]). - aneroide

Puede utilizar "+" para devolver extender, en lugar de extender en su lugar.

l1=range(10)

l1+[11]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

l2=range(10,1,-1)

l1+l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

Del mismo modo += para el comportamiento en el lugar, pero con ligeras diferencias de append & extend. Una de las mayores diferencias de += de append y extend es cuando se utiliza en ámbitos de función, consulte esta entrada del blog.

Respondido el 05 de enero de 17 a las 10:01

¿El uso del '+' para devolver la extensión tiene algún efecto sobre la complejidad del tiempo? - franklin

@franklin, consulte esta respuesta para obtener más detalles: stackoverflow.com/a/28119966/2230844 - denfromufa

No veo cómo esto responde a la pregunta: picante

append(object) - Actualiza la lista agregando un objeto a la lista.

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - Esencialmente concatena dos listas.

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]

Respondido el 05 de junio de 18 a las 10:06

extend() se puede utilizar con un argumento de iterador. Aquí hay un ejemplo. Desea hacer una lista a partir de una lista de listas de esta manera:

De

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

que desea

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Puedes utilizar itertools.chain.from_iterable() para hacerlo. La salida de este método es un iterador. Su implementación es equivalente a

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Volviendo a nuestro ejemplo, podemos hacer

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

y obtén la lista de buscados.

Así es como de manera equivalente extend() se puede usar con un argumento de iterador:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Respondido el 05 de junio de 18 a las 10:06

Esta respuesta no contrasta extender con adjuntar y, por lo tanto, no responde a la pregunta: picante

Este es el equivalente de append y extend usando el + operador:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]

Respondido el 14 de enero de 15 a las 19:01

¡¿Por qué no = +?! Más conciso - denfromufa

adjuntar(): Básicamente se usa en Python para agregar un elemento.

Ejemplo 1:

>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]

Ejemplo 2:

>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]

ampliar(): Donde extender (), se usa para fusionar dos listas o insertar varios elementos en una lista.

Ejemplo 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Ejemplo 2:

>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]

Respondido 10 Oct 17, 20:10

Un punto interesante que se ha insinuado, pero no explicado, es que extender es más rápido que agregar. Para cualquier bucle que tenga anexar dentro, se debe considerar que se reemplaza por list.extend (procesados_elementos).

Tenga en cuenta que la captura de nuevos elementos puede resultar en la reasignación de toda la lista a una mejor ubicación en la memoria. Si esto se hace varias veces porque agregamos 1 elemento a la vez, el rendimiento general se ve afectado. En este sentido, list.extend es análogo a "" .join (stringlist).

Respondido 06 ago 14, 13:08

Append agrega todos los datos a la vez. Todos los datos se agregarán al índice recién creado. Por otro lado, extend, como su nombre indica, extiende la matriz actual.

Por ejemplo:

list1 = [123, 456, 678]
list2 = [111, 222]

Con append obtenemos:

result = [123, 456, 678, [111, 222]]

Mientras tanto extend obtenemos:

result = [123, 456, 678, 111, 222]

Respondido 09 Abr '17, 07:04

Un diccionario de inglés define las palabras append y extend como:

anexar: agrega (algo) al final de un documento escrito.
ampliar: hacer más grande. Agrandar o expandir


Con ese conocimiento, ahora entendamos

1) La diferencia entre los append y extend

append:

  • Anexa cualquier objeto de Python tal cual al final de la lista (es decir, como último elemento de la lista).
  • La lista resultante puede estar anidada y contener elementos heterogéneos (es decir, lista, cadena, tupla, diccionario, conjunto, etc.)

extend:

  • Acepta cualquier iterable como su argumento y hace la lista mayores.
  • La lista resultante es siempre una lista unidimensional (es decir, sin anidamiento) y puede contener elementos heterogéneos en ella (por ejemplo, caracteres, enteros, flotantes) como resultado de aplicar list(iterable).

2) Similitud entre append y extend

  • Ambos toman exactamente un argumento.
  • Ambos modifican la lista en su lugar.
  • Como resultado, ambos retornos None.

Ejemplo

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
list.append(object)

Respondido el 12 de Septiembre de 19 a las 13:09

Espero poder hacer un complemento útil a esta pregunta. Si su lista almacena un objeto de tipo específico, por ejemplo Info, aquí hay una situación que extend El método no es adecuado: en un for bucle y generando un Info objeto cada vez y usando extend para almacenarlo en su lista, fallará. La excepción es la siguiente:

TypeError: el objeto 'Info' no es iterable

Pero si usa el append método, el resultado es correcto. Porque cada vez que usas el extend , siempre lo tratará como una lista o cualquier otro tipo de colección, lo iterará y lo colocará después de la lista anterior. Un objeto específico no se puede iterar, obviamente.

Respondido 09 Abr '17, 07:04

Para distinguirlos intuitivamente

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

Es como l1 reproducir un cuerpo dentro de su cuerpo (anidado).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

Es como si dos individuos separados se casaran y construyeran una familia unida.

Además, hago una hoja de trucos exhaustiva de todos los métodos de la lista para su referencia.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

Respondido el 07 de junio de 18 a las 02:06

extend(L) extiende la lista agregando todos los elementos en la lista dada L.

>>> a
[1, 2, 3]
a.extend([4])  #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]

contestado el 21 de mayo de 19 a las 10:05

append "extiende" la lista (en su lugar) por solo un artículo, el único objeto pasado (como argumento).

extend "extiende" la lista (en su lugar) por tantos artículos como el objeto pasado (como argumento) contiene.

Esto puede resultar un poco confuso para str objetos.

  1. Si pasa una cadena como argumento: append agregará un solo elemento de cadena al final, pero extend agregará tantos elementos "únicos" 'str' como la longitud de esa cadena.
  2. Si pasa una lista de cadenas como argumento: append todavía agregará un solo elemento de 'lista' al final y extend agregará tantos elementos de 'lista' como la longitud de la lista aprobada.
def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

produce:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

respondido 31 mar '18, 19:03

Agregar y extender son uno de los mecanismos de extensibilidad en Python.

Agregar: agrega un elemento al final de la lista.

my_list = [1,2,3,4]

Para agregar un nuevo elemento a la lista, podemos usar el método append de la siguiente manera.

my_list.append(5)

La ubicación predeterminada en la que se agregará el nuevo elemento es siempre en la posición (longitud + 1).

Insertar: el método de inserción se utilizó para superar las limitaciones de agregar. Con insertar, podemos definir explícitamente la posición exacta en la que queremos que se inserte nuestro nuevo elemento.

Descriptor de método de inserción (índice, objeto). Se necesitan dos argumentos, el primero es el índice en el que queremos insertar nuestro elemento y el segundo el elemento en sí.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

Extender: Esto es muy útil cuando queremos unir dos o más listas en una sola lista. Sin ampliar, si queremos unir dos listas, el objeto resultante contendrá una lista de listas.

a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]

Si intentamos acceder al elemento en la posición 2, obtenemos una lista ([3]), en lugar del elemento. Para unir dos listas, tendremos que usar append.

a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]

Para unirse a varias listas

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]

Respondido 17 Jul 18, 08:07

¿Por qué está respondiendo una pregunta que ya ha sido respondida muchas veces? Esta pregunta tiene 10 años ... - Mike - SMT

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.