SSH com paramiko

em mai 20 2013 | Ferramentas, Módulos, Programação

SSH é um protocolo de rede criptografado que realiza conexão segura entre computadores e permite executar comandos remotamente. Em diversas situações é necessário automatizar o processo de conexão e execução de comandos em um computador remoto.

Com esta necessidade descobri o Paramiko, um módulo Python que fornece um interface ao protocolo SSH2. Para instalar o Paramiko é necessário instalar antes o PyCrypto, que pode ser encontrado via easy_install ou no repositório da sua distribuição Linux. Encontrei algumas dificuldades para instalar o pycrypto no Windows, por sorte existem alguns binários compilados do pycrypto: http://www.voidspace.org.uk/python/modules.shtml#pycrypto

Depois é só instalar o paramiko via easy_install ou procurando no repositório da distro Linux.

O paramiko tem uma classe base que fornece toda a interface para comunicação: paramiko.SSHClient. Para criar um objeto e criar uma conexão com um servidor é bem simples:

import paramiko
ssh = paramiko.SSHClient()
ssh.connect('127.0.0.1', username='anderson', password='123')

Neste exemplo, a função ‘connect’ está conectando ao servidor SSH local, passando nome de usuário e senha através dos parâmetros ‘username’ e ‘password’, respectivamente.

Quando você conecta em um servidor ssh pela primeira vez, uma chave é automaticamente armazenada em disco num arquivo chamado “.ssh/known_hosts” na sua pasta home. Para isto é preciso o usuário, manualmente, aceitar o armazenamento da chave do servidor, confirmando a confiabilidade deste. Para fazermos isso automaticamente através do Paramiko, utilizamos o objeto “set_missing_host_key_policy”, passando “paramiko.AutoAddPolicy()” como parâmetro para aceitar automaticamente as chaves. Então, nosso código anterior pode ser modificado:

import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('127.0.0.1', username='anderson', password='123')

Tenha o cuidado de somente utilizar este artifício com servidores que você confia.

Enviando comandos via ssh

Já aprendemos como conectar em um computador remotamente via ssh. Agora vamos ver como enviar comandos e receber os resultados destes comandos. Isto é feito com o método “exec_command” do SSHClient(). Este método retorna uma tupla de objetos (stdin, stdout, stderr) que você pode ler (no caso do stdout e stderr) ou escrever (stdin). A sintaxe para executar um comando é a seguinte:

stdin, stdout, stderr = ssh.exec_command('ls\n')

Que vai enviar o comando ‘ls’ para listar os arquivos do diretório atual. Para exibir o retorno deste comando podemos ler o conteúdo do objeto stdout:

print stdout.readlines()

Para fechar a conexão ssh, fazemos:

ssh.close()

Em alguns casos precisamos enviar outras informações para execução do comando, como por exemplo uma senha de administrador. Podemos fazer isto escrevendo no objeto stdin.

stdin, stdout, stderr = ssh.exec_command('sudo fdisk -l\n')
stdin.write('1234\n')
stdin.flush()
print stdout.readlines()

O retorno dos comando pode ser tratado com as poderosas ferramentas de manipulação de string de Python, ou ainda filtradas com expressões regulares, dando ainda mais opções ao programador na hora de criar um script completo. Em outro post darei mais detalhes sobre a utilização do Paramiko.

Nenhum comentário

Como criar um crawler pra Twitter

em fev 07 2012 | Programação, Tutorial, Web

Neste post vamos criar um crawler para recuperar tweets públicos. Tweets públicos são aqueles que não necessitam de autenticação, ou seja, não é necessário ter uma conta no Twitter para ler esses tweets. Com Python, é bem simples recuperar qualquer status do Twitter, para isso, vamos utilizar o pacote python-twitter, que pode ser instalado via setuptools:

$ easy_install python-twitter

Ou, pode ser baixado neste link. Para instalar, extraia o conteúdo, vá até a pasta onde foi extraído e faça:

$ python setup.py build
$ python setup.py install

O python-twitter provê acesso a API do Twitter via código Python.

Para ler a Api e buscar ajuda, faça:

$ pydoc twitter.Status
$ pydoc twitter.User
$ pydoc twitter.DirectMessage

Para começar a utilizar o python-twitter, basta importar o pacote e criar uma instância da classe twitter.Api():

