Krix Apolinário » Python

Lançado Python 2.7

Krix Apolinário — Tue, 06 Jul 2010 17:26:28 +0000

A equipe de desenvolvimento Python anunciou ontem o lançamento da versão final do Python 2.7 e será a última versão principal da série 2.x, contudo será também um período extendido para correção de bugs.

Esta nova versão inclui muitos recursos que foram liberados primeiramente no Python 3.1.

Para ver com mais detalhes as alterações nesta versão acesse aqui.

É isso gente vim só avisar

Alguns Exercícios em Python – Parte 2

Krix Apolinário — Wed, 31 Mar 2010 12:29:54 +0000

Oie pessoal, dando continuidade a sequência de exercícios, conforme expliquei no post de ontem, hoje irei colocar mais duas questões.

Estou procurando colocar o script de forma mais auto-explicativa possível e comentando, mas qualquer dúvida que possa existir, pode perguntar, seja aqui nos comentários, na página contato ou por email, ok?

Então vamos as questões:

Contruir um script que receba o código de N produtos e o classifique de acordo com a tabela abaixo:

Código	Classificação
1	Alimento não-perecível
2 a 4	Alimento perecível
5 e 6	Vestuario
7	Higiene Pessoal
8 a 15	Limpeza e utensilios domésticos

A quantidade N de produtos deve ser fornecida ao programa.

#!/usr/bin/env python
 
# Krix Apolinario - krix@krix.com.br
# Created: Tue 31 Mar 2010 08:36:03 AM BRT
# Last Change: Wed 31 Mar 2010 09:23:55 AM BRT
# Description: Script que recebeo codigo de N produtos e o classifica de acordo com uma tabela.
 
if __name__ == "__main__": 
	try:
		# Recebendo quantidade de produtos.
		quantidade = int(raw_input('Informe a quantidade de produtos: '))
		# Inicio do laco para perguntar as N vezes, onde N e a quantidade de produtos a consultar.
		while quantidade != 0:
			# Recebendo codigo do produto.
			codigo = int(raw_input('\nInforme o codigo do produto: '))
			# Inicio da classificacao do produto por codigo.
			if codigo == 1:
				print '\nAlimento nao-perecivel'
			elif codigo >= 2 and codigo <= 4:
				print '\nAlimento perecivel'
			elif codigo >= 5 and codigo <= 6:
				print '\nVestuario'
			elif codigo == 7:
				print '\nHigiene Pessoal'
			elif codigo >= 8 and codigo <= 15:
				print '\nLimpeza e utensilios domesticos'
			else:
				print '\nCodigo Invalido'
			# Subtraindo 1 da quantidade.
			quantidade = quantidade - 1
	except:
		print 'Ooops... Favor verificar se os dados informados estao corretos.'

Elabore um script para calcular a média ponderada de três notas de um aluno, sabendo que os respectivos pesos são 2, 3 e 5.

#!/usr/bin/env python
 
# Krix Apolinario - krix@krix.com.br
# Created: Tue 30 Mar 2010 09:24:06 AM BRT
# Last Change: Tue 30 Mar 2010 09:47:43 AM BRT
# Description: Script para calcular a media ponderada entre tres notas, onde os pesos sao: 2, 3 e 5.
 
if __name__ == "__main__": 
	try:
		#  Recebendo as notas.
		nota1 = float(raw_input('Informe a nota 1: '))
		nota2 = float(raw_input('Informe a nota 2: '))
		nota3 = float(raw_input('Informe a nota 3: '))
		# Calculando a media ponderada.
		media = float(((nota1*2)+(nota2*3)+(nota3*5))/(2+3+5))
		# Exibindo o resultado.
		print media
	except:
		print 'Ooops... Favor verificar se os dados informados estao corretos.'

Bom gente amanhã coloco mais outras questões, ainda faltam 4.

Até amanhã

Alguns Exercícios em Python – Parte 1

Krix Apolinário — Tue, 30 Mar 2010 14:24:08 +0000

Oie gente, tudo bonzinho?

Ontem uma amiga minha me pediu uma ajuda para fazer um exercício que o professor da cadeira de Introdução a Programação passou.

Sabemos que no começo é complicado mesmo, mas com o passar do tempo a gente vê que a ‘coisa’ é pior do que estávamos pensando e a tendência é ficar complicado SEMPRE, rsrs

