[Python Basics 2] Tutorial súper detallado para amigos principiantes

prefacio

Artículo anterior
[Python Basics 1] Tutorial súper detallado para amigos principiantes

6.2 Tuplas

Tuple es muy similar a list, pero tuple es inmutable, es decir, tuple no se puede modificar y tuple se define mediante elementos separados por comas entre paréntesis.

• Admite operaciones de indexación y corte
• Puede usar in para ver si un elemento está en la tupla.
• tupla vacía()
• Una tupla que contiene solo un elemento ("a") # necesita agregar una coma

Ventajas: la tupla es más rápida que la lista; la 'protección contra escritura' para los datos que no necesitan modificarse puede hacer que el código sea más seguro

tuple与list可以相互转换，使用内置的函数list()和tuple()。

l = [1, 2, 3]
print( l )# [1, 2, 3]

t = tuple(l)
print(t) # (1, 2, 3)

l = list(t)
print (l) #[1, 2, 3]

El uso más común de tuplas es en sentencias de impresión, como en el siguiente ejemplo:

name = "Runsen"
age = 20
print( "Name: %s; Age: %d") % (name, age)
# Name: Runsen; Age: 20

La función es la siguiente:

• contar (valor)

Devuelve el número de elementos de la tupla cuyo valor es valor

t = (1, 2, 3, 1, 2, 3)
print (t.count(2) )# 2

• index(valor, [inicio, [parada]])

Devuelve el índice de la primera aparición de valor en la lista, o una excepción si no hay ningunaValueError

t = (1, 2, 3, 1, 2, 3)
print( t.index(3) )# 2
try:
    print (t.index(4))
except ValueError as V:
    print(V)  # there is no 4 in tuple

6.3 Diccionarios

Un diccionario consta de pares clave-valor y las claves deben ser únicas;

p.ej:d = {key1:value1, key2:value2}；

Un diccionario vacío está representado por {}; los pares clave-valor en el diccionario no están ordenados. Si desea un orden específico, debe ordenarlos antes de usarlos;

d[key] = value, si ya existe en el diccionario, keyasígnele un valor value; de lo contrario, agregue un nuevo par clave-valor key/value;

Úselo del d[key] para eliminar pares clave-valor, para juzgar si hay una clave en el diccionario, puede usar in o no in;

d = {
    
    }
d["1"] = "one"
d["2"] = "two"
d["3"] = "three"

del d["3"]

for key, value in d.items():
    print ("%s --> %s" % (key, value))
#1 --> one
#2 --> two

La función dict es la siguiente:

• claro()

eliminar todos los elementos del diccionario

d1 = {
    
    "1":"one", "2":"two"}
d1.clear()
print (d1 )# {}

• Copiar()

Devolver una copia del diccionario (copia superficial)

d1 = {
    
    "1":"one", "2":"two"}
d2 = d1.copy()
print( d2 )#{'1': 'one', '2': 'two'}

print(d1 == d2) # True
print(d1 is d2) # False

Los valores de copia superficial son los mismos, pero los objetos son diferentes y las direcciones de memoria son diferentes.

• dict.fromkeys(seq,val=Ninguno)

Cree y devuelva un nuevo diccionario, use los elementos en la secuencia seq como las claves del diccionario, y val es el valor inicial correspondiente a todas las claves del diccionario (el valor predeterminado es Ninguno)

l = [1, 2, 3]
t = (1, 2, 3)
d3 = {
    
    }.fromkeys(l)
print (d3) #{1: None, 2: None, 3: None}

d4 = {
    
    }.fromkeys(t, "default")
print(d4) #{1: 'default', 2: 'default', 3: 'default'}

• obtener (clave, [predeterminado])

Devuelve el valor correspondiente a la clave clave en el dictado del diccionario, si la clave no existe en el diccionario, devuelve el valor predeterminado (el valor predeterminado es Ninguno)

d5 = {
    
    1:"one", 2:"two", 3:"three"}
print (d5.get(1) )#one
print (d5.get(5)) #None
print (d5.get(5, "test") )#test

• tiene_clave(clave)

Determinar si hay una clave clave en el diccionario

d6 = {
    
    1:"one", 2:"two", 3:"three"}
print( d6.has_key(1) ) #True
print (d6.has_key(5))  #False

• elementos()

Devuelve una lista que contiene tuplas de pares (clave, valor) en el diccionario

d7 = {
    
    1:"one", 2:"two", 3:"three"}
for item in d7.items():
    print (item)
#(1, 'one')
#(2, 'two')
#(3, 'three')

for key, value in d7.items():
    print ("%s -- %s" % (key, value))
#1 -- one
#2 -- two
#3 -- three

• llaves()

Devuelve una lista que contiene todas las claves del diccionario.

d8 = {
    
    1:"one", 2:"two", 3:"three"}

