MANIPULANDO LISTAS

Pois é, pessoal. Trabalhar com listas é fundamental para quem trabalha com manipulação de dados.

Então, hoje vamos a algumas "falcatruas" possíveis com listas:

Aqui temos a lista1 com os vilões e a lista2 com os heróis.
A lista3 é uma "lista de listas" contendo as listas 1 e 2. Muito legal, né?

>>> lista1 = ["Piccolo","Vegeta","Freeza","Cell","Majimboo"]
>>> lista1
['Piccolo', 'Vegeta', 'Freeza', 'Cell', 'Majimboo']
>>> lista2=["Kuririn","Yamcha","Tenshinhan","Gohan","Goku"]
>>> lista2
['Kuririn', 'Yamcha', 'Tenshinhan', 'Gohan', 'Goku']
>>> lista3=[lista1,lista2]
>>> lista3
[['Piccolo', 'Vegeta', 'Freeza', 'Cell', 'Majimboo'], ['Kuririn', 'Yamcha', 'Tenshinhan', 'Gohan', 'Goku']]

Aqui temos a lista1 com os vilões e a lista2 com os heróis.
A lista3 é uma "lista de listas" contendo as listas 1 e 2. Muito legal, né?

Você quer ordenar as lista? Sim? Então vamos ordená-las por ordem alfabética:

>>> lista1.sort()
>>> lista2.sort()
>>> lista1
['Cell', 'Freeza', 'Majimboo', 'Piccolo', 'Vegeta']
>>> lista2
['Gohan', 'Goku', 'Kuririn', 'Tenshinhan', 'Yamcha']
>>> lista3
[['Cell', 'Freeza', 'Majimboo', 'Piccolo', 'Vegeta'], ['Gohan', 'Goku', 'Kuririn', 'Tenshinhan', 'Yamcha']]


Vamos agora imprimir cada elemento das listas:

>>> for i in  lista1:    print(i)

Cell
Freeza
Majimboo
Piccolo
Vegeta
>>> for i in lista2:    print(i)

Gohan
Goku
Kuririn
Tenshinhan
Yamcha
>>> for i in lista3:    print(i)

['Cell', 'Freeza', 'Majimboo', 'Piccolo', 'Vegeta']
['Gohan', 'Goku', 'Kuririn', 'Tenshinhan', 'Yamcha']

Vamos agora imprimir apenas o elemento [1] de cada lista:

>>> print(lista1[1])
Freeza
>>> print(lista2[1])
Goku
>>> print(lista3[1])
['Gohan', 'Goku', 'Kuririn', 'Tenshinhan', 'Yamcha']

Agora vamos incluir elementos:

>>> lista1.append("Tao Pai Pai")
>>> lista1
['Cell', 'Freeza', 'Majimboo', 'Piccolo', 'Vegeta', 'Tao Pai Pai']
>>> lista2.append("Mestre Kame")
>>> lista2
['Gohan', 'Goku', 'Kuririn', 'Tenshinhan', 'Yamcha', 'Mestre Kame']
>>> lista3.append(["Bulma","Chichi","Vovó Uranai","Lunch","Videl","Maron"])
>>> lista3

[['Cell', 'Freeza', 'Majimboo', 'Piccolo', 'Vegeta', 'Tao Pai Pai'], ['Gohan', 'Goku', 'Kuririn', 'Tenshinhan', 'Yamcha', 'Mestre Kame'], ['Bulma', 'Chichi', 'Vovó Uranai', 'Lunch', 'Videl', 'Maron']]

Note que foi inserida uma nova lista de mulheres em lista3, que é uma "lista de listas".


Agora vamos apagar um elemeto da lista:

>>> lista1.pop(3)
'Piccolo'
>>> lista1
['Cell', 'Freeza', 'Majimboo', 'Vegeta', 'Tao Pai Pai']
>>> lista2.pop(lista2.index("Yamcha"))
'Yamcha'
>>> lista2
['Gohan', 'Goku', 'Kuririn', 'Tenshinhan', 'Mestre Kame']
>>> lista3.pop(2[3])
>>> lista3[2].pop(lista3[2].index("Videl"))
'Videl'