As questões do exercício eram para ser escritos em algoritmo PORTUGOL, maaaaaaas eu ‘intrometida’ resolvi fazer em Python também, contudo fiz isso para que minha amiga começasse a se familiarizar com uma linguagem e acho que Python seria uma ótima opção.

Como são 10 questões irei fazer o seguinte, colocarei 4 hoje e vou colocando as outras aos poucos, ok?

Outra coisa, opiniões seram sem sempre bem vindas.

Então vamos as questões:

Escrever um script que leia um número inteiro e imprima o seu sucessor e seu antecessor:

#!/usr/bin/env python
 
# Krix Apolinario - krix@krix.com.br
# Created: Tue 30 Mar 2010 08:58:19 AM BRT
# Last Change: Tue 30 Mar 2010 09:24:27 AM BRT
# Description: Script para retornar o antecessor e o sucessor do numero informamdo.
 
if __name__ == "__main__": 
	try:
		# Recebendo os numeros.
		numero = int(raw_input('Informe um numero: '))
		# 'Calculando' antecessor e sucessor do numero.
		antecessor = (numero - 1)
		sucessor = (numero + 1)
		# Exibindo o resultado.
		print 'Antecessor: %s \nSucessor: %s' % (antecessor, sucessor)
	except:
		print 'Ooops... Favor verificar se os dados informados estao corretos.'

Escrever um script que leia dois números inteiros e imprima o resultado da soma destes dois valores. Antes do resultado, deve ser impressa a seguinte mensagem “SOMA”

#!/usr/bin/env python
 
# Krix Apolinario - krix@krix.com.br
# Created: Tue 30 Mar 2010 08:58:19 AM BRT
# Last Change: Tue 30 Mar 2010 10:18:30 AM BRT
# Description: Script para somar dois numeros.
 
if __name__ == "__main__": 
	try:
		# Recebendo os numeros.
		numero1 = int(raw_input('Informe o primeiro numero: '))
		numero2 = int(raw_input('Informe o segundo numero: '))
		# Soma os numeros. 
		soma = (numero1 + numero2)
		# Exibe o resultado.
		print 'SOMA %d' % soma
	except:
		print 'Ooops... Favor verificar se os dados informados estao corretos.'

Escreva um script que calcule a área de um terreno a paritr da leitura das dimensões do mesmo. Ao final escreva a área total e as dimensões.

#!/usr/bin/env python
 
# Krix Apolinario - krix@krix.com.br
# Created: Tue 30 Mar 2010 08:58:19 AM BRT
# Last Change: Tue 30 Mar 2010 11:21:28 AM BRT
# Description: Script para calcular a area de um terreno.
 
 
if __name__ == "__main__": 
	try:
		# Recebendo as dimenssoes.
		base = float(raw_input('Informe a base: '))
		altura = float(raw_input('Informe a altura: '))
		# Soma os numeros. 
		area = (base * altura)
		# Exibe o resultado.
		print '''
Base: %s
Altura: %s
Area do terreno: %s
		''' % (base, altura, area)
	except:
		print 'Ooops... Favor verificar se os dados informados estao corretos.'

Escreva um script que leia dois números e efetue a adição. Caso o valor somando seja maior que 20, este deverá ser apresentado somando a ele mais 8; caso o valor somado seja menor ou igual a 20, este deverá ser apresentado subtraindo 5.

#!/usr/bin/env python
 
# Krix Apolinario - krix@krix.com.br
# Created: Tue 30 Mar 2010 08:58:19 AM BRT
# Last Change: Tue 30 Mar 2010 09:34:08 AM BRT
# Description: Script para somar dois numeros e se o resultador for maior que 20 acrescentar 8 senao subtrair 5.
 
if __name__ == "__main__": 
	try:
		# Recebendo os numeros.
		numero1 = float(raw_input('Informe o primeiro numero: '))
		numero2 = float(raw_input('Informe o segundo numero: '))
		# Soma os numeros. 
		soma = (numero1 + numero2)
		# Verificando valor da soma.
		if soma > 20:
			soma = (soma + 8)
		else:
			soma = (soma - 5)
		# Exibe o resultado.
		print '%d' % soma
	except:
		print 'Ooops... Favor verificar se os dados informados estao corretos.'

Bom gente, amanhã faço um post com mais algumas questões.

DreamPie – Novo Shell Para Python

Krix Apolinário — Tue, 23 Feb 2010 13:58:32 +0000

