segunda-feira, 3 de outubro de 2016

Dividir para conquistar: split(' ')



Muito bem. Um comandinho muito bacana presente em várias linguagens, não poderia faltar no nosso querido e amado Python, não é?
Ele é o split (do inglês: dividir).

Por exemplo:

Tenho a seguinte string:

biografia = 'Chuck Norris,10031940,Ryan,Oklahoma,EUA'

Poxa vida! Tenho muita informação numa variável só! E se eu quiser manipular esses dados de uma forma mais legal?
Simples: split nele!!!
Note que o que separa as informações é uma vírgula (pode ser ponto e vírgula, hífen, espaço, ponto, qualquer caractere).
Então eu uso o split e digo a ele: Mermão! Separa essa string onde houver vírgulas!
Isso em Pythonês é assim:

>>> biografia = biografia.split(',')
>>> biografia
['Chuck Norris', '10031940', 'Ryan', 'Oklahoma', 'EUA']

Legal né?
Agora fica mais fácil de manipular:

>>> nome = biografia[0]
>>> nome
'Chuck Norris'
>>> nascimento = biografia[1]
>>> nascimento
'10031940'
>>> cidade = biografia[2]
>>> cidade
'Ryan'
>>> estado = biografia[3]
>>> estado
'Oklahoma'
>>> pais = biografia[4]
>>> pais
'EUA'


Nem doeu, né?

Dúvidas? Reclamações? Sugestões? Zoações?

Deixe os comentários aqui!!!

E lembrem-se:

É....
esqueci...

sexta-feira, 11 de março de 2016

IMPORTANDO FUNÇÕES E CLASSES FEITAS POR MIM (Bibliotecas)



Pessoas, boa vida!

#ESSA DICA É EXCLUSIVA PARA USUÁRIOS WINDOWS

Uma das dificuldades que tive quando comecei a desenvolver em Python foi para importar funções e classes de arquivos externos.

Quando o arquivo .py está na mesma pasta, isso é bem simples. Basta dar um import com o nome do método ou classe que deseja que tá tudo certo.
No entanto, se o arquivo estiver em outra pasta, começa a complicar.

Vou mostrar aqui duas maneiras para se fazer isso:

1) Utilizando o SYS PATH:


Importamos a biblioteca SYS e executamos o comando SYS.PATH.INSERT para inserir o diretório (pasta) onde se encontram os arquivos que desejamos importar.
O número 1, é pra informar que vamos adicionar ao system path o caminho informado.

import sys

sys.path.insert(1,'C:\\Users\\KamiSama\\Dev\\Python\\Python\\commands\\diagnostic')
sys.path.insert(1,'C:\\Users\\KamiSama\\Dev\\Python\\Python\\socket')

Nesse caso, o Python adiciona o caminho à lista de endereços que ele busca para importar as bibliotecas.

2) Inserir o caminho diretamente no PATH do Windows.


Quem utiliza as versões de Windows 7, 8 ou 10, basta clicar em "Iniciar" e digitar "Variáveis de ambiente do sistema" e dar Enter quando aparecer o resultado da busca.

Figura 1: Busca por "Variáveis de ambiente do sistema" no Windows 10.
Aparecerá uma tela com as propriedades do sistema, onde você clicará no botão Variáveis do Sistema, seguindo os passos abaixo:

Figura 2: Propriedades do Sistema - Windows 10


Figura 3: Variáveis de ambiente  - Windows 10
Figura 4: Editar variável de ambiente - Windows 10

ATENÇÃO: Caso esteja utilizando o Windows 7, a tela para inserir o caminho da sua pasta é diferente. Para inserir o caminho, clique duas vezes sobre o 'Path', vá até o fim da linha, coloque o caractere ponto e vírgula (;) e insira o endereço, como a seguir:

Figura 5: Variáveis de ambiente - Windows 7
Figura 6: Editar Variável de Sistema - Windows 7

SUCESSOOOOOOO!!!

Figura 7: Exemplo de import 


Você já pode importar suas tão queridas pastinhas sem precisar passar o endereço toda vez que for utilizá-las!

#FicaADica


segunda-feira, 13 de julho de 2015

Criando um executável (.exe)

Olá pessoas.


Desculpem a demora, mas o final de semestre na faculdade estava me bloqueando.

Vou tentar tirar o atraso (no sentido não figurado) agora nas férias escolares.

Pois bem. Todo mundo quer criar um programa e sair espalhando por aí entre os amiguinhos, não é verdade?

Mas os amiguinhos não querem, de maneira geral, instalar o Python pra poder executar o código (muitos até querem mas não fazem ideia do que é isso, pois o poder de luta deles é menor que o do Chaos e do Oolong)



Então, como fazer pra fazer? MUITO SIMPLES: Criamos um executável!!!

Sim, senhor escrevedor desse blog. Mas como faço isso?

Acalme-se, jovem leitor! Aqui vai a explicação:

Existe uma ferramenta chamada CX_FREEZE que faz isso pra você. Faça o download adequado para a versão de Python que você está utilizando, instale e... voilà!

Depois de instalado, você precisa criar um arquivo de nome setup.py que deve ser armazenado na mesma pasta onde está o arquivo .py que você deseja transformar em .exe.
Vamos cirar um hello_world.py:

print("Hello World\n")


O arquivo setup.py deve ser:

from cx_Freeze import setup, Executable

setup(
    name="Hello World EXECUTABLE",
    version = "1.0.0",
    description = ".py to .exe",
    executables = [Executable("hello_world.py")])


Ôpa! Mas senhor escrevedor desse blog! Eu executei esse código e nada aconteceu!!!

Já disse pra se acalmar, jovem leitor! Não execute esse código!

Você precisa fazer o que se segue:

  1. Abra um prompt do MS-DOS (cmd)
  2. Acesse o local do arquivo setup.py
  3. execute a linha de comando python setup.py build

Agora sim está pronto o seu hello_world.exe!!!
Note que será criada uma pasta build dentro da pasta onde está o seu código. Dentro desta pasta tem uma outra pasta contendo todos os arquivos necessários para a execução do seu programa.

—IMPORTANTE—

Quando for enviar aos seus coleguinhas o seu programa, não envie apenas o executável (*.exe). Ele precisa de todos aqueles outros arquivos dentro da pasta build para ser executado, portanto, compacte a pasta e diga para seus coleguinhas extraírem tudo para que o seu programa funcione.

E não se esqueça: 13 de julho é o quê, Torloni???



quinta-feira, 30 de abril de 2015

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.
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:

>>> forin  lista1:    print(i)

Cell
Freeza
Majimboo
Piccolo
Vegeta
>>> for 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!

terça-feira, 21 de abril de 2015

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!

segunda-feira, 20 de abril de 2015

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!

domingo, 12 de abril de 2015

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 é?