- Nossa senhora! Fiquei tonto agora com essas falcatruas!!!

Calma, amigão! Vou explicar

>>> lista1.pop(3)
Excluí o elemento de índice 3 da lista1.
Note que o Python devolve o valor do elemento excluído. Caso não queira este retorno, utilize o remove em lugar do pop.

>>> lista2.pop(lista2.index("Yamcha"))
'Yamcha'
O comando lista2.index("Yamcha") me retorna o índice dentro da lista que contém o valor "Yamcha". Daí o retorno deste comando me dá o valor do indice que será excluído como lista3.pop.
**IMPORTANTE** Caso houverem dentro da lista dois elementos com o mesmo valor, apenas o primeiro será retornado com o index!

Agora vou criar uma lista doidona pra você perceber o poder da lista em Python.

>>> doidona=[1,23,"Android","Bom dia",("a","b","c"),["YuYu Hakusho","CDZ","DBZ","Giban"],lista2]
>>> doidona
[1, 23, 'Android', 'Bom dia', ('a', 'b', 'c'), ['YuYu Hakusho', 'CDZ', 'DBZ', 'Giban'], ['Gohan', 'Goku', 'Kuririn', 'Tenshinhan', 'Mestre Kame']]
>>> for i in doidona:    print(type(i))

<class 'int'>
<class 'int'>
<class 'str'>
<class 'str'>
<class 'tuple'>
<class 'list'>

<class 'list'>

Ficou feliz né? Cada elemento da lista é de um tipo!!! Espetacular. E dá pra 'enfiar' qualquer tipo de dados numa lista, incluindo uma própria lista! Não é demais?

Pois bem pessoal, Espero ter ajudado mais uma vez.

Não deixem de comentar. E se tiverem algum pedido, deixem aqui nos comentários também!

Até a próxima!

IDEs PARA PYTHON

Bem pessoal, meu grande mestre sr. Marcelo Barros me disse há uns dois anos, que já percorreu várias IDEs e que não adianta, a melhor é a IDLE que já vem com o Python na instalação.
A vantagem aqui é que ele é nativo e, portanto, não precisa preocupar com configurações chatas e importar bibliotecas e tal...
A desvantagem é que não tem nada de debug, não tem ferramentas de links ou referências, etc. Outro problema é que se for trabalhar com o TKInter, a biblioteca gráfica do Python, o IDLE dá problema, pois ele próprio foi feito usando o TKInter.
Mas em compensação você tem um interação com o Shell e pode manipular as variáveis com os valores armazenados logo após da execução.

Na época, eu para testar este ensinamento, encontrei uma outra IDE chamada SCITE que serve pra outras linguagens como Pearl, LUA, Ruby, etc. Eu gosto dele pelo simples fato de ele mostrar o numero das linhas, coisa que o IDLE não faz. Isso é muito útil quando o Python retorna aquele lindo erro na linha ## e você tem que localizar a linha ou ficar contando.
Mas o ruim é que não tem o shell do Python pra você "brincar" e testar possibilidades.

Conheço desenvolvedores, como o meu amigo Frederico Martins, que utilizam o bom e velho Eclipse com o PyDev. Há também a possibilidade de utilizar o NetBeans. Este eu tentei mas logo desisti porque ele é muito difícil de configurar e entender o que ele quer da vida... Pra quem já está habituado a usar o NetBeans para Java, pode ser que entenda melhor. Se fizer muita questão, devem haver tutoriais pra isso no YouTube e/ou Google.

Agora, o descobrimento das Américas para mim, foi o mais lindo do mundo chamado PyCharm (eu sei que o nome é meio estranho, mas não fui eu quem batizou as Américas também), foi uma indicação do sr. Pedro Santos e foi um alívio para nós.

Me perdoem a gíria, mas esse é CABULOSO!

