Memoria de lista de diccionario de Python
El lenguaje Python es simple y claro, y se puede lograr la misma función con menos código. Entre ellos, los cuatro tipos de datos integrados de Python son indispensables: lista, tupla, dict y conjunto. A continuación se muestra un breve resumen de ellos.
Directorio
Literalmente significa un conjunto. En Python, los elementos de la lista están representados por corchetes [] y la lista se puede definir de la siguiente manera:
L = [12,'China',19.998]
Se puede ver que los elementos Los tipos no necesitan ser iguales. Por supuesto, también puedes definir una lista vacía:
L = []
Las listas en Python están ordenadas, por lo que si quieres acceder a la lista, obviamente debes acceder a través de el número de secuencia, como el subíndice de una matriz, comenzando desde 0:
gt gt gt print L[0]
12
No cruces el límite; de lo contrario, informará un error.
gt gt gt print L[3]
Rastreo (última llamada):
Archivo "ltstdin>, línea 1, en módulo lt gt
Error de índice: índice de lista fuera de rango
También se puede acceder a la lista en orden inverso y el número de secuencia está representado por un subíndice, como "contando X desde abajo". Por ejemplo, el subíndice -1 significa recíproco. Primer elemento:
gt gt gtL = [12,'China',19.998]
gt gt gtprintL[-1]
19.998
-4 obviamente está fuera de lugar
gt gt gtPrint L[-4]
Rastreo (última llamada):
Archivo" ltpyshell#2 >, línea 1, en el módulo lt gt
Imprimir L[-4]
Error de índice: índice de lista fuera de rango
gt gt gt
La lista se agrega al final mediante el método incorporado append() y se agrega a la posición especificada mediante el método insert() (el subíndice comienza desde 0):
gt gt gtL = [12,' China', 19.998]
gt gt gtL.append('Jack')
gt gt gtprintL
[12,'China',19.998, 'Jack']
gt gt gtl .insert (1, 3.14)
gt gt gt print L
[12, 3.14, 'China', 19.998 , 'Jack']
gt gt gt
Elimine el último elemento de cola mediante pop(), o puede especificar un parámetro para eliminar en la posición especificada:
gt gt gtpop()
Jack
gt gt gtprint L
[12, 3.14, 'China', 19.998]
gt gt gtpop(0)
12
gt gt gtprint L
[3.14,'China ',19.998]
También puedes copiar y reemplazar usando subíndices.
gt gt gtL[1] = 'Estados Unidos'
gt gt gtprintL
[3.14, 'Estados Unidos', 19.998]
Tupla
Una tupla puede considerarse como una lista "inmutable", y el acceso también se expresa mediante subíndices y corchetes ():
gt gt gtt = (3.14, 'China ', 'Jason')
gt gt gt print t
(3.14, "China", "Jason")
Pero no puedes reasignar el reemplazo:
gt gt gtt[1] = 'Estados Unidos'
Rastreo (última llamada):
Archivo" ltpyshell#21 >, línea 1, en el módulo lt gt
t[1] = 'Estados Unidos'
Error de tipo: el objeto 'tupla' no admite la asignación de elementos
Ni los métodos pop, insert y append
Puedes crear una tupla de elementos vacía:
t =()
o una tupla de un solo elemento (por ejemplo, agrega una coma para evitar y declarar una ambigüedad de enteros). ):
t = (3.14,)
Entonces, ¿de qué sirve este tipo de tupla? Ya sabes, si quieres un Si la función devuelve múltiples valores de retorno, solo Necesita devolver una tupla, porque la tupla contiene múltiples valores y es inmutable (al igual que final en Java, por supuesto, la tupla también es mutable, como:
gt gt gtt = (3.14). , 'China', 'Jason', ['A', 'B'])
gt gt gtprint t
(3.14,'China','Jason',[' A','B'])
gt gt gtL = t[3]
gt gt gtL[0 ] = 122
gt gt gtL[1 ] = 233
gt gt gtprint t
(3.14,'China','Jason',[ 122, 233])
Esto se debe a que el -llamado inmutabilidad de Tuple significa que la posición a la que apunta es inmutable, porque el cuarto elemento en este ejemplo no es un tipo básico, sino un tipo de lista, por lo que T La posición de la lista señalada permanece sin cambios, pero el contenido de la lista en sí puede cambiar porque la asignación de la lista en la memoria es discontinua.
Diccionario
Dict es un tipo de datos muy importante en Python. Al igual que su significado literal, es un tipo de vida. diccionario, que en realidad es un par clave-valor clave-valor.
De manera similar a HashMap, puede usar llaves {} para definir una estructura similar a la definición del lenguaje C:
gt gt gtd = {
Adam: 95 años,
Lisa: 85,
Bart: 59,
Paul: 75
}
gt gt gtprint d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
Puedes ver que todos los resultados impresos son Clave: El formato del Valor , su longitud se puede calcular mediante la función len (también se pueden usar listas y tuplas):
gt gt gt lens (d)
Cuatro
Tú puede agregar elementos directamente al dict mediante pares clave-valor:
gt gt gtprint d
{ 'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
gt gt gtd['Jones'] = 99
gt gt gtprintd
{ 'Lisa': 85, 'Paul' : 75, 'Adam': 95, 'Jones': 99, 'Bart': 59}
La lista y la tupla usan subíndices para acceder al contenido, mientras que dict usa claves: (cadena, entero, punto flotante y Tuple se pueden usar como claves Dict).
gt gt gtPrint d['Adam']
95
Si el elemento no existe, se informará un error:
gt gt gtPrint d['Jack']
Rastreo (última llamada):
Archivo "ltpyshell#40>, línea 1, en módulo lt gt
Imprimir d['Jack']
Error de clave: "Jack"
Así que es mejor comprobar si la clave existe antes de acceder:
gt gt gtIf "Adam" en d: print "exist key"
Clave existente
O utilice el método de adquisición del seguro directamente:
gt gt gtprint d.get(' Adam ')
95
gt gt gtprint d.get('Jason ')
Nadie
En cuanto a atravesar un dict, en realidad significa recorrer el conjunto de todas sus claves y luego usar esta clave para obtener el valor correspondiente:
gt gt gtPara la clave en d: print key,' :', d.get(key)
Lisa: 85 años
Paul: 75
Adam: 95
Bart: 59
Dict tiene algunas características:
La velocidad de búsqueda es rápida, ya sea 10 o 65438 100000, la velocidad es la misma, pero ocupa más memoria, pero la lista ocupa menos memoria. Esto es similar a la diferencia entre matrices y listas vinculadas: las matrices no saben cuánto espacio abrir, por lo que a menudo abren un gran espacio al principio, pero la búsqueda directa por subíndice ocupa menos espacio. debe recorrerse en orden, lo que resulta en una velocidad lenta.
Dict está desordenado y List es un conjunto ordenado, por lo que Dict no se puede usar para almacenar conjuntos ordenados.
Las claves son inmutables. Los valores son mutables. Una vez que se agrega un par clave-valor a un dict, su clave correspondiente no se puede cambiar, pero el valor se puede cambiar.
Por lo tanto, List no se puede usar como clave de Dict, pero se puede usar como valor:
gt gt gtprint d
{ 'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jones': 99, 'Bart': 59}
gt gt gtd['NewList'] = [12, 23, 'Jack']
gt gt gt print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85 , 'Paul' : 75}
La clave no se puede repetir. (En el siguiente ejemplo, se agrega un ' Jone ': 0, pero en realidad la clave ' Jone ' ya existe, por lo que solo se cambia el valor original).
gt gt gt print d
{'Bart': 59, 'NuevaLista': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}
gt gt gtd['Jones'] = 0
gt gt gt print d
{'Bart': 59, 'NuevaLista': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 0, 'Lisa': 85, 'Paul': 75}
Dict merge, cómo fusionar dos Dict en uno, puedes usar función dict:
gt gt gtd1 = {'Mike': 12, 'Jack': 19}
gt gt gtd2 = {'jone': 22, 'ivy': 17 }
gt gt gtd merge = dict(d 1 . items() D2 . items())
gt gt gtPrint combinación de datos
{ 'Mike ' : 12, 'Jack': 19, 'Jones': 22, 'Ivy': 17}
o
gt gt gtdMerge2 = dict(d1, **d2)
gt gt gt imprimir datos fusionados 2
{'Mike': 12, 'Jack': 19, 'Jones': 22, 'Ivy': 17}
El método 2 es mucho más rápido que el método 1. El método 2 es equivalente a:
gt gt gtdMerge3 = dict(d1)
gt gt gtdMerge3.update(d2)
gt gt gt imprimir combinación de datos
{'Mike': 12, 'Jack': 19, 'Jones': 22, 'Ivy': 17}
Establecer
Set es como sacar una clave de un Dict, similar a una lista, pero el contenido no se puede repetir. Se crea llamando al método set():
gt gt gts = set(['A', 'B', 'C'])
Como dict es Ninguno en orden, el conjunto está desordenado y no puede contener elementos duplicados.
El significado de acceder a un conjunto es solo verificar si un elemento está en el conjunto:
gt gt gtPrint "A" in s
True
p>gt gt gtImprimir "D" en s
Incorrecto
Distingue entre mayúsculas y minúsculas.
También se recorre para:
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59) ])
#Tuple
Para x en s:
Imprimir x[0], ':', x[1]
gt gt gt
Lisa: 85
Adam: 95
Bart: 59
Agregar y eliminar elementos (no repetidos). Al agregar elementos, use el método add() de set:
gt gt gts = set ([1, 2, 3])
gt gt gts.add(4)< / p>
gt gt gt print s
set([1, 2, 3, 4])
Si el elemento agregado ya existe en el conjunto, add() no dará un error, pero no se agregará:
gt gt gts = set([1, 2, 3])
gt gt gts.add(3)< /p >
gt gt gt print s
Colección ([1, 2, 3])
Al eliminar elementos de la colección, utilice el método remove() del colección:
p>gt gt gts = set ([1, 2, 3, 4])
gt gt gts.remove(4)
gt gt gtprints
Set([1, 2, 3])
Si el elemento que se elimina no existe en el conjunto, remove() informará un error:
gt gt gts = set([1, 2, 3])
gt gt gts.remove(4)
Rastreo (última llamada):
Archivo" lt entrada estándar>, línea 1, en el módulo lt gt
Error de clave: 4
Entonces, si desea determinar si un elemento cumple con algunas condiciones diferentes, establezca es la mejor opción. Ejemplo a continuación:
mes=set(['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto' , 'septiembre', 'octubre', 'noviembre', ])
x1 = 'febrero'
x2 = 'dom'
Si mes x1:
Imprimir "x1: OK"
En caso contrario:
Imprimir "x1: Error"
Si x2 está en meses:
Imprimir "x2: OK"
En caso contrario:
Imprimir "x2: Error"
gt gt gt
x1: OK
x2: Error