import twitter
api = twitter.Api()

Então, é possível obter os últimos tweets públicos facilmente com a função GetPublicTimeline, que retorna uma lista contendo em torno de 20 objetos do tipo twitter.Status, o texto do tweet em si está no atributo text:

tweets = api.GetPublicTimeline()
for tweet in tweets:
    print tweet.text

Agora, para recuperar os 20 últimos tweets de um usuário específico, existe a função GetUserTimeline. Trocando ‘user‘ por um usuário real do twitter no código abaixo, você obtém uma lista semelhante a que foi retornada pela função GetPublicTimeline:

user_tweets = api.GetUserTimeline('user')
for tweet in user_tweets:
    print tweet.text

A função GetUserTimeline permite configurar a quantidade de tweets a serem recuperados através do parâmetro count:

user_tweets = []
tweets = api.GetUserTimeline(user, count=30)
for tweet in tweets:
    user_tweets.append(tweet.text.encode('utf-8') + '\n')
print user_tweets

Neste código utilizei a função encode para imprimir caracteres especiais em português.

Você pode encontrar mais detalhes das funções mostradas aqui na documentação da API, basta fazer no terminal:


$ pydoc twitter.Api

11 comentários

Python – Dividindo uma lista em n partes

em jan 18 2012 | Programação

frequentemente eu uso esse código, então ao invés de ir no código antigo vou neste post.
Basicamente o que eu quero é o seguinte: Tenho uma lista e quero dividir em n partes quase-iguais. Explico

Suponha a lista [1,2,3,4,5,6,7,8,9,10] quero dividir a lista em 5 partes.

A divisão da lista resultaria em [1,2], [3,4], [5,6], [7,8], [9,10]

Ok, isso é chato de fazer…

Mas vamos ao código.

#A lista
lista = [1,2,3,4,5,6,7,8,9,10]

#quebrando tudo
def quebrador(lista,partes):
    return list(lista[ parte*len(lista)/partes:(parte+1)*len(lista)/partes ] for parte in range(partes))
print quebrador(lista,5)
print quebrador(lista,2)
print quebrador(lista,10)
print quebrador(lista,0)

É possível que ocorrram variações para o tipo de lista.

original: http://romulojales.com/python-dividindo-uma-lista-em-n-partes

Nenhum comentário

Python e lambda

em jan 16 2012 | Core

Sabe lambda? Lambda é algo muito legal. Com lambda você pode criar em tempo de execução funções e fazer algumas graças.

Vejamos algo bonito com lambda. Suponha a função fatorial.

A função fatorial é definida tal que dado um número x o fatorial deste número é:

x*(x-n) com n variando de (x-1) até 1.

Logo podemos traduzir num código python:

def fatorial(x):
 if x<=1:
   return 1
 else:
   return x*fatorial(x-1)

Esse código usa recursão, espero que você saiba o que é recursão… ;)

Bom, com lambda esse mesmo código pode ter apenas uma linha, duvida?

fatorial = lambda x: 1 if x <=1 else x*fatorial(x-1)

Definimos em fatorial uma função que executa o calculo de um fatorial de um dado número x.

Agora abra o seu interpratador python copie e cole o código para testar. Né lindo?

Python tanto na versão 2 quanto na versão 3 define lambda com um atalho para criação de funções. A sintaxe é definida assim:

lambda_form  ::= "lambda" [parameter_list]: expression
old_lambda_form ::=  "lambda" [parameter_list]: old_expression

Vou ler para você: uma expressão lambda é formada pela palavra reservada lambda seguida por uma lista (não o objeto lista) de parametros seperada por “:” e a expressão.

No nosso código a cima, fatorial é o nome da expressão lambda. O python sabe que a função é um lambda porque você disse isso usando a string lambda logo no inicio da expressão.

O x é o parametro. Se você quisesse passar mais parametros, bastava separa-lo por virgulas. Assim:

funcao = lambda x,y,z: x+y+z

pergunta, qual o retorno de funcao(1,2,3) ?

Agora a parte mais difícil, a expressão.

A expressão é como você vai manipular os parametros para ter um retorno. Com lambda não é necessário por a palavra reservada return.

Essa expressão só pode ser de três formas:

  • Uma comando de uma linha (x+1)
  • outra expressão lambda.
  • Ou uma expressão condicional. (incluem testes de lógica [or, and, not] )