Tem debugger, tem shell do Python, tem até um MSDOS, também conhecido como CMD ou Terminal de Comandos.
Enfim. Nem tenho como enumerar as vantagens de se usar o PyCharm. Digamos que comparando os demais com ele seria comparar o Yajirobe com o Kakaroto.

Mestre Marcelo! Tenho certeza que você não tinha me dito do PyCharm na época pelo meu melhor aprendizado! Muito obrigado!

EXPLORANDO UM POUCO MAIS A MANIPULAÇÃO DE STRINGS

Oi pessoas.
Me desculpem pelo hiato, mas é que as provas chegaram aí, já viram, né?

Pois bem, enquanto eu não consigo chegar no Salão do Tempo pra estudar um ano inteiro em um dia, vou fazendo o possível pra manter o blog atualizado.

Então... que tal brincar mais um pouquinho com strings???

Já aprendemos a inverter a string utilizando o [::-1] e também aprendemos a inverter a string de hexa com a biblioteca binascii.
Agora ensinarei aqui a inverter a string hexa sem transformar os dados, ou seja, trabalharemos diretamente com strings o tempo todo.

Supondo que a string seja:
'4b494b4f48c394' 
Que traduzindo de HEX para ASCII significa "KIKOHÔ".
Vamos inverter para que o resultado seja:
'94c3484f4b494b'  ou seja "ÔHOKIK".

>>> a='4b494b4f48c394'
>>> b=''
>>> for i in range(len(a),0,-2):    b=b+a[i-2:i]
>>> b
'94c3484f4b494b'

Muito bom, né?

O que isso quer dizer?

Muito bem. O for todo mundo conhece né? Não?
Então aqui vai:

for i in range(100):    .......

Isso quer dizer que 'i' irá receber os números de 0 a 99, pois irá fazer 100 iterações.

for i in range (1,100,1):    ........

Isso quer dizer que 'i' irá receber valores de 1 a 100 com passos de 1 em 1.

for i in range (1,100,2):    ........

Isso quer dizer que 'i' irá receber os valores de 1 a 100 com passos de 2 em dois, ou seja: 1,3,5,7,...,97,99.

Então voltando ao exemplo:

for i in range(len(a),0,-2):    b=b+a[i-2:i]

len(a) é o tamanho da string. No nosso caso 4b494b4f48c394 tem 14 caracteres, então len(a) = 14, daí o range NESSE CASO é: range(14,0,-2), então i recebe valores de 14 a 0 com passos de -2 (2 decrescente).

Aí vemos as instruções: b=b+a[i-2:i]. 

Na primeira iteração b está vazio (''), mas receberá a concatenação da string b ('') e do fragmento de string a[i-2:i], como o valor de 'i' na primeira iteração é 14, então será a[14-2:14] ou a[12:14]='94'. Ao fim dessa iteração b='94'

Na primeira iteração b contém ('94'), mas receberá a concatenação da string b ('94') e do fragmento de string a[i-2:i], como o valor de 'i' na segunda iteração é 12, então será a[12-2:12] ou a[10:12]='c3'. Ao fim dessa iteração b='94c3'.

E aí vai até que o range chegue a 0, percorrendo toda a string em a.

Por hoje é só, pessoal!

BRINCANDO COM STRINGS - ÍNDICES E INVERSÕES

Vamos agora fazer umas 'falcatruas' com strings.

Escolhi strings por serem o resultado de muitas conversões

Vamos ao princípio básico: o índice.

>>> a='KAKAROTO'
>>> a[0]
'K'
>>> a[1]
'A'
>>> a[2]
'K'
>>> a[3]
'A'
>>> a[4]
'R'
>>> a[5]
'O'
>>> a[6]
'T'
>>> a[7]
'O'
>>> a[8]
Traceback (most recent call last):
  File "<pyshell#103>", line 1, in <module>
    a[8]
IndexError: string index out of range

Percebemos aqui então que o índice sempre começa com 0 (zero) e termina com o tamanho (lenth) -1. Ou seja, tem 8 caracteres de 0 a 7.

Aqui os escolhemos todos os índices do início [0] até [2]
>>> a[:2]
'KA'
Aqui escolhemos todos os índices maiores que dois até o fim na string
>>> a[2:]

