Julio Cirugía Plástica
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& gtPrint L[0]
12
No cruces el límite; de lo contrario, se informará un error.
& gt& gt& gtPrint L[3]
Rastreo (última llamada):
Archivo " & ltstdin>, línea 1, en & lt módulo & gt
Error de índice: índice de lista fuera de rango
También se puede acceder a las listas en orden inverso y el número de secuencia está representado por un subíndice, como "cuenta X desde abajo" Por ejemplo, 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]
Rastreo (última llamada ):
p>Archivo "<pyshell#2>, línea 1, en <module>
Imprimir L[-4]
Error de índice: listar índice fuera de range
& 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& gtPrint L
[12,'China',19.998,'Jack']
& gt& gt& gtl .insert(1,3.14)
& gt& gt& gtPrint L
[12, 3.14, 'China', 19.998, 'Jack']
& gt& gt& gt
Quitar la última cola elemento a través de pop(), o puede especificar un parámetro para eliminar 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 se puede copiar y reemplazar con subíndices.
& gt& gt& gtL[1] = 'Estados Unidos'
& gt& gt& gtPrint L
[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& gtprint t
(3.14, "China", "Jason")
Pero no puedes reasignar reemplazos:
& gt& gt& gtt[1] = 'Estados Unidos'
Rastreo (última llamada):
Archivo " <pyshell#21>, línea 1, en <module>
t[1] = 'Estados Unidos'
error de tipo: el objeto 'tupla' no admite la asignación de elementos
Tampoco hay métodos pop, insert y append
Puedes crear una tupla de elementos vacíos:
t =()
O una tupla de un solo elemento (como. agregando una coma para evitar y declarar una ambigüedad de enteros):
t = (3.14,)
Entonces, ¿para qué sirve este tipo de tupla? una función para devolver 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, también es variable, 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 la llamada inmutabilidad de Tuple significa que la posición señalada es inmutable, porque la posición señalada en este ejemplo es inmutable. Los cuatro elementos no son tipos básicos, sino tipos de 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 diccionario muy tipo de datos importante en Python. Al igual que su significado literal, es un diccionario viviente, 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 años,
Bart: 59 años,
Paul: 75
}
& gt& gt& gtPrint d
{'Lisa':85,'Paul':75,'Adam':95,'Bart':59}
Puedes ver que los resultados impresos son clave : Formato de valor, su longitud se puede calcular mediante la función len (también se puede usar Lista, tupla):
& gt& gt& gt Lens (d)
Cuatro
Puedes agregar elementos directamente al dictado mediante pares clave-valor:
& gt& gt& gtprintd
{ 'Lisa': 85, 'Paul': 75, 'Adam ': 95, 'Bart': 59}
& gt& gt& gtd['Jones'] = 99
& gt& gt& gtprint d
{ 'Lisa ': 85, 'Paul': 75, 'Adam': 95, 'Jones': 99, 'Bart': 59}
Las listas y tuplas usan subíndices para acceder al contenido, mientras que las claves dict se usan: ( Se pueden utilizar cadenas, números enteros, puntos flotantes y tuplas como claves Dict).
& gt& gt& gtPrint d['Adam']
95
Si el artículo no existe, se informará un error:
& gt& gt& gtPrint d['Jack']
Rastreo (última llamada):
Archivo "<pyshell#40>, línea 1, en < Modules>
Imprimir d['Jack']
Error de clave: "Jack"
Por lo tanto, es mejor verificar 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')
Nadie
En cuanto a atravesar un dict, en realidad atraviesa el conjunto de todas sus claves y luego usa esta clave para obtener el valor correspondiente:
& gt& gt& gt Para 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, solo ocupa espacio y la memoria es relativamente grande. La lista ocupa menos memoria, pero la velocidad de búsqueda es como la diferencia entre matrices y listas vinculadas. Las matrices no saben cuánto espacio abrir, por lo que a menudo abren un espacio grande al principio, pero pasan directamente el subíndice. La búsqueda es muy rápida. La lista vinculada ocupa poco espacio, pero la búsqueda 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 realizar. utilizado para almacenar un conjunto ordenado.
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 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& gtprintd
{ '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& gtprint d
{'Bart': 59, 'NuevaLista': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}< / p>
& 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 Dicts en uno, puedes use la 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& gtImprimir combinación de datos
{'Mike':12,'Jack':19,'Jones':22,'Ivy':17}
O
& gt& gt& gtdMerge2 = dict( d1, **d2)
& gt& gt& gtImprimir 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& gtImprimir combinación de datos
{'Mike':12,'Jack':19,'Jones':22, 'Ivy':17 }
Establecer
Establecer 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 Desordenado, el conjunto está desordenado y no puede contener elementos duplicados.
El significado de acceder a una colección es solo verificar si un elemento está en la colección:
& gt& gt& gtImprimir "A" en s
Verdadero
& 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 )
& gt& gt& gtprint s
set([1, 2, 3, 4])
Si el elemento agregado ya existe en el conjunto, agregue () no da error pero no se agrega:
& 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 la eliminación de la colección () método:
& gt& gt& gts = set ([1, 2, 3, 4])
& gt& gt& gts.remove(4)
& gt& gt& gtprints
Collection([1, 2, 3])
Si el elemento que se elimina no existe en la colección, remove() informará un error:
& gt& gt& gts = set([1, 2, 3])
& gt& gt& gts.remove(4)
Rastreo (última llamada):
Archivo "& ltstandard input>, línea 1, en & ltmodule& gt
Error crítico: 4
Entonces, si desea juzgar un elemento si existen algunas condiciones diferentes, cumplido, set 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 = 'sol'
Si mes x1:
Imprimir "x1: normal"
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