O DreamPie vem com um novo conceito para um shell interativo, onde a janela é dividida em caixa de histórico, que permite visualizar comandos anteriores e sua saída, e a caixa de código, onde você escreve seu código. Você também pode copiar o código de qualquer lugar, editá-lo e executá-lo imediatamente.

Abaixo listei algumas das características dele:

O código fica formatado com um recuo de quatro espaços.

Preenchimento automático de atributos e de arquivo.

Permite-lhe guardar o histórico da sessão como um arquivo HTML. O arquivo pode ser carregado no DreamPie e rapidamente refazer os comandos anteriores.

Suporta interativo com matplotlib.

Suporta Python 2.5, Python 2.6, Jython 2,5, 2,6 IronPython e Python 3.1. Funciona em Windows, Mac e Linux.

Extremamente rápido e responsivo.

Licenciado sob a GPL versão 3.

Para conhecer melhor acesse o site.

PS: Ainda não parei para futucar, só instalei e dei uma leve “olhada”, mas o pouco que eu mexi gostei

Python Para Desenvolvedores – Segunda Edição

Krix Apolinário — Tue, 19 Jan 2010 17:08:02 +0000

Em maio do ano passado postei aqui no blog sobre o lançamento do livro Python Para Desenvolverores de autoria de Luiz Eduardo Borges e hoje eu venho dizer que ele lançou a segunda edição do livro que vem nessa nova edição com 107 páginas a mais, totalizando 360.

Li boa parte da primeira edição infelizmente parei por falta de tempo, mas a leitura desse livro vale a pena.

Novamente parabenizo o Luiz pelo livro e que ele e desejo que ele tenha o merecido reconhecimento.

Para fazer o download do livre acesse aqui.

“Já está disponível para download a segunda edição do livro Python para Desenvolvedores. A primeira edição foi uma iniciativa inédita, sendo o primeiro livro livre em português sobre a linguagem de programação. A publicação é distribuída sob uma licença Creative Commons, que ajuda garantir o direito autoral, ao mesmo tempo que permite copiar, distribuir, exibir e criar obras derivadas, democratizando o acesso ao conhecimento.Com mais de cem páginas a mais que a anterior, a nova edição traz vários assuntos inéditos e uma extensa revisão do conteúdo. Voltado para desenvolvedores que já tem conhecimento de programação, as 360 páginas do livro explicam de forma simples e objetiva, as tecnologias envolvendo a linguagem utilizadas em projetos. Os capítulos abordam entre outros tópicos, interfaces gráficas, aplicações para Internet e sistemas distribuídos.

Luiz Eduardo Borges, analista de sistemas com pós-graduação em Ciência da Computação pela Universidade do Estado do Rio de Janeiro, buscou a criação de um material abrangente, capaz de fornecer ao leitor explicações e exemplos práticos da maior parte do ferramental disponível na linguagem para o desenvolvimento de soluções de problemas comuns e alguns bastante incomuns de computação.”

FONTE

Curso de Python

Krix Apolinário — Sat, 05 Dec 2009 23:25:16 +0000

Oie gente, tudo bonzinho?

Desde setembro o Magnun iniciou em seu blog um curso de Python, tenho acompanhado o curso e a linguagem usada por ele é bem simples o que é ótimo principalmente para aqueles que estão iniciando.

Acesse o link do curso e aproveitem

Arquivos & Python

Krix Apolinário — Thu, 17 Sep 2009 10:03:39 +0000

Algo que venho constantemente usando em meus scripts Python é a manipulação de arquivos, seja criando ou acrescendo textos. Para isso vou usar um exemplo para começar a explicar:

Text = '''
192.168.2.32
192.168.2.63
192.168.2.86
192.168.2.90
'''
 
MyFile = open('/home/krix/list_ips.txt', 'w')
MyFile.write(Text)
MyFile.close()

O código acima cria o arquivo (ou se ele já existe o sobescreve) /home/krix/list_ips.txt inserindo o texto declarado na variável Text e em seguida o fecha. Parece bem simples não é?! E é. A manipulação de arquivos com Python é realmente bem simples.

A sintaxe da função open() é:

open(arquivo[, modo[, tamanho do buffer]])

O primeiro parâmetro arquivo é obrigatório e como se pode ver é o nome e/ou caminho do arquivo a ser aberto;