'KAROTO'
Aqui escolhemos os quatro último índices.
>>> a[-4:]
'ROTO'
Aqui escolhemos todos os índices do início até o quarto último.
>>> a[:-4]
'KAKA'
Aqui escolhemos todos os índices, do primeiro [0] até o índice do tamanho total da string [len(a)]. O resultado é mesmo que se não especificássemos os índices, mas é de cunho didático.
>>> a[0:len(a)]

'KAKAROTO'
Aqui escolhemos do terceiro índice o tamanho total da string menos dois (total-2).
>>> a[3:len(a)-2]
'ARO'
Para entender direitinho  essa coisa de índice, veja a imagem lá em cima, ok?

Mas e se eu receber a string invertida???
Aí tem esse comando:

>>> b='ATEGEV'
>>> b[::-1]

'VEGETA'



Nossa! Que máximo!!! Ficou fácil inverter, hein? 
ÔPA! Péraí caceta! Fui inverter minha string de um resultado em HEX, deu errado!

Não se desespere! Vamos ver:

>>> h = hex(2341522)
>>> h
'0x23ba92'
>>> h[::-1]
'29ab32x0'

Realmente não deu muito certo. O que fazer?

Vamos lá.
Aqui utilizaremos uma biblioteca chamada binascii. Informações aqui e aqui.


>>> h= hex(2341522)
>>> h
'0x23ba92'
>>> h.split('x')[1]
'23ba92'
>>> h=h.split('x')[1]
>>> h
'23ba92'
>>> import binascii
>>> result=binascii.unhexlify(h[0:len(h)].encode())
>>> result
b'#\xba\x92'
>>> result[::-1]
b'\x92\xba#'
>>> result=binascii.unhexlify(h.encode())
>>> result
b'#\xba\x92'
>>> result=hexlify(result[::-1]).decode()
>>> result
'92ba23'

Vixxx Maria!!! Quanta informação!!!

Vamos com calma.
A parte do split, já vimos em um post anterior.
A parte do binascii.hexlify, transformou a string em um hexadecimal 'binário'. Daí, quando invertemos com o  [::-1], ao invés de inverter cada um dos caracteres, invertemos os bytes (conjuntos de oito bits).
A parte do binascii.unhexlify transfmormou o hexadecimal 'binário' em uma string novamente.
Tão lindo, não é?

CONVERSÕES ENTRE BASES: DECIMAL, HEXADECIMAL, INTEIRO, BINÁRIO E OCTAL

Bem... continuando com o assunto "conversões", vamos passar para as bases numéricas.

Se você está começando agora neste mundo de bases numéricas e ainda não pegou a "manha" da coisa, sugiro que leia estas dicas que lhe serão muito úteis no entendimento.

Pois bem. Vamos começar com o mais fácil: base decimal.

Atribuindo um valor decimal:

>>> inteiro = 65535
>>> inteiro
65535
>>> type(inteiro)
<class 'int'>

Transformando em hexadecimal (vimos no post anterior):

>>> hexadecimal = hex(inteiro)
>>> hexadecimal
'0xffff'
>>> type(hexadecimal)
<class 'str'>

Transformando em binário:

>>> binário = bin(inteiro)
>>> binário
'0b1111111111111111'
>>> type(binário)
<class 'str'>

Transformando em octal:

>>> octal=oct(inteiro)
>>> octal
'0o177777'
>>> type(octal)
<class 'str'>
_____________________________________________
Para os apressadinhos, vou adiantar que há uma maneira de transformar um número decimal em hexadecimal em que o resultado é em binário (bytes) e não uma string como o hex(inteiro), mas a explicação darei em outra oportunidade:

Primeiro, importamos a biblioteca struct, depois usamos-na para a conversão:

LITTLE ENDIAN (default):

>>>import struct
>>> struct.pack('<l',inteiro)
b'\xff\xff\x00\x00'

BIG ENDIAN:
>>> struct.pack('>l',inteiro)
b'\x00\x00\xff\xff'