for key in d8.keys():
    print (key)
#1
#2
#3

• valores()

Devuelve una lista que contiene todos los valores del diccionario

d8 = {
    
    1:"one", 2:"two", 3:"three"}
for value in d8.values():
    print( value)
#one
#two
#three

• pop(clave, [predeterminado])

Si la clave clave existe en el diccionario, elimínela y devuelva dict[clave], si no existe y no se proporciona ningún valor predeterminado, se generará una excepción KeyError

d9 = {
    
    1:"one", 2:"two", 3:"three"}
print (d9.pop(1) )#one
print( d9) #{2: 'two', 3: 'three'}
print( d9.pop(5, None)) #None
try:
    d9.pop(5)  # raise KeyError
except KeyError, ke:
    print ( "KeyError:", ke) #KeyError:5

• bebida()

Elimine cualquier par clave-valor y devuelva el par clave-valor, si el diccionario está vacío, se generará una excepción KeyError

d10 = {
    
    1:"one", 2:"two", 3:"three"}

print (d10.popitem() ) #(1, 'one')
print (d10)  #{2: 'two', 3: 'three'}

• establecer por defecto (clave, [predeterminado])

Si hay una clave en el diccionario, devuelva el valor vlaue, si no hay clave, agregue la clave, el valor es predeterminado, el valor predeterminado es Ninguno

d = {
    
    1:"one", 2:"two", 3:"three"}

print (d.setdefault(1))  #one
print (d.setdefault(5))  #None
print( d)  #{1: 'one', 2: 'two', 3: 'three', 5: None}
print (d.setdefault(6, "six")) #six
print (d)  #{1: 'one', 2: 'two', 3: 'three', 5: None, 6: 'six'}

• actualizar (dict2)

Agregue los elementos de dict2 al dict, y cuando se repita la clave, sobrescribirá el valor de la clave en el dict

d = {
    
    1:"one", 2:"two", 3:"three"}
d2 = {
    
    1:"first", 4:"forth"}

d.update(d2)
print (d)  #{1: 'first', 2: 'two', 3: 'three', 4: 'forth'}

• ver elementos ()

Devuelve un objeto de vista, una lista de pares (clave, valor), similar a una vista. La ventaja es que si cambia el diccionario, la vista cambiará sincrónicamente. Durante el
proceso de iteración, el diccionario no puede cambiar; de lo contrario, se informará una excepción.

d = {
    
    1:"one", 2:"two", 3:"three"}
for key, value in d.viewitems():
    print ("%s - %s" % (key, value))
#1 - one
#2 - two
#3 - three

• teclas de vista ()

Devuelve un objeto de vista, una lista de claves.

d = {
    
    1:"one", 2:"two", 3:"three"}
for key in d.viewkeys():
    print( key)
#1
#2
#3

• vervalores()

Devuelve un objeto de vista, una lista de valores

d = {
    
    1:"one", 2:"two", 3:"three"}
for value in d.viewvalues():
    print (value)
#one
#two
#three

6.4 Secuencia

El tipo de secuencia significa que se accede a los elementos del contenedor en orden de índice a partir de 0, y se puede acceder a uno o más elementos a la vez; las listas, las tuplas y las cadenas son todas secuencias.
Las tres características principales de la secuencia son

• Operadores de indexación y división
• índice para obtener un elemento específico
• El corte puede obtener una secuencia parcial

Operadores de indexación y división

numbers = ["zero", "one", "two", "three", "four"]
  
print (numbers[1] )# one
print (numbers[-1] )# four
#print( numbers[5]) # raise IndexError
print (numbers[:]) # ['zero', 'one', 'two', 'three', 'four']
print (numbers[3:]) # ['three', 'four']
print (numbers[:2]) # ['zero', 'one']
print (numbers[2:4] )# ['two', 'three']
print (numbers[1:-1] )# ['one', 'two', 'three'] 

El primer número (antes de los dos puntos) en el operador de división indica dónde comienza la división, y el segundo número (después de los dos puntos) indica dónde termina la división.

Si no especifica el primer número, Python comienza al principio de la secuencia. Si no se especifica un segundo número, Python se detiene al final de la secuencia.

Tenga en cuenta que la secuencia devuelta comienza en la posición inicial y termina justo antes de la posición final. Es decir, la posición inicial se incluye en el segmento de secuencia, mientras que la posición final se excluye del segmento. El corte se puede hacer con números negativos. Los números negativos se utilizan en posiciones que cuentan desde el final de la secuencia.

Por fin

Baozi, que acaba de empezar a ponerse en contacto con Python, puede enviarme un mensaje privado si no entiende nada.

¡También he preparado toneladas de tutoriales en video gratuitos, libros electrónicos en PDF y código fuente! ¡Solo tome la tarjeta de presentación al final del artículo!