O segundo parâmetro modo, que não é obrigatório, será uma string que indicará o modo como o arquivo será aberto. São eles:

r (read): O arquivo é aberto somente para leitura. Quando não informado o modo este será o padrão.

MyFile = open('/home/krix/list_ips.txt', 'r')
ReadingFile = MyFile.read()
MyFile.close()
print ReadingFile

w (write): O arquivo é aberto somente para escrita e será bloqueado caso exista subescrevendo seu conteúdo e criado se não existir.

MyFile = open('/home/krix/list_ips.txt', 'w')
MyFile.write(Text)
MyFile.close()

a (append): O arquivo é aberto somente para escrita contudo ao contrário do w que subescreve o conteúdo do arquivo ele irá acrescentar ao arquivo.

MyFile = open('/home/krix/list_ips.txt', 'a')
NewIPs = []
NewIPs.append(Text)
MyFile.write((' '.join(NewIPs))+"\n")
MyFile.close()

Todos os modos acima citados quando seguido do caracter mais (+) o arquivo será aberto tanto para leitura quanto para escrita.

Quando os modos r, w ou a estiver seguido do caracter b ou t isso indicará a forma de manupulação do arquivos, o b indicará que será binário e o t em texto e quando não informado o t será o padrão.

MyFile = open('/home/krix/list_ips.txt', 'w+')

MyFile = open('/home/krix/list_ips.txt', 'wb')

O terceiro parâmetro tamanho do buffer, também não obrigatório, e controla o comportamento do buffer do arquivo. Se 0 não será bufferizado, se 1 será bufferizado e se for um número positivo maior que 1 indicará o tamanho do buffer em bytes.

Acima usamos alguns métodos como o read, write e close mas não falamos nada sobre eles então abaixo irei dá uma definição a eles e a alguns outros métodos que julguei indispensáveis:

read(): Lê o arquivo.

MyFile.read()

readline(size): Lê uma só linha do arquivo. Size será a quantidade de caracteres que será lido na linha.

MyFile.readline()

readlines(size): Lê todas as linhas do arquivo e retorna numa lista. Size será o número de bytes a ser lido.

MyFile.readlines()

write(str): Escreve a string passada no arquivo.

MyFile.write(Text)

writelines(): Escreve no arquivo todas as strings de uma lista.

MyFile.writelines(list)

O que seria o mesmo que:

for line in list:
    MyFile.writelines(line)

close(): Fecha o arquivo.

MyFile.close()

No exemplo que dei mais acima quando falei sobre o modo a você percebeu que usei dois métodos que os quais ainda não tinha comentado, o join e o append. O join tem a função de concatenar uma string a outra o que seria justamente o que eu precisaria no código. O append adiciona um ítem ao final de uma lista. Dadas as definições vamos explicar: Se eu tivesse ignorado o append e usasse somente o join para adicionar o Text ao arquivo será que funcionaria sem problemas? Sim, mas sem problemas?!?! Humm, isso já seria relativo, se eu retirasse e dexasse o código assim:

MyFile = open('/home/krix/list_ips.txt', 'a')
MyFile.write((' '.join(Text))+"\n")
MyFile.close()

O arquivo ficaria assim:

1 9 2 . 1 6 8 . 2 . 3 2
1 9 2 . 1 6 8 . 2 . 6 3
1 9 2 . 1 6 8 . 2 . 8 6
1 9 2 . 1 6 8 . 2 . 9 0

Mas deixando como o exemplo inicial o arquivo ficaria assim:

192.168.2.32
192.168.2.63
192.168.2.86
192.168.2.90

Fico por aqui com o post, acho que já falei demais .

- a para anexar (append);

MyFile = open('/home/krix/list_ips.txt', 'a')
NewIPs = []
NewIPs.append(Text)
MyFile.write((''.join(NewIPs))+"\n")
MyFile.close()

Auto Completar no Interpretador Python

Krix Apolinário — Tue, 15 Sep 2009 09:32:43 +0000

Faz um tempinho que não escrevo nenhum post mas juro que não é má vontade, é que estou resolvendo umas bronquinhas mas prometo que vou procurar ficar mais presente.

Essa semana estava procurando sobre um determinado assunto e acabei encontrando uma dica passada pelo Petry em seu blog (que por sinal eu não conhecia), onde fala sobre o uso do TAB para auto completar as funções no interpretador Python, algo que é muito útil.

