Programação RPi Python 08: listas Python e matrizes de bytes

No tutorial anterior, aprendemos sobre a sintaxe básica e vários elementos da linguagem Python. Python oferece seis tipos de sequências: strings, bytes, matrizes de bytes, intervalo, tuplas e listas.

É importante ressaltar que as strings, bytes, intervalo e tuplas são sequências imutáveis ​​que não podem ser modificadas depois de definidas. Só é possível criar ou destruir essas sequências. Isso deixa as listas e matrizes de bytes como as únicas sequências mutáveis.

Python também oferece suporte a coleções não ordenadas, como conjuntos, conjuntos congelados e dicionários. Os conjuntos congelados são imutáveis ​​e os conjuntos e dicionários são coleções mutáveis. Além disso, estruturas de dados definidas pelo usuário podem ser definidas como classes e são sempre mutáveis.

Sequências e coleções imutáveis ​​são úteis quando determinados valores de dados precisam ser usados ​​em todo o código. Sequências e coleções mutáveis ​​são úteis na manutenção de valores de dados relacionados que podem ser agrupados por motivos específicos. Como os valores de dados em uma sequência/coleção mutável podem ser modificados em qualquer lugar do código, eles são usados ​​idealmente para manipulação e processamento de dados. Afinal, em qualquer programa estamos manipulando e processando valores de dados.

Normalmente, usaremos sequências ou coleções (não ordenadas) de valores de dados na maioria dos aplicativos. Portanto, é essencial entender como os valores dos dados nessas sequências/coleções mutáveis ​​podem ser modificados e manipulados. As listas, matrizes de bytes, conjuntos e dicionários estão disponíveis como sequências/coleções Python mutáveis. Vamos revisar cada um.

Listas

Listas são uma coleção ordenada mutável de itens. Os itens de uma lista são arbitrários e podem ser de qualquer tipo. Uma lista é definida por um construtor list ou usando um par de colchetes ( ).

Também é possível adicionar, remover e modificar os itens de uma lista. Esses itens podem ser acessados ​​através de chaves inteiras ou índices. A chave ou índice dos itens de uma lista começa do zero. Portanto, o primeiro item possui uma chave ou índice 0. Isso significa que se “x” for uma lista, seus itens podem ser acessados ​​como x(y) onde y é a chave/índice do item que está sendo acessado. Se um índice negativo for usado, o item será acessado do final da lista e não do início.

No final da lista, os índices começam em -1.

Por exemplo:

X = (1, 2, 3, 4)
X(1) # Retorna 2
X(-1) #Retorna 4

Um ou mais itens de uma lista podem ser modificados, individualmente ou por meio de uma fatia. Para fazer isso individualmente, acesse o item da lista como uma referência de destino em uma tarefa ou tarefa aumentada da seguinte maneira:

X = (1, 2, 3, 4)
X(1) = 'uma' # x = (1, 'uma', 3, 4)
X(2) += 22 # x = (1, uma, 25, 4)

Ao usar uma atribuição aumentada para modificar um item da lista, o tipo de dados da expressão RHS deve ser o mesmo dos itens. Caso contrário, o resultado será um erro semântico.

Vários itens de uma lista também podem ser modificados juntos usando o operador de fatiamento como referência de destino em uma instrução de atribuição como esta:

X = (1, 2, 3, 4)
X(1:3) = (22, 33) # x = (1, 22, 33, 4)

Uma fatia x(a:b) modificará todos os itens com um índice entre a e b-1 da lista “x”, mas não “b”. A fatia pode ser atribuída a qualquer iterável. Se a fatia for atribuída a um iterável com menos itens que a fatia, os itens que não forem atribuídos serão removidos da lista. Se a fatia for atribuída a um iterável com mais itens que a fatia, os itens extras serão anexados após o último item da fatia.

Aqui está um exemplo:

X = (1, 2, 3, 4)
X(1:3) = (22) # x = (1, 22, 4)
X = (1, 2, 3, 4)
X(1:3) = (22, 33, 44) # x = (1, 22, 33, 44, 4)

Se uma fatia vazia x(a:a) receber determinados valores/objetos de dados, esses valores/objetos serão anexados antes do item com o índice “a: na lista “x”. Da mesma forma, uma fatia pode cobrir a lista inteira e religar novos valores/objetos a ela usando a expressão x(:) como referência de destino para a lista “x”.

Considere este exemplo:

X = (1, 2, 3, 4)
X(1:1) = (22) # x = (1, 22, 2, 3, 4)
X = (1, 2, 3, 4)
X(:) = (22, 33, 44) # x = (22, 33, 44)

Qualquer item ou fatia de itens pode ser excluído de uma lista usando a instrução “del”. Aqui, um operador de fatiamento também pode usar o passo para pular a exclusão de itens em um intervalo regular.

Aqui estão alguns exemplos:

X = (1, 2, 3, 4, 5, 6, 7, 8, 9)
del X (8) # x = (1, 2, 3, 4, 5, 6, 7, 8)
del X(4:6) # x = (1, 2, 3, 4, 7, 8)
del X(4:) # x = (1, 2, 3, 4)
del X(::2) # x = (2, 4)

As listas têm estes métodos:

Esses métodos podem ser aplicados nas listas usando a sintaxe list_name.method_name. Aqui está um exemplo:

x = ('leão', 'tigre')=
x.append('elefante') # x = ('leão', 'tigre', 'elefante')
x.insert(0, 'leopardo') # x = ('leopardo', 'tigre', 'elefante')
x.extend(('gato', 'cobra')) # x = ('leopardo', 'tigre', 'elefante', 'gato', 'cobra')
x.remove('cobra') # x = ('leopardo', 'tigre', 'elefante', 'gato')
x.pop(0) # x = ('tigre', 'elefante', 'gato')
x.index('gato') # retorna 2
y = x.copy # y = ('tigre', 'elefante', 'gato')
x.count('gato') # retorna 1
x.count('leão') # retorna 0
x.sort # x = ('gato', 'elefante', 'tigre')
def f(e):
retornar len(e)
x.sort(key = f) # x = ('gato', 'tigre', 'elefante')
x.reverse # x = ('elefante', tigre, 'gato')
claro # x =

Estas funções integradas aceitam listas como argumentos:

Uma lista pode ser passada como argumento para a função len para obter o tamanho dessa lista. Aqui está um exemplo:

x = (1, 2, 3, 4)
len(x) #retorna 4

Esta tabela resume as operações comuns de listas usando operadores, instruções, métodos ou funções:

Strings, bytes e matrizes de bytes

Strings são uma sequência imutável de caracteres Unicode (Python V3) ou ASCII (Python V2). Bytes são uma sequência imutável de bytes. Matrizes de bytes são uma sequência mutável de bytes.

Strings são definidas como sequências entre aspas simples, duplas ou triplas dos caracteres Unicode/ASCII. Qualquer item em um iterável destinado a ser usado como string deve ter aspas. Caso contrário, o Python irá tratá-lo como um identificador e assumir que é uma referência.

Aqui está um exemplo:

x = ('a', 'b', 'c')
uma = 12
b = 10
c = 11
y = (a, b, c)
print(x) # Imprime ('a', 'b', 'c')
print(y) # Imprime (12, 10, 11)

Strings são sequências imutáveis. Isso significa que não é possível adicionar, remover ou modificar qualquer item (caractere Unicode/ASCII) de uma string acessando seu índice. Então, estes são inválido declarações:

x = “Píton”
x(0) = “J” #INVÁLIDO
del x(0) #INVÁLIDO

No entanto, é possível realizar a manipulação de strings usando métodos construídos, funções e funções definidas pelo usuário. Os caracteres semelhantes em um objeto string podem ser substituídos usando a função replace .

Confira este exemplo:

x = 'PPython'
x = x.substituir(“P”, “J”)
imprimir (x)

Bytes são definidos pela função byte ou prefixando “b” antes de uma string de bytes. Bytes também são sequências imutáveis. Não é possível adicionar, remover ou modificar bytes em um objeto byte acessando-os a partir de seu índice. Aqui estão exemplos válidos de objetos de byte:

x = b“Píton”
x = byte (“Python”)

Matrizes de bytes são uma versão mutável de bytes. Eles podem ser definidos usando a função bytearray . Estes exemplos válidos de bytes e matrizes de bytes:

x = bytearray(“Python”, 'utf-8') #string definida como matriz de bytes
x = bytearray(b“Python”)
x = bytearray((1, 2, 3, 4, 5,))
x = bytearray # bytearray vazio

Se uma string for definida como uma matriz de bytes usando a função bytearray , a string deverá ser colocada entre aspas e a codificação deverá ser passada como um argumento. Ao contrário dos bytes, as matrizes de bytes são mutáveis, o que significa que é possível adicionar, remover ou modificar itens (bytes) em uma matriz de bytes acessando-os por meio de seu índice.

No entanto, os itens de uma matriz de bytes só podem ser acessados ​​através de um operador de fatiamento. Isto é um inválido exemplo de modificação da matriz de bytes:

x = bytearray(b”Python”)
imprimir (x)
x(0) = b”J” #INVÁLIDO
imprimir (x)

Aqui está um exemplo válido de modificação da matriz de bytes:

x = bytearray(b”Python”)
print(x) #retorna bytearray(b'Python')
x(0:1) = b”J”
print(x) #retorna bytearray(b'Jython')

O exemplo a seguir mostra adicionar, remover, modificar e anexar bytes em uma matriz de bytes:

x = bytearray(b”Python”)
imprimir (x)
x(6:) = b” é divertido” #adicionando itens à matriz de bytes por atribuição
print(x) #prints bytearray(b'Python é divertido')
x.append(110) #anexando itens à matriz de bytes
x.append(121)
print(x) #prints bytearray(b'Python é engraçado')
x(6 🙂 = b”” #removendo itens na matriz de bytes por atribuição
print(x) #prints bytearray(b'Python é engraçado')
x(6:) = b”Objetos”
print(x) #prints bytearray(b'Objetos Python')
del x(6:) #removendo itens na matriz de bytes pela instrução del
print(x) #prints bytearray(b'Python')

Certifique-se de testar todos esses códigos de exemplo no Raspberry Pi.

No próximo tutorialdiscutiremos como manipular valores de dados em conjuntos e dicionários.

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.