No fatorial eu usei uma expressão condicional. Na funcao eu usei uma expressão de uma linha. E poderia usar outra expressão lambda.

Mas para memorizar, você deve escrever a sua expressão sempre com uma linha.

Você pode fazer uso de recursão e uso avançados de exepressão.

original : http://romulojales.com/python-e-lambda/

Nenhum comentário

Tornando o Vim uma IDE amigável pra Python

em jan 10 2012 | Ferramentas, Programação, Tutorial

Em um post anterior eu falei sobre como habilitar o auto-complete no vim pra código em python. Recentemente encontrei um post num blog com dicas mostrando como tornar o vim numa IDE completa pra Python. Testei algumas funcionalidades que tornaram o vim bem amigável pra programar e gerenciar código. Fiz todos os testes no Ubuntu, em outros sistemas Linux deve ser similar. Neste post vou passar essa experiência que tive configurando e usando o vim para criar código python.

Antes de tudo, instale os pacotes vim-full e vim-python se estiverem disponíveis nos repositórios do seu sistema. As configuração no vim são feitas num arquivo chamado vimrc, nas últimas versões do Ubuntu ele fica localizado na pasta /etc/vim e precisa ser root para modificá-lo.

Destaque de código

Para habilitar highlighting (destaque do código) no vim adicione a seguinte linha no arquivo vimrc:

syntax on

No seu arquivo vimrc pode ser que esta linha venha comentada e acompanhada das seguintes linhas:

if has("syntax")
    syntax on
endif

Basta descomentar estas linhas que o highlighting ficará disponível.

Indentação

Como a indentação em Python é fundamental, sem ela podem ocorrer erros no código, uma ide que  tenha auto-indentação é ideal.  No arquivo vimrc procure as seguintes linhas e descomente ou adicione se elas já não estiverem no arquivo:

" Habilita auto-indentação
if has("autocmd")
 filetype plugin indent on
endif

Número de linhas

Para exibir o número das linhas no vim adicione o seguinte no vimrc:

" Habilitar número de linhas
set number

" Alternar exibição de número de linhas (facilita na hora de copiar)
nnoremap <F2> :set nonumber!<CR>: set foldcolumn=0<CR>
Vim com highlighting para Python e número de linhas

Vim com highlighting para Python e número de linhas



Navegação pelo código


Uma funcionalidade muito útil é a navegação pelo código. Com esta ferramenta habilitada é possível ver todas as classes e funções presentes no seu código e poder pular automaticamente pra qualquer uma delas.


Primeiro, é preciso instalar o pacote exuberant-ctags, disponível no repositório com este mesmo nome. Depois, baixe o taglist, que é um plugin do vim. Coloque o arquivo taglist.vim na pasta ~/.vim/plugin e o taglist.txt na pasta ~/.vim/doc, vá até esta última pasta, inicie o vim e rode :helptags. (com ‘.’ no final) e já estará instalado.


Vim com code explorer
Code Explorer para o Vim


Agora é preciso fazer algumas alterações no vimrc:


" Exibe nome da função
let g:ctags_statusline=1
" Inicializar script automaticamente
let generate_tags=1
" Exibe os resultados em uma janela vertical
let Tlist_Use_Horiz_Window=0
" Atalho para exibição da Taglist
nnoremap TT :TlistToggle<CR>
map <F4> :TlistToggle<CR>
" Configurações para exibição da Taglist
let Tlist_Use_Right_Window = 1
let Tlist_Compact_Format = 1
let Tlist_Exit_OnlyWindow = 1
let Tlist_GainFocus_On_ToggleOpen = 1
let Tlist_File_Fold_Auto_Close = 1



A Taglist estará disponível através do atalho F4 ou digitando “TT” (dois ‘t’ maiúsculos)

As últimas configurações servem para exibir uma janela vertical à direita mostrando a taglist e ganhar foco quando é chamada.


Ocultar Código


Quando o seu código começa a ter muitas funções e classes fica difícil ter uma visão geral do que está disponível no código. A maioria das IDE’s possuem uma funcionalidade para ocultar parte do código e mostrar somente a assinatura ou definição de classes e funções.


