Mais um pouco ainda sobre listas e strings
Mais um pouco listas ainda e strings
Nesta provinha trabalharemos um pouco mais com lista e com strings.
Strings
Mutabilidade
Mutabilidade: listas são mutáveis; podemos alterar um componente, lst[i] = x
,
Imutabilidade: strings são imutáveis; não podemos alterar um componente, s[i] = 'x'
, ERRO :-\
Tipos nativos: int
, float
, bool
, str
, list
, Nonetype
int
, float
, bool
e NoneType
são tipos de dados primitivos, pois seus valores não são compostos de partes menores. Eles não podem ser “quebrados”.
Strings (str
) e listas (list
) são diferentes pois são compostos de partes menores.
Um caractere é um símbolos gráficos como letras, pontuação, espaços que são exibidos na tela. Exemplos de caracteres diferentes de letras: ' '
, '\n'
, '*'
, '-'
,
Os componentes de uma lista podem ser qualquer coisa. Já os componentes de strings são somente caracteres.
A manipulação de listas e strings é muito semelhante. Há, no entanto, uma diferença fundamental: strings são imutáveis!.
Tipos formados por partes menores são chamados de coleção de tipos de dados.
Dependendo do que fizermos desejamos tratar uma coleção de tipos como uma única entidade ou desejamos acessar as suas partes.
Esta ambiguidade pode ser útil.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| I | n | s | t | . | | M | a | t | e | m | á | t | i | c | a |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
-16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
Strings são uma sequência de caracteres delimitadas por "
ou '
.
Caractere '\n'
Caracteres ao sempre exibidos por print()
exibem símbolos gráfico e efeitos não gráficos.
0 1 2
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| l | i | n | h | a | 0 |\n | l | i | n | h | a | 1 |\n | l | i | n |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Algumas operações
A seguir está uma tabela resumindo algumas das operações sobre strings. No que segue s
e t
são strings e ini
,fim
, passo
e n
são números inteiros.
Operação | Resultado |
---|---|
x in s |
True se x é item de s , senão False |
x not in s |
False se x é item de s , senão True |
s + t |
a concatenação se s e t |
s * n ou n * s |
equivalente a s ser concatenada n vezes |
s[i] |
i-ésimo caractere de s |
s[ini:fim] |
fatia de s de ini a fim |
s[ini:fim:passo] |
fatia de s de ini a fim com passo passo |
len(s) |
comprimento de s |
s == t |
True se s e t são iguais, senão False |
s is t |
strings são imutabilidade, equivalente a s == t |
s[i]='x' |
ERRO, strings são imutáveis |
Criar uma string
Para criar uma string vazia fazemos
In [9]: string_vazia = ""
In [10]: string_vazia
Out[10]: ''
In [11]: string_vazia = ''
In [12]: string_vazia
Out[12]: ''
Para cria uma nova string fazemos
In [13]: s = "Como é bom estudar MAC0110!"
In [14]: s
Out[14]: 'Como é bom estudar MAC0110!'
In [15]: print(s)
Como é bom estudar MAC0110!
Strings são imutáveis, não podemos alterar seus componentes
In [18]: s = "MAC0110"
In [19]: s[2] = 'T' # ERRO
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-19-32c1c57e2e7a> in <module>
----> 1 s[2] = 'T'
TypeError: 'str' object does not support item assignment
Não alteramos strings, contruímos novas strings.
Criar strings com f
-strings
In [29]: s = f"n = {123}" # note o f no início
In [30]: s
Out[30]: 'n = 123'
In [31]: print(s)
n = 123
In [32]: t = f"pi = {3.14}" # note o f no início
In [33]: t
Out[33]: 'pi = 3.14'
In [37]: nome = 'Maria'
In [38]: w = f"nome = {nome}"
In [39]: w
Out[39]: 'nome = Maria'
In [40]: n = 123
In [41]: s = f"n = {n}"
In [43]: w
Out[43]: 'nome = Maria'
In [44]: pi = 3.14
In [45]: t = f'pi = {pi}'
In [46]: t
Out[46]: 'pi = 3.14'
função str()
Para converter um objeto para uma string utilizamos a função nativa str()
.
In [46]: s = str(123)
In [47]: s
Out[47]: '123'
In [48]: s = str(True)
In [49]: s
Out[49]: 'True'
In [50]: s = str(None)
In [51]: s
Out[51]: 'None'
In [52]: print(s)
None
In [53]: s = str(3.1415926)
In [54]: s
Out[54]: '3.1415926'
In [55]: print(s)
3.1415926
In [56]: s = str(True)
In [57]: s
Out[57]: 'True'
In [58]: s = str([1,2,3])
In [59]: s
Out[59]: '[1, 2, 3]'
Percorrer uma string
Há várias maneiras e percorrermos uma string.