Então temos:

>>> binhex=struct.pack('>l',inteiro)
>>> type(binhex)
<class 'bytes'>
>>> binhex
b'\x00\x00\xff\xff'
_____________________________________________

Vamos agora partir para o octal:

Transformando em inteiro:
>>> octal='0o177777'
>>> inteiro=int(octal,8)
>>> inteiro
65535
>>> type(inteiro)
<class 'int'>

Transformando em hexadecimal. Nesse caso, temos que dar uma "roubadinha":

>>> octal='0o177777'
>>> hexadecimal=int(octal,8)
>>> octal='0o177777'
>>> hexadecimal=hex(int(octal,8))
>>> hexadecimal
'0xffff'
>>> type(hexadecimal)
<class 'str'>

A mesma "roubadinha" para binário:

>>> octal='0o177777'
>>> binário=bin(int(octal,8))
>>> binário
'0b1111111111111111'
>>> type(binário)
<class 'str'>

E por último, vamos para o binário:

Transformando em inteiro:

>>> binário='0b1111111111111111'
>>> inteiro=int(binário,2)
>>> inteiro
65535
>>> type(inteiro)
<class 'int'>

Transformando em hexadecimal (roubandinha):

>>> hexadecimal=hex(int(binário,2))
>>> hexadecimal
'0xffff'
>>> type(hexadecimal)
<class 'str'>

Transformando em octal (roubadinha):

>>> octal=oct(int(binário,2))
>>> octal
'0o177777'
>>> type(octal)
<class 'str'>

CONVERSÕES INTEIRO - HEXADECIMAL - INTEIRO

O ruim do Python 3.x é que a maioria dos resultados é dado como uma string.
Então se você, por exemplo, atribui um inteiro à uma variável e converte para Hexadecimal, terá uma string como retorno.
Observe:

>>> inteiro=64
>>> type(inteiro)
<class 'int'>
>>> hexadecimal=hex(inteiro)
>>> type(hexadecimal)
<class 'str'>
>>> inteiro
64
>>> hexadecimal
'0x40'

Nada mal, você pensa, afinal os valores estão certos. Porém os tipos não estão. Isso à princípio não faz muita diferença. Mas quando você começar a manipular esses dados, vai ter problemas certamente.

Bem... chega de Lero-Lero.
Vamos a algumas transformações:

String em inteiro:

>>> a = 'ac6cad'
>>> int(a,16)
11300013

Inteiro em string:

>>> b=11300013
>>> b
11300013
>>> hex(b)
'0xac6cad'

Para tirar o '0x' da string:

>>> hex(b).split('x')[1]
'ac6cad'

'split' é para "fatiar" a string. o ('x') é o pondo onde você irá fatiar, neste caso. Portanto, se você fizer:

>>> hex(b).split('x')
['0', 'ac6cad']

então a primeira posição [0] contém '0' e a segunda posição [1] contém ['ac6cad'].


Bem... espero ter ajudado no começo....

Qualquer outro tipo de conversão hex-int ou int-hex necessário, por favor, deixem um comentário que terei prazer em incluir neste tópico.

Introdução ao Python 3 - A Escolha

Estou muito contente em iniciar esse blog, pois tenho certeza que ajudarei muitas pessoas que, como eu, buscaram ajuda por aí e tiveram que "rebolar" pra achar uma resposta.

Já vou avisando que não sou um Super Sayajin no Python, mas meu poder de luta é quase oito mil.

Pois bem. A primeira opção que fiz ao entrar no mundo do Python foi escolher trabalhar com as versões 3.x, uma vez que todos usam as 2.x por N razões.

Entretanto, essa foi a principal razão de eu não cair pra esse lado. Pensei assim: "Serei um dos pioneiros a utilizar o Python 3.x então, quando ele se tornar popular, já serei pelo menos o Tenshinhan, quase chegando a ser o Guririn."

Darei então aqui algumas dicas começando por conversores de valores (a primeira m$%#@ que você via enfrentar no Python3).

Então!!! Aqui vamos nós!!