No Vim isso é possível através de um plugin. Para instalá-lo baixe o arquivo neste link, crie uma pasta chamada ftplugin dentro da pasta ~/.vim e copie o plugin para a pasta ftplugin. A tecla ‘F’ (<Shift> + f) oculta ou exibe todo o código dentro de funções e classes, enquanto que a tecla ‘f” exibe ou oculta o código onde está o cursor.


Ocultar código automaticamente no Vim
Ocultar código no Vim


Project Explorer


Essa é uma das principais funções de uma IDE: organizar seu projeto. No Vim é preciso instalar o plugin NerdTree, que pode ser baixado aqui. Para instalar basta extrair o conteúdo do arquivo .zip na pasta ~/.vim. Rode  :helptags. (com ‘.’ no final) e rode :help NERD_tree.txt para ver o arquivo de ajuda. Pra utilizar o plugin digite :NERDTree e será aberta uma janela com o conteúdo da pasta atual.


Na página de scripts do vim, você pode encontrar outros plugins de Python para o vim. Se você testar algum outro plugin ou tiver uma funcionalidade interessante que eu não comentei no post, deixe sua experiência nos comentários.



											
										
                    	


            

              Um comentário            
          
	        

      	        

            
Criando um crawler pra páginas HTML com BeautifulSoup

        

		
              
						 em dez 31 2011 | Programação, Tutorial, Web				               

	

	

              

											
										
Neste post vamos aprender a como criar um crawler pra recuperar páginas HTML utilizando o BeautifulSoup com Python. O BeautifulSoup pode ser usado para arquivos HTML ou XML, com ele fica muito simples navegar e buscar textos em páginas HTML. Uma grande vantagem da BeautifulSoup é que ela consegue criar uma estrutura mesmo com páginas html mal formatadas, facilitando o trabalho do programador.


Inicie o interpretador Python para testar os códigos que vamos apresentar a seguir.


Para processar páginas HTML, importe o BeautifulSoup da seguinte forma:


from BeautifulSoup import BeautifulSoup



Se você for processar arquivos XML:


from BeautifulSoup import BeautifulStoneSoup



Por enquanto vamos processar apenas páginas html.

Vamos usar a biblioteca urllib2 para recuperar uma página html.


import urllib2
pagina = urllib2.urlopen("http://www.globo.com").read()



Isso vai criar uma string com todo o código html da página.

Então, para criar o parser basta:


soup = BeautifulSoup(pagina)



É possível transformar esse objeto BeautifulSoup em string com o método prettify, que manipula o código bruto adicionando quebra de linha e espaçamento recriando a estrutura do código html.


soup.prettify()



Para listar todos os links da página recuperada, usamos o método findAll:


links = soup.findAll('a')



Neste código, ‘links‘ é uma lista contendo objetos do tipo Tag da biblioteca BeautifulSoup (class BeautifulSoup.Tag). Vamos agora, listar somente os links (tirando qualquer texto ou marcação) que estão nesses objetos Tag:


for link in links:
    print link['href']



Para recuperar somente uma área da página, é possível usar o método find com o parâmetro id, por exemplo:


colunas = soup.find(id="glb-area-colunas")
linkscol = colunas.findAll('a')
for link in linkscol:
    print link['href']



A biblioteca BeautifulSoup facilita muito na hora de criar parsers e crawlers para páginas html ou xml. Usada junto com o urllib2 são poderosos aliados na recuperação de informação na web.



											
										
                    	


            

              Nenhum comentário            
          
	        

      	        

            
Palestra sobre canivete suíço de Python

        

		
              
						 em dez 04 2011 | Ferramentas, Programação				               

	

	

              

											
										
Esta semana tive a oportunidade de ministrar uma palestra para os alunos da Farec (Faculdade do Recife) falando sobre o Python, incluindo biblioteca padrão, pacotes e frameworks úteis para todo tipo de projeto. Fiz um apanhado geral de Python para que os alunos se interessassem um pouco mais pela linguagem. A seguir estão os slides:


Canivete python






											
										
                    	


            

              Um comentário            
          
	        

      	        

            
Tutorial básico de NumPy

        

		
              
						 em out 25 2011 | Ferramentas, Programação, Tutorial				               

	

	

              

											
										
NumPy é um pacote de Python que  suporta operações com vetores e matrizes e é essencial para a computação científica com Python. O NumPy é baseado em C, portanto tem um desempenho superior se comparado às operações com vetores originais do Python. Neste post eu quero mostrar uma introdução básica ao NumPy para os iniciantes.


