[Python] base gramatical-7, estructura de secuencia

Others 2021-01-22 14:08:07 views: null

1.7 Estructura de secuencia

Objetos mutables y objetos mutables

Hay tres tipos principales de tipos de datos integrados en Python:

  • Número : entero, punto flotante

  • Secuencia: cadena, lista, tupla, conjunto

  • Mapeo : Diccionario

Según se pueda modificar in situ, se divide en dos categorías:

  • Objetos inmutables (números, cadenas, tuplas, colecciones inmutables)

    Ningún tipo de objeto en la categoría inmutable admite la modificación in situ, pero puede crear nuevos objetos y asignar los resultados a variables

  • Objetos mutables (listas, diccionarios, colecciones mutables)

    Por el contrario, los tipos mutables siempre se pueden modificar in situ mediante operaciones relacionadas sin la necesidad de crear nuevos objetos de datos.

Secuencia de operaciones generales

Indexar, dividir, agregar, multiplicar, iterar y verificar la membresía

Operación de índice

Todos los elementos en el índice están numerados (subíndices), los subíndices comienzan a contar desde 0, por supuesto, en Python, también puede usar subíndices negativos para acceder a los elementos, el subíndice de todo el último elemento es -1 (el último)

>>> word = "hello"
>>> word[0]
'h'
>>> word[2]
'l'
>>> word[-1]
'o'
>>> word[-5]
'h'
>>> word[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Para la cantidad literal de la secuencia, puede usar directamente la operación de subíndice, sin la necesidad de variables

>>> "hello"[3]
'l'
>>> "hello"[-1]
'o'

Operación de corte

La indexación es ir una pieza de datos a la vez, y la división es tomar una pieza de datos a la vez. Se deben determinar el inicio y el final, incluido el tamaño del paso (el valor predeterminado es 1).

>>> word = "12345678"
>>> word[0:3]
'123'
>>> word[-3:-1]
'67'

Ya sea un índice positivo o un índice negativo, el pedido debe estar garantizado

>>> word[1:8:2]
'2468'
>>> word[-6:-2:3]
'36'
>>> word[7:1:-2]
'864'
>>> word[-1:-5:-1]
'8765'
>>> word[-1:-5:1]
''
>>> word[:]
'12345678'
>>> word[2:]
'345678'
>>> word[:5]
'12345'
>>> word[-5:]
'45678'
>>> word[-3::-1]
'654321'

El tamaño del paso es positivo, aumentando desde el principio hasta el final.

El tamaño del paso es negativo, comenzando a terminar disminuye

>>> text = "我爱你"
>>> text = text[::-1]
>>> text
'你爱我'
>>> text = text[-1:-4:-1]
>>> text
'我爱你'

Agregar operación

Se refiere a la fusión de dos secuencias, que generará un nuevo objeto de secuencia sin cambiar el valor de la secuencia original.

>>> s1 = "abc"
>>> s2 = "ABC"
>>> s1 + s2
'abcABC'
>>> s1
'abc'
>>> s2
'ABC'

La suma solo se puede realizar entre secuencias del mismo tipo

Multiplicar la operación

Multiplica la secuencia por el número x y repite esta secuencia x veces para crear una nueva secuencia.

>>> s1
'abc'
>>> s3 = s1 * 3
>>> s3
'abcabcabc'

Operación iterativa

Puede iterar cada elemento en la secuencia en el bucle for, o iterar sobre los subíndices para obtener los elementos

>>> s1
'abc'
>>> for i in s1:
...     print(i)
...
a
b
c
>>> for i in range(len(s1)):
...     print(s1[i])
...
a
b
c
​
>>> word[0] = '9'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Operación de verificación de membresía

Es verificar si un elemento de datos existe en la secuencia actual

>>> '8' in word
True
>>> 8 in word
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'in <string>' requires string as left operand, not int
​
>>> '10' not in word
True
>>> '10' in word
False
>>> 5 in range(0,10)

Cuerda

Objeto inmutable, una colección ordenada de caracteres, que se utiliza para almacenar y representar información de texto básica.

Las cadenas no pueden modificar el valor in situ y la longitud de la cadena no se puede modificar una vez definida.

Si realmente desea modificar la cadena, solo puede crear una copia de la cadena, y el contenido de la copia es el contenido modificado

Método de cadena de prueba:

  • isalnum (): Verifique que solo se incluyan números y letras

  • isalpha (): verifica que solo se incluyan letras

  • isdigit (): verifica que solo se incluyan números

  • isidentifier (): verifica si es un identificador legal

  • islower (): verifica si las letras del contenido están todas en minúsculas

  • isupper (): verifica si las letras del contenido están todas en mayúsculas

  • isspace (): verifica si solo contiene espacios

Método de cadena de búsqueda:

  • termina con (str): verifica si el final del sufijo str

  • startswith (str): verifica si el prefijo comienza con str

  • find (str): Devuelve la primera aparición de str de izquierda a derecha, o -1 si no existe. rfind () en su lugar

  • index (str): la función es la misma que encontrar, si no existe, habrá una excepción

  • count (str): registra el número de apariciones de str, sin sobrescribir

Convertir cadena:

  • capitalize (): copia la cadena y escribe en mayúscula la primera letra

  • lower (): convierte todas las letras a minúsculas

  • upper (): convierte todas las letras a mayúsculas

  • title (): copia la cadena y escribe en mayúscula la primera letra de cada palabra

  • swapcase (): copia la cadena, convierte minúsculas a mayúsculas y mayúsculas a minúsculas

  • reemplazar (a, b): Reemplaza a en la cadena original con b para generar una nueva cadena

  • split (str): use str como separador para dividir la cadena, y el resultado es una lista de caracteres

  • partición (str): tome str como la parte central, divida la cadena en dos partes, izquierda y derecha

Eliminar espacios de cadena:

  • lstrip (): quita el espacio en el lado izquierdo de la cadena

  • rstrip ()

  • tira()

Cadena de formato:

  • centro (w): use w como ancho para mostrar el contenido en el centro

  • ligero()

  • rjust ()

>>> "123abc".isalnum()
True
>>> "我爱你123abc*!&@%#^&%&".isalnum()
False
>>> "abc".isalpha()
True
>>> "123".isalpha()
False
>>> "123abc".isalpha()
False
>>> "123".isdigit()
True
>>> "abc".isdigit()
False
>>> "sum".isidentifier()
True
>>> "123abc".isidentifier()
False
>>> "abc".islower()
True
>>> "ABC".islower()
False
>>> "123abc".islowe()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'islowe'
>>> "123abc".islower()
True
>>> "     ".isspace()
True
>>> " ad asd asd".isspace()
False
>>> "123,456,789".find("456")
4
>>> "123,456,789".rfind("456")
4
>>> word = "123456789456"
>>> word.find("456")
3
>>> word.rfind("456")
9
>>> word
'123456789456'
>>> word.index("123")
0
>>> word.index("456")
3
>>> word.find("666")
-1
>>> word.index("666")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> "121212121".count("121")
2
>>> name = "anglababy"
>>> name.capitalize()
'Anglababy'
>>> name
'anglababy'
>>> "Andy Mimi Lala".lower()
'andy mimi lala'
>>> "Andy Mimi Lala".lower().upper()
'ANDY MIMI LALA'
>>> "mynameishaha".title()
'Mynameishaha'
>>> "my name is haha".title()
'My Name Is Haha'
>>> s= "my name is haha".title()
>>> s
'My Name Is Haha'
>>> s.swpacase()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'swpacase'
>>> s.swapcase()
'mY nAME iS hAHA'
>>> s = "宇智波萨斯尅，宇智波马达啦，宇智波一大气，宇智波欧鼻头"
>>> s.replace("宇智波","千手")
'千手萨斯尅，千手马达啦，千手一大气，千手欧鼻头'
>>> s
'宇智波萨斯尅，宇智波马达啦，宇智波一大气，宇智波欧鼻头'
>>> s.split("，")
['宇智波萨斯尅', '宇智波马达啦', '宇智波一大气', '宇智波欧鼻头']
>>> l = s.split("，")
>>> l[1]
'宇智波马达啦'
>>> "莫西莫西海雅库摩多摩多".partition("雅")
('莫西莫西海', '雅', '库摩多摩多')
>>> "123456789".partition("456")
('123', '456', '789')
>>> "    123".lstrip()
'123'
>>> "123   ".rsrtip()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'rsrtip'
>>> "123   ".rstrip()
'123'
>>> "    8798    ".strip()
'8798'
>>> "I Love You".center(16)
'   I Love You   '
>>> s = "abc"
>>> s.center(10)
'   abc    '
>>> s.ljust(10)
'abc       '
>>> s.rjust(10)
'       abc'

Lista

Las listas son el tipo más flexible de objetos de colección ordenados en Python. A diferencia de las cadenas, las listas pueden contener cualquier tipo de objeto: números, cadenas e incluso listas. De manera similar, a diferencia de las cadenas, las listas son objetos mutables y todas admiten operaciones que se modifican en su lugar, y la longitud de las listas también es variable.

Variable: en el espacio de la lista, la dirección almacenada y que apunta a un determinado objeto de datos es variable

Cómo se creó la lista

Especificar elementos directamente

>>> [1,2,3,4,5]
>>> l = [1,2,3,4,5]

Especificar la longitud pero no especificar los elementos equivale a crear una lista vacía de longitud n pero sin direcciones de objetos de datos

>>> l = [None] * 10
>>> l
[None, None, None, None, None, None, None, None, None, None]

Utilice la función de lista para convertir otros datos en una lista. Estos datos deben ser iterables. El iterable puede ser operado por el bucle for.

>>> list() # 得到一个长度为0的列表
[]
>>> l = list("abcd")
>>> l
['a', 'b', 'c', 'd']
>>> l[0]
'a'
>>> l[-1]
'd'
>>> l = list(range(0,5))
>>> l
[0, 1, 2, 3, 4]
>>> l  =list(1234)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

Lista de operaciones específicas

  • Modificar elementos

    >>> l
[0, 1, 2, 3, 4]
>>> l[0]=5
>>> l
[5, 1, 2, 3, 4]

     

  • Modificación de corte

    >>> l = [1,2,3,4,5,6,7,8,9]
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l[3:7] = [666,888,999]
>>> l
[1, 2, 3, 666, 888, 999, 8, 9]

     

  • Eliminar operación

    >>> l
[1, 2, 3, 666, 888, 999, 8, 9]
>>> del l[3]
>>> l
[1, 2, 3, 888, 999, 8, 9]
>>> del l[-3]
>>> l
[1, 2, 3, 888, 8, 9]
>>> del l   # 删除列表对象 连着变量也一同删除
>>> l
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'l' is not defined

     

Funciones integradas para listas

  • append (): agrega un objeto de elemento al final de la lista

    >>> l = [1,2,3]
>>> l.append(4)
>>> l
[1, 2, 3, 4]
>>> l1 = [1,2,3,4]
>>> l2 = [5,6,7,8]
>>> l1.append(l2)
>>> l1
[1, 2, 3, 4, [5, 6, 7, 8]]
>>> l1.append("abc")
>>> l1
[1, 2, 3, 4, [5, 6, 7, 8], 'abc']

     

  • clear (): Limpia la lista, no significa eliminar el objeto de la lista

    >>> l.clear()
>>> l
[]

     

  • copy (): copia un nuevo objeto de lista, coherente con el contenido de la lista original, y devuelve la dirección de la nueva lista

    >>> l1 = [1,2,3,4]
>>> l2 = l1
>>> l2[0] = 5
>>> l1
[5, 2, 3, 4]
>>> l2 = l1.copy()
>>> l1
[5, 2, 3, 4]
>>> l2
[5, 2, 3, 4]
>>> l2[0]=10
>>> l1
[5, 2, 3, 4]
>>> l2
[10, 2, 3, 4]

     

  • count (): cuente el número de veces que un elemento aparece en la lista

    >>> l = [1,1,2,3,1,2,3,4,3,2,1,1,2]
>>> l.count(2)
4

     

  • extend (): Extiende el contenido de otras listas a la lista actual (agrega todos los elementos de esta última a la lista actual a su vez)

    >>> l1 = [1,2,3,4]
>>> l2 = [5,6,7,8]
>>> l1.extend(l2)
>>> l1
[1, 2, 3, 4, 5, 6, 7, 8]
>>> l2
[5, 6, 7, 8]
>>> l1.extend("abc")
>>> l1
[1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c']
>>> l1.extend(123)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

#如何理解extend?
lst = []
def extend(lter):
    for i in Iter:
        lst.append(i)

    A diferencia de agregar dos secuencias, agregar dos secuencias crea directamente un nuevo objeto de secuencia

  • index (): Devuelve el índice de la esquina del elemento de izquierda a derecha, lanza una excepción si no existe

    >>> l = [1,2,3,4]
>>> l.index(3)
2
>>> l.index(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 5 is not in list
​
>>> l.find(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'find'

     

  • insert (): Inserta un elemento en una posición determinada, si la marca de la esquina está fuera de los límites, si es un número negativo, es el penúltimo número; si la marca de la esquina es mayor que la longitud de la lista, agrégalo al final

    >>> l
[1, 2, 3, 4]
>>> l.insert(2,5)
>>> l
[1, 2, 5, 3, 4]
>>> l.insert(10,6)
>>> l
[1, 2, 5, 3, 4, 6]
>>> l.insert(-2,7)
>>> l
[1, 2, 5, 3, 7, 4, 6]

     

  • pop (): elimina un elemento al final de la lista, abre la pila; añadir se entiende como empujar la pila

    >>> l = [1,2,3,4]
>>> l.append(5)
>>> l
[1, 2, 3, 4, 5]
>>> l.pop()
5
>>> l
[1, 2, 3, 4]

     

  • remove (): elimina el primer elemento especificado de izquierda a derecha

    >>> l
[1, 2, 3, 4]
>>> l.remove(4)
>>> l
[1, 2, 3]
>>> l.remove(2)
>>> l
[1, 3]
>>> l = [1,1,1,2,2,3,3]
>>> l.remove(1)
>>> l
[1, 1, 2, 2, 3, 3]

     

  • reverse (): invierte la lista

    >>> l.reverse()
>>> l
[3, 3, 2, 2, 1, 1]

     

  • sort (): ordenar

    >>> l = [3,2,9,1,6,5,7,4,8]
>>> l.sort()
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l.reverse()
>>> l
[9, 8, 7, 6, 5, 4, 3, 2, 1]

     

Comprensión de listas

Es crear una lista a través de una declaración de bucle for

>>> l1 = [1,2,3,4,5,6,7,8,9,10]
>>> l1 = list(range(1,11))
>>> l1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> l1 = [x for x in range(1,11)]
>>> l1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> l1 = [x for x in range(1,21) if x%3==0 ]
>>> l1
[3, 6, 9, 12, 15, 18]
>>> l2 = [x/2 for x in l1]
>>> l2
[1.5, 3.0, 4.5, 6.0, 7.5, 9.0]

Algoritmo de búsqueda binaria

La premisa es que nuestra secuencia debe estar ordenada (creciente, decreciente)

# 二分查找
def binarySearch(lst, key):
    min_index = 0
    max_index = len(lst) - 1
    mid_index = (min_index + max_index) // 2
    while lst[mid_index] != key:
        if lst[mid_index] < key:
            min_index = mid_index + 1
        elif lst[mid_index] > key:
            max_index = mid_index - 1
        if min_index > max_index:
            return -1
        mid_index = (min_index + max_index) // 2
    return mid_index
​
lst = [x for x in range(1,13)]
print(binarySearch(lst,9))
print(binarySearch(lst,1))
print(binarySearch(lst,8.5))
print(binarySearch(lst,15))
lst = [x ** 2 for x in range(1,13)]
print(binarySearch(lst,121))
print(binarySearch(lst,120))

 

Seleccionar algoritmo de clasificación

def selectionSort(lst):
    for i in range(len(lst) - 1):
        for j in range(i+1,len(lst)):
            if lst[i] > lst[j]:
                lst[i],lst[j] = lst[j],lst[i]
                """
                temp = lst[i]
                lst[i] = lst[j]
                lst[j] = temp
                """
lst = [5,1,9,8,2,6,7,4,3]
selectionSort(lst)
print(lst)
 

Algoritmo de clasificación de burbujas

def bubbleSort(lst):
    for i in range(len(lst) - 1):
        for j in range(len(lst) - 1 - i):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
lst = [5,1,9,8,2,6,7,4,3]
bubbleSort(lst)
print(lst)

 

Algoritmo de ordenación por inserción

def insertionSort(lst):
    for i in range(1,len(lst)):
        e = lst[i]
        j = i
        while j > 0 and lst[j - 1] > e:
            lst[j] = lst[j - 1]
            j -= 1
        lst[j] = e
lst = [5,1,9,8,2,6,7,4,3]
insertionSort(lst)
print(lst)

 

Contando el algoritmo de clasificación

def countingSort(lst):
    minVal = min(lst)
    maxVal = max(lst)
    temp = [0] * (maxVal - minVal + 1)
    offset = minVal
    for number in lst:
        temp[number - offset] += 1
    i = 0
    for index in range(len(temp)):
        for k in range(temp[index]):
            lst[i] = index + offset
            i += 1
​
lst = [5,1,9,8,2,6,7,4,3]
countingSort(lst)
print(lst)

 

Algoritmo de clasificación base

import random
def getIndex(num,r):
    if len(str(num)) < r:
        return 0
    return int(str(num)[-r])
​
def radixSort(lst):
    maxVal = max(lst)
    radix = len(str(maxVal))
    temp = [None] * 10
    for i in range(10):
        temp[i] = []
​
    # 1个位 2十位 3百位
    for r in range(1,radix + 1):
        for num in lst:
            temp[getIndex(num,r)].append(num)
        i = 0
        for k in range(len(temp)):
            if len(temp[k]) != 0:
                for j in range(len(temp[k])):
                    lst[i] = temp[k][j]
                    i += 1
                temp[k].clear()
lst = []
for i in range(20):
    lst.append(random.randint(1,300))
radixSort(lst)
print(lst)

Tupla

Es una especie de secuencia como una lista, entre paréntesis()

Una tupla es una secuencia inmutable, que puede entenderse como una lista inmutable

Excepto que los elementos internos no se pueden modificar (adición, eliminación, modificación), otro uso es similar a la lista

>>> t = ()
>>> type(t)
<class 'tuple'>
>>> t = (1)
>>> type(t)
<class 'int'>
>>> t = (1,)
>>> type(t)
<class 'tuple'>
>>> t = (1,2,3)
>>> type(t)
<class 'tuple'>
>>> t = 1,2,3,4,5
>>> type(t)
<class 'tuple'>
>>> t = "你好","世界","哈哈"
>>> type(t)
<class 'tuple'>
>>> l = [1,2,3,4,5]
>>> type(l)
<class 'list'>
>>> t = tuple(l)
>>> t
(1, 2, 3, 4, 5)
>>> t = tuple("abcde")
>>> t
('a', 'b', 'c', 'd', 'e')

Mismos operaciones para elementos y listas

  • cuenta () 、 índice ()

  • len () 、 max () 、 min () 、 tupla ()

>>> t = (1,2,3,4,5)
>>> max(t)
5
>>> min(t)
1
>>> len(t)
5
>>> t.count(5)
1
>>> t.index(3)
2
>>> t.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'sort'
>>> t.find(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'find'

Operaciones no permitidas en tuplas

  • Modificar y agregar elementos

  • Eliminar un elemento (pero puede eliminar la tupla completa)

  • Todos los métodos que modifican los elementos internos de la tupla

>>> t.append(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>> t.remove(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'remove'
>>> t
(1, 2, 3, 4, 5)
>>> t[0] = 666
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del t[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>> del t
>>> t
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 't' is not defined

Una tupla solo garantiza que sus elementos secundarios de primer nivel sean inmutables. Para los elementos anidados, no se garantiza que sea inmutable

Para decirlo sin rodeos, significa que la dirección del objeto almacenado en la tupla es inmutable

>>> t = (1,2,[3,4])
>>> t[0] = 666
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t[2] = [5,6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t[2][0] = 5
>>> t[2][1] = 6
>>> t
(1, 2, [5, 6])
>>> id(t[2])
53493544
>>> t[2].append(7)
>>> t
(1, 2, [5, 6, 7])
>>> id(t[2])
53493544

Por lo tanto, cuando utilice tuplas, intente utilizar los tipos de datos de objetos inmutables como números, cadenas y tuplas como elementos.

¿Cuándo lo usas habitualmente? Una vez que los datos están confirmados y no se pueden cambiar, utilice

>>> address = ("172.16.20.222","8080") # IP地址与端口号绑定

 

Supongo que te gusta

Origin blog.csdn.net/trichloromethane/article/details/108267507
Recomendado
Clasificación
Diario
Más
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)
2024-06-04(0)
2024-06-03(1)
2024-06-02(0)
2024-06-01(2)
2024-05-31(0)
2024-05-30(0)
2024-05-29(1)

Code World

© 2018 codetd.com