Datos del diccionario en 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 deseas 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& gtPrint L[0]
12
Nunca cruces el límite De lo contrario, obtendrá un error.
& gt& gt& gtPrint L【3】
Rastreo (última llamada):
Archivo "<standard input", línea 1, en & lt module>
Error de índice: índice de lista fuera de rango
También se puede acceder a la lista en orden inverso, con el número de secuencia representado por un subíndice, por ejemplo, "X comenzando en la parte inferior". , el subíndice -1 representa el último elemento:
& gt& gt& gtl =[12,'China',19.998]
& gt& gt& gtPrint L[- 1]
19.998
-4 está obviamente fuera de línea
& gt& gt& gtPrint L【-4】
Retroceso (el más reciente. call):
Archivo "<pyshell#2", línea 1, en <module>
Imprimir L【-4】
Error de índice: el índice de la lista no está disponible 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 (la 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
Eliminar el último por pop() Un elemento final, 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& gtMúsica pop (0)
12
& gt& gt& gtPrint 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 representa mediante subíndices y corchetes ():
& gt& gt& gtt = ( 3.14, 'China','Jason')
& gt& gt& gtprint t
(3.14,'China','Jason')
Pero no puedes reasignar el sustituto:
& gt& gt& gtt[1]='Estados Unidos'
Rastreo (última llamada):
Archivo "<pyshell #21》, línea 1 , en & ltmodule>
t[1]='Estados Unidos'
Error de tipo: el objeto 'tupla' no admite la asignación de elementos
p>Hay tampoco hay métodos pop, insert y append
Puedes crear una tupla de elementos vacíos:
t = ()
O simplemente tuplas de elementos (p. ej. agregando comas para prevenir y declarar ambigüedades plásticas):
t = (3.14
Entonces, ¿de qué sirve este tipo de tupla? Ya sabes, si Para tener una función, devuelve múltiples valores de retorno, solo necesita devolver una tupla, porque las tuplas contienen múltiples valores y son inmutables (al igual que final en Java, por supuesto, las tuplas también son mutables, por ejemplo:
& 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 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 Lista, por lo que la posición de la lista señalada por T permanece sin cambios, 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. En el significado literal, 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& gt print d
{"Lisa": 85 años, "Paul": 75 años, "Adam": 95 años, "Bart": 59 años}
Puede ver que los resultados impresos están en el 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& gtprint d
{"Lisa": 85, "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 para acceder 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 "<pyshell#40", línea 1, en & lt Modules>
Imprimir d ['Jack']
Error de clave: "Jack"
Por lo tanto, es mejor comprobar si la clave existe antes de acceder a ella:
& gt& gt& gtSi "Adam" en d: imprima "clave existente"
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')
p>
No uno
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& gtFor Key in d: print key: ':', d.get(key)
Lisa: 85 años
Paul: 75 años
Adán: 95 años
Bart: 59 años
Dict tiene algunas características:
La velocidad de búsqueda es muy rápida, ya sea 10 o 65438+100,000. Por otro lado, la lista ocupa mucha memoria, pero la búsqueda es más lenta. Es como la diferencia entre matrices y listas vinculadas, por lo que generalmente no saben cuánto espacio abrir. Hay mucho espacio, pero la búsqueda directa por subíndice será muy rápida. Sin embargo, la lista vinculada ocupa muy poco espacio, pero la búsqueda debe recorrerse en orden, lo que resulta en una velocidad muy lenta.
Dict no es. secuencial. Ordenada, la lista 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. la clave correspondiente no se puede cambiar, 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& gtprint 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& gtprint 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,'NewList' :[12 , 23, Jack], 'Adam': 95, 'Jone': 0, 'Lisa': 85, 'Paul': 75 }
Dict merge, cómo fusionar dos Dict en uno, puedes use la función dict:
& 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& gtImprimir combinación de datos
{'Mike':12,'Jack':19,'Jones':22,'Ivy':17}
O
& gt& gt& gtd fusionan 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 fusionar 3. actualización (D2)
& gt& gt& gtImprimir fusión de datos
{'Mike':12,'Jack ':19,' Jones':22,'Ivy':17}
Configuración
La configuración es como sacar una tecla en un Dict, similar a una lista, pero el contenido no se puede repetir. Se crea llamando al método set():
>& gt>s = set(['A', 'B', 'C'])
Al igual que dict es como desordenado , 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& gtImprimir "A" en 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 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 . 4 )
& gt& gt& gtprints
Colección ([1, 2, 3, 4])
Si el elemento agregado ya existe en la colección, agregue () no da error, pero no se agregará:
& gt& gt& gts = set([1, 2, 3])
& gt& gt& gts add(3)
& gt& gt& gtprints
Colección ([1, 2, 3])
Al eliminar elementos de la colección, utilice The. método remove() de la colección:
& gt& gt& gts = colección ([1, 2, 3, 4])
& gt& gt& gtRemove (4)
& gt& gt& gtprints
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& gtRemove (4)
Retroceder (última llamada):
Archivo "<standard input", línea 1, en <module>
Error clave: 4
Entonces, si queremos juzgar un elemento si se cumplen algunas condiciones diferentes, establezca es la mejor opción:
meses = set(['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', ' Septiembre', 'Octubre', 'Noviembre', 'Diciembre', ])
x 1 ='Feb'
x2 ='Dom'
Si x1 está en meses:
Imprimir "x1: normal"
En caso contrario:
Imprimir "x1: Error"
Si x2 está en meses en meses:
Imprimir "x2: OK"
En caso contrario:
Imprimir "x2: Error"
& gt& gt& gt
x1: OK
x2: Error