INSTALAÇÃO


Primeiro vamos instalar o NumPy. No Windows, basta baixar a última versão do numpy no site do SourceForge e instalar facilmente com o arquivo .exe. No Linux, instale o pacote “python-numpy” ou mesmo usando o easy_install numpy.


Pronto, agora é só abrir o console Python e importar o pacote:


>>> import numpy as np


CRIAÇÃO DE ARRAY


Para criar um array, é bem simples:


>>> a = np.array([0,1,2,3,4,5])
>>> a
array([0,1,2,3,4,5])




A função array do NumPy, recebe uma lista de Python e transforma em um array NumPy. Você pode checar o tipo:


>>> type(a)



E o tipo dos elementos:


>>> a.dtype



Para criar matrizes multidimensionais é bem simples também:


>>> a = np.array([[0,1,2,3], [4,5,6,7], [8,9,10,11]])



A função arange é bem parecida com a função range, só que retorna um array ao invés de uma lista:


>>> x = np.arange(11.)
array([  0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])



É possível definir mais parâmetros pra função arange:


>>> x = np.arange(10, 30, 5) #(limite inferior, limite superior, passo)
array([10, 15, 20, 25])



TAMANHO DO ARRAY


A propriedade shape mostra o tamanho de cada dimensão da matriz:


>>> a.shape
(3,4)



É possível, também, modificar essa propriedade:


>>> a.shape = (2,6)
>>> a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])



ACESSANDO ELEMENTOS


Para acessar elementos:


>>> a[1,3]
9



É possível acessar vários elementos ao mesmo tempo:


>>> a[0,3:5]


matriz de inteiros
Fonte: SciPy 2011 - Jonathan Rocher


 array([3, 4])


>>> a[4:,4:]

 array([[44, 45],

 [54, 55]])


>>> a[:,2]

 array([2,12,22,32,42,52])


>>> a[2::2,::2]

 array([[20, 22, 24],

 [40, 42, 44]])


MATRIZ TRANSPOSTA


Para obter a matriz transposta existem duas formas:


>>> a.transpose()
>>> a.T
array([[ 0, 4, 8],
 [ 1, 5, 9],
 [ 2, 6, 10],
 [ 3, 7, 11]])



FUNÇÕES IMPORTANTES


A função sum soma todos os elementos do array:


>>> np.sum(a)
66



Podemos usar o parâmetro axis e determinar em qual eixo queremos a soma:


>>> np.sum(a, axis=0)
array([12, 15, 18, 21])
>>> np.sum(a, axis=1)
array([ 6, 22, 38])



Alternativamente, podemos usar o método sum:


>>> a.sum()
66
>>> a.sum(axis=0)
array([12, 15, 18, 21])



As funções amin e amax retornam o valor mínimo e o valor máximo do array, respectivamente:


>>> b = np.array([3.4, 5., 33., 8.])
>>> np.amin(b)
3.4
>>> np.amax(b)
33.0



argmin e argmax retornam o índice do menor valor e do maior valor do array, respectivamente:


>>> b.argmax()
2
>>> b.argmin()
0



O atributo flat retorna um iterator que permite acessar elementos de um array multidimensional como se ele fosse uma lista:


>>> a = np.array([[0,1,2,3], [4,5,6,7], [8,9,10,11]])
>>> a.flat
<numpy.flatiter object... >
>>> a.flat[:]
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])



Existem ainda outras diversas funções que podemos explorar em outro post.



											
										
                    	


            

              Nenhum comentário            
          
	        

      	        

            
Entendendo Decorators de forma simples

        

		
              
						 em out 24 2011 | Programação, Tutorial				               

	

	

              

											
										
O que é quando usar um decorator:


Sabe aquela trecho de código que vive se repetindo no seu código e você acha um saco ter repetir? Imagine que esse trecho repetido necessite uma refatoração e imagine que seu projeto é grande você já começa a vislumbrar um cenário caótico.


As boas práticas de programação tentam prevenir este tipo de problema. Mas tem horas que nem o seu mega modelo resolve. Um caso simples é quando o trecho de código que se repete necessita de parametrização ou muda de acordo com o contexto.


Decorators são uma tentativa de “economizar” código, manter a sanidade e as boas práticas de programação. Ok, eu sei que a razão principal de um decorator não é essa. Dá uma passada na PEP para descobrir mais. O lance é meio inception. Então eu curto a minha explicação… ;) 