Para que fique por padrão em seu interpretador Python crie o arquivo $HOME/.pythonrc e insira o seguinte código:

import readline
import rlcompleter
readline.parse_and_bind('tab: complete')

Você também pode rodar esse código diretamento no interpretador Python mas fazendo isso, sempre que acessar terá que refazer e criando o arquivo não será necerrário. Contudo não podemos esquecer de declarar a variável indicando o local do .pythonrc no .bashrc, então adicione as linhas abaixo no $HOME/.bashrc :

PYTHONSTARTUP="$HOME/.pythonrc"
export PYTHONSTARTUP

Após isso basta restartar o shell e rodar o interpretador Python:

[krix@rogue]$ source /home/krix/.bashrc
[krix@rogue]$ python
Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> str. [TAB+TAB]
str.__add__(                      str.__init__(                     str.__subclasses__(               str.join(
str.__base__(                     str.__instancecheck__(            str.__subclasshook__(             str.ljust(
str.__bases__                     str.__itemsize__                  str.__weakrefoffset__             str.lower(
str.__basicsize__                 str.__le__(                       str._formatter_field_name_split(  str.lstrip(
str.__call__(                     str.__len__(                      str._formatter_parser(            str.mro(
str.__class__(                    str.__lt__(                       str.capitalize(                   str.partition(
str.__cmp__(                      str.__mod__(                      str.center(                       str.replace(
str.__contains__(                 str.__module__                    str.count(                        str.rfind(
str.__delattr__(                  str.__mro__                       str.decode(                       str.rindex(
str.__dict__                      str.__mul__(                      str.encode(                       str.rjust(
str.__dictoffset__                str.__name__                      str.endswith(                     str.rpartition(
str.__doc__                       str.__ne__(                       str.expandtabs(                   str.rsplit(
str.__eq__(                       str.__new__(                      str.find(                         str.rstrip(
str.__flags__                     str.__reduce__(                   str.format(                       str.split(
str.__format__(                   str.__reduce_ex__(                str.index(                        str.splitlines(
str.__ge__(                       str.__repr__(                     str.isalnum(                      str.startswith(
str.__getattribute__(             str.__rmod__(                     str.isalpha(                      str.strip(
str.__getitem__(                  str.__rmul__(                     str.isdigit(                      str.swapcase(
str.__getnewargs__(               str.__setattr__(                  str.islower(                      str.title(
str.__getslice__(                 str.__sizeof__(                   str.isspace(                      str.translate(
str.__gt__(                       str.__str__(                      str.istitle(                      str.upper(
str.__hash__(                     str.__subclasscheck__(            str.isupper(                      str.zfill(
>>> str.

Muito bom não é?! Mas antes de dá esse post como finalizado acho importante falar um pouco sobre os módulos que usamos para que isso ocorresse:

readline: Este módulo permite a edição de linha de comando usando o GNU readline. O módulo readline define algumas funções para facilitar a leitura e escrita de arquivos de histórico do interpretador Python. Este módulo pode ser usado diretamente ou através do módulo rlcompleter, como fizemos aqui. Deste módulo fizemos uso de uma de suas funções a parse_and_bind(string) que, analisar e executar uma única linha de um arquivo.
rlcompleter: Este módulo define uma função de conclusão adequada para o módulo readline completando identificadores válidos Python e palavras-chave.

Agora porque o nome da variável adicionada no .bashrc foi PYTHONSTARTUP e não qualquer outra? Esta é uma variável de ambiente que influencia no comportamento da linguagem onde, o arquivo nela declarado é executado no mesmo espaço interactivo, onde os comandos são executados durante a sessão interativa (no caso o interpretador Python).

Você pode obter mais informações sobre esse e outros módulos e funções aqui.

este módulo permite a edição de linha de comando usando o GNU readline.

Procurando String em Arquivo com Python

Krix Apolinário — Sat, 01 Aug 2009 10:02:53 +0000

Por esses dias fiz um módulo em Python para buscar uma palavra em algum determinado arquivo, pois achei mais viável para o que estava fazendo, então decidi compartilhar com vocês, e para isso fiz também um script, irei mostrar os dois aqui . Opniões serão bem vinda, óbvio .

Script SearchString.py

  1 #!/usr/bin/env python
  2
  3 # Krix Apolinario - krix@krix.com.br
  4
  5 from re import compile
  6 from sys import argv, exit
  7
  8 if __name__ == "__main__":
  9 ····if len(argv) != 3:
 10 ········print 'Usage: %s  ' % argv[0]
 11 ········exit(1)
 12
 13 ····String = argv[1]
 14 ····File = argv[2]
 15
 16 ····try:
 17 ········FileSearch = open(File, 'r')
 18 ········ReadingFile = FileSearch.read()
 19 ········ReadingFile = ReadingFile.split('\n')
 20 ········StringSearching = compile(String)
 21 ········for Line in ReadingFile:
 22 ············FoundString = StringSearching.search(Line)
 23 ············if (FoundString):
 24 ················print Line
 25 ········FileSearch.close()
 26 ········exit(0)
 27 ····except IOError:
 28 ········print 'Oooops... Falhou...'
 29 ········exit(2)

Módulo searchstring.py

  1 #!/usr/bin/env python
  2
  3 # Krix Apolinario - krix@krix.com.br
  4
5 from re import compile
 6 from sys import argv, exit
 7
 8 def searchstring(String, File):
 9 ····FileSearch = open(File, 'r')
 10 ····ReadingFile = FileSearch.read()
 11 ····ReadingFile = ReadingFile.split('\n')
 12 ····StringSearching = compile(String)
 13 ····for Line in ReadingFile:
 14 ········FoundString = StringSearching.search(Line)
 15 ········if (FoundString):
 16 ············return True
 17 ····FileSearch.close()
 18 ····return False

Abaixo coloquei um exemplo do uso do script e como usei o módulo re (Regular Expression) posso fazer buscas mais precisas. O arquivo que escolhi para mostrar os exemplos foi o script do post Enviando Email em Python:

[krix@sorcerss]$ ./SearchString.py sender sendmail.py
    sender        = 'relatorio@krix.com.br'
    ''' % (sender, recipient)
    server.sendmail(sender, recipient, message)

[krix@sorcerss]$ ./SearchString.py " sender" sendmail.py
    sender        = 'relatorio@krix.com.br'

[krix@sorcerss]$ ./SearchString.py "\(sender" sendmail.py
    ''' % (sender, recipient)
    server.sendmail(sender, recipient, message)

[krix@sorcerss]$ ./SearchString.py "^# " sendmail.py
# -*- coding: iso-8859-1 -*-
# Krix Apolinário - krix@krix.com.br

Enviando Email em Python

Krix Apolinário — Sat, 11 Jul 2009 10:23:38 +0000

Python tem um módulo smtplib que permite o envio de emails tradicionais através do protocolo SMTP. Antes de falar sobre o módulo vamos dá uma olhada no código abaixo:

 1  #!/usr/bin/env python
 2  # -*- coding: iso-8859-1 -*-
 3
 4  # Krix Apolinário - krix@krix.com.br
 5
 6  import smtplib
 7
 8  def MySendMail():
 9      server        = smtplib.SMTP('smtp.krix.com.br', 25)
10      sender        = 'relatorio@krix.com.br'
11      recipient     = 'krix@krix.com.br'
12      message       = '''
13      From: %s
14      To: %s
15      Subject: Email de teste
16      Corpo do email
17      ''' % (sender, recipient)
18      server.sendmail(sender, recipient, message)
19      server.quit()
20
21  if __name__ == "__main__":
22     try:
23         MySendMail()
24     except IOError:
25         print 'Ooops... O email não foi enviado...'

A classe SMTP controla a conexão com um servidor SMTP, para isso informei, host e a porta. O método SMTP.sendmail(sender, recipient, message) envia o email e o método SMTP.quit() termina a sessão com o servidor SMTP e fecha a conexão.

No exemplo acima como pode ser observado o corpo do email é um texto atribuído a uma variável, mas e se você estiver usando um script que irá gerar um log em um arquivo e você além de querer que esse log fique no arquivo salvo, você quer que ele também seja enviado por email, nesse caso ficaria assim:

 8  def MySendMail():
 9      server        = smtplib.SMTP('smtp.krix.com.br', 25)
10      sender        = 'relatorio@krix.com.br'
11      recipient     = 'krix@krix.com.br'
12      directory     = '/home/krix/message_for_email.txt'
13      open_archive  = open(directory, 'r')
14      message       = open_archive.read()
15      server.sendmail(sender, recipient, message)
16      server.quit()
17      open_archive.close()