Matriz de valores del 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]
It 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, comienza desde 0:
gt gt gt imprime L[0]
12
No cruces el límite; de lo contrario, obtendrá un error.
gt gt gt print L【3】
Rastreo (última llamada):
Archivo "lt entrada estándar", 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, con los números de secuencia representados por subíndices, como "X comenzando desde abajo". Por ejemplo, el subíndice -1 representa el último elemento:
gt gt gtl = [12, 'China', 19.998]
gt gt gt print L [-1]
19.998
-4 está obviamente fuera de línea
gt gt gt imprime 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
El método incorporado append() agrega la lista al final, y el método insert() agrega la lista a la posición especificada (el subíndice comienza desde 0):
gt gt gtl = [12, 'China', 19.998]
gt gt gtl .append("Jack")
gt gt gt print L
[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
Elimina el último elemento de cola mediante pop(), o puedes especifique un parámetro para eliminar la posición especificada:
gt gt gt pop()
Jack
gt gt gt print L
[ 12, 3.14, 'China', 19.998 】
gt gt gt música pop (0)
12
gt gt gt print L
[3.14, 'China', 19.998】
También puedes copiar y reemplazar subíndices.
gt gt gtl【1】="Estados Unidos"
gt gt gtPrint L
【3.14, 'Estados Unidos', 19.998】
Tuplas
Las tuplas pueden verse como listas "inmutables", y el acceso también se indica mediante subíndices y corchetes ():
gt gt gtt = (3.14,' China' ,'Jason')
gt gt gt print t
(3.14,'China','Jason')
Pero no puedes volver a asignar 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 pop, insertar y agregar métodos
Puedes crear una tupla de elementos vacíos:
t = ()
o una tupla de un solo elemento (por ejemplo, agregar una coma a prevenir y declarar ambigüedades plásticas):
t = (3.14
Entonces, ¿para qué sirve este tipo de tupla? Ya sabes, si quieres que una función devuelva múltiples Para devolver un valor, solo necesita devolver una tupla, porque una tupla contiene múltiples valores y es inmutable (al igual que final en Java, por supuesto, una tupla también es mutable, por ejemplo:
gt gt). gtt = (3.14,'China','Jason',['A',B'])
gt gt gtprintt
(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 La llamada inmutabilidad de Tuple significa que la posición señalada es inmutable, porque el cuarto elemento en este ejemplo no es un tipo básico, sino un tipo de lista, por lo que la posición de la lista señalada por T no cambia, pero el contenido de. la lista en sí se 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. es un diccionario viviente, que en realidad es un par clave-valor clave-valor.
Similar a HashMap, se puede definir mediante llaves {}, similar a la estructura que define el lenguaje C:
gt gt gtd = {
Adam: 95 años,
Lisa: 85 años,
Bart: 59 años,
Paul: 75 años
}
gt gt gtPrint d
{"Lisa": 85 años, "Paul": 75 años, "Adam": 95 años, "Bart": 59 años}
Puedes ver la impresión. Todos los resultados están en formato Clave:Valor, y su longitud se puede calcular mediante la función len (también se puede usar Lista, tupla):
gt gt gt lens
四
Puedes agregar elementos directamente al dict mediante pares clave-valor:
gt gt gt print d
{"Lisa" : 85 años, "Paul": 75 años, "Adam": 95 años, "Bart": 59 años}
gt gt gtd [Jones] = 99
gt gt gtprint d
{ "Lisa": 85 años, "Paul": 75 años, "Adam": 95 años, "Jones": 99 años, "Bart": 59 años}
Las listas y tuplas usan subíndices Acceden al contenido mientras que dict usa claves: (cadenas, números enteros, puntos flotantes y tuplas se pueden usar como claves Dict).
gt gt gtPrint d【'Adam'】
95
Si la clave no existe, se informará un error:
gt gt gtPrint d【'Jack'】
Rastreo (última llamada):
Archivo "ltpyshell#40", línea 1, en el módulo lt gt
Imprimir d【'Jack'】
Error de clave: "Jack"
Por lo tanto, es mejor comprobar si la clave existe antes de acceder:
gt gt gtSi "Adam" en d: imprime "clave existente"
Clave existente
O utilice directamente el método de adquisición del seguro:
gt gt gtprint d.get ('Adam')
95
gt gt gtprint d.get('Jason')
Nadie
En cuanto a atravesar el dict, en realidad itera sobre el conjunto de todas sus claves y luego usa esta clave para obtener el valor correspondiente:
gt gt gt Para una clave en d: imprime la clave: ':', d.get (clave)
Lisa: 85 años
Paul: 75 años
Adam: 95 años
Bart: 59 años old
Dict tiene algunas características:
La velocidad de búsqueda es muy rápida, ya sea 10 o 65438 100,000, la velocidad es la misma, pero ocupa mucha memoria. Por otro lado, la lista ocupa menos memoria pero la búsqueda es más lenta. Es como la diferencia entre las matrices y las listas vinculadas. Las matrices no saben cuánto espacio abrir, por lo que generalmente abren mucho espacio al principio, pero pasan. directamente. La búsqueda de subíndices será muy rápida. Sin embargo, la lista vinculada ocupa muy poco espacio, pero la búsqueda debe recorrerse en orden, lo que la hace muy lenta.
Dict está desordenado y List. es una colección ordenada, por lo que no puede usar Dict para almacenar colecciones ordenadas.
Las claves son inmutables y los valores son mutables. Una vez que se agrega un par clave-valor a un dict, su clave correspondiente no puede ser. pero el valor se puede cambiar.
Por lo tanto, una Lista no se puede usar como clave para un Dict, pero se puede usar como valor:
gt gt gtprint d
{"Lisa": 85 años, "Paul ": 75 años, "Adam": 95 años, "Jones": 99 años, "Bart": 59 años}
gt gt gtd['NewList']=[12, 23 , Jack]
gt gt gt print d
{'Bart': 59, 'Nueva lista': [12, 23, 'Jack'], 'Adam': 95, 'Jones': 99, 'Lisa' ': 85, 'Paul': 75 }
Las claves no se pueden repetir. (En el siguiente ejemplo, se agrega un "Jone": 0, pero en realidad la clave "Jone" ya existe, por lo que el valor original simplemente se cambia).
gt gt gt print d
{'Bart': 59, 'Nueva lista': [12, 23, 'Jack'], 'Adam': 95, 'Jones': 99, 'Lisa': 85, 'Paul': 75 }
gt gt gtd【'Jones'】= 0
gt gt gtprint d
{'Bart': 59, 'NuevaLista': [12, 23 , Jack], 'Adam': 95, 'Jone': 0, 'Lisa': 85, 'Paul': 75 }
Dict merge, cómo fusionar dos Dict en uno, se puede usar el dict función:
gt gt gtd 1 = {'Mike': 12, 'Jack': 19}
gt gt gtD2 = {'jone': 22, 'ivy' : 17 }
gt gt gtd merge = dict (d 1 . items () D2 . items ())
gt gt gt imprimir combinación de datos
{ 'Mike ': 12, 'Jack': 19, 'Jones': 22, 'Ivy': 17 }
o
gt gt gtd merge 2 = dict(d 1, ** 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 gtd merge 3 = dict(d 1)
gt gt gtd merge 3 . actualizar (D2)
gt gt gt imprimir combinación de datos
{'Mike': 12, 'Jack': 19, 'Jones': 22, 'Ivy' ': 17 }
Configuración
La configuración es como sacar una clave en 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'])
Al igual que dict es Ninguno Al igual que el orden, el conjunto también está desordenado y no puede contener elementos duplicados.
El objetivo de acceder a una colección es solo para ver si el elemento está en la colección:
gt gt gt print "A" in s
True< /p >
gt gt gt imprime "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 años
Adam: 95 años
Bart: 59 años
Agregar y eliminar elementos (no repetido). Al agregar elementos, utilice el método add() de set:
gt gt gts = set ([1, 2, 3])
gt gt gts .
gt gt gt print s
Colección ([1, 2, 3, 4])
Si el elemento agregado ya existe en la colección, agregue( ) no dará error, pero no se agregará:
gt gt gts = set([1,2,3])
gt gt gts .add(3)
gt gt gt print s
Colección ([1, 2, 3])
Al eliminar elementos de la colección, utilice el método remove() de la colección :
gt gt gts = set ([1, 2, 3, 4])
gt gt gt remove (4)
gt gt gt print s
Set ([1, 2, 3])
Si el elemento eliminado no está en el conjunto, remove() informará un error:
gt gt gts =set([1, 2, 3])
gt gt gt remove(4)
Rastreo (última llamada):
Archivo "lt Standard input", línea 1, en el módulo lt gt
Error clave: 4
Entonces, si queremos determinar si un elemento cumple con algunas condiciones diferentes, set es lo mejor elección . Ejemplo a continuación:
meses = set(['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio' ', 'agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre', ])
x 1 ='Febrero'
x2 ='Dom'
Si x1 está en meses:
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