Então, se você viu um @ em cima de um método no código. Parabéns, você já sabe o que é um decorator e provavelmente já utiliza.


Criando um decorator:


- “mas eu quero criar um decorator”


Ok. Para fazer isso é simples:


Defina um método cujo o parametro será a assinatura de uma função decorada.


Então brinque com a função e retorne a função ou outra função. Lindo não? (se lembra que eu disse que era meio inception?)


Mas o decorator é isso mesmo. É um cara que vai pegar sua função bonitinha é modifica-la. Ou mesmo desfigura-la. Vou mostrar como cria um decorator brincando.


Suponha que você criou uma função de somar:


def sum(a,b)
  return a+b



Função linda! Bom agora vou bagunçar a vida do cidadão que usa essa função e fazer que a soma seja a – b. Mas eu não quero perder o código original. Isto é um trabalho para o decorador:


def bagunca(funcao):
  def subtrai(a,b):
   return a-b
 return subtrai

@bagunca
def sum(a,b):
  return a+b



Bom, agora deixo com vocês executarem o código no terminal e compreende que aconteceu com a função sum. Acredito que desta forma você compreenderá o uso do decorator.


até a próxima,



											
										
                    	


            

              Nenhum comentário            
          
	        

      	        

            
Transformando seu código Python em executável com o py2exe

        

		
              
						 em set 14 2011 | Ferramentas, Programação, Tutorial				               

	

	

              

											
										
Em diversas situações é necessário criar um arquivo executável a partir do seu código. Às vezes é preciso entregar um programa a um cliente que não tem Python instalado ou não tem as diversas bibliotecas que você usou pra criar sua aplicação. Ou até mesmo no caso de você querer usar o seu programa em qualquer outra máquina Windows sem precisar da instalação do Python. Neste post vamos fazer um tutorial sobre como fazer isso utilizando o py2exe.


INSTALAÇÃO


O primeiro passo é instalar o py2exe. Pra isso basta ir ao site e baixar a última versão. Baixe a versão para o seu Windows (32 ou 64 bits) e de acordo com a versão do python (2.5, 2.6, 2.7…).  A instalação é simples e padrão. Após a instalação adicione a pasta de scripts ao PATH do sistema, geralmente C:\Python27\Scripts.


TUTORIAL


Primeiro vamos escrever um código qualquer em Python. Você pode escrever um código importando qualquer pacote, desde que este esteja instalado no seu sistema. Para este exemplo você pode escrever seu próprio código, eu vou dar um simples exemplo utilizando a biblioteca matemática do Python, crie um arquivo em qualquer pasta chamado calc.py e escreva o seguinte código:


import math
def main():
    modelo = raw_input("Digite 1 para seno e 2 para cosseno: ")
    n = raw_input("Entre com um número: ")
    choice = int(modelo)
    num = float(n)

    if choice == 1:
        print math.sin(num)

    elif choice == 2:
        print math.cos(num)

if __name__ == "__main__":
    main()



Teste o seu código:


C:\Pythonize> python calc.py


O segundo passo é criar um script de setup. Crie um arquivo chamado setup_calc.py na mesma pasta que você salvou o código anterior e escreva este código:


from distutils.core import setup
import py2exe
setup(console=['calc.py'])



Pronto, para criar seu arquivo executável, rode seu script:


C:\Pythonize> python setup_calc.py py2exe


Serão criadas duas pastas: build e dist. A pasta build é usada somente para compilar o código e criar o executável e pode ser excluída após o término do processo. A pasta dist contém os arquivos necessários para rodar sua aplicação. Agora você pode testar seu executável:


C:\Pythonize>cd dist


C:\Pythonize\dist>calc.exe


Digite 1 para seno e 2 para cosseno: 1


Entre com um número: 4


-0.756802495308


Funcionando muito bem!


Se você quer distribuir seu programa e levar para outro computador Windows, é preciso levar toda a pasta dist para que sua aplicação funcione corretamente. Para outras informações, veja o tutorial do py2exe.


Para utilizar o py2exe com outros pacotes e módulos, veja o link: Working with Various Packages and Modules.



											
										
                    	


            

              2 comentários            
          
	        

            
	

Página 1 de 212