Guia Rápido Do Python 3 - 240401 - 232852


Python 3 - Guia rápido

Anúncios
 Página anterior Próxima página 
O que é novo no Python 3?

O módulo __future__
O Python 3.x introduziu algumas palavras-chave e recursos incompatíveis com o Python
2 que podem ser importados através do módulo __future__ embutido no Python 2. É
recomendado usar as importações de __future__, se você estiver planejando o suporte
ao Python 3.x para o seu código.
Por exemplo, se quisermos o comportamento de divisão de inteiros do Python 3.x no

Python 2, adicione a seguinte declaração de importação.
from __future__ import division
A função de impressão
A mudança mais notável e mais amplamente conhecida no Python 3 é como a função
de impressão é usada. O uso de parênteses () com função de impressão agora é
obrigatório. Foi opcional no Python 2.
print "Hello World" #is acceptable in Python 2

print ("Hello World") # in Python 3, print must be followed by ()
A função print () insere uma nova linha no final, por padrão. No Python 2, ele pode ser
suprimido colocando ',' no final. No Python 3, "end = ''" acrescenta espaço ao invés de
nova linha.
print x, # Trailing comma suppresses newline in Python 2

print(x, end=" ") # Appends a space instead of a newline in Python 3
Leitura de entrada do teclado

O Python 2 possui duas versões de funções de entrada, input () e raw_input () . A
função input () trata os dados recebidos como string, se estiverem incluídos entre aspas
"" ou "", caso contrário, os dados serão tratados como números.
No Python 3, a função raw_input () é reprovada. Além disso, os dados recebidos são
sempre tratados como string.
In Python 2
>>> x = input('something:')
something:10 #entered data is treated as number
>>> x
10
>>> x = input('something:')
something:'10' #entered data is treated as string
>>> x
'10'
>>> x = raw_input("something:")
something:10 #entered data is treated as string even without ''
>>> x
'10'
>>> x = raw_input("something:")
something:'10' #entered data treated as string including ''
>>> x
"'10'"
In Python 3
>>> x = input("something:")
something:10
>>> x
'10'
something:'10' #entered data treated as string with or without ''
>>> x
"'10'"
>>> x = raw_input("something:") # will result NameError

Traceback (most recent call last):
File "<pyshell#3>", line 1, in
<module>
x = raw_input("something:")
NameError: name 'raw_input' is not defined
Divisão Integer
No Python 2, o resultado da divisão de dois inteiros é arredondado para o inteiro mais
próximo. Como resultado, 3/2 mostrará 1. Para obter uma divisão de ponto flutuante, o
numerador ou denominador deve ser explicitamente usado como float. Assim, 3.0 / 2
ou 3 / 2.0 ou 3.0 / 2.0 resultará em 1.5
O Python 3 avalia 3/2 como 1.5 por padrão, o que é mais intuitivo para novos
programadores.
Representação Unicode
O Python 2 requer que você marque uma string com au se quiser armazená-la como
Unicode.
O Python 3 armazena strings como Unicode, por padrão. Temos cadeias de caracteres
Unicode (utf-8) e classes de 2 bytes: matrizes de bytes e bytes.
Função xrange () removida

No Python 2 range () retorna uma lista, e xrange () retorna um objeto que gerará
apenas os itens no intervalo quando necessário, economizando memória.
No Python 3, a função range () é removida e xrange () foi renomeado como range ().
Além disso, o objeto range () suporta o fatiamento no Python 3.2 e posterior.
levantar exceção
O Python 2 aceita as duas notações, a sintaxe "antiga" e a "nova"; O Python 3 gera um
SyntaxError se não colocarmos o argumento de exceção entre parênteses.
raise IOError, "file error" #This is accepted in Python 2

raise IOError("file error") #This is also accepted in Python 2
raise IOError, "file error" #syntax error is raised in Python 3
raise IOError("file error") #this is the recommended syntax in Python 3
Argumentos em exceções
No Python 3, os argumentos para exceção devem ser declarados com a palavra-chave
'as'.
except Myerror, err: # In Python2

except Myerror as err: #In Python 3
Função next () e método .next ()

No Python 2, next () como um método de objeto gerador, é permitido. No Python 2, a
função next (), para iterar o objeto gerador, também é aceita. No Python 3, no entanto,
next (0 como um método gerador é descontinuado e gera AttributeError.
gen = (letter for letter in 'Hello World') # creates generator object

next(my_generator) #allowed in Python 2 and Python 3
my_generator.next() #allowed in Python 2. raises AttributeError in Python 3
Utilitário 2to3
Juntamente com o interpretador Python 3, o script 2to3.py geralmente é instalado na
pasta tools / scripts. Ele lê o código-fonte do Python 2.xe aplica uma série de fixadores
para transformá-lo em um código válido do Python 3.x.
Here is a sample Python 2 code (area.py):
def area(x,y = 3.14):

a = y*x*x
print a
return a
a = area(10)
print "area",a
To convert into Python 3 version:
$2to3 -w area.py
Converted code :
def area(x,y = 3.14): # formal parameters

a = y*x*x
print (a)
return a
a = area(10)
print("area",a)
Python 3 - Visão Geral

O Python é uma linguagem de script de alto nível, interpretada, interativa e orientada a
objetos. O Python é projetado para ser altamente legível. Ele usa palavras-chave
inglesas freqüentemente enquanto as outras linguagens usam pontuações. Tem menos
construções sintáticas do que outras linguagens.
O Python é Interpretado - o Python é processado em tempo de execução

pelo interpretador. Você não precisa compilar seu programa antes de executá-
lo. Isso é semelhante ao PERL e ao PHP.
Python é interativo - Você pode realmente sentar em um prompt do Python e

interagir diretamente com o interpretador para escrever seus programas.
O Python é orientado a objeto - o Python suporta o estilo orientado a objeto

ou a técnica de programação que encapsula o código dentro de objetos.
O Python é uma linguagem para iniciantes - o Python é uma ótima linguagem

para os programadores iniciantes e suporta o desenvolvimento de uma ampla
gama de aplicativos, desde processamento de texto simples a navegadores
WWW a jogos.
História do Python
Python foi desenvolvido por Guido van Rossum no final dos anos oitenta e início dos
anos noventa no Instituto Nacional de Pesquisa de Matemática e Ciência da
Computação na Holanda.
O Python é derivado de muitas outras linguagens, incluindo o shell ABC,

Modula-3, C, C ++, Algol-68, SmallTalk, Unix e outras linguagens de script.
Python é protegido por direitos autorais. Como o Perl, o código-fonte do Python

agora está disponível sob a licença GNU General Public License (GPL).
O Python agora é mantido por uma equipe central de desenvolvimento do
instituto, embora Guido van Rossum ainda tenha um papel vital na direção de
seu progresso.
O Python 1.0 foi lançado em novembro de 1994. Em 2000, o Python 2.0 foi
lançado. O Python 2.7.11 é a última edição do Python 2.
Enquanto isso, o Python 3.0 foi lançado em 2008. O Python 3 não é

retrocompatível com o Python 2. A ênfase no Python 3 estava na remoção de
construções e módulos de programação duplicados, de modo que "deveria
haver um - e de preferência apenas um - maneira óbvia de fazê-lo. " O Python
3.5.1 é a última versão do Python 3.
Recursos do Python
Os recursos do Python incluem -
Fácil de aprender - o Python tem poucas palavras-chave, estrutura simples e

uma sintaxe claramente definida. Isso permite que o aluno escolha a linguagem
rapidamente.
Fácil de ler - o código Python é mais claramente definido e visível aos olhos.
Fácil de manter - o código-fonte do Python é bastante fácil de manter.
Uma ampla biblioteca padrão - o tamanho da biblioteca do Python é muito

portátil e compatível com várias plataformas no UNIX, Windows e Macintosh.
Modo Interativo - Python tem suporte para um modo interativo que permite
testes interativos e depuração de trechos de código.
Portátil - o Python pode ser executado em uma ampla variedade de

plataformas de hardware e possui a mesma interface em todas as plataformas.
Extensível - Você pode adicionar módulos de baixo nível ao interpretador

Python. Esses módulos permitem que os programadores adicionem ou
personalizem suas ferramentas para serem mais eficientes.
Bancos de dados - o Python fornece interfaces para todos os principais bancos

de dados comerciais.
Programação de GUI - Python suporta aplicativos GUI que podem ser criados
e portados para muitas chamadas de sistema, bibliotecas e sistemas Windows,
como o Windows MFC, Macintosh e o sistema X Window do Unix.
Escalável - Python fornece uma melhor estrutura e suporte para programas

grandes do que scripts de shell.
Além dos recursos mencionados acima, o Python tem uma lista grande de bons
recursos. Alguns estão listados abaixo -
Suporta métodos de programação funcional e estruturada, bem como OOP.
Ele pode ser usado como uma linguagem de script ou pode ser compilado para
codificar byte para criar aplicativos grandes.
Ele fornece tipos de dados dinâmicos de alto nível e suporta a verificação

dinâmica de tipos.
Suporta coleta automática de lixo.
Pode ser facilmente integrado com C, C ++, COM, ActiveX, CORBA e Java.
Python 3 - Configuração do Ambiente

O Python 3 está disponível para Windows, Mac OS e a maioria dos tipos de sistema
operacional Linux. Embora o Python 2 esteja disponível para muitos outros sistemas
operacionais, o suporte ao Python 3 também não foi disponibilizado para eles ou foi
descartado.
Configuração do ambiente local

Abra uma janela de terminal e digite "python" para descobrir se ela já está instalada e
qual versão está instalada.
Obtendo Python
Plataforma Windows
Binários da versão mais recente do Python 3 (Python 3.5.1) estão disponíveis nesta
página de download
As seguintes opções de instalação diferentes estão disponíveis.
Arquivo zip embutido no Windows x86-64
Instalador executável do Windows x86-64
Instalador baseado na web do Windows x86-64
Arquivo zip incorporável do Windows x86
Instalador executável do Windows x86
Instalador baseado na web do Windows x86
Nota - Para instalar o Python 3.5.1, os requisitos mínimos do SO são o Windows 7 com
SP1. Para as versões 3.0 a 3.4.x, o Windows XP é aceitável.
Plataforma Linux
Tipos diferentes de Linux usam gerenciadores de pacotes diferentes para a instalação
de novos pacotes.
No Ubuntu Linux, o Python 3 é instalado usando o seguinte comando do terminal.
$sudo apt-get install python3-minimal

Instalação da fonte
Faça o download do tarball de origem compactada do URL de download do Python -

https://www.python.org/ftp/python/3.5.1/Python-3.5.1.tgz
Extract the tarball

tar xvfz Python-3.5.1.tgz
Configure and Install:
cd Python-3.5.1
./configure --prefix = /opt/python3.5.1
make
sudo make install
Mac OS
Baixe os instaladores do Mac OS a partir desta URL -
https://www.python.org/downloads/mac-osx/
Instalador do Mac OS X de 64 bits / 32 bits - python-3.5.1-macosx10.6.pkg
Instalador i386 / PPC para Mac OS X de 32 bits - python-3.5.1-macosx10.5.pkg
Clique duas vezes neste arquivo de pacote e siga as instruções do assistente para
instalar.
O código fonte mais atualizado e atual, binários, documentação, notícias, etc., estão
disponíveis no site oficial do Python -
Site Oficial do Python - https://www.python.org/
Você pode baixar a documentação do Python no seguinte site. A documentação está

disponível nos formatos HTML, PDF e PostScript.
Site de Documentação Python - www.python.org/doc/
Configurando o PATH
Programas e outros arquivos executáveis podem estar em vários diretórios. Portanto, os
sistemas operacionais fornecem um caminho de pesquisa que lista os diretórios que ele
procura por executáveis.
As características importantes são -
O caminho é armazenado em uma variável de ambiente, que é uma sequência

nomeada mantida pelo sistema operacional. Esta variável contém informações
disponíveis para o shell de comando e outros programas.
A variável path é nomeada como PATH no Unix ou Path no Windows (o Unix

faz distinção entre maiúsculas e minúsculas; o Windows não é).
No Mac OS, o instalador manipula os detalhes do caminho. Para invocar o

interpretador Python de qualquer diretório em particular, você deve adicionar o
diretório Python ao seu caminho.
Definindo o caminho no Unix / Linux
Para adicionar o diretório Python ao caminho de uma sessão específica no Unix -
No shell csh - digite setenv PATH "$ PATH: / usr / local / bin / python3" e
pressione Enter.
No bash shell (Linux) - digite export PYTHONPATH = / usr / local / bin /

python3.4 e pressione Enter.
No shell sh ou ksh - digite PATH = "$ PATH: / usr / local / bin / python3" e
pressione Enter.
Nota - / usr / local / bin / python3 é o caminho do diretório Python.
Definindo Caminho no Windows

Para adicionar o diretório Python ao caminho de uma sessão específica no Windows -
No prompt de comando, digite o caminho% path%; C: \ Python e pressione

Enter.
Nota - C: \ Python é o caminho do diretório Python
Variáveis de ambiente do Python

Aqui estão importantes variáveis de ambiente, que são reconhecidas pelo Python -
Sr. Variável e Descrição

Não.
PYTHONPATH
Tem um papel semelhante ao PATH. Essa variável informa ao interpretador

Python onde localizar os arquivos de módulo importados para um programa.
1
Ele deve incluir o diretório da biblioteca de origem do Python e os diretórios
que contêm o código-fonte do Python. PYTHONPATH às vezes é predefinido
pelo instalador do Python.
PYTHONSTARTUP
Ele contém o caminho de um arquivo de inicialização que contém o código

2 fonte do Python. Ele é executado toda vez que você inicia o intérprete. É
nomeado como .pythonrc.py no Unix e contém comandos que carregam
utilitários ou modificam PYTHONPATH.
3 PYTHONCASEOK
Ele é usado no Windows para instruir o Python a encontrar a primeira
correspondência insensível a maiúsculas e minúsculas em uma instrução de
importação. Defina esta variável para qualquer valor para ativá-lo.
PITÔNOME
É um caminho de pesquisa de módulo alternativo. Geralmente, ela é

4
incorporada nos diretórios PYTHONSTARTUP ou PYTHONPATH para facilitar as
bibliotecas de módulos de comutação.
Executando Python
Existem três maneiras diferentes de iniciar o Python -
Interpretador Interativo
Você pode iniciar o Python a partir do Unix, do DOS ou de qualquer outro sistema que
forneça um interpretador de linha de comando ou uma janela de shell.
Digite python na linha de comando.
Comece a codificar imediatamente no intérprete interativo.
$python # Unix/Linux
or
python% # Unix/Linux
or
C:>python # Windows/DOS
Aqui está a lista de todas as opções de linha de comando disponíveis -
Sr. Opção e Descrição

Não.
-d
1
fornecer saída de depuração
-O
2
gerar bytecode otimizado (resultando em arquivos .pyo)
-S
3 não executar o site de importação para procurar caminhos do Python na

inicialização
4 -v
saída detalhada (rastreio detalhado em instruções de importação)

-X
5 desativar exceções internas baseadas em classe (apenas use strings);

obsoleto começando com a versão 1.6
-c cmd
6
executar script Python enviado como string cmd
Arquivo
7
execute o script Python de um determinado arquivo
Script da linha de comando

Um script Python pode ser executado na linha de comando, invocando o interpretador
em seu aplicativo, conforme mostrado no exemplo a seguir.
$python script.py # Unix/Linux

or
python% script.py # Unix/Linux
or
C:>python script.py # Windows/DOS
Nota - Certifique-se de que o modo de permissão de arquivo permita a execução.
Ambiente de desenvolvimento integrado

Você também pode executar o Python a partir de um ambiente Graphical User Interface
(GUI), se tiver um aplicativo GUI em seu sistema que suporte Python.
Unix - IDLE é o primeiro Unix IDE para Python.
Windows - PythonWin é a primeira interface do Windows para Python e é um

IDE com uma GUI.
Macintosh - A versão para Macintosh do Python, juntamente com o IDE IDLE,

está disponível no site principal, podendo ser baixada como arquivos MacBinary
ou BinHex.
Se você não for capaz de configurar o ambiente adequadamente, você pode obter ajuda
do administrador do sistema. Certifique-se de que o ambiente Python esteja
configurado corretamente e funcionando perfeitamente bem.
Nota - Todos os exemplos dados nos capítulos subseqüentes são executados com a
versão Python 3.4.1 disponível no Windows 7 e no Ubuntu Linux.
Já criamos o ambiente de Programação em Python online, para que você possa

executar todos os exemplos disponíveis online enquanto estiver aprendendo teoria.
Sinta-se à vontade para modificar qualquer exemplo e executá-lo online.
Python 3 - sintaxe básica

A linguagem Python tem muitas semelhanças com Perl, C e Java. No entanto, existem
algumas diferenças definidas entre os idiomas.
Primeiro programa em Python

Vamos executar os programas em diferentes modos de programação.
Programação de modo interativo

Chamar o interpretador sem passar um arquivo de script como um parâmetro exibe o
seguinte prompt -
$ python
Python 3.3.2 (default, Dec 10 2013, 11:35:01)

[GCC 4.6.3] on Linux
Type "help", "copyright", "credits", or "license" for more information.
>>>
On Windows:
Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>
Digite o seguinte texto no prompt do Python e pressione Enter -
>>> print ("Hello, Python!")
Se você estiver executando a versão mais antiga do Python (Python 2.x), o uso de
parênteses como função inprint é opcional. Isso produz o seguinte resultado -
Hello, Python!
Programação de modo de script

Chamar o interpretador com um parâmetro de script inicia a execução do script e
continua até que o script seja concluído. Quando o script é concluído, o intérprete não
está mais ativo.
Vamos escrever um programa Python simples em um script. Os arquivos Python

possuem a extensão .py . Digite o seguinte código-fonte em um arquivo test.py -
 Demonstração ao vivo
print ("Hello, Python!")
Assumimos que você tenha o interpretador Python definido na variável PATH . Agora,
tente executar este programa da seguinte maneira -
No linux
$ python test.py
Isso produz o seguinte resultado -

Olá, Python!
No Windows
C:\Python34>Python test.py
Olá, Python!
Vamos tentar outra maneira de executar um script Python no Linux. Aqui está o arquivo
test.py modificado -
#!/usr/bin/python3
print ("Hello, Python!")
Nós assumimos que você tem o interpretador Python disponível no diretório / usr / bin.
Agora, tente executar este programa da seguinte maneira -
$ chmod +x test.py # This is to make file executable

$./test.py
Hello, Python!
Identificadores Python
Um identificador Python é um nome usado para identificar uma variável, função, classe,
módulo ou outro objeto. Um identificador começa com uma letra A a Z ou a a z ou um
sublinhado (_) seguido por zero ou mais letras, sublinhados e dígitos (0 a 9).
O Python não permite caracteres de pontuação como @, $ e% nos identificadores.

Python é uma linguagem de programação sensível a maiúsculas e minúsculas. Assim,
Manpower e mão de obra são dois identificadores diferentes no Python.
Aqui estão as convenções de nomenclatura para identificadores Python -
Nomes de classes começam com uma letra maiúscula. Todos os outros

identificadores começam com uma letra minúscula.
Iniciar um identificador com um único sublinhado à esquerda indica que o

identificador é particular.
Iniciar um identificador com dois sublinhados principais indica um identificador

privado forte.
Se o identificador também terminar com dois sublinhados à direita, o

identificador será um nome especial definido por idioma.
Palavras reservadas
A lista a seguir mostra as palavras-chave do Python. Estas são palavras reservadas e
você não pode usá-las como constantes ou variáveis ou quaisquer outros nomes de
identificadores. Todas as palavras-chave do Python contêm apenas letras minúsculas.
e exec não
Como finalmente ou
afirmar para passar
pausa de impressão
classe global levantar
continuar E se Retorna
def importar experimentar
del em enquanto
elif é com
outro lambda produção
exceto
Linhas e Indentação
O Python não usa chaves ({}) para indicar blocos de código para definições de classe e
função ou controle de fluxo. Blocos de código são denotados por indentação de linha,
que é rigidamente aplicada.
O número de espaços no recuo é variável, mas todas as instruções dentro do bloco

devem ser recuadas na mesma quantia. Por exemplo -
if True:
print ("True")
else:
print ("False")
No entanto, o seguinte bloco gera um erro -
if True:
print ("Answer")
print ("True")
else:
print "(Answer")
print ("False")
Assim, em Python, todas as linhas contínuas recuadas com o mesmo número de

espaços formariam um bloco. O exemplo a seguir tem vários blocos de instruções -
Nota - Não tente entender a lógica neste momento. Apenas certifique-se de entender
os vários blocos, mesmo se eles estiverem sem chaves.
#!/usr/bin/python3
import sys
try:
# open file stream
file = open(file_name, "w")
except IOError:
print ("There was an error writing to", file_name)
sys.exit()
print ("Enter '", file_finish,)
print "' When finished"
while file_text != file_finish:
file_text = raw_input("Enter text: ")
if file_text == file_finish:
# close the file
file.close
break
file.write(file_text)
file.write("\n")
file.close()
file_name = input("Enter filename: ")
if len(file_name) == 0:
print ("Next time please enter something")
sys.exit()
try:
file = open(file_name, "r")
except IOError:
print ("There was an error reading file")
sys.exit()
file_text = file.read()
file.close()
print (file_text)
Declarações de várias linhas

As declarações no Python geralmente terminam com uma nova linha. O Python, no
entanto, permite o uso do caractere de continuação de linha (\) para indicar que a linha
deve continuar. Por exemplo -
total = item_one + \
item_two + \
item_three
As instruções contidas nos colchetes [], {} ou () não precisam usar o caractere de

continuação de linha. Por exemplo -
days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
Cotação em Python
O Python aceita aspas simples ('), double (") e tripla (' '' ou" "") para indicar literais de
string, desde que o mesmo tipo de aspas inicie e termine a string.
As aspas triplas são usadas para dividir a string em várias linhas. Por exemplo, todos os
itens a seguir são legais -
word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines and sentences."""
Comentários em Python
Um sinal de hash (#) que não está dentro de uma string literal é o começo de um
comentário. Todos os caracteres após o #, até o final da linha física, fazem parte do
comentário e o interpretador Python os ignora.
#!/usr/bin/python3
# First comment
print ("Hello, Python!") # second comment
Hello, Python!
Você pode digitar um comentário na mesma linha depois de uma declaração ou

expressão -
name = "Madisetti" # This is again comment
O Python não possui recurso de comentários de várias linhas. Você tem que comentar
cada linha individualmente da seguinte maneira -
# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.
Usando linhas em branco

Uma linha contendo apenas espaços em branco, possivelmente com um comentário, é
conhecida como uma linha em branco e o Python a ignora totalmente.
Em uma sessão de intérprete interativa, você deve inserir uma linha física vazia para
finalizar uma instrução de múltiplas linhas.
Esperando pelo usuário

A linha a seguir do programa exibe o prompt e a instrução que diz "Pressione a tecla
Enter para sair" e aguarda o usuário executar uma ação -
#!/usr/bin/python3
input("\n\nPress the enter key to exit.")
Aqui, "\ n \ n" é usado para criar duas novas linhas antes de exibir a linha atual.
Quando o usuário pressiona a tecla, o programa termina. Este é um bom truque para
manter uma janela do console aberta até que o usuário termine com um aplicativo.
Múltiplas instruções em uma única linha

O ponto-e-vírgula (;) permite várias instruções em uma única linha, desde que
nenhuma instrução inicie um novo bloco de código. Aqui está um recorte de amostra
usando o ponto e vírgula -
import sys; x = 'foo'; sys.stdout.write(x + '\n')
Vários grupos de instruções como suítes

Grupos de instruções individuais, que formam um único bloco de código, são chamados
de suítes no Python. Instruções complexas ou complexas, como if, while, def e class
requerem uma linha de cabeçalho e um conjunto.
As linhas de cabeçalho iniciam a instrução (com a palavra-chave) e terminam com dois-

pontos (:) e são seguidas por uma ou mais linhas que compõem o conjunto. Por
exemplo -
if expression :
suite
elif expression :
suite
else :
suite
Argumentos da Linha de Comando

Muitos programas podem ser executados para fornecer algumas informações básicas
sobre como eles devem ser executados. Python permite que você faça isso com - h -
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUG=x)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit
[ etc. ]
Você também pode programar seu script de maneira que ele deva aceitar várias
opções. Argumentos de linha de comando é um tópico avançado. Vamos entender
isso.
Python 3 - Tipos Variáveis
Variáveis não são nada além de locais de memória reservados para armazenar valores.
Isso significa que quando você cria uma variável, você reserva algum espaço na
memória.
Com base no tipo de dados de uma variável, o intérprete aloca memória e decide o que
pode ser armazenado na memória reservada. Portanto, atribuindo diferentes tipos de
dados às variáveis, você pode armazenar números inteiros, decimais ou caracteres
nessas variáveis.
Atribuindo Valores a Variáveis

Variáveis do Python não precisam de declaração explícita para reservar espaço de
memória. A declaração acontece automaticamente quando você atribui um valor a uma
variável. O sinal de igual (=) é usado para atribuir valores a variáveis.
O operando à esquerda do operador = é o nome da variável e o operando à direita do

operador = é o valor armazenado na variável. Por exemplo -
#!/usr/bin/python3
counter = 100 # An integer assignment

miles = 1000.0 # A floating point
name = "John" # A string
print (counter)
print (miles)
print (name)
Aqui, 100, 1000.0 e "John" são os valores atribuídos às variáveis counter, miles e name,
respectivamente. Isso produz o seguinte resultado -
100
1000.0
John
Atribuição Múltipla
O Python permite que você atribua um único valor a várias variáveis simultaneamente.
Por exemplo -
a = b = c = 1
Aqui, um objeto inteiro é criado com o valor 1 e todas as três variáveis são atribuídas
ao mesmo local de memória. Você também pode atribuir vários objetos a várias
variáveis. Por exemplo -
a, b, c = 1, 2, "john"
Aqui, dois objetos inteiros com valores 1 e 2 são atribuídos às variáveis aeb,
respectivamente, e um objeto de string com o valor "john" é atribuído à variável c.
Tipos de dados padrão

Os dados armazenados na memória podem ser de vários tipos. Por exemplo, a idade de
uma pessoa é armazenada como um valor numérico e seu endereço é armazenado
como caracteres alfanuméricos. O Python possui vários tipos de dados padrão que são
usados para definir as operações possíveis neles e o método de armazenamento para
cada um deles.
Python tem cinco tipos de dados padrão -
Números
Corda
Lista
Tuple
Dicionário
Números Python
Tipos de dados numéricos armazenam valores numéricos. Objetos numéricos são
criados quando você atribui um valor a eles. Por exemplo -
var1 = 1
var2 = 10
Você também pode excluir a referência a um objeto numérico usando a instrução del .
A sintaxe da instrução del é -
del var1[,var2[,var3[....,varN]]]]
Você pode excluir um único objeto ou vários objetos usando a instrução del .
Por exemplo -
del var
del var_a, var_b
Python suporta três tipos numéricos diferentes -
int (números inteiros assinados)
float (valores reais de ponto flutuante)
complexo (números complexos)
Todos os inteiros no Python3 são representados como inteiros longos. Portanto, não há
nenhum tipo de número separado por tanto tempo.
Exemplos
Aqui estão alguns exemplos de números -
int flutuador complexo
10 0,0 3,14 j
100 15,20 45.j
-786 -21,9 9.322e-36j
080 32,3 + e18 .876j
-0490 -90. -6545 + 0J
-0x260 -32,54e100 3e + 26J
0x69 70,2-E12 4.53e-7j
Um número complexo consiste em um par ordenado de números reais de ponto

flutuante denotado por x + yj, onde x e y são números reais e j é a unidade imaginária.
Cordas Python
Strings em Python são identificadas como um conjunto contíguo de caracteres
representados nas aspas. O Python permite um par de aspas simples ou duplas.
Subconjuntos de strings podem ser obtidos usando o operador slice ([] e [:]) com
índices começando em 0 no começo da string e indo de -1 até o final.
O sinal de mais (+) é o operador de concatenação de strings e o asterisco (*) é o

operador de repetição. Por exemplo -
#!/usr/bin/python3
str = 'Hello World!'
print (str) # Prints complete string

print (str[0]) # Prints first character of the string
print (str[2:5]) # Prints characters starting from 3rd to 5th
print (str[2:]) # Prints string starting from 3rd character
print (str * 2) # Prints string two times
print (str + "TEST") # Prints concatenated string
Isso produzirá o seguinte resultado -
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
Listas de Python
As listas são as mais versáteis dos tipos de dados compostos do Python. Uma lista
contém itens separados por vírgulas e entre colchetes ([]). Até certo ponto, as listas
são semelhantes às matrizes em C. Uma das diferenças entre elas é que todos os itens
pertencentes a uma lista podem ser de tipos de dados diferentes.
Os valores armazenados em uma lista podem ser acessados usando o operador de fatia
([] e [:]) com índices começando em 0 no começo da lista e indo até o final de -1. O
sinal de mais (+) é o operador de concatenação de lista e o asterisco (*) é o operador
de repetição. Por exemplo -
#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]

tinylist = [123, 'john']
print (list) # Prints complete list

print (list[0]) # Prints first element of the list
print (list[1:3]) # Prints elements starting from 2nd till 3rd
print (list[2:]) # Prints elements starting from 3rd element
print (tinylist * 2) # Prints list two times
print (list + tinylist) # Prints concatenated lists
['abcd', 786, 2.23, 'john', 70.200000000000003]

abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']
Tuplas Python
Uma tupla é outro tipo de dados de sequência que é semelhante à lista. Uma tupla
consiste em vários valores separados por vírgulas. Diferentemente das listas, no
entanto, as tuplas são colocadas entre parênteses.
A principal diferença entre listas e tuplas são - As listas são colocadas entre colchetes
([]) e seus elementos e tamanhos podem ser alterados, enquanto as tuplas são
colocadas entre parênteses (()) e não podem ser atualizadas. As tuplas podem ser
consideradas como listas somente leitura . Por exemplo -
#!/usr/bin/python3
tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )

tinytuple = (123, 'john')
print (tuple) # Prints complete tuple

print (tuple[0]) # Prints first element of the tuple
print (tuple[1:3]) # Prints elements starting from 2nd till 3rd
print (tuple[2:]) # Prints elements starting from 3rd element
print (tinytuple * 2) # Prints tuple two times
print (tuple + tinytuple) # Prints concatenated tuple
('abcd', 786, 2.23, 'john', 70.200000000000003)

abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')
O código a seguir é inválido com a tupla, porque tentamos atualizar uma tupla, o que
não é permitido. Caso semelhante é possível com listas -
#!/usr/bin/python3
tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 # Invalid syntax with tuple
list[2] = 1000 # Valid syntax with list
Dicionário Python
Os dicionários do Python são do tipo hash-table. Eles funcionam como matrizes
associativas ou hashes encontrados em Perl e consistem em pares de valores-chave.
Uma chave de dicionário pode ser quase qualquer tipo de Python, mas geralmente são
números ou cadeias de caracteres. Valores, por outro lado, podem ser qualquer objeto
Python arbitrário.
Os dicionários são colocados entre chaves ({}) e os valores podem ser atribuídos e
acessados usando colchetes ([]). Por exemplo -
#!/usr/bin/python3
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print (dict['one']) # Prints value for 'one' key

print (dict[2]) # Prints value for 2 key
print (tinydict) # Prints complete dictionary
print (tinydict.keys()) # Prints all the keys
print (tinydict.values()) # Prints all the values
This is one
This is two
{'name': 'john', 'dept': 'sales', 'code': 6734}
dict_keys(['name', 'dept', 'code'])
dict_values(['john', 'sales', 6734])
Os dicionários não têm conceito de ordem entre os elementos. É incorreto dizer que os
elementos estão "fora de ordem"; eles são simplesmente desordenados.
Conversão de tipo de dados
Às vezes, você pode precisar realizar conversões entre os tipos internos. Para converter
entre tipos, você simplesmente usa os nomes dos tipos como uma função.
Existem várias funções internas para executar a conversão de um tipo de dados para
outro. Essas funções retornam um novo objeto representando o valor convertido.
Sr. Não. Descrição da função
int (x [, base])
1
Converte x para um inteiro. A base especifica a base, se x for uma string.
flutuante (x)
2
Converte x em um número de ponto flutuante.
complexo (real [, imag])

3
Cria um número complexo.
str (x)
4
Converte o objeto x em uma representação de string.
repr (x)
5
Converte o objeto x em uma string de expressão.
eval (str)
6
Avalia uma string e retorna um objeto.
tupla (s)
7
Converte s em uma tupla.
lista (s)
8
Converte s em uma lista.
conjunto (s)
9
Converte s para um conjunto.
ditto (d)
10
Cria um dicionário. d deve ser uma sequência de tuplas (chave, valor).
11 frozenset (s)
Converte s em um conjunto congelado.
chr (x)
12
Converte um inteiro em um caractere.
unichr (x)
13
Converte um inteiro em um caractere Unicode.
ord (x)
14
Converte um único caractere em seu valor inteiro.
hex (x)
15
Converte um inteiro em uma string hexadecimal.
oct (x)
16
Converte um inteiro em uma string octal.
Python 3 - Operadores Básicos

Operadores são as construções, que podem manipular o valor dos operandos. Considere
a expressão 4 + 5 = 9. Aqui, 4 e 5 são chamados de operandos e + é chamado de
operador.
Tipos de Operador
A linguagem Python suporta os seguintes tipos de operadores -
Operadores aritméticos
Operadores de comparação (relacional)
Operadores de atribuição
Operadores lógicos
Operadores bit a bit
Operadores de Associação
Operadores de Identidade
Vamos dar uma olhada em todos os operadores, um por um.
Operadores Aritméticos Python

Suponha que a variável a detenha o valor 10 e a variável b mantenha o valor 21, então
-
Mostrar exemplo
Operador Descrição Exemplo
Adiciona valores em ambos os lados do

+ Adição a + b = 31
operador.
Subtrai o operando à direita do

- Subtração a - b = -11
operando da esquerda.
Multiplica valores em ambos os lados do

* Multiplicação a * b = 210
operador
Divide o operando esquerdo pelo

/ Divisão b / a = 2,1
operando direito
Divide o operando esquerdo pelo

% Módulo b% a = 1
operando direito e retorna o restante
Executa cálculo exponencial (potência)

** Expoente a ** b = 10 à potência 20
em operadores
Divisão do Piso - A divisão dos

operandos onde o resultado é o
quociente no qual os dígitos após o
9 // 2 = 4 e 9,0 // 2,0 = 4,0,
ponto decimal são removidos. Mas se
// -11 // 3 = -4, -11,0 // 3 =
um dos operandos for negativo, o
-4,0
resultado é floored, isto é, arredondado
para longe de zero (para infinito
negativo):
Operadores de comparação de Python

Esses operadores comparam os valores em ambos os lados e decidem a relação entre
eles. Eles também são chamados de operadores relacionais.
-
Mostrar exemplo
Se os valores de dois operandos forem

== iguais, a condição se tornará (a == b) não é verdade.
verdadeira.
!= Se os valores de dois operandos não (a! = b) é verdade.

forem iguais, a condição se tornará
verdadeira.
Se o valor do operando à esquerda for

> maior que o valor do operando à direita, (a> b) não é verdade.
a condição se tornará verdadeira.
Se o valor do operando esquerdo for

< menor que o valor do operando direito, (a <b) é verdade.
a condição se tornará verdadeira.
Se o valor do operando à esquerda for

maior ou igual ao valor do operando à
>= (a> = b) não é verdade.
direita, a condição se tornará
verdadeira.
Se o valor do operando esquerdo for

menor ou igual ao valor do operando
<= (a <= b) é verdade.
direito, a condição se tornará
verdadeira.
Operadores de atribuição de Python

-
Mostrar exemplo
Atribui valores de operandos do lado c = a + b atribui valor de a +

= direito ao operando do lado esquerdo b em c
Adiciona o operando direito ao operando

+ = Adicionar c + = a é equivalente a c = c
esquerdo e atribui o resultado ao
AND +a
operando esquerdo
Subtrai o operando direito do operando

c - = a é equivalente a c = c -
- = Subtrair E esquerdo e atribui o resultado ao
a
operando esquerdo
Multiplica o operando direito com o

* = Multiplicar c * = a é equivalente a c = c
operando esquerdo e atribui o resultado
AND *a
ao operando esquerdo
Divide o operando esquerdo com o c / = a é equivalente a c = c /

/ = Divide AND operando direito e atribui o resultado ao ac / = a é equivalente a c = c
operando esquerdo /a
Demora módulo usando dois operandos

c% = a é equivalente a c =
% = Módulo E e atribui o resultado ao operando
c% a
esquerdo
** = Expoente Executa cálculo exponencial (energia) c ** = a é equivalente a c =
AND nos operadores e atribui valor ao c ** a
operando esquerdo
// = Divisão de Executa divisão de piso em operadores c // = a é equivalente a c = c

andar e atribui valor ao operando esquerdo // a
Operadores Bitwise em Python

O operador bit a bit trabalha em bits e executa a operação bit a bit. Assuma se a = 60;
eb = 13; Agora, em formato binário, eles serão os seguintes -
a = 0011 1100
b = 0000 1101
-----------------
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~ a = 1100 0011
A função bin () do Python pode ser usada para obter representação binária de um
número inteiro.
Os seguintes operadores Bitwise são suportados pela linguagem Python -
Mostrar exemplo
Operador copia um pouco, para o

Binário E resultado, se existir em ambos os (a & b) (significa 0000 1100)
operandos
Ele copia um pouco, se existir em (a | b) = 61 (significa 0011

| OR binário qualquer operando. 1101)
Ele copia o bit, se estiver definido em (a ^ b) = 49 (significa 0011

^ XOR binário um operando, mas não em ambos. 0001)
(~ a) = -61 (significa 1100

~ Complemento 0011 na forma de
É unário e tem o efeito de 'flipping' bits.
Binário complemento de 2 devido a
um número binário assinado.
<< O valor do operando esquerdo é movido

para a esquerda pelo número de bits a << 2 = 240 (significa 1111
Deslocamento
especificado pelo operando direito. 0000)
Binário Esquerdo
>> O valor do operando esquerdo é movido a >> 2 = 15 (significa 0000
Deslocamento para a direita pelo número de bits 1111)
Binário Direito especificado pelo operando direito.
Operadores lógicos do Python

Os seguintes operadores lógicos são suportados pela linguagem Python. Suponha que a
variável a mantenha True e a variável b mantenha False e depois -
Mostrar exemplo
Se ambos os operandos forem

e lógica e verdadeiros, a condição se tornará (aeb) é Falso.
verdadeira.
Se algum dos dois operandos for

OU Lógica OU diferente de zero, a condição se tornará (a ou b) é verdadeiro.
verdadeira.
Usado para inverter o estado lógico de

não lógico NOT Não (a e b) é verdadeiro.
seu operando.
Operadores de Afiliação Python

Os operadores de associação do Python testam a associação em uma sequência, como
strings, listas ou tuplas. Existem dois operadores de associação, conforme explicado
abaixo -
Mostrar exemplo
Avalia para true se encontrar uma x em y, aqui resulta em 1 se

em variável na sequência especificada e x é um membro da sequência
false caso contrário. y.
Avalia para true se não encontrar uma x não em y, aqui não resulta
não em variável na sequência especificada e em 1 se x não é um membro
false caso contrário. da sequência y.
Operadores de Identidade Python

Operadores de identidade comparam os locais de memória de dois objetos. Existem
dois operadores de identidade, conforme explicado abaixo -
Mostrar exemplo
Avalia para verdadeiro se as variáveis

em ambos os lados do operador x é y, aqui é resultado em 1
é
apontam para o mesmo objeto e, caso se id (x) é igual a id (y).
contrário, são falsas.
Avalia para falso se as variáveis em

x não é y, aqui não resulta
ambos os lados do operador apontarem
não é em 1 se id (x) não for igual a
para o mesmo objeto e verdadeiro de
id (y).
outra forma.
Precedência de Operadores Python

A tabela a seguir lista todos os operadores da maior precedência para a mais baixa.
Mostrar exemplo
Sr. Operador e Descrição

Não.
**
1
Exponenciação (aumentar ao poder)
~+-
2 Complemento, unário mais e menos (os nomes dos métodos para os dois
últimos são + @ e - @)
* /% //
3
Multiplicar, dividir, módulo e divisão de piso
+-
4
Adição e subtração
>> <<
5
Deslocamento bit a bit à direita e à esquerda
E
6
Bitwise 'AND'
^|
7
Exclusivo de bits 'OR' e 'OR' regular
8 <= <>> =
Operadores de comparação
<> ==!
9
Operadores de igualdade
=% = / = // = - = + = * = ** =
10
Operadores de atribuição
é não é
11
Operadores de identidade
em não em
12
Operadores de associação
não ou e
13
Operadores lógicos
Python 3 - Tomada de Decisão

A tomada de decisão é a antecipação de condições que ocorrem durante a execução de
um programa e ações especificadas tomadas de acordo com as condições.
As estruturas de decisão avaliam várias expressões, que produzem VERDADEIRO ou

FALSO como o resultado. Você precisa determinar qual ação executar e quais instruções
executar se o resultado for VERDADEIRO ou FALSO, caso contrário.
A seguir está a forma geral de uma estrutura de tomada de decisão típica encontrada
na maioria das linguagens de programação -
A linguagem de programação Python assume qualquer valor diferente de zero e não
nulo como TRUE e qualquer valor zero ou nulo como valor FALSE.
A linguagem de programação Python fornece os seguintes tipos de declarações de

tomada de decisão.
Sr. Declaração & Descrição

Não.
se declarações
1 Uma instrução if consiste em uma expressão booleana seguida de uma ou

mais instruções.
if ... else statements
2 Uma instrução if pode ser seguida por uma instrução else opcional , que é
executada quando a expressão booleana é FALSE.
aninhado se instruções
3 Você pode usar um caso ou else if declaração dentro de outro se ou else if

declaração (s).
Vamos passar rapidamente por cada declaração de tomada de decisão.
Suítes de instrução única

Se o conjunto de uma cláusula if consistir apenas em uma única linha, ela poderá
continuar na mesma linha que a instrução de cabeçalho.
Exemplo
Aqui está um exemplo de uma cláusula if de uma linha
#!/usr/bin/python3
var = 100
if ( var == 100 ) : print ("Value of expression is 100")
print ("Good bye!")
Saída
Quando o código acima é executado, produz o seguinte resultado -
Value of expression is 100

Good bye!
Python 3 - Loops
Em geral, as instruções são executadas seqüencialmente - a primeira instrução em uma
função é executada primeiro, seguida pela segunda e assim por diante. Pode haver uma
situação em que você precise executar um bloco de código várias vezes.
As linguagens de programação fornecem várias estruturas de controle que permitem

caminhos de execução mais complicados.
Uma instrução de loop nos permite executar uma instrução ou grupo de instruções
várias vezes. O diagrama a seguir ilustra uma instrução de loop -
A linguagem de programação Python fornece os seguintes tipos de loops para lidar com
os requisitos de loop.
Sr. Tipo de loop e descrição

Não.
1 enquanto loop
Repete uma instrução ou grupo de instruções enquanto uma determinada
condição é VERDADEIRA. Ele testa a condição antes de executar o corpo do
loop.
para loop
2 Executa uma seqüência de instruções várias vezes e abrevia o código que

gerencia a variável de loop.
loops aninhados
3 Você pode usar um ou mais loop dentro de qualquer outro enquanto, ou para
loop.
Declarações de controle de loop

As instruções de controle Loop mudam a execução de sua seqüência normal. Quando a
execução deixa um escopo, todos os objetos automáticos que foram criados nesse
escopo são destruídos.
O Python suporta as seguintes instruções de controle.
Sr. Declaração de controle e descrição

Não.
declaração de quebra
1 Encerra a instrução de loop e transfere a execução para a instrução

imediatamente após o loop.
continuar instrução
2 Faz com que o loop pule o restante de seu corpo e repita imediatamente sua
condição antes de reiterar.
passar declaração
A instrução de transmissão no Python é usada quando uma instrução é
3 requerida sintaticamente, mas você não deseja que nenhum comando ou
código seja executado.
Vamos percorrer as instruções de controle de loop brevemente.
Iterador e Gerador
O iterador é um objeto que permite a um programador percorrer todos os elementos
de uma coleção, independentemente de sua implementação específica. No Python, um
objeto iterador implementa dois métodos, iter () e next () .
Objetos String, List ou Tuple podem ser usados para criar um Iterator.
list = [1,2,3,4]
it = iter(list) # this builds an iterator object
print (next(it)) #prints next available element in iterator
Iterator object can be traversed using regular for statement
!usr/bin/python3
for x in it:
print (x, end=" ")
or using next() function
while True:
try:
print (next(it))
except StopIteration:
sys.exit() #you have to import sys module for this
Um gerador é uma função que produz ou produz uma seqüência de valores usando o
método yield.
Quando uma função geradora é chamada, ela retorna um objeto gerador sem iniciar a
execução da função. Quando o método next () é chamado pela primeira vez, a função
começa a executar até atingir a instrução yield, que retorna o valor obtido. O
rendimento mantém o controle, isto é, lembra a última execução e a segunda chamada
seguinte () continua do valor anterior.
Exemplo
O exemplo a seguir define um gerador, que gera um iterador para todos os números de
Fibonacci.
#!usr/bin/python3
import sys
def fibonacci(n): #generator function
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(5) #f is iterator object
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
Python 3 - Números
Tipos de dados numéricos armazenam valores numéricos. Eles são tipos de dados
imutáveis. Isso significa que alterar o valor de um tipo de dados numérico resulta em
um objeto recém-alocado.
Objetos numéricos são criados quando você atribui um valor a eles. Por exemplo -
var1 = 1
var2 = 10
Você também pode excluir a referência a um objeto numérico usando a instrução del .
A sintaxe da instrução del é -
del var1[,var2[,var3[....,varN]]]]
Você pode excluir um único objeto ou vários objetos usando a instrução del . Por
exemplo -
del var
del var_a, var_b
Python suporta diferentes tipos numéricos -
int (inteiros assinados) - Eles são freqüentemente chamados de inteiros ou

inteiros . São números inteiros positivos ou negativos sem ponto decimal. Os
inteiros no Python 3 são de tamanho ilimitado. O Python 2 possui dois tipos
inteiros - int e long. Não há mais ' long integer ' no Python 3.
float (valores reais de ponto flutuante) - Também chamados de floats, eles

representam números reais e são escritos com um ponto decimal dividindo o
inteiro e as partes fracionárias. Flutuadores também podem estar em notação
2
científica, com E ou e indicando a potência de 10 (2.5e2 = 2.5 x 10 = 250).
complex (números complexos) - são da forma a + bJ, onde a e b são floats

e J (ou j) representa a raiz quadrada de -1 (que é um número imaginário). A
parte real do número é a, e a parte imaginária é b. Números complexos não são
muito usados na programação Python.
É possível representar um inteiro em formato hexa-decimal ou octal
>>> number = 0xA0F #Hexa-decimal

>>> number
2575
>>> number = 0o37 #Octal

>>> number
31
Exemplos
Aqui estão alguns exemplos de números.
int flutuador complexo
10 0,0 3,14 j
100 15,20 45.j
-786 -21,9 9.322e-36j
080 32,3 + e18 .876j
-0490 -90. -6545 + 0J
-0 × 260 -32,54e100 3e + 26J

0 × 69 70,2-E12 4.53e-7j
Um número complexo consiste em um par ordenado de números reais de ponto

flutuante denotado por a + bj, onde a é a parte real eb é a parte imaginária do número
complexo.
Conversão de Tipo de Número

O Python converte números internamente em uma expressão contendo tipos mistos
para um tipo comum de avaliação. Às vezes, você precisa forçar um número
explicitamente de um tipo para outro para satisfazer os requisitos de um operador ou
parâmetro de função.
Digite int (x) para converter x em um inteiro simples.
Digite long (x) para converter x em um inteiro longo.
Digite float (x) para converter x em um número de ponto flutuante.
Digite complex (x) para converter x em um número complexo com parte real x
e parte zero imaginária.
Digite complexo (x, y) para converter x e y em um número complexo com

parte real x e parte imaginária y. x e y são expressões numéricas
Funções Matemáticas
O Python inclui as seguintes funções que executam cálculos matemáticos.
Sr. Função e Devoluções (Descrição)

Não.
abs (x)
1 O valor absoluto de x: a distância (positiva) entre x e zero.
ceil (x)
2 O teto de x: o menor inteiro não menor que x.
cmp (x, y)
3 -1 se x <y, 0 se x == y, ou 1 se x> y. Deprecado em Python 3. Em vez disso,

use return (x> y) - (x <y) .
exp (x)
4 x
O exponencial de x: e
5 fabs (x)
O valor absoluto de x.
andar (x)
6 O piso de x: o maior número inteiro não maior que x.
log (x)
7 O logaritmo natural de x, para x> 0.
log10 (x)
8 O logaritmo de base 10 de x para x> 0.
max (x1, x2, ...)

9 O maior dos seus argumentos: o valor mais próximo do infinito positivo
min (x1, x2, ...)

10 O menor dos seus argumentos: o valor mais próximo do infinito negativo.
modf (x)
11 As partes fracionária e inteira de x em uma tupla de dois itens. Ambas as

partes têm o mesmo sinal que x. A parte inteira é retornada como um float.
pow (x, y)
12 O valor de x ** y.
round (x [, n])
x arredondado para n dígitos do ponto decimal. O Python arredonda para
13 longe de zero como um desempatador: round (0.5) é 1.0 e round (-0.5) é
-1.0.
sqrt (x)
14 A raiz quadrada de x para x> 0.
Funções de números aleatórios

Números aleatórios são usados para aplicativos de jogos, simulações, testes, segurança
e privacidade. Python inclui as seguintes funções que são comumente usadas.
Sr. Descrição da função

Não.
escolha (seq)
1 Um item aleatório de uma lista, tupla ou string.
randrange ([start,] stop [, passo])

2 Um elemento selecionado aleatoriamente do intervalo (iniciar, parar, passo).
3 aleatória()
Um float aleatório r, tal que 0 é menor ou igual a re é menor que 1
semente ([x])
Define o valor inicial do inteiro usado na geração de números aleatórios.
4 Chame essa função antes de chamar qualquer outra função de módulo
aleatório. Retorna Nenhum.
shuffle (lst)
5 Randomiza os itens de uma lista no lugar. Retorna Nenhum.
uniforme (x, y)
6 Um float aleatório r, tal que x é menor que ou igual a r e r é menor que y.
Funções trigonométricas
O Python inclui as seguintes funções que executam cálculos trigonométricos.

Não.
acos (x)
1 Retorna o arco cosseno de x, em radianos.
asin (x)
2 Retorne o arco seno de x, em radianos.
atan (x)
3 Retorna o arco tangente de x, em radianos.
atan2 (y, x)
4 Retorna atan (y / x), em radianos.
cos (x)
5 Retorna o cosseno de x radianos.
hipotago (x, y)
6 Retornar a norma euclidiana, sqrt (x * x + y * y).
sin (x)
7 Retorne o seno de x radianos.
bronzeado (x)
8 Retorna a tangente de x radianos.
9 graus (x)
Converte o ângulo x de radianos para graus.
radianos (x)
10 Converte o ângulo x de graus para radianos.
Constantes matemáticas
O módulo também define duas constantes matemáticas -
Sr. Constantes e Descrição

Não.
pi
1
A constante matemática pi.
e
2
A constante matemática e.
Python 3 - Cordas
Strings estão entre os tipos mais populares em Python. Podemos criá-los simplesmente
colocando caracteres entre aspas. O Python trata aspas simples da mesma forma que
as aspas duplas. Criar strings é tão simples quanto atribuir um valor a uma variável.
Por exemplo -
var1 = 'Hello World!'

var2 = "Python Programming"
Acessando Valores em Strings

Python não suporta um tipo de caractere; estas são tratadas como cadeias de
comprimento um, assim também consideradas uma substring.
Para acessar substrings, use os colchetes para fatiar junto com o índice ou índices para
obter sua substring. Por exemplo -
#!/usr/bin/python3

var2 = "Python Programming"
print ("var1[0]: ", var1[0])

print ("var2[1:5]: ", var2[1:5])

var1[0]: H
var2[1:5]: ytho
Atualizando Strings
Você pode "atualizar" uma string existente (re) atribuindo uma variável a outra string.
O novo valor pode ser relacionado ao seu valor anterior ou a uma string completamente
diferente. Por exemplo -
#!/usr/bin/python3

print ("Updated String :- ", var1[:6] + 'Python')
Updated String :- Hello Python
Personagens de fuga
A tabela a seguir é uma lista de caracteres de escape ou não imprimíveis que podem
ser representados com notação de barra invertida.
Um personagem de escape é interpretado; em uma única citação, bem como cadeias

duplas entre aspas.
Notação de barra Caráter

Descrição
invertida hexadecimal
\uma 0x07 Sino ou alerta
\b 0x08 Backspace
\ cx Controle-x
\ Cx Controle-x
\e 0x1b Escapar
\f 0x0c Formfeed
\ M- \ Cx Meta-Control-x
\n 0x0a Nova linha
\ nnn Notação Octal, onde n está na faixa de 0,7
\r 0x0d Retorno de carro
\s 0x20 Espaço
\t 0x09 Aba
\v 0x0b Guia vertical
\x Personagem x
Notação hexadecimal, em que n está na faixa

\ xnn
de 0,9, af ou AF
Operadores Especiais de String

Suponha que a variável de string a contém 'Hello' e a variável b contém 'Python', então
-
a + b vai
+ Concatenação - Adiciona valores em ambos os lados do operador dar
HelloPython
a * 2 vai
Repetição - Cria novas strings, concatenando várias cópias da
* dar -
mesma string
HelloHello
um [1] vai
[] Fatia - Dá o caractere do índice fornecido
dar e
a [1: 4]
[:] Faixa de alcance - fornece os caracteres do intervalo especificado
dará ell
Associação - Retorna verdadeiro se um caractere existir na string H em um

em dada vai dar 1
Associação - Retorna verdadeiro se um caractere não existir na M não em

não em string dada um vai dar
1
Raw String - Suprime o significado real dos caracteres Escape. A print r '\ n'
sintaxe para strings não processadas é exatamente a mesma que
imprime \ n
para strings normais, com exceção do operador de string raw, a
r/R e imprime
letra "r", que precede as aspas. O "r" pode ser minúscula (r) ou
maiúscula (R) e deve ser colocado imediatamente antes da R '\ n'prints
primeira marca de aspas. \n
Veja na
% Formato - Executa a formatação de String próxima
seção
Operador de formatação de string

Um dos recursos mais legais do Python é o operador de formato de string%. Esse
operador é exclusivo de strings e compensa o pacote de funções da família printf () de
C. A seguir, um exemplo simples -
#!/usr/bin/python3
print ("My name is %s and weight is %d kg!" % ('Zara', 21))
My name is Zara and weight is 21 kg!
Aqui está a lista de conjuntos completos de símbolos que podem ser usados junto
com% -
Sr. Formatar símbolo e conversão

Não.
%c
1
personagem
%s
2
conversão de strings via str () antes da formatação
%Eu
3
inteiro decimal assinado
%d
4
inteiro decimal assinado
%você
5
inteiro decimal sem sinal
%o
6
inteiro octal
%x
7
inteiro hexadecimal (letras minúsculas)
%X
8
inteiro hexadecimal (letras maiúsculas)
9 %e
notação exponencial (com minúscula 'e')
%E
10
notação exponencial (com UPPERcase 'E')
%f
11
número real de ponto flutuante
%g
12
o menor de% f e% e
%G
13
o menor de% f e% E
Outros símbolos e funcionalidades suportados estão listados na tabela a seguir -
Sr. Símbolo e Funcionalidade

Não.
*
1
argumento especifica largura ou precisão
-
2
justificação à esquerda
+
3
exibir o sinal
<sp>
4
deixar um espaço em branco antes de um número positivo
5 adicione o zero octal à esquerda ('0') ou o valor hexadecimal '0x' ou '0X',

dependendo se 'x' ou 'X' foram usados.
0
6
pad da esquerda com zeros (em vez de espaços)
7 %
'%%' deixa você com um único literal '%'
(var)
8
variável de mapeamento (argumentos do dicionário)
mn
9 m é a largura total mínima e n é o número de dígitos a exibir após o ponto

decimal (se for o caso).
Citações triplas
As citações triplas do Python vêm ao salvamento, permitindo que as strings abranjam
várias linhas, incluindo NEWLINEs verbais, TABs e quaisquer outros caracteres
especiais.
A sintaxe para aspas triplas consiste em três aspas simples ou duplas consecutivas .
#!/usr/bin/python3
para_str = """this is a long string that is made up of

several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print (para_str)
Quando o código acima é executado, produz o seguinte resultado. Observe como cada
caractere especial foi convertido em sua forma impressa, até a última NEWLINE no final
da string entre o "up". e fechando aspas triplas. Observe também que NEWLINEs
ocorrem com um retorno de carro explícito no final de uma linha ou com seu código de
escape (\ n) -
this is a long string that is made up of

several lines and non-printable characters such as
TAB ( ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
], or just a NEWLINE within
the variable assignment will also show up.
As strings raw não tratam a barra invertida como um caractere especial. Cada caractere
que você coloca em uma string permanece do jeito que você escreveu
#!/usr/bin/python3
print ('C:\\nowhere')
C:\nowhere
Agora vamos fazer uso de string raw. Nós colocaríamos expressão na expressão "da
seguinte forma -
#!/usr/bin/python3
print (r'C:\\nowhere')
C:\\nowhere
String Unicode
No Python 3, todas as strings são representadas em Unicode. O Python 2 é armazenado
internamente como ASCII de 8 bits, portanto, é necessário anexar 'u' para torná-lo
Unicode. Não é mais necessário agora.
Métodos de String Embutidos

Python inclui os seguintes métodos internos para manipular strings -
Sr. Métodos e Descrição

Não.
capitalizar()
1 Capitaliza a primeira letra da string
centro (largura, fillchar)
2 Retorna uma string preenchida com fillchar com a string original centralizada
em um total de colunas de largura .
count (str, beg = 0, end = len (string))
3 Conta quantas vezes str ocorre na string ou em uma subseqüência de string

se o índice inicial do início e final do índice for dado.
decode (codificação = 'UTF-8', erros = 'estrito')
4 Decodifica a string usando o codec registrado para codificação. codificação

padrão para a codificação padrão de string.
codificar (codificação = 'UTF-8', erros = 'estrito')
5 Retorna a versão da string codificada da string; no erro, o padrão é gerar um

ValueError, a menos que erros sejam dados com 'ignore' ou 'replace'.
6 endswith (sufixo, beg = 0, end = len (string))

Determina se seqüência de caracteres ou uma subseqüência de seqüência de
caracteres (se for iniciado índice início e final do índice final são fornecidos)
termina com sufixo; retorna verdadeiro se assim e falso caso contrário.
expandtabs (tabsize = 8)
7 Expande as guias em string para vários espaços; O padrão é 8 espaços por

guia, se o tamanho da guia não for fornecido.
find (str, beg = 0 end = len (string))

Determine se str ocorre na string ou em uma subcadeia de strings se o início
8 do índice e o final do índice final receberem o índice de retornos se forem
encontrados e -1 caso contrário.
índice (str, beg = 0, end = len (string))

9 O mesmo que find (), mas gera uma exceção se str não for encontrado.
isalnum ()
10 Retorna true se string tiver pelo menos 1 caractere e todos os caracteres

forem alfanuméricos e caso contrário, false.
isalfa ()
11 Retorna true se string tiver pelo menos 1 caractere e todos os caracteres

forem alfabéticos e falsos caso contrário.
isdigit ()
12 Retorna true se string contiver apenas dígitos e false caso contrário.
é inferior()
13 Retorna true se string tiver pelo menos um caractere em maiúsculas e todos

os caracteres em maiúsculas estiverem em minúsculas e falsos caso contrário.
isnumeric ()
14 Retorna true se uma string unicode contiver apenas caracteres numéricos e

false caso contrário.
isspace ()
15 Retorna true se string contiver apenas caracteres de espaço em branco e false

caso contrário.
istitle ()
16 Retorna true se a string estiver corretamente "titlecased" e falsa caso

contrário.
17 isupper ()
Retorna true se string tiver pelo menos um caractere em maiúsculas e todos
os caracteres em maiúsculas estiverem em maiúsculas e false em outro caso.
junte-se (seq)
18 Mescla (concatena) as representações de string de elementos na sequência

seq em uma string, com string separadora.
len (string)
19 Retorna o comprimento da string
ljust (largura [, fillchar])
20 Retorna uma string preenchida com espaço com a sequência original

justificada à esquerda para um total de colunas de largura.
mais baixo()
21 Converte todas as letras maiúsculas em string para minúsculas.
lstrip ()
22 Remove todos os principais espaços em branco em string.
maketrans ()
23 Retorna uma tabela de conversão a ser usada na função translate.
max (str)
24 Retorna o caractere alfabético máximo da string str.
min (str)
25 Retorna o caractere alfabético min da string str.
substituir (antigo, novo [, max])
26 Substitui todas as ocorrências de antigo em string por ocorrências novas ou no

máximo, se max for dado.
rfind (str, beg = 0, end = len (string))

27 O mesmo que find (), mas procura para trás na string.
rindex (str, beg = 0, end = len (string))

28 O mesmo que index (), mas procura para trás na string.
rjust (largura, [, fillchar])
29 Retorna uma string preenchida com espaço com a string original justificada à
direita para um total de colunas de largura.
30 rstrip ()
Remove todos os espaços em branco finais da string.
split (str = "", num = string.count (str))

Divide a string de acordo com o str de delimitador (espaço se não for
31 fornecido) e retorna a lista de substrings; dividir em no máximo num
substrings se dado.
splitlines (num = string.count ('\ n'))
32 Divide a string em todos os (ou num) NEWLINEs e retorna uma lista de cada
linha com NEWLINEs removidos.
startswith (str, beg = 0, end = len (string))

Determina se uma string ou uma subseqüência de string (se for iniciada a
33 indexação beg e end index end for dada) começa com string de substring;
retorna verdadeiro se assim e falso caso contrário.
tira ([chars])
34 Executa tanto lstrip () quanto rstrip () na string
swapcase ()
35 Inverte o caso de todas as letras em string.
título()
36 Retorna a versão "titlecased" da string, ou seja, todas as palavras começam

com maiúsculas e as restantes são minúsculas.
translate (table, deletechars = "")
37 Traduz string de acordo com a tabela de tradução str (256 caracteres),

removendo os da string.
superior()
38 Converte letras minúsculas em string para maiúsculas.
zfill (largura)
Retorna a string original da esquerda com zeros para um total de caracteres
39 de largura; destinado a números, zfill () retém qualquer sinal dado (menos um
zero).
isdecimal ()
40 Retorna true se uma string unicode contiver apenas caracteres decimais e

false caso contrário.
Python 3 - Listas
A estrutura de dados mais básica do Python é a sequência . Cada elemento de uma
sequência recebe um número - sua posição ou índice. O primeiro índice é zero, o
segundo índice é um e assim por diante.
O Python tem seis tipos de sequências, mas os mais comuns são listas e tuplas, que
veríamos neste tutorial.
Há certas coisas que você pode fazer com todos os tipos de sequência. Essas operações
incluem indexação, fatiamento, adição, multiplicação e verificação de associação. Além
disso, o Python possui funções internas para encontrar o tamanho de uma sequência e
para encontrar seus maiores e menores elementos.
Listas de Python
A lista é o tipo de dados mais versátil disponível no Python, que pode ser escrito como
uma lista de valores separados por vírgula (itens) entre colchetes. O importante sobre
uma lista é que os itens em uma lista não precisam ser do mesmo tipo.
Criar uma lista é tão simples quanto colocar diferentes valores separados por vírgulas
entre colchetes. Por exemplo -
list1 = ['physics', 'chemistry', 1997, 2000];

list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
Semelhante aos índices de string, os índices de lista começam em 0 e as listas podem

ser divididas, concatenadas e assim por diante.
Acessando Valores em Listas

Para acessar valores em listas, use os colchetes para fatiar junto com o índice ou
índices para obter o valor disponível nesse índice. Por exemplo -
#!/usr/bin/python3
list1 = ['physics', 'chemistry', 1997, 2000]

list2 = [1, 2, 3, 4, 5, 6, 7 ]
print ("list1[0]: ", list1[0])

print ("list2[1:5]: ", list2[1:5])
list1[0]: physics
list2[1:5]: [2, 3, 4, 5]
Atualizando Listas
Você pode atualizar um ou vários elementos de listas, dando a fatia no lado esquerdo
do operador de atribuição, e você pode adicionar a elementos em uma lista com o
método append (). Por exemplo -
#!/usr/bin/python3  Demonstração ao vivo
list = ['physics', 'chemistry', 1997, 2000]

print ("Value available at index 2 : ", list[2])
list[2] = 2001
print ("New value available at index 2 : ", list[2])
Nota - O método append () é discutido na seção seguinte.
Value available at index 2 : 1997

New value available at index 2 : 2001
Excluir elementos da lista

Para remover um elemento list, você pode usar a instrução del se você souber
exatamente qual (is) elemento (s) você está excluindo. Você pode usar o método
remove () se não souber exatamente quais itens excluir. Por exemplo -
#!/usr/bin/python3
list = ['physics', 'chemistry', 1997, 2000]

print (list)
del list[2]
print ("After deleting value at index 2 : ", list)
['physics', 'chemistry', 1997, 2000]

After deleting value at index 2 : ['physics', 'chemistry', 2000]
Nota - o método remove () é discutido na seção subsequente.
Operações básicas da lista

As listas respondem aos operadores + e * como se fossem strings; eles significam
concatenação e repetição aqui também, exceto que o resultado é uma nova lista, não
uma string.
Na verdade, as listas respondem a todas as operações gerais de sequência que usamos

em strings no capítulo anterior.
Expressão Python Resultados Descrição
len ([1, 2, 3]) 3 comprimento
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] Concatenação
['Olá!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] Repetição
3 em [1, 2, 3] Verdade Filiação

para x em [1,2,3]: print (x, end = '') 123 Iteração
Indexação, fatiamento e matrizes

Como as listas são seqüências, a indexação e o fatiamento funcionam da mesma
maneira para listas, como para strings.
Assumindo a seguinte entrada -
L = ['C++'', 'Java', 'Python']
L [2] 'Python' Compensações começam em zero
L [-2] 'Java' Negativo: conte a partir da direita
L [1:] ['Java', 'Python'] Cortando seções de buscas
Funções e métodos de lista incorporados

Python inclui as seguintes funções de lista -

Não.
cmp (list1, list2)

1 Não está mais disponível no Python 3.
len (lista)
2 Dá o comprimento total da lista.
max (lista)
3 Retorna o item da lista com o valor máximo.
min (lista)
4 Retorna o item da lista com o valor mínimo.
lista (seq)
5 Converte uma tupla na lista.
Python inclui os seguintes métodos de lista -
Sr. Métodos e Descrição

Não.
1 list.append (obj)
Acrescenta objeto obj a listar
list.count (obj)
2 Retorna a contagem de quantas vezes obj ocorre na lista
list.extend (seq)
3 Acrescenta o conteúdo de seq a lista
list.index (obj)
4 Retorna o índice mais baixo na lista que obj aparece
list.insert (index, obj)

5 Insere objeto obj na lista no índice de deslocamento
list.pop (obj = lista [-1])

6 Remove e retorna último objeto ou obj da lista
list.remove (obj)
7 Remove objeto obj da lista
list.reverse ()
8 Inverte os objetos da lista no lugar
list.sort ([func])
9 Classifica objetos da lista, use compare func se for dado
Python 3 - Tuplas
Uma tupla é uma sequência de objetos Python imutáveis. Tuplas são seqüências, assim
como listas. A principal diferença entre as tuplas e as listas é que as tuplas não podem
ser alteradas ao contrário das listas. As tuplas usam parênteses, enquanto as listas
usam colchetes.
Criar uma tupla é tão simples quanto colocar diferentes valores separados por vírgulas.
Opcionalmente, você pode colocar esses valores separados por vírgula entre parênteses
também. Por exemplo -
tup1 = ('physics', 'chemistry', 1997, 2000)

tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
A tupla vazia é escrita como dois parênteses contendo nada -
tup1 = ();
Para escrever uma tupla contendo um único valor, você deve incluir uma vírgula,
mesmo que haja apenas um valor -
tup1 = (50,)
Como os índices de string, os índices da tupla começam em 0 e podem ser fatiados,

concatenados e assim por diante.
Acessando Valores em Tuplas

Para acessar valores na tupla, use os colchetes para fatiar junto com o índice ou índices
para obter o valor disponível naquele índice. Por exemplo -
#!/usr/bin/python3
tup1 = ('physics', 'chemistry', 1997, 2000)

tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])

print ("tup2[1:5]: ", tup2[1:5])
tup1[0]: physics
tup2[1:5]: (2, 3, 4, 5)
Atualizando tuplas
Tuplas são imutáveis, o que significa que você não pode atualizar ou alterar os valores
dos elementos da tupla. Você pode pegar partes das tuplas existentes para criar novas
tuplas, como demonstra o exemplo a seguir -
#!/usr/bin/python3
tup1 = (12, 34.56)

tup2 = ('abc', 'xyz')
# Following action is not valid for tuples

# tup1[0] = 100;
# So let's create a new tuple as follows

tup3 = tup1 + tup2
print (tup3)
(12, 34.56, 'abc', 'xyz')
Excluir elementos da tupla

A remoção de elementos individuais da tupla não é possível. Não há, é claro, nada de
errado em reunir outra tupla com os elementos indesejados descartados.
Para remover explicitamente uma tupla inteira, basta usar a instrução del . Por
exemplo -
#!/usr/bin/python3
tup = ('physics', 'chemistry', 1997, 2000);
print (tup)
del tup;
print ("After deleting tup : ")
print (tup)
Isso produz o seguinte resultado.
Nota - Uma exceção é levantada. Isso ocorre porque, depois do lançamento , a tupla
não existe mais.
('physics', 'chemistry', 1997, 2000)

After deleting tup :
File "test.py", line 9, in <module>
print tup;
NameError: name 'tup' is not defined
Operações básicas de tuplas

Tuplas respondem aos operadores + e * muito parecido com strings; eles significam
concatenação e repetição aqui também, exceto que o resultado é uma nova tupla, não
uma string.
Na verdade, as tuplas respondem a todas as operações gerais de sequência que usamos

em strings no capítulo anterior.
len ((1, 2, 3)) 3 comprimento
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) Concatenação
('Olá!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') Repetição
3 in (1, 2, 3) Verdade Filiação
para x em (1,2,3): print (x, end = '') 123 Iteração
Indexação, fatiamento e matrizes

Como as tuplas são seqüências, a indexação e o fatiamento funcionam da mesma
maneira para as tuplas, como para strings, assumindo a seguinte entrada -
T=('C++', 'Java', 'Python')
T [2] 'Python' Compensações começam em zero

T [-2] 'Java' Negativo: conte a partir da direita
T [1:] ('Java', 'Python') Cortando seções de buscas
Sem Delimitadores de Inclusão

Nenhum Delimitador delimitador é qualquer conjunto de múltiplos objetos, separados
por vírgulas, escritos sem identificar símbolos, ou seja, colchetes para listas, parênteses
para tuplas, etc., padrão para tuplas, como indicado nestes exemplos curtos.
Funções de Tuple incorporadas

Python inclui as seguintes funções de tupla -

Não.
cmp (tuple1, tuple2)

1 Compara elementos de ambas as tuplas.
len (tuple)
2 Dá o comprimento total da tupla.
max (tupla)
3 Retorna o item da tupla com o valor máximo.
min (tupla)
4 Retorna o item da tupla com o valor mínimo.
tupla (seq)
5 Converte uma lista em tupla.
Python 3 - Dicionário
Cada chave é separada de seu valor por dois pontos (:), os itens são separados por
vírgulas e a coisa toda é colocada entre chaves. Um dicionário vazio sem nenhum item
é escrito com apenas duas chaves, assim: {}.
As chaves são exclusivas em um dicionário, enquanto os valores podem não ser. Os

valores de um dicionário podem ser de qualquer tipo, mas as chaves devem ser de um
tipo de dados imutável, como strings, números ou tuplas.
Acessando Valores no Dicionário

Para acessar elementos de dicionário, você pode usar os colchetes familiares
juntamente com a chave para obter seu valor. A seguir, um exemplo simples -
#!/usr/bin/python3
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
dict['Name']: Zara
dict['Age']: 7
Se tentarmos acessar um item de dados com uma chave, que não faz parte do
dicionário, receberemos um erro da seguinte forma:
#!/usr/bin/python3
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print ("dict['Alice']: ", dict['Alice'])
dict['Zara']:
print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'
Atualizando Dicionário
Você pode atualizar um dicionário adicionando uma nova entrada ou um par de valores-
chave, modificando uma entrada existente ou excluindo uma entrada existente,
conforme mostrado em um exemplo simples fornecido abaixo.
#!/usr/bin/python3

dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School" # Add new entry

print ("dict['School']: ", dict['School'])
dict['Age']: 8
dict['School']: DPS School
Excluir elementos do dicionário

Você pode remover elementos de dicionário individuais ou limpar todo o conteúdo de
um dicionário. Você também pode excluir o dicionário inteiro em uma única operação.
Para remover explicitamente um dicionário inteiro, basta usar a instrução del . A seguir,
um exemplo simples -
#!/usr/bin/python3
del dict['Name'] # remove entry with key 'Name'

dict.clear() # remove all entries in dict
del dict # delete entire dictionary

print ("dict['School']: ", dict['School'])
Isso produz o seguinte resultado.
Uma exceção é levantada porque depois do del dict , o dicionário não existe mais.
dict['Age']:
print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable
Nota - O método del () é discutido na seção subsequente.
Propriedades de chaves de dicionário

Os valores do dicionário não têm restrições. Eles podem ser qualquer objeto Python
arbitrário, seja objetos padrão ou objetos definidos pelo usuário. No entanto, o mesmo
não é verdade para as chaves.
Há dois pontos importantes para lembrar sobre as chaves do dicionário -
(a) Mais de uma entrada por chave não é permitida. Isso significa que nenhuma chave
duplicada é permitida. Quando chaves duplicadas são encontradas durante a atribuição,
a última atribuição ganha. Por exemplo -
#!/usr/bin/python3
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}

dict['Name']: Manni
(b) As chaves devem ser imutáveis. Isso significa que você pode usar strings, números
ou tuplas como chaves de dicionário, mas algo como ['key'] não é permitido. A seguir,
um exemplo simples -
#!/usr/bin/python3
dict = {['Name']: 'Zara', 'Age': 7}


dict = {['Name']: 'Zara', 'Age': 7}
TypeError: list objects are unhashable
Funções e Métodos do Dicionário Integrado

Python inclui as seguintes funções do dicionário -

Não.
cmp (dict1, dict2)

1 Não está mais disponível no Python 3.
len (dict)
2 Dá o comprimento total do dicionário. Isso seria igual ao número de itens no

dicionário.
str (dict)
3 Produz uma representação de string imprimível de um dicionário
tipo (variável)
4 Retorna o tipo da variável passada. Se variável passada é dicionário, então

retornaria um tipo de dicionário.
O Python inclui os seguintes métodos de dicionário -
Sr. Método e Descrição

Não.
dict.clear ()
1 Remove todos os elementos do dicionário dict
dict.copy ()
2 Retorna uma cópia superficial do dicionário dict
dict.fromkeys ()
3 Crie um novo dicionário com chaves de seq e valores configurados para

valor .
4 dict.get (key, default = None)
Para chave , retorna valor ou padrão se a chave não estiver no dicionário
dict.has_key (chave)
5 Removido, use a operação em vez disso.
dict.items ()
6 Retorna uma lista de pares de tupla do dict (chave, valor)
dict.keys ()
7 Retorna a lista de chaves do dicionário
dict.setdefault (key, default = None)
8 Semelhante a get (), mas definirá dict [key] = default se a chave ainda não
estiver no dict
dict.update (dict2)
9 Adiciona pares de valores-chave do dicionário dict2 ao dict
dict.values ()
10 Lista de dicionário retorna dict valores 's
Python 3 - data e hora

Um programa em Python pode manipular data e hora de várias maneiras. A conversão
entre formatos de data é uma tarefa comum para computadores. Os módulos de
horário e calendário do Python ajudam a rastrear datas e horas.
O que é Tick?
Intervalos de tempo são números de ponto flutuante em unidades de segundos.
Instantes particulares no tempo são expressos em segundos desde as 12h00 de 1 de
janeiro de 1970 (época).
Existe um módulo de horário popular disponível no Python que fornece funções para
trabalhar com horários e para converter entre representações. A função time.time ()
retorna a hora atual do sistema em ticks desde as 00:00, 1 de janeiro de 1970 (época).
Exemplo
#!/usr/bin/python3
import time; # This is required to include time module.
ticks = time.time()
print ("Number of ticks since 12:00am, January 1, 1970:", ticks)
Isto produziria um resultado algo como segue -

Number of ticks since 12:00am, January 1, 1970: 1455508609.34375
A aritmética de datas é fácil de fazer com carrapatos. No entanto, datas antes da época
não podem ser representadas neste formulário. Datas no futuro distante também não
podem ser representadas desta forma - o ponto de corte é em algum momento em
2038 para UNIX e Windows.
O que é o TimeTuple?
Muitas das funções de tempo do Python lidam com o tempo como uma tupla de 9
números, como mostrado abaixo -
Índice Campo Valores
0 Ano de 4 dígitos 2016
1 Mês 1 a 12
2 Dia 1 a 31
3 Hora 0 a 23
4 Minuto 0 a 59
5 Segundo 0 a 61 (60 ou 61 são segundos-bissextos)
6 Dia da semana 0 a 6 (0 é segunda-feira)
7 Dia do ano 1 a 366 (dia juliano)
8 Horário de -1, 0, 1, -1 significa que a biblioteca determina o horário de

verão verão
Por exemplo -
import time
print (time.localtime());
Isso produziria um resultado como segue -
time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, tm_hour = 9,

tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)
A tupla acima é equivalente à estrutura struct_time . Essa estrutura tem os seguintes

atributos -
Índice Atributos Valores
0 tm_year 2016
1 tm_mon 1 a 12
2 tm_mday 1 a 31
3 tm_hour 0 a 23
4 tm_min 0 a 59
5 tm_sec 0 a 61 (60 ou 61 são segundos-bissextos)
6 tm_wday 0 a 6 (0 é segunda-feira)
7 tm_yday 1 a 366 (dia juliano)
8 tm_isdst -1, 0, 1, -1 significa que a biblioteca determina o horário de verão
Obtendo hora atual

Para traduzir um instante de tempo de segundos desde o valor de ponto flutuante de
época para uma tabela de horários, passe o valor de ponto flutuante para uma função
(por exemplo, hora local) que retorna uma tupla de tempo com todos os nove itens
válidos.
#!/usr/bin/python3
import time
localtime = time.localtime(time.time())
print ("Local current time :", localtime)
Isso produziria o seguinte resultado, que poderia ser formatado em qualquer outra
forma apresentável -
Local current time : time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15,

tm_hour = 9, tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)
Obtendo o tempo formatado

Você pode formatar a qualquer momento como por sua exigência, mas um método
simples para obter tempo em um formato legível é asctime () -
Demonstração ao vivo  Demonstração ao vivo
#!/usr/bin/python3
import time
localtime = time.asctime( time.localtime(time.time()) )

print ("Local current time :", localtime)
Isso produziria o seguinte resultado -
Local current time : Mon Feb 15 09:34:03 2016
Obtendo calendário por um mês

O módulo de calendário fornece uma ampla gama de métodos para jogar com
calendários anuais e mensais. Aqui, imprimimos um calendário para um determinado
mês (janeiro de 2008) -
#!/usr/bin/python3
import calendar
cal = calendar.month(2016, 2)
print ("Here is the calendar:")
print (cal)
Here is the calendar:

February 2016
Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29
O tempo do módulo
Existe um módulo de tempo popular disponível no Python, que fornece funções para
trabalhar com tempos e para converter entre representações. Aqui está a lista de todos
os métodos disponíveis.

Não.
time.altzone
O deslocamento do fuso horário do horário local, em segundos a oeste do
1 UTC, se houver um definido. Isso é negativo se o fuso horário do horário de

verão local estiver a leste da UTC (como na Europa Ocidental, incluindo o
Reino Unido). Use isso se a luz do dia for diferente de zero.
time.asctime ([tupletime])
2 Aceita uma tupla de tempo e retorna uma string legível de 24 caracteres,

como "Ter Dez 11 18:07:14 2008".
Rélogio de ponto( )
Retorna o tempo atual da CPU como um número de segundos em ponto
3 flutuante. Para medir os custos computacionais de diferentes abordagens, o
valor de time.clock é mais útil que o de time.time ().
time.ctime ([seg.])
4 Como asctime (localtime (secs)) e sem argumentos é como asctime ()
5 time.gmtime ([segs])
Aceita um instante expresso em segundos desde a época e retorna uma hora-
tupla t com a hora UTC. Nota - t.tm_isdst é sempre 0
time.localtime ([segs])
Aceita um instante expresso em segundos desde a época e retorna uma hora-
6 tupla t com a hora local (t.tm_isdst é 0 ou 1, dependendo se o DST se aplica a
segundos instantâneos por regras locais).
time.mktime (tupletime)
Aceita um instante expresso como uma tupla de tempo na hora local e retorna
7 um valor de ponto flutuante com o instante expresso em segundos desde a
época.
time.sleep (secs)
8 Suspende o thread de chamada por segundos seg.
time.strftime (fmt [, tupletime])
9 Aceita um instante expresso como uma tupla no tempo local e retorna uma
string representando o instante, conforme especificado pela string fmt.
time.strptime (str, fmt = '% a% b% d% H:% M:% S% Y')
10 Analisa str de acordo com a string de formato fmt e retorna o instante no

formato time-tuple.
time.time ()
11 Retorna o instante de tempo atual, um número de segundos de ponto

flutuante desde a época.
time.tzset ()
12 Redefine as regras de conversão de tempo usadas pelas rotinas da biblioteca.

A variável de ambiente TZ especifica como isso é feito.
Existem dois atributos importantes disponíveis com o módulo de tempo. Eles são
Sr. Atributo e Descrição

Não.
time.timezone
Atributo time.timezone é o deslocamento em segundos do fuso horário local

1
(sem DST) de UTC (> 0 nas Américas; <= 0 na maior parte da Europa, Ásia,
África).
2 time.tzname
Atributo time.tzname é um par de cadeias dependentes do idioma, que são os

nomes do fuso horário local sem e com o horário de verão, respectivamente.
O módulo do calendário
O módulo de calendário fornece funções relacionadas ao calendário, incluindo funções
para imprimir um calendário de texto para um determinado mês ou ano.
Por padrão, o calendário leva a segunda-feira como o primeiro dia da semana e o

domingo como o último. Para alterar isso, chame a função calendar.setfirstweekday
() .
Aqui está uma lista de funções disponíveis com o módulo de calendário -

Não.
calendar.calendar (ano, w = 2, l = 1, c = 6)
Retorna uma string de múltiplas linhas com um calendário para o ano ano
1 formatado em três colunas separadas por espaços c. w é a largura em
caracteres de cada data; cada linha tem comprimento 21 * w + 18 + 2 * c. l é
o número de linhas para cada semana.
calendar.firstweekday ()
Retorna a configuração atual para o dia da semana que começa a cada

2
semana. Por padrão, quando o calendário é importado pela primeira vez, isso
é 0, significando segunda-feira.
calendar.isleap (ano)
3
Retorna Verdadeiro se o ano for um ano bissexto; caso contrário, False.
calendar.leapdays (y1, y2)
4 Retorna o número total de dias bissextos nos anos dentro do intervalo (y1,
y2).
calendar.month (ano, mês, w = 2, l = 1)
Retorna uma string de múltiplas linhas com um calendário para o mês, mês do
5 ano, uma linha por semana mais duas linhas de cabeçalho. w é a largura em
caracteres de cada data; cada linha tem comprimento 7 * w + 6. l é o número
de linhas para cada semana.
6 calendar.monthcalendar (ano, mês)
Retorna uma lista de listas de ints. Cada subliste denota uma semana. Dias
fora do mês mês do ano ano são definidos como 0; Os dias dentro do mês
estão definidos para o dia do mês, 1 e para cima.
calendar.monthrange (ano, mês)
Retorna dois inteiros. O primeiro é o código do dia da semana para o primeiro

7 dia do mês do ano do ano; o segundo é o número de dias do mês. Códigos da
semana são 0 (segunda-feira) a 6 (domingo); os números dos meses são de 1
a 12.
calendar.prcal (ano, w = 2, l = 1, c = 6)
8
Como print calendar.calendar (ano, w, l, c).
calendar.prmonth (ano, mês, w = 2, l = 1)

9
Como print calendar.month (ano, mês, w, l).
calendar.setfirstweekday (dia da semana)
10 Define o primeiro dia de cada semana para o dia da semana do código do dia
da semana. Códigos da semana são 0 (segunda-feira) a 6 (domingo).
calendar.timegm (tupletime)
O inverso de time.gmtime: aceita um instante de tempo na forma time-tuple e

11
retorna o mesmo instante que um número de segundos de ponto flutuante
desde a época.
calendar.weekday (ano, mês, dia)
Retorna o código do dia da semana para a data especificada. Códigos da

12
semana são 0 (segunda-feira) a 6 (domingo); os números dos meses são 1
(janeiro) a 12 (dezembro).
Outros módulos e funções

Se você estiver interessado, então aqui você encontrará uma lista de outros módulos e
funções importantes para brincar com data e hora em Python -
O módulo datetime
O módulo pytz
O módulo dateutil
Python 3 - Funções
Uma função é um bloco de código organizado e reutilizável usado para executar uma
única ação relacionada. Funções fornecem melhor modularidade para sua aplicação e
um alto grau de reutilização de código.
Como você já sabe, o Python oferece muitas funções internas como print (), etc., mas
você também pode criar suas próprias funções. Essas funções são chamadas de funções
definidas pelo usuário.
Definindo uma Função

Você pode definir funções para fornecer a funcionalidade necessária. Aqui estão regras
simples para definir uma função no Python.
Blocos de função começam com a palavra-chave def seguida pelo nome da

função e parênteses (()).
Quaisquer parâmetros ou argumentos de entrada devem ser colocados dentro

desses parênteses. Você também pode definir parâmetros dentro desses
parênteses.
A primeira declaração de uma função pode ser uma instrução opcional - a

cadeia de documentação da função ou docstring .
O bloco de código dentro de cada função começa com dois pontos (:) e é
recuado.
A instrução return [expressão] sai de uma função, retornando opcionalmente

uma expressão ao chamador. Uma declaração de retorno sem argumentos é a
mesma que retornar Nenhuma.
Sintaxe
def functionname( parameters ):
"function_docstring"
function_suite
return [expression]
Por padrão, os parâmetros têm um comportamento posicional e você precisa informá-

los na mesma ordem em que foram definidos.
Exemplo
A função a seguir usa uma string como parâmetro de entrada e a imprime na tela
padrão.
def printme( str ):

"This prints a passed string into this function"
print (str)
return
Chamando uma Função

Definir uma função fornece um nome, especifica os parâmetros que devem ser incluídos
na função e estrutura os blocos de código.
Uma vez finalizada a estrutura básica de uma função, você pode executá-la chamando-
a de outra função ou diretamente do prompt do Python. A seguir, um exemplo para
chamar a função printme ()
#!/usr/bin/python3
# Function definition is here

def printme( str ):
print (str)
return
# Now you can call printme function

printme("This is first call to the user defined function!")
printme("Again second call to the same function")
This is first call to the user defined function!

Again second call to the same function
Passar por referência vs valor

Todos os parâmetros (argumentos) na linguagem Python são passados por referência.
Isso significa que, se você alterar o que um parâmetro faz referência dentro de uma
função, a alteração também reflete novamente na função de chamada. Por exemplo -
#!/usr/bin/python3

def changeme( mylist ):
"This changes a passed list into this function"
print ("Values inside the function before change: ", mylist)
mylist[2]=50
print ("Values inside the function after change: ", mylist)
return
# Now you can call changeme function

mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
Aqui, estamos mantendo a referência do objeto passado e acrescentando valores no

mesmo objeto. Portanto, isso produziria o seguinte resultado -
Values inside the function before change: [10, 20, 30]

Values inside the function after change: [10, 20, 50]
Values outside the function: [10, 20, 50]
Há mais um exemplo em que o argumento está sendo passado por referência e a

referência está sendo sobrescrita dentro da função chamada.
#!/usr/bin/python3

def changeme( mylist ):
"This changes a passed list into this function"
mylist = [1,2,3,4] # This would assi new reference in mylist
print ("Values inside the function: ", mylist)
return
# Now you can call changeme function

mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
O parâmetro mylist é local para a função changeme. Alterar mylist dentro da função
não afeta minha lista. A função não realiza nada e finalmente isso produziria o seguinte
resultado -
Values inside the function: [1, 2, 3, 4]

Values outside the function: [10, 20, 30]
Argumentos da Função
Você pode chamar uma função usando os seguintes tipos de argumentos formais -
Argumentos Requeridos
Argumentos de palavras-chave
Argumentos padrão
Argumentos de comprimento variável
Argumentos Requeridos
Argumentos requeridos são os argumentos passados para uma função na ordem
posicional correta. Aqui, o número de argumentos na chamada de função deve
corresponder exatamente à definição da função.
Para chamar a função printme () , você definitivamente precisa passar um argumento,

caso contrário, ele dá um erro de sintaxe da seguinte forma -
#!/usr/bin/python3

def printme( str ):
print (str)
return

printme()

printme();
TypeError: printme() takes exactly 1 argument (0 given)
Argumentos de palavras-chave
Argumentos de palavras-chave estão relacionados às chamadas de função. Quando
você usa argumentos de palavra-chave em uma chamada de função, o chamador
identifica os argumentos pelo nome do parâmetro.
Isso permite ignorar argumentos ou colocá-los fora de ordem porque o interpretador

Python pode usar as palavras-chave fornecidas para corresponder aos valores com
parâmetros. Você também pode fazer chamadas de palavras-chave para a função
printme () das seguintes maneiras -
#!/usr/bin/python3

def printme( str ):
print (str)
return

printme( str = "My string")
My string
O exemplo a seguir fornece uma imagem mais clara. Observe que a ordem dos
parâmetros não importa.
#!/usr/bin/python3

def printinfo( name, age ):
"This prints a passed info into this function"
print ("Name: ", name)
print ("Age ", age)
return
# Now you can call printinfo function

printinfo( age = 50, name = "miki" )
Name: miki
Age 50
Argumentos Padrão
Um argumento padrão é um argumento que assume um valor padrão se um valor não
for fornecido na chamada de função para esse argumento. O exemplo a seguir dá uma
idéia sobre argumentos padrão, imprime a idade padrão se não for passada -
#!/usr/bin/python3

def printinfo( name, age = 35 ):
"This prints a passed info into this function"
print ("Name: ", name)
print ("Age ", age)
return

printinfo( age = 50, name = "miki" )
printinfo( name = "miki" )
Name: miki
Age 50
Name: miki
Age 35
Argumentos de comprimento variável

Pode ser necessário processar uma função para mais argumentos do que você
especificou ao definir a função. Esses argumentos são chamados de argumentos de
comprimento variável e não são nomeados na definição da função, diferentemente dos
argumentos obrigatórios e padrão.
A sintaxe para uma função com argumentos de variável não palavra-chave é fornecida
abaixo -
def functionname([formal_args,] *var_args_tuple ):

"function_docstring"
function_suite
return [expression]
Um asterisco (*) é colocado antes do nome da variável que contém os valores de todos
os argumentos variáveis não-chave. Esta tupla permanece vazia se nenhum argumento
adicional for especificado durante a chamada de função. A seguir, um exemplo simples -
#!/usr/bin/python3

def printinfo( arg1, *vartuple ):
"This prints a variable passed arguments"
print ("Output is: ")
print (arg1)
for var in vartuple:
print (var)
return

printinfo( 10 )
printinfo( 70, 60, 50 )
Output is:
10
Output is:
70
60
50
As funções anônimas
Essas funções são chamadas anônimas porque não são declaradas da maneira padrão
usando a palavra-chave def . Você pode usar a palavra-chave lambda para criar
pequenas funções anônimas.
Os formulários lambda podem receber qualquer número de argumentos, mas

retornam apenas um valor na forma de uma expressão. Eles não podem conter
comandos ou várias expressões.
Uma função anônima não pode ser uma chamada direta para impressão porque
lambda requer uma expressão.
As funções Lambda têm seu próprio namespace local e não podem acessar
variáveis diferentes das que estão em sua lista de parâmetros e aquelas no
namespace global.
Embora pareça que os lambdas são uma versão de uma linha de uma função,
eles não são equivalentes a instruções embutidas em C ou C ++, cuja finalidade
é empilhar a alocação por função de passagem, durante a invocação por
motivos de desempenho.
Sintaxe
A sintaxe das funções lambda contém apenas uma única instrução, que é a seguinte -
lambda [arg1 [,arg2,.....argn]]:expression
A seguir, um exemplo para mostrar como funciona a forma lambda -

#!/usr/bin/python3

sum = lambda arg1, arg2: arg1 + arg2
# Now you can call sum as a function

print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))

Value of total : 30
Value of total : 40
A declaração de retorno
A instrução return [expressão] sai de uma função, retornando opcionalmente uma
expressão ao chamador. Uma declaração de retorno sem argumentos é a mesma que
retornar Nenhuma.
Todos os exemplos dados abaixo não estão retornando nenhum valor. Você pode
retornar um valor de uma função da seguinte maneira -
#!/usr/bin/python3

def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2
print ("Inside the function : ", total)
return total
# Now you can call sum function

total = sum( 10, 20 )
print ("Outside the function : ", total )
Inside the function : 30

Outside the function : 30
Escopo das Variáveis

Todas as variáveis em um programa podem não estar acessíveis em todos os locais
nesse programa. Isso depende de onde você declarou uma variável.
O escopo de uma variável determina a parte do programa onde você pode acessar um
identificador específico. Existem dois escopos básicos de variáveis em Python -
Variáveis globais
Variáveis locais
Variáveis globais vs. locais

Variáveis que são definidas dentro de um corpo de função têm um escopo local e
aquelas definidas fora têm um escopo global.
Isso significa que as variáveis locais podem ser acessadas apenas dentro da função em
que são declaradas, enquanto as variáveis globais podem ser acessadas em todo o
corpo do programa por todas as funções. Quando você chama uma função, as variáveis
declaradas dentro dela são colocadas no escopo. A seguir, um exemplo simples -
#!/usr/bin/python3
total = 0 # This is global variable.

def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2; # Here total is local variable.
print ("Inside the function local total : ", total)
return total
# Now you can call sum function

sum( 10, 20 )
print ("Outside the function global total : ", total )
Inside the function local total : 30

Outside the function global total : 0
Python 3 - Módulos
Um módulo permite que você organize logicamente seu código Python. Agrupar código
relacionado em um módulo torna o código mais fácil de entender e usar. Um módulo é
um objeto Python com atributos arbitrariamente nomeados que você pode vincular e
referenciar.
Simplesmente, um módulo é um arquivo que consiste em código Python. Um módulo

pode definir funções, classes e variáveis. Um módulo também pode incluir código
executável.
Exemplo
O código Python para um módulo chamado aname normalmente reside em um arquivo
namedaname.py. Aqui está um exemplo de um módulo simples, support.py -
def print_func( par ):

print "Hello : ", par
return
A declaração de importação
Você pode usar qualquer arquivo de origem do Python como um módulo executando
uma instrução de importação em algum outro arquivo de origem do Python. A
importação tem a seguinte sintaxe -
import module1[, module2[,... moduleN]
Quando o interpretador encontra uma declaração de importação, ele importa o módulo

se o módulo estiver presente no caminho de pesquisa. Um caminho de pesquisa é uma
lista de diretórios que o interpretador pesquisa antes de importar um módulo. Por
exemplo, para importar o módulo hello.py, você precisa colocar o seguinte comando no
topo do script -
#!/usr/bin/python3
# Import module support

import support
# Now you can call defined function that module as follows

support.print_func("Zara")
Hello : Zara
Um módulo é carregado apenas uma vez, independentemente do número de vezes que

é importado. Isso impede que a execução do módulo aconteça repetidamente, se
ocorrerem várias importações.
A partir de ... declaração de importação

A instrução python from permite importar atributos específicos de um módulo para o
namespace atual. A partir de ... import tem a seguinte sintaxe -
from modname import name1[, name2[, ... nameN]]
Por exemplo, para importar a função fibonacci do módulo fib, use a seguinte instrução -
#!/usr/bin/python3
# Fibonacci numbers module
def fib(n): # return Fibonacci series up to n

result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a + b
return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Esta declaração não importa o módulo inteiro fib no namespace atual; Ele apenas
introduz o item fibonacci do módulo fib na tabela de símbolos globais do módulo de
importação.
A declaração from ... import *

Também é possível importar todos os nomes de um módulo para o namespace atual
usando a seguinte declaração de importação -
from modname import *
Isso fornece uma maneira fácil de importar todos os itens de um módulo para o
namespace atual; no entanto, essa declaração deve ser usada com moderação.
Executando Módulos como Scripts

Dentro de um módulo, o nome do módulo (como uma string) está disponível como o
valor da variável global __name__. O código no módulo será executado, como se você
tivesse importado, mas com o __name__ definido como "__main__".
Adicione este código no final do seu módulo -

#!/usr/bin/python3
# Fibonacci numbers module
def fib(n): # return Fibonacci series up to n

result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a + b
return result
if __name__ == "__main__":
f = fib(100)
print(f)
Quando você executar o código acima, a seguinte saída será exibida.
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Localizando Módulos
Quando você importa um módulo, o interpretador Python procura o módulo nas
seqüências a seguir -
O diretório atual.
Se o módulo não for encontrado, o Python pesquisará cada diretório na variável

de shell PYTHONPATH.
Se tudo mais falhar, o Python verificará o caminho padrão. No UNIX, esse

caminho padrão é normalmente / usr / local / lib / python3 /.
O caminho de busca do módulo é armazenado no módulo do sistema sys como a

variável sys.path . A variável sys.path contém o diretório atual, PYTHONPATH, e o
padrão dependente da instalação.
A variável PYTHONPATH
O PYTHONPATH é uma variável de ambiente, consistindo em uma lista de diretórios. A
sintaxe de PYTHONPATH é a mesma da variável PATH do shell.
Aqui está um PYTHONPATH típico de um sistema Windows -
set PYTHONPATH = c:\python34\lib;
E aqui está um PYTHONPATH típico de um sistema UNIX -
set PYTHONPATH = /usr/local/lib/python

Namespaces e escopo
Variáveis são nomes (identificadores) que mapeiam para objetos. Um namespace é um
dicionário de nomes de variáveis (chaves) e seus objetos correspondentes (valores).
Uma instrução Python pode acessar variáveis em um namespace local e no

namespace global . Se uma variável local e uma global tiverem o mesmo nome,
a variável local fará sombra à variável global.
Cada função tem seu próprio namespace local. Os métodos de classe seguem a
mesma regra de escopo que as funções comuns.
O Python faz suposições sobre se as variáveis são locais ou globais. Assume-se

que qualquer variável atribuída a um valor em uma função é local.
Portanto, para atribuir um valor a uma variável global em uma função, você
deve primeiro usar a instrução global.
A declaração global VarName diz ao Python que VarName é uma variável global. O
Python pára de procurar o namespace local pela variável.
Por exemplo, definimos uma variável Money no namespace global. Dentro da função
Money, atribuímos a Money um valor, portanto, o Python assume Money como uma
variável local.
No entanto, acessamos o valor da variável local Money antes de configurá-lo, portanto,

um UnboundLocalError é o resultado. Descomentando a declaração global corrige o
problema.
#!/usr/bin/python3
Money = 2000
def AddMoney():
# Uncomment the following line to fix the code:
# global Money
Money = Money + 1
print (Money)
AddMoney()
print (Money)
A função dir ()
A função interna dir () retorna uma lista classificada de strings contendo os nomes
definidos por um módulo.
A lista contém os nomes de todos os módulos, variáveis e funções definidos em um

módulo. A seguir, um exemplo simples -
#!/usr/bin/python3
# Import built-in module math

import math
content = dir(math)
print (content)
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',

'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
'sqrt', 'tan', 'tanh']
Aqui, a variável de string especial __name__ é o nome do módulo, e __file__ é o nome

do arquivo a partir do qual o módulo foi carregado.
As funções globais () e locais ()

As funções globals () e locals () podem ser usadas para retornar os nomes nos
namespaces globais e locais, dependendo do local de onde eles são chamados.
Se locals () for chamado de dentro de uma função, ele retornará todos os

nomes que podem ser acessados localmente a partir dessa função.
Se globals () for chamado de dentro de uma função, ele retornará todos os

nomes que podem ser acessados globalmente a partir dessa função.
O tipo de retorno de ambas as funções é o dicionário. Portanto, os nomes podem ser

extraídos usando a função keys () .
A função reload ()
Quando um módulo é importado para um script, o código na parte de nível superior de
um módulo é executado apenas uma vez.
Portanto, se você quiser reexecutar o código de nível superior em um módulo, poderá

usar a função reload () . A função reload () importa um módulo importado
anteriormente novamente. A sintaxe da função reload () é esta -
reload(module_name)
Aqui, module_name é o nome do módulo que você deseja recarregar e não a string que
contém o nome do módulo. Por exemplo, para recarregar o módulo hello, faça o
seguinte -
reload(hello)
Pacotes em Python
Um pacote é uma estrutura de diretório de arquivos hierárquica que define um único
ambiente de aplicativo Python que consiste em módulos e subpacotes e sub-subpacotes
e assim por diante.
Considere um arquivo Pots.py disponível no diretório de telefone. Este arquivo tem a
seguinte linha de código fonte -
#!/usr/bin/python3
def Pots():
print ("I'm Pots Phone")
Similar, temos outros dois arquivos com diferentes funções com o mesmo nome acima.
Eles são
Arquivo Phone / Isdn.py com a função Isdn ()
Arquivo Phone / G3.py com a função G3 ()
Agora, crie mais um arquivo __init__.py no diretório Phone -
Telefone / __ init__.py
Para disponibilizar todas as suas funções quando você tiver importado o Telefone, você
precisará colocar instruções de importação explícitas em __init__.py da seguinte
maneira -
from Pots import Pots

from Isdn import Isdn
from G3 import G3
Depois de adicionar essas linhas a __init__.py, você terá todas essas classes disponíveis
ao importar o pacote do Phone.
#!/usr/bin/python3
# Now import your Phone Package.

import Phone
Phone.Pots()
Phone.Isdn()
Phone.G3()
I'm Pots Phone

I'm 3G Phone
I'm ISDN Phone
No exemplo acima, tomamos o exemplo de uma única função em cada arquivo, mas
você pode manter várias funções em seus arquivos. Você também pode definir classes
Python diferentes nesses arquivos e, em seguida, pode criar seus pacotes fora dessas
classes.
Python 3 - Arquivos I / O
Este capítulo cobre todas as funções básicas de E / S disponíveis no Python 3. Para
mais funções, consulte a documentação padrão do Python.
Imprimir na tela
A maneira mais simples de produzir saída é usando a instrução print , onde você pode
passar zero ou mais expressões separadas por vírgulas. Essa função converte as
expressões que você passa para uma string e grava o resultado na saída padrão da
seguinte maneira -
#!/usr/bin/python3
print ("Python is really a great language,", "isn't it?")
Isso produz o seguinte resultado na sua tela padrão -
Python is really a great language, isn't it?
Lendo a entrada do teclado

O Python 2 tem duas funções internas para ler dados da entrada padrão, que por
padrão vem do teclado. Essas funções são input () e raw_input ()
No Python 3, a função raw_input () é reprovada. Além disso, as funções input () lêem

os dados do teclado como string, independentemente de estarem entre aspas ('' ou "")
ou não.
A função de entrada
A função input ([prompt]) é equivalente a raw_input, exceto pelo fato de assumir que
a entrada é uma expressão Python válida e retorna o resultado avaliado para você.
#!/usr/bin/python3
something:10
>>> x
'10'
something:'10' #entered data treated as string with or without ''
>>> x
"'10'"
Abrindo e fechando arquivos

Até agora, você estava lendo e escrevendo para a entrada e saída padrão. Agora,
vamos ver como usar arquivos de dados reais.
O Python fornece funções básicas e métodos necessários para manipular arquivos por
padrão. Você pode fazer a maior parte da manipulação de arquivos usando um objeto
de arquivo .
A função aberta
Antes de ler ou escrever um arquivo, você precisa abri-lo usando a função open () do
Python. Essa função cria um objeto de arquivo , que seria utilizado para chamar outros
métodos de suporte associados a ele.
Sintaxe
file object = open(file_name [, access_mode][, buffering])
Aqui estão os detalhes dos parâmetros -
file_name - O argumento file_name é um valor de string que contém o nome

do arquivo que você deseja acessar.
access_mode - O access_mode determina o modo no qual o arquivo deve ser

aberto, isto é, leitura, escrita, anexação, etc. Uma lista completa de valores
possíveis é fornecida abaixo na tabela. Este é um parâmetro opcional e o modo
de acesso a arquivos padrão é lido (r).
buffering - Se o valor do buffer estiver definido como 0, nenhum buffer

ocorrerá. Se o valor do buffer é 1, o buffer de linha é executado ao acessar um
arquivo. Se você especificar o valor do buffer como um inteiro maior que 1, a
ação do buffer será executada com o tamanho do buffer indicado. Se negativo,
o tamanho do buffer é o padrão do sistema (comportamento padrão).
Aqui está uma lista dos diferentes modos de abrir um arquivo -
Sr. Modo e descrição

Não.
1 Abre um arquivo apenas para leitura. O ponteiro do arquivo é colocado no

início do arquivo. Este é o modo padrão.
rb
2 Abre um arquivo para leitura somente em formato binário. O ponteiro do

arquivo é colocado no início do arquivo. Este é o modo padrão.
r+
3 Abre um arquivo para leitura e gravação. O ponteiro do arquivo colocado no

início do arquivo.
4 rb +
Abre um arquivo para leitura e gravação em formato binário. O ponteiro do

arquivo colocado no início do arquivo.
W
5 Abre um arquivo apenas para gravação. Sobrescreve o arquivo se o arquivo

existir. Se o arquivo não existir, cria um novo arquivo para gravação.
wb
Abre um arquivo para gravação somente em formato binário. Sobrescreve o

6
arquivo se o arquivo existir. Se o arquivo não existir, cria um novo arquivo
para gravação.
w+
Abre um arquivo para escrita e leitura. Sobrescreve o arquivo existente se o

7
arquivo existir. Se o arquivo não existir, cria um novo arquivo para leitura e
gravação.
wb +
Abre um arquivo para escrever e ler em formato binário. Sobrescreve o

8
arquivo existente se o arquivo existir. Se o arquivo não existir, cria um novo
arquivo para leitura e gravação.
uma
Abre um arquivo para anexar. O ponteiro do arquivo está no final do arquivo,

9
se o arquivo existir. Ou seja, o arquivo está no modo de acréscimo. Se o
arquivo não existir, ele cria um novo arquivo para gravação.
ab
Abre um arquivo para anexar em formato binário. O ponteiro do arquivo está

10
no final do arquivo, se o arquivo existir. Ou seja, o arquivo está no modo de
acréscimo. Se o arquivo não existir, ele cria um novo arquivo para gravação.
um +
Abre um arquivo para anexar e ler. O ponteiro do arquivo está no final do

11
arquivo, se o arquivo existir. O arquivo é aberto no modo de acréscimo. Se o
arquivo não existir, ele cria um novo arquivo para leitura e gravação.
12 ab +
Abre um arquivo para anexar e ler em formato binário. O ponteiro do arquivo

está no final do arquivo, se o arquivo existir. O arquivo é aberto no modo de
acréscimo. Se o arquivo não existir, ele cria um novo arquivo para leitura e
gravação.
O arquivo Object Attributes
Depois que um arquivo é aberto e você tem um objeto de arquivo , você pode obter
várias informações relacionadas a esse arquivo.
Aqui está uma lista de todos os atributos relacionados a um objeto de arquivo -
Sr. Atributo e Descrição

Não.
file.closed
1
Retorna true se o arquivo estiver fechado, caso contrário, false.
file.mode
2
Retorna o modo de acesso com o qual o arquivo foi aberto.
nome do arquivo
3
Retorna o nome do arquivo.
Nota - o atributo softspace não é suportado no Python 3.x
Exemplo
#!/usr/bin/python3
# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)
print ("Closed or not : ", fo.closed)
print ("Opening mode : ", fo.mode)
fo.close()
Name of the file: foo.txt

Closed or not : False
Opening mode : wb
O método close ()
O método close () de um objeto de arquivo libera qualquer informação não escrita e
fecha o objeto de arquivo, após o qual não se pode mais escrever.
O Python fecha automaticamente um arquivo quando o objeto de referência de um

arquivo é reatribuído a outro arquivo. É uma boa prática usar o método close () para
fechar um arquivo.
Sintaxe
fileObject.close();
Exemplo
#!/usr/bin/python3
# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)
# Close opened file

fo.close()
Name of the file: foo.txt
Lendo e escrevendo arquivos

O objeto de arquivo fornece um conjunto de métodos de acesso para facilitar nossas
vidas. Veríamos como usar os métodos read () e write () para ler e gravar arquivos.
O método write ()
O método write () grava qualquer string em um arquivo aberto. É importante observar
que as strings Python podem ter dados binários e não apenas texto.
O método write () não adiciona um caractere de nova linha ('\ n') ao final da string -
Sintaxe
fileObject.write(string);
Aqui, o parâmetro passado é o conteúdo a ser gravado no arquivo aberto.
Exemplo
#!/usr/bin/python3
# Open a file
fo = open("foo.txt", "w")
fo.write( "Python is a great language.\nYeah its great!!\n")
# Close opend file

fo.close()
O método acima criaria o arquivo foo.txt e gravaria determinado conteúdo naquele

arquivo e, finalmente, fecharia esse arquivo. Se você abrir este arquivo, ele terá o
seguinte conteúdo -
Python is a great language.

Yeah its great!!
O método read ()
O método read () lê uma string de um arquivo aberto. É importante observar que as
strings Python podem ter dados binários. além dos dados de texto.
Sintaxe
fileObject.read([count]);
Aqui, o parâmetro passado é o número de bytes a serem lidos no arquivo aberto. Este
método começa lendo desde o início do arquivo e se a contagem estiver faltando, então
ele tenta ler o máximo possível, talvez até o final do arquivo.
Exemplo
Vamos pegar um arquivo foo.txt , que criamos acima.
#!/usr/bin/python3
# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)
# Close opened file

fo.close()
Read String is : Python is
Posições de arquivo
O método tell () informa a posição atual dentro do arquivo; Em outras palavras, a
próxima leitura ou gravação ocorrerá nesse número de bytes a partir do início do
arquivo.
O método seek (offset [, from]) altera a posição atual do arquivo. O argumento offset
indica o número de bytes a serem movidos. O argumento from especifica a posição de
referência de onde os bytes devem ser movidos.
Se from estiver definido como 0, o início do arquivo será usado como a posição de
referência. Se estiver definido para 1, a posição atual é usada como posição de
referência. Se estiver definido como 2, o final do arquivo será considerado como a
posição de referência.
Exemplo
Vamos pegar um arquivo foo.txt , que criamos acima.
#!/usr/bin/python3
# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)
# Check current position

position = fo.tell()
print ("Current file position : ", position)
# Reposition pointer at the beginning once again

position = fo.seek(0, 0)
str = fo.read(10)
print ("Again read String is : ", str)
# Close opened file

fo.close()
Read String is : Python is

Current file position : 10
Again read String is : Python is
Renomeando e Excluindo Arquivos

O módulo Python os fornece métodos que ajudam você a executar operações de
processamento de arquivos, como renomear e excluir arquivos.
Para usar este módulo, você precisa importá-lo primeiro e depois chamar qualquer
função relacionada.
O método rename ()
O método rename () recebe dois argumentos, o nome do arquivo atual e o novo nome
do arquivo.
Sintaxe
os.rename(current_file_name, new_file_name)
Exemplo
A seguir, um exemplo para renomear um arquivo existente test1.txt -
#!/usr/bin/python3
import os
# Rename a file from test1.txt to test2.txt

os.rename( "test1.txt", "test2.txt" )
O método remove ()
Você pode usar o método remove () para excluir arquivos fornecendo o nome do
arquivo a ser excluído como argumento.
Sintaxe
os.remove(file_name)
Exemplo
A seguir, um exemplo para excluir um arquivo existente test2.txt -
#!/usr/bin/python3
import os
# Delete file test2.txt

os.remove("text2.txt")
Diretórios em Python
Todos os arquivos estão contidos em vários diretórios, e o Python não tem nenhum
problema em lidar com isso também. O módulo os tem vários métodos que ajudam a
criar, remover e alterar diretórios.
O método mkdir ()
Você pode usar o método mkdir () do módulo os para criar diretórios no diretório
atual. Você precisa fornecer um argumento para esse método, que contém o nome do
diretório a ser criado.
Sintaxe
os.mkdir("newdir")
Exemplo
A seguir, um exemplo para criar um teste de diretório no diretório atual -
#!/usr/bin/python3
import os
# Create a directory "test"

os.mkdir("test")
O método chdir ()
Você pode usar o método chdir () para alterar o diretório atual. O método chdir ()
recebe um argumento, que é o nome do diretório em que você deseja criar o diretório
atual.
Sintaxe
os.chdir("newdir")
Exemplo
A seguir, um exemplo para entrar no diretório "/ home / newdir" -
#!/usr/bin/python3
import os
# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")
O método getcwd ()
O método getcwd () exibe o diretório de trabalho atual.
Sintaxe
os.getcwd()
Exemplo
A seguir, um exemplo para fornecer o diretório atual -
#!/usr/bin/python3
import os
# This would give location of the current directory

os.getcwd()
O método rmdir ()
O método rmdir () exclui o diretório, que é passado como um argumento no método.
Antes de remover um diretório, todo o conteúdo deve ser removido.
Sintaxe
os.rmdir('dirname')
Exemplo
A seguir, um exemplo para remover o diretório "/ tmp / test". É necessário fornecer um
nome completo do diretório, caso contrário, ele procuraria esse diretório no diretório
atual.
#!/usr/bin/python3
import os
# This would remove "/tmp/test" directory.

os.rmdir( "/tmp/test" )
Métodos relacionados a arquivos e diretórios

Existem três fontes importantes, que fornecem uma ampla gama de métodos utilitários
para manipular e manipular arquivos e diretórios em sistemas operacionais Windows e
Unix. Eles são os seguintes -
Métodos de objeto de arquivo
O objeto de arquivo fornece funções para manipular arquivos.
Métodos de Objeto OS
Isso fornece métodos para processar arquivos e diretórios.
Python 3 - Manipulação de Exceções

O Python fornece dois recursos muito importantes para lidar com qualquer erro
inesperado em seus programas em Python e para incluir recursos de depuração neles -
Manipulação de exceção - Isso seria abordado neste tutorial. Aqui está uma
lista de exceções padrão disponíveis em Python - Exceções padrão .
Assertions - Isso seria coberto no tutorial Assertions in Python 3 .
Exceções Padrão
Aqui está uma lista de exceções padrão disponíveis no Python. -
Sr. Nome e descrição da exceção

Não.
Exceção
1
Classe base para todas as exceções
StopIteration
2 Gerado quando o método next () de um iterador não aponta para nenhum

objeto.
SystemExit
3
Criado pela função sys.exit ().
Erro padrão
4 Classe base para todas as exceções internas, exceto StopIteration e

SystemExit.
ArithmeticError
5
Classe base para todos os erros que ocorrem no cálculo numérico.
OverflowError
6
Gerado quando um cálculo excede o limite máximo para um tipo numérico.
FloatingPointError
7
Gerado quando um cálculo de ponto flutuante falha.
8 ZeroDivisonError
Gerado quando divisão ou módulo por zero ocorre para todos os tipos
numéricos.
AssertionError
9
Criado em caso de falha da declaração do Assert.
AttributeError
10
Gerado em caso de falha de referência ou atribuição de atributo.
EOFError
11 Gerado quando não há entrada da função raw_input () ou input () e o final do

arquivo é atingido.
ImportError
12
Gerado quando uma declaração de importação falha.
KeyboardInterrupt
13 Gerado quando o usuário interrompe a execução do programa, geralmente

pressionando Ctrl + c.
LookupError
14
Classe base para todos os erros de pesquisa.
IndexError
15
Gerado quando um índice não é encontrado em uma sequência.
KeyError
16
Gerado quando a chave especificada não é encontrada no dicionário.
NameError
17 Gerado quando um identificador não é encontrado no espaço de nomes local

ou global.
UnboundLocalError
18 Gerado ao tentar acessar uma variável local em uma função ou método, mas
nenhum valor foi atribuído a ela.
19 EnvironmentError
Classe base para todas as exceções que ocorrem fora do ambiente Python.
IOError
20 Gerado quando uma operação de entrada / saída falha, como a instrução print
ou a função open () ao tentar abrir um arquivo que não existe.
OSError
21
Gerado por erros relacionados ao sistema operacional.
Erro de sintaxe
22
Gerado quando há um erro na sintaxe do Python.
IndentationError
23
Gerado quando o recuo não é especificado corretamente.
Erro no sistema
24 Gerado quando o interpretador encontra um problema interno, mas quando

esse erro é encontrado, o interpretador Python não sai.
SystemExit
25 Gerado quando o interpretador Python é encerrado usando a função sys.exit

(). Se não for tratado no código, faz com que o intérprete saia.
TypeError
26 Gerado quando uma operação ou função é tentada e é inválida para o tipo de

dados especificado.
ValueError
27 Gerado quando a função interna de um tipo de dados tem o tipo válido de

argumentos, mas os argumentos têm valores inválidos especificados.
RuntimeError
28
Gerado quando um erro gerado não se enquadra em nenhuma categoria.
NotImplementedError
29 Gerado quando um método abstrato que precisa ser implementado em uma

classe herdada não é realmente implementado.
Asserções em Python
Uma afirmação é uma verificação de sanidade que você pode ativar ou desativar
quando terminar o teste do programa.
A maneira mais fácil de se pensar em uma afirmação é compará-la a uma

declaração raise-if (ou, para ser mais preciso, a uma declaração raise-if-not).
Uma expressão é testada e, se o resultado aparecer falso, uma exceção é
levantada.
As asserções são executadas pela instrução asser, a mais nova palavra-chave

para o Python, introduzida na versão 1.5.
Os programadores freqüentemente colocam asserções no início de uma função

para verificar se há uma entrada válida e depois de uma chamada de função
para verificar se há saída válida.
A declaração de afirmação
Quando encontra uma declaração de afirmação, o Python avalia a expressão que a
acompanha, o que é de fato verdade. Se a expressão é falsa, o Python gera uma
exceção AssertionError .
A sintaxe para assert é -
assert Expression[, Arguments]
Se a asserção falhar, o Python usa ArgumentExpression como o argumento para o

AssertionError. As exceções AssertionError podem ser capturadas e tratadas como
qualquer outra exceção, usando a instrução try-except. Se eles não forem manipulados,
eles terminarão o programa e produzirão um traceback.
Exemplo
Aqui está uma função que converte uma determinada temperatura de graus Kelvin para
graus Fahrenheit. Como o 0 ° K está tão frio quanto possível, a função fica suspensa se
a temperatura for negativa -
#!/usr/bin/python3
def KelvinToFahrenheit(Temperature):
assert (Temperature >= 0),"Colder than absolute zero!"
return ((Temperature-273)*1.8)+32
print (KelvinToFahrenheit(273))
print (int(KelvinToFahrenheit(505.78)))
print (KelvinToFahrenheit(-5))
32.0
451
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!
O que é exceção?
Uma exceção é um evento, que ocorre durante a execução de um programa que
interrompe o fluxo normal das instruções do programa. Em geral, quando um script
Python encontra uma situação com a qual ele não consegue lidar, ele gera uma
exceção. Uma exceção é um objeto Python que representa um erro.
Quando um script Python gera uma exceção, ele deve manipular a exceção
imediatamente, caso contrário, ela será encerrada e encerrada.
Manipulando uma exceção

Se você tiver algum código suspeito que possa gerar uma exceção, você pode defender
seu programa colocando o código suspeito em um bloco try: Após o try: block, inclua
uma instrução except , seguida por um bloco de código que manipula o problema da
maneira mais elegante possível.
Sintaxe
Aqui está a sintaxe simples de try .... except ... else blocks -
try:
You do your operations here
......................
except ExceptionI:
If there is ExceptionI, then execute this block.
except ExceptionII:
If there is ExceptionII, then execute this block.
......................
else:
If there is no exception then execute this block.
Aqui estão alguns pontos importantes sobre a sintaxe acima mencionada -
Uma única instrução try pode ter várias instruções, exceto. Isso é útil quando o
bloco try contém instruções que podem lançar diferentes tipos de exceções.
Você também pode fornecer uma exceção genérica, que manipula qualquer
exceção.
Após a (s) cláusula (s) exceto, você pode incluir uma cláusula else. O código no
bloco else é executado se o código no bloco try: não gerar uma exceção.
O else-block é um bom lugar para o código que não precisa da proteção do try:
block.
Exemplo
Este exemplo abre um arquivo, grava conteúdo no arquivo e sai com graça porque não
há nenhum problema -
#!/usr/bin/python3
try:
fh = open("testfile", "w")
fh.write("This is my test file for exception handling!!")
except IOError:
print ("Error: can\'t find file or read data")
else:
print ("Written content in the file successfully")
fh.close()
Written content in the file successfully
Exemplo
Este exemplo tenta abrir um arquivo no qual você não tem permissão de gravação,
então ele gera uma exceção -
#!/usr/bin/python3
try:
fh = open("testfile", "r")
except IOError:
else:
print ("Written content in the file successfully")
Error: can't find file or read data
O exceto cláusula sem exceções

Você também pode usar a instrução except sem exceções definidas da seguinte maneira
-
try:
......................
except:
If there is any exception, then execute this block.
......................
else:
Esse tipo de instrução try-except captura todas as exceções que ocorrem. A utilização
desse tipo de instrução try-except não é considerada uma boa prática de programação,
porque captura todas as exceções, mas não faz com que o programador identifique a
causa raiz do problema que pode ocorrer.
O exceto cláusula com múltiplas exceções
Você também pode usar a mesma instrução exceto para manipular várias exceções da
seguinte maneira -
try:
......................
except(Exception1[, Exception2[,...ExceptionN]]]):
If there is any exception from the given exception list,
then execute this block.
......................
else:
A cláusula try-finally
Você pode usar um bloco finally: junto com um bloco try:. O finally: block é um lugar
para colocar qualquer código que deve ser executado, quer o bloco de tentativas tenha
levantado uma exceção ou não. A sintaxe da declaração try-finally é essa -
try:
You do your operations here;
......................
Due to any exception, this may be skipped.
finally:
This would always be executed.
......................
Nota - Você pode fornecer, exceto cláusula (s), ou uma cláusula finally, mas não
ambas. Você não pode usar cláusula else junto com uma cláusula finally.
Exemplo
#!/usr/bin/python3
try:
finally:
fh.close()
Se você não tem permissão para abrir o arquivo no modo de escrita, isso produzirá o
seguinte resultado -
Error: can't find file or read data
O mesmo exemplo pode ser escrito de forma mais clara como segue -
#!/usr/bin/python3
try:
try:
finally:
print ("Going to close the file")
fh.close()
except IOError:
Going to close the file
Quando uma exceção é lançada no bloco try , a execução passa imediatamente para o
bloco finally . Depois que todas as instruções no bloco finally são executadas, a exceção
é levantada novamente e é tratada nas instruções except , se presentes na próxima
camada superior da instrução try-except .
Argumento de uma exceção

Uma exceção pode ter um argumento , que é um valor que fornece informações
adicionais sobre o problema. O conteúdo do argumento varia por exceção. Você captura
um argumento de exceção fornecendo uma variável na cláusula except da seguinte
maneira -
try:
......................
except ExceptionType as Argument:
You can print value of Argument here...
Se você escrever o código para manipular uma única exceção, poderá ter uma variável
seguindo o nome da exceção na instrução except. Se você estiver interceptando várias
exceções, poderá ter uma variável seguindo a tupla da exceção.
Essa variável recebe o valor da exceção que contém principalmente a causa da exceção.
A variável pode receber um único valor ou vários valores na forma de uma tupla. Esta
tupla geralmente contém a string de erro, o número do erro e um local de erro.
Exemplo
A seguir, um exemplo de uma única exceção -
#!/usr/bin/python3
# Define a function here.

def temp_convert(var):
try:
return int(var)
except ValueError as Argument:
print ("The argument does not contain numbers\n", Argument)
# Call above function here.

temp_convert("xyz")
The argument does not contain numbers

invalid literal for int() with base 10: 'xyz'
Levantar uma exceção
Você pode gerar exceções de várias maneiras usando a instrução raise. A sintaxe geral
para a instrução raise é a seguinte -
Sintaxe
raise [Exception [, args [, traceback]]]
Aqui, Exceção é o tipo de exceção (por exemplo, NameError) e argumento é um valor

para o argumento de exceção. O argumento é opcional; se não for fornecido, o
argumento de exceção é Nenhum.
O argumento final, traceback, também é opcional (e raramente usado na prática) e, se

presente, é o objeto traceback usado para a exceção.
Exemplo
Uma exceção pode ser uma string, uma classe ou um objeto. A maioria das exceções
levantadas pelo núcleo Python são classes, com um argumento que é uma instância da
classe. Definir novas exceções é muito fácil e pode ser feito da seguinte maneira -
def functionName( level ):

if level <1:
raise Exception(level)
# The code below to this would not be executed
# if we raise the exception
return level
Nota - Para capturar uma exceção, uma cláusula "except" deve se referir à mesma
exceção lançada como um objeto de classe ou uma string simples. Por exemplo, para
capturar a exceção acima, devemos escrever a cláusula except da seguinte forma -
try:
Business Logic here...
except Exception as e:
Exception handling here using e.args...
else:
Rest of the code here...
O exemplo a seguir ilustra o uso de levantar uma exceção -

#!/usr/bin/python3
def functionName( level ):

if level <1:
raise Exception(level)
# The code below to this would not be executed
# if we raise the exception
return level
try:
l = functionName(-10)
print ("level = ",l)
except Exception as e:
print ("error in level argument",e.args[0])
Isso produzirá o seguinte resultado
error in level argument -10
Exceções Definidas pelo Usuário

O Python também permite que você crie suas próprias exceções derivando classes das
exceções internas padrão.
Aqui está um exemplo relacionado ao RuntimeError . Aqui, uma classe é criada com
subclasse de RuntimeError . Isso é útil quando você precisa exibir informações mais
específicas quando uma exceção é capturada.
No bloco try, a exceção definida pelo usuário é levantada e capturada no bloco except.
A variável e é usada para criar uma instância da classe Networkerror .
class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
Então, depois de ter definido a classe acima, você pode aumentar a exceção da
seguinte forma -
try:
raise Networkerror("Bad hostname")
except Networkerror,e:
print e.args
Python 3 - Orientado a Objetos

O Python tem sido uma linguagem orientada a objetos desde a época em que existiu.
Devido a isso, criar e usar classes e objetos são francamente fáceis. Este capítulo ajuda
você a se tornar um especialista no uso do suporte à programação orientada a objetos
do Python.
Se você não tem nenhuma experiência anterior com programação orientada a objeto
(OO), você pode querer consultar um curso introdutório sobre ela ou pelo menos um
tutorial de algum tipo para que você tenha uma noção dos conceitos básicos.
No entanto, aqui está uma pequena introdução da Programação Orientada a Objetos

(OOP) para ajudá-lo -
Visão geral da terminologia de OOP

Classe - Um protótipo definido pelo usuário para um objeto que define um
conjunto de atributos que caracterizam qualquer objeto da classe. Os atributos
são membros de dados (variáveis de classe e variáveis de instância) e métodos,
acessados via notação de ponto.
Variável de classe - Uma variável compartilhada por todas as instâncias de

uma classe. Variáveis de classe são definidas dentro de uma classe, mas fora de
qualquer um dos métodos da classe. Variáveis de classe não são usadas com
tanta freqüência quanto as variáveis de instância.
Membro de dados - Uma variável de classe ou variável de instância que

contém dados associados a uma classe e seus objetos.
Sobrecarga de função - A atribuição de mais de um comportamento a uma

função específica. A operação executada varia de acordo com os tipos de
objetos ou argumentos envolvidos.
Variável de instância - Uma variável que é definida dentro de um método e

pertence apenas à instância atual de uma classe.
Herança - A transferência das características de uma classe para outras classes

derivadas dela.
Instância - um objeto individual de uma determinada classe. Um objeto obj

que pertence a uma classe Circle, por exemplo, é uma instância da classe
Circle.
Instantiation - A criação de uma instância de uma classe.
Method - Um tipo especial de função que é definido em uma definição de

classe.
Object - Uma instância exclusiva de uma estrutura de dados definida por sua
classe. Um objeto compreende os membros de dados (variáveis de classe e
variáveis de instância) e métodos.
Sobrecarga do operador - A atribuição de mais de uma função a um operador

específico.
Criando Classes
A instrução de classe cria uma nova definição de classe. O nome da classe segue
imediatamente a classe de palavra-chave seguida por dois pontos da seguinte forma:
class ClassName:
'Optional class documentation string'
class_suite
A classe tem uma string de documentação, que pode ser acessada via
ClassName .__ doc__ .
O class_suite consiste em todas as instruções do componente que definem

membros da classe, atributos de dados e funções.
Exemplo
A seguir, um exemplo de uma classe Python simples -
class Employee:
'Common base class for all employees'
empCount = 0
def __init__(self, name, salary):

self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print ("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print ("Name : ", self.name, ", Salary: ", self.salary)
A variável empCount é uma variável de classe cujo valor é compartilhado entre

todas as instâncias de um nesta classe. Isso pode ser acessado como
Employee.empCount de dentro da classe ou fora da classe.
O primeiro método __init __ () é um método especial, que é chamado de

construtor de classe ou método de inicialização que o Python chama quando
você cria uma nova instância dessa classe.
Você declara outros métodos de classe, como funções normais, com a exceção
de que o primeiro argumento para cada método é self . O Python adiciona o
argumento próprio à lista para você; você não precisa incluí-lo quando você
chama os métodos.
Criando Objetos de Instância

Para criar instâncias de uma classe, você chama a classe usando o nome da classe e
passa os argumentos que o método __init__ aceita.
This would create first object of Employee class

emp1 = Employee("Zara", 2000)
This would create second object of Employee class
emp2 = Employee("Manni", 5000)
Acessando Atributos
Você acessa os atributos do objeto usando o operador ponto com objeto. A variável de
classe seria acessada usando o nome da classe da seguinte maneira -
emp1.displayEmployee()
Agora, colocando todos os conceitos juntos

#!/usr/bin/python3
class Employee:
empCount = 0

self.name = name
#This would create first object of Employee class"

#This would create second object of Employee class"
Name : Zara ,Salary: 2000

Name : Manni ,Salary: 5000
Total Employee 2
Você pode adicionar, remover ou modificar atributos de classes e objetos a qualquer

momento.
emp1.salary = 7000 # Add an 'salary' attribute.

emp1.name = 'xyz' # Modify 'age' attribute.
del emp1.salary # Delete 'age' attribute.
Em vez de usar as instruções normais para acessar os atributos, você pode usar as
seguintes funções -
O getattr (obj, name [, default]) - para acessar o atributo do objeto.
O hasattr (obj, nome) - para verificar se um atributo existe ou não.
O setattr (obj, nome, valor) - para definir um atributo. Se o atributo não

existir, ele será criado.
O delattr (obj, nome) - para excluir um atributo.
hasattr(emp1, 'salary') # Returns true if 'salary' attribute exists

getattr(emp1, 'salary') # Returns value of 'salary' attribute
setattr(emp1, 'salary', 7000) # Set attribute 'salary' at 7000
delattr(emp1, 'salary') # Delete attribute 'salary'
Atributos de Classe Internos

Toda classe Python continua seguindo os atributos internos e eles podem ser acessados
usando o operador de ponto como qualquer outro atributo -
__dict__ - Dicionário que contém o namespace da classe.
__doc__ - Cadeia de documentação de classe ou nenhuma, se não for definida.

__name__ - nome da classe.
__module__ - Nome do módulo no qual a classe está definida. Este atributo é

"__main__" no modo interativo.
__bases__ - Uma tupla possivelmente vazia contendo as classes base, na

ordem de sua ocorrência na lista de classes base.
Para a classe acima, vamos tentar acessar todos esses atributos -

#!/usr/bin/python3
class Employee:
empCount = 0

self.name = name

print ("Employee.__doc__:", Employee.__doc__)
print ("Employee.__name__:", Employee.__name__)
print ("Employee.__module__:", Employee.__module__)
print ("Employee.__bases__:", Employee.__bases__)
print ("Employee.__dict__:", Employee.__dict__ )
Employee.__doc__: Common base class for all employees

Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: (<class 'object'>,)
Employee.__dict__: {
'displayCount': <function Employee.displayCount at 0x0160D2B8>,
'__module__': '__main__', '__doc__': 'Common base class for all employees',
'empCount': 2, '__init__':
<function Employee.__init__ at 0x0124F810>, 'displayEmployee':
<function Employee.displayEmployee at 0x0160D300>,
'__weakref__':
<attribute '__weakref__' of 'Employee' objects>, '__dict__':
<attribute '__dict__' of 'Employee' objects>
}
Destruindo Objetos (Coleta de Lixo)

O Python exclui objetos desnecessários (tipos internos ou instâncias de classes)
automaticamente para liberar o espaço da memória. O processo pelo qual o Python
recupera periodicamente blocos de memória que não estão mais em uso é denominado
como Coleta de lixo.
O coletor de lixo do Python é executado durante a execução do programa e é acionado

quando a contagem de referência de um objeto atinge zero. A contagem de referência
de um objeto é alterada conforme o número de aliases que apontam para ele é
alterado.
A contagem de referência de um objeto aumenta quando é atribuído um novo nome ou

colocado em um contêiner (lista, tupla ou dicionário). A contagem de referência do
objeto diminui quando é excluída com del , sua referência é reatribuída ou sua
referência sai do escopo. Quando a contagem de referência de um objeto chega a zero,
o Python a coleta automaticamente.
a = 40 # Create object <40>

b = a # Increase ref. count of <40>
c = [b] # Increase ref. count of <40>
del a # Decrease ref. count of <40>

b = 100 # Decrease ref. count of <40>
c[0] = -1 # Decrease ref. count of <40>
Você normalmente não notará quando o coletor de lixo destruir uma instância órfã e
recuperar seu espaço. No entanto, uma classe pode implementar o método especial
__del __ () , chamado de destruidor, que é invocado quando a instância está prestes a
ser destruída. Esse método pode ser usado para limpar quaisquer recursos não-
memória usados por uma instância.
Exemplo
Este destruidor __del __ () imprime o nome da classe de uma instância que está
prestes a ser destruída.
#!/usr/bin/python3
class Point:
def __init__( self, x=0, y=0):
self.x = x
self.y = y
def __del__(self):
class_name = self.__class__.__name__
print (class_name, "destroyed")
pt1 = Point()
pt2 = pt1
pt3 = pt1
print (id(pt1), id(pt2), id(pt3)) # prints the ids of the obejcts
del pt1
del pt2
del pt3

140338326963984 140338326963984 140338326963984
Point destroyed
Nota - Idealmente, você deve definir suas classes em um arquivo separado, então você
deve importá-las em seu arquivo de programa principal usando a declaração de
importação .
No exemplo acima, assumindo a definição de uma classe Point está contida em point.py
e não há outro código executável nela.
#!/usr/bin/python3
import point
p1 = point.Point()
Herança de Classe
Em vez de começar de um rascunho, você pode criar uma classe derivando-a de uma
classe pré-existente listando a classe pai entre parênteses após o novo nome da classe.
A classe filha herda os atributos de sua classe pai e você pode usar esses atributos
como se eles estivessem definidos na classe filha. Uma classe filha também pode
substituir membros e métodos de dados do pai.
Sintaxe
Classes derivadas são declaradas como suas classes pai; no entanto, uma lista de
classes base para herdar é fornecida após o nome da classe -
class SubClassName (ParentClass1[, ParentClass2, ...]):

'Optional class documentation string'
class_suite
Exemplo
#!/usr/bin/python3
class Parent: # define parent class

parentAttr = 100
def __init__(self):
print ("Calling parent constructor")
def parentMethod(self):
print ('Calling parent method')
def setAttr(self, attr):

Parent.parentAttr = attr
def getAttr(self):
print ("Parent attribute :", Parent.parentAttr)
class Child(Parent): # define child class

def __init__(self):
print ("Calling child constructor")
def childMethod(self):
print ('Calling child method')
c = Child() # instance of child

c.childMethod() # child calls its method
c.parentMethod() # calls parent's method
c.setAttr(200) # again call parent's method
c.getAttr() # again call parent's method
Calling child constructor

Calling child method
Calling parent method
Parent attribute : 200
De maneira semelhante, você pode dirigir uma classe de várias classes pai da seguinte
maneira -
class A: # define your class A

.....
class B: # define your calss B

.....
class C(A, B): # subclass of A and B

.....
Você pode usar as funções issubclass () ou isinstance () para verificar os

relacionamentos de duas classes e instâncias.
A função booleana issubclass (sub, sup) retorna True, se a subclasse sub é

realmente uma subclasse da superclasse sup .
A função booleana isinstance (obj, Class) retorna True, se obj é uma

instância da classe Class ou é uma instância de uma subclasse de Class
Substituindo Métodos
Você sempre pode substituir seus métodos de classe pai. Um motivo para substituir os
métodos do pai é que você pode querer funcionalidade especial ou diferente na sua
subclasse.
Exemplo
#!/usr/bin/python3
class Parent: # define parent class

def myMethod(self):
print ('Calling parent method')
class Child(Parent): # define child class

def myMethod(self):
print ('Calling child method')
c = Child() # instance of child

c.myMethod() # child calls overridden method
Calling child method
Métodos de Sobrecarga de Base

A tabela a seguir lista algumas funcionalidades genéricas que você pode substituir em
suas próprias classes -
Sr. Método, descrição e chamada de amostra

Não.
__init__ (self [, args ...])
1 Construtor (com quaisquer argumentos opcionais)
Chamada de Amostra: obj = className (args)
__del __ (auto)
2 Destructor, apaga um objeto
Chamada de Amostra: del obj
__repr __ (auto)
3 Representação de string avaliavel
Chamada de Amostra: repr (obj)
__str __ (auto)
4 Representação de Cadeia Imprimível
Chamada de Amostra: str (obj)
__cmp__ (self, x)
5 Comparação de objetos
Chamada de Amostra: cmp (obj, x)
Sobrecarregando Operadores
Suponha que você tenha criado uma classe Vector para representar vetores
bidimensionais. O que acontece quando você usa o operador mais para adicioná-los? O
mais provável é que o Python grite com você.
Você poderia, no entanto, definir o método __add__ em sua classe para realizar a
adição de vetores e, em seguida, o operador mais se comportaria conforme a
expectativa -
Exemplo
#!/usr/bin/python3
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
Vector(7,8)
Esconder dados
Os atributos de um objeto podem ou não ser visíveis fora da definição da classe. Você
precisa nomear os atributos com um prefixo sublinhado duplo, e esses atributos não
estarão diretamente visíveis para pessoas de fora.
Exemplo
#!/usr/bin/python3
class JustCounter:
__secretCount = 0
def count(self):
self.__secretCount += 1
print (self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print (counter.__secretCount)
1
2
print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'
O Python protege esses membros alterando internamente o nome para incluir o nome
da classe. Você pode acessar esses atributos como object._className__attrName . Se
você substituísse sua última linha da seguinte maneira, então funciona para você -
.........................
print (counter._JustCounter__secretCount)
1
2
2
Python 3 - expressões regulares

Uma expressão regular é uma seqüência especial de caracteres que ajuda você a
encontrar ou encontrar outras strings ou conjuntos de strings, usando uma sintaxe
especializada mantida em um padrão. Expressões regulares são amplamente usadas no
mundo UNIX.
O módulo re fornece suporte completo para expressões regulares semelhantes a Perl no

Python. O módulo re gera a exceção re.error se ocorrer um erro ao compilar ou usar
uma expressão regular.
Nós cobriríamos duas funções importantes, que seriam usadas para manipular
expressões regulares. No entanto, uma coisa pequena primeiro: Existem vários
caracteres, que teriam um significado especial quando forem usados na expressão
regular. Para evitar qualquer confusão ao lidar com expressões regulares, usaríamos
Raw Strings como r'expression ' .
Padrões básicos que correspondem a caracteres únicos

Sr. Expressão e Correspondências
Não.
a, X, 9, <
1
personagens comuns apenas se encaixam exatamente.
. (um periodo)
2
corresponde a qualquer caractere único, exceto a nova linha '\ n'
\W
3 corresponde a um caractere de "palavra": uma letra ou dígito ou barra

inferior [a-zA-Z0-9_].
\W
4
corresponde a qualquer caractere não pertencente à palavra.
5
\b
limite entre palavra e não palavra
\s
6 corresponde a um único caractere de espaço em branco - espaço, nova linha,

retorno, tabulação
\S
7
corresponde a qualquer caractere que não seja espaço em branco.
\ t, \ n,
8
guia, nova linha, retorno
\d
9
dígito decimal [0-9]
^
10
corresponde ao início da string
$
11
corresponde ao final da string
\
12
inibir o "especialismo" de um personagem.
Sinalizadores de compilação
Os sinalizadores de compilação permitem modificar alguns aspectos de como as
expressões regulares funcionam. As bandeiras estão disponíveis no re módulo sob dois
nomes, um nome longo como IGNORECASE e uma forma curta de uma letra como I.
Sr. Bandeira e Significado

Não.
ASCII, A
1 Faz várias fugas como \ w, \ b, \ s e \ d correspondem apenas a caracteres

ASCII com a respectiva propriedade.
2 DOTALL, S
Faça, combine qualquer personagem, incluindo novas linhas

IGNORECASE, eu
3
Faça correspondências insensíveis a maiúsculas e minúsculas
LOCALE, L
4
Faça um jogo com reconhecimento de localidade
MULTILINA, M
5
Correspondência de várias linhas, afetando ^ e $
VERBOSE, X (para 'estendido')
6 Ativar REs verbosos, que podem ser organizados de forma mais limpa e
compreensível
A função de jogo
Essa função tenta corresponder o padrão RE à string com sinalizadores opcionais .
Aqui está a sintaxe para esta função -
re.match(pattern, string, flags = 0)
Aqui está a descrição dos parâmetros -
Sr. Parâmetro e Descrição

Não.
padronizar
1
Esta é a expressão regular a ser correspondida.
corda
2 Esta é a string, que seria pesquisada para corresponder ao padrão no início da

string.
bandeiras
3 Você pode especificar diferentes sinalizadores usando OR (|) bit a bit. Estes
são modificadores, listados na tabela abaixo.
A função re.match retorna um objeto de correspondência em sucesso, None na falha.

Usamos a função group (num) ou groups () do objeto de correspondência para obter
a expressão correspondente.
Sr. Método e descrição do objeto de correspondência
Não.
grupo (num = 0)
1 Este método retorna a correspondência inteira (ou numero de subgrupo

específico)
grupos ()
2 Este método retorna todos os subgrupos correspondentes em uma tupla

(vazia se não houver nenhum)
Exemplo
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
print ("matchObj.group() : ", matchObj.group())
print ("matchObj.group(1) : ", matchObj.group(1))
print ("matchObj.group(2) : ", matchObj.group(2))
else:
print ("No match!!")
matchObj.group() : Cats are smarter than dogs

matchObj.group(1) : Cats
matchObj.group(2) : smarter
A função de pesquisa
Essa função procura pela primeira ocorrência do padrão RE dentro da string com
sinalizadores opcionais .
Aqui está a sintaxe para esta função -
re.search(pattern, string, flags = 0)
Sr. Parâmetro e Descrição

Não.
padronizar
1
Esta é a expressão regular a ser correspondida.
2 corda
Esta é a string, que seria pesquisada para corresponder ao padrão em

qualquer lugar da string.
bandeiras
3 Você pode especificar diferentes sinalizadores usando OR (|) bit a bit. Estes
são modificadores, listados na tabela abaixo.
A função re.search retorna um objeto de correspondência em sucesso, nenhum em

falha. Usamos a função group (num) ou groups () do objeto de correspondência para
obter a expressão correspondente.
Sr. Método e descrição do objeto de correspondência

Não.
grupo (num = 0)
1 Este método retorna a correspondência inteira (ou numero de subgrupo

específico)
grupos ()
2 Este método retorna todos os subgrupos correspondentes em uma tupla

(vazia se não houver nenhum)
Exemplo
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs";
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
if searchObj:
print ("searchObj.group() : ", searchObj.group())
print ("searchObj.group(1) : ", searchObj.group(1))
print ("searchObj.group(2) : ", searchObj.group(2))
else:
print ("Nothing found!!")
matchObj.group() : Cats are smarter than dogs

matchObj.group(1) : Cats
matchObj.group(2) : smarter
Correspondência versus pesquisa

Python oferece duas operações primitivas diferentes com base em expressões
regulares: correspondem cheques para uma partida apenas no início da cadeia,
enquanto busca verifica se há uma correspondência em qualquer lugar na string (isto é
o que Perl faz por padrão).
Exemplo
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs";
matchObj = re.match( r'dogs', line, re.M|re.I)

if matchObj:
print ("match --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
searchObj = re.search( r'dogs', line, re.M|re.I)

if searchObj:
print ("search --> searchObj.group() : ", searchObj.group())
else:
print ("Nothing found!!")
No match!!
search --> matchObj.group() : dogs
Pesquisar e substituir
Uma das mais importantes re métodos que usam expressões regulares é sub .
Sintaxe
re.sub(pattern, repl, string, max=0)
Esse método substitui todas as ocorrências do padrão RE em string por repl ,

substituindo todas as ocorrências, a menos que max seja fornecido. Este método
retorna uma string modificada.
Exemplo
#!/usr/bin/python3
import re
phone = "2004-959-559 # This is Phone Number"
# Delete Python-style comments

num = re.sub(r'#.*$', "", phone)
print ("Phone Num : ", num)
# Remove anything other than digits

num = re.sub(r'\D', "", phone)
print ("Phone Num : ", num)

Phone Num : 2004-959-559
Phone Num : 2004959559
Modificadores de expressões regulares: sinalizadores

de opção
Os literais de expressões regulares podem incluir um modificador opcional para
controlar vários aspectos da correspondência. Os modificadores são especificados como
um sinalizador opcional. Você pode fornecer vários modificadores usando OR exclusivo
(|), conforme mostrado anteriormente e pode ser representado por um deles -
Sr. Modificador e Descrição

Não.
re.I
1
Executa a correspondência insensível a maiúsculas e minúsculas.
re.L
Interpreta palavras de acordo com a localidade atual. Essa interpretação afeta

2
o grupo alfabético (\ w e \ W), bem como o comportamento de contorno de
palavras (\ b e \ B).
re.M
Faz com que $ combine o final de uma linha (não apenas o final da string) e
3
faz com que ^ combine o início de qualquer linha (não apenas o início da
string).
re.S
4 Faz um ponto (ponto) corresponder a qualquer caractere, incluindo uma nova

linha.
re.U
5 Interpreta letras de acordo com o conjunto de caracteres Unicode. Esse

sinalizador afeta o comportamento de \ w, \ W, \ b, \ B.
re.X
Permite a sintaxe de expressão regular "mais bonita". Ele ignora o espaço em

6
branco (exceto dentro de um conjunto [] ou quando escapou por uma barra
invertida) e trata o # sem escape como um marcador de comentário.
Padrões de Expressão Regular
Exceto pelos caracteres de controle, (+?. * ^ $ () [] {} | \) , Todos os caracteres são
compatíveis. Você pode escapar de um caractere de controle precedendo-o com uma
barra invertida.
A tabela a seguir lista a sintaxe da expressão regular disponível em Python -
Aqui está a lista de sintaxe de expressão regular no Python.
Exemplos de Expressões Regulares

Caracteres literais
Sr. Exemplo e Descrição
Não.
python
1
Combine "python".
Classes de personagens
Não.
[Pp] ython
1
Correspondência "Python" ou "python"
esfregue [ye]
2
Correspondência "rubi" ou "rube"
[aeiou]
3
Corresponder a qualquer vogal minúscula
[0-9]
4
Corresponder qualquer dígito; o mesmo que [0123456789]
[az]
5
Corresponder a qualquer letra ASCII minúscula
6 [AZ]
Corresponder a qualquer letra ASCII maiúscula
[a-zA-Z0-9]
7
Combine qualquer um dos itens acima
[^ aeiou]
8
Corresponder a algo que não seja uma vogal de letras minúsculas
[^ 0-9]
9
Corresponde a algo diferente de um dígito
Classes Especiais de Personagem

Não.
.
1
Corresponder qualquer caractere, exceto nova linha
\d
2
Corresponder um dígito: [0-9]
\D
3
Corresponde a um não-dígito: [^ 0-9]
\s
4
Corresponder um caractere de espaço em branco: [\ t \ r \ n \ f]
\S
5
Corresponder o não-branco ao espaço: [^ \ t \ r \ n \ f]
\W
6
Corresponder um caractere de uma única palavra: [A-Za-z0-9_]
\W
7
Corresponder um caractere não-palavra-chave: [^ A-Za-z0-9_]
Casos de Repetição
Não.
rubi?
1
Correspondência "rub" ou "ruby": o y é opcional
rubi*
2
Combine "esfregar" mais 0 ou mais ys
rubi +
3
Combine "esfregar" mais 1 ou mais
\ d {3}
4
Combine exatamente 3 dígitos
\ d {3,}
5
Combine 3 ou mais dígitos
\ d {3,5}
6
Corresponde a 3, 4 ou 5 dígitos
Repetição Nongreedy
Isso corresponde ao menor número de repetições -

Não.
<. *>
1
Repetição gananciosa: combina "<python> perl>"
<. *?>
2
Nongreedy: combina "<python>" em "<python> perl>"
Agrupando com Parênteses

Não.
\D\d+
1
Nenhum grupo: + repete \ d
(\ D \ d) +
2
Agrupado: + repete \ D \ d par
([Pp] ython (,)?) +

3
Combine "Python", "Python, python, python" etc.
Backreferences
Isso corresponde a um grupo previamente combinado novamente -

Não.
([Pp]) ython & \ 1ails

1
Combine python e baldes ou Python e baldes
(['"]) [^ \ 1] * \ 1
2 Cadeia simples ou com aspas duplas. \ 1 corresponde ao que o primeiro grupo

correspondeu. \ 2 corresponde ao que o segundo grupo correspondeu, etc.
Alternativas
Não.
python | perl
1
Correspondência "python" ou "perl"
esfregar (y | le)
2
Correspondência "rubi" ou "rublo"
Python (! + | \?)
3
"Python" seguido por um ou mais! ou um?
Âncoras
Isso precisa especificar a posição da correspondência.

Não.
^ Python
1
Combine "Python" no início de uma string ou linha interna
Python $
2
Combine "Python" no final de uma string ou linha
\ APython
3
Combine "Python" no início de uma string
Python \ Z
4
Combine "Python" no final de uma string
\ bPython \ b
5
Combine "Python" em um limite de palavra
\ brub \ B
6 \ B é o limite não-palavra-chave: combinar "esfregar" em "rube" e "ruby",

mas não sozinho
Python (? =!)
7
Combine "Python", se seguido por um ponto de exclamação.
Python (? !!)
8
Combine "Python", se não for seguido por um ponto de exclamação.
Sintaxe Especial com Parênteses

Não.
R (? # Comentário)
1
Corresponde "R". Todo o resto é um comentário
2 R (? I) uby
Não faz distinção entre maiúsculas e minúsculas ao combinar "uby"
R (? I: uby)
3
O mesmo que acima
esfregar (?: y | le))

4
Agrupar apenas sem criar backreference \ 1
Python 3 - Programação CGI

O Common Gateway Interface, ou CGI, é um conjunto de padrões que define como as
informações são trocadas entre o servidor da Web e um script personalizado. As
especificações CGI são atualmente mantidas pelo NCSA.
O que é CGI?
A Common Gateway Interface, ou CGI, é um padrão para programas de
gateway externos que interagem com servidores de informações, como
servidores HTTP.
A versão atual é CGI / 1.1 e o CGI / 1.2 está em andamento.
Navegação na Web
Para entender o conceito de CGI, vamos ver o que acontece quando clicamos em um
hiperlink para procurar uma determinada página da web ou URL.
Seu navegador entra em contato com o servidor da Web HTTP e exige o URL, ou
seja, nome do arquivo.
Servidor Web analisa o URL e procura pelo nome do arquivo. Se encontrar esse
arquivo, ele o envia de volta ao navegador, caso contrário, envia uma
mensagem de erro indicando que você solicitou um arquivo errado.
O navegador da Web recebe resposta do servidor da Web e exibe o arquivo

recebido ou a mensagem de erro.
No entanto, é possível configurar o servidor HTTP para que sempre que um arquivo em
um determinado diretório seja solicitado que o arquivo não seja enviado de volta; em
vez disso, ele é executado como um programa, e qualquer que seja a saída desse
programa, ele é enviado de volta para o seu navegador exibir. Essa função é chamada
de Common Gateway Interface ou CGI e os programas são chamados de scripts CGI.
Esses programas CGI podem ser um script Python, um script PERL, um script Shell, um
programa C ou C ++ etc.
Diagrama de arquitetura CGI
Suporte e Configuração do Servidor Web

Antes de prosseguir com a programação CGI, certifique-se de que seu servidor da Web
suporta CGI e está configurado para lidar com programas CGI. Todos os programas CGI
a serem executados pelo servidor HTTP são mantidos em um diretório pré-configurado.
Este diretório é chamado Diretório CGI e por convenção é nomeado como / var / www /
cgi-bin. Por convenção, os arquivos CGI têm extensão como. cgi, mas você também
pode manter seus arquivos com extensão python .py .
Por padrão, o servidor Linux é configurado para executar apenas os scripts no diretório
cgi-bin em / var / www. Se você quiser especificar qualquer outro diretório para
executar seus scripts CGI, comente as seguintes linhas no arquivo httpd.conf -
<Directory "/var/www/cgi-bin">
AllowOverride None
Options ExecCGI
Order allow,deny
Allow from all
</Directory>
<Directory "/var/www/cgi-bin">
Options All
</Directory>
Aqui, assumimos que você tenha o Web Server instalado e funcionando com sucesso e
você pode executar qualquer outro programa CGI como Perl ou Shell, etc.
Primeiro programa CGI

Aqui está um link simples, que está ligado a um script CGI chamado hello.py . Este
arquivo é mantido no diretório / var / www / cgi-bin e possui o seguinte conteúdo.
Antes de executar seu programa CGI, certifique-se de alterar o modo de arquivo
usando o comando chmod 755 hello.py UNIX para tornar o arquivo executável.
#!/usr/bin/python
print ("Content-type:text/html\r\n\r\n")
print ('<html>')
print ('<head>')
print ('<title>Hello Word - First CGI Program</title>')
print ('</head>')
print ('<body>')
print ('<h2>Hello Word! This is my first CGI program</h2>')
print ('</body>')
print ('</html>')
Nota - A primeira linha no script deve ser o caminho para o executável do Python. No
Linux, deve ser #! / Usr / bin / python3
Insira o seguinte URL no seu navegador
http://localhost:8080/cgi-bin/hello.py
Olá Palavra! Este é meu primeiro programa CGI
Este script hello.py é um script Python simples, que grava sua saída no arquivo
STDOUT, ou seja, screen. Há um recurso importante e extra disponível, que é a
primeira linha a ser impressa . Tipo de conteúdo: text / html \ r \ n \ r \ n . Essa
linha é enviada de volta ao navegador e especifica o tipo de conteúdo a ser exibido na
tela do navegador.
Até agora você deve ter entendido o conceito básico de CGI e você pode escrever
muitos programas CGI complicados usando Python. Esse script pode interagir com
qualquer outro sistema externo também para trocar informações, como o RDBMS.
Cabeçalho HTTP
A linha Tipo de conteúdo: text / html \ r \ n \ r \ n faz parte do cabeçalho HTTP
que é enviado ao navegador para entender o conteúdo. Todo o cabeçalho HTTP estará
no seguinte formato -
HTTP Field Name: Field Content
For Example
Content-type: text/html\r\n\r\n
Existem alguns outros cabeçalhos HTTP importantes, que você usará freqüentemente
em sua programação CGI.
Sr. Cabeçalho e Descrição

Não.
Tipo de conteúdo:
1 Uma sequência MIME que define o formato do arquivo que está sendo
retornado. Exemplo é tipo de conteúdo: text / html
Expira: Data
A data em que as informações se tornam inválidas. Ele é usado pelo

2
navegador para decidir quando uma página precisa ser atualizada. Uma string
de data válida está no formato 01 de janeiro de 1998, 12:00:00 GMT.
Localização: URL
3 O URL que é retornado em vez do URL solicitado. Você pode usar esse campo
para redirecionar uma solicitação para qualquer arquivo.
Última modificação: data

4
A data da última modificação do recurso.
Comprimento do conteúdo: N
O comprimento, em bytes, dos dados que estão sendo retornados. O

5
navegador usa esse valor para relatar o tempo estimado de download de um
arquivo.
Set-Cookie: String
6
Definir o cookie passado pela string
Variáveis de ambiente CGI

Todos os programas CGI têm acesso às seguintes variáveis de ambiente. Essas
variáveis desempenham um papel importante ao escrever qualquer programa CGI.
Sr. Nome e descrição da variável

Não.
1 TIPO DE CONTEÚDO
O tipo de dados do conteúdo. Usado quando o cliente está enviando

conteúdo anexado ao servidor. Por exemplo, upload de arquivo.
COMPRIMENTO DO CONTEÚDO
2 O comprimento da informação da consulta. Está disponível apenas para

solicitações POST.
HTTP_COOKIE
3
Retorna os cookies definidos na forma de par chave e valor.
HTTP_USER_AGENT
O campo de cabeçalho de solicitação do User-Agent contém informações

4
sobre o agente do usuário que originou a solicitação. É o nome do
navegador da web.
PATH_INFO
5
O caminho para o script CGI.
QUERY_STRING
6 As informações codificadas por URL enviadas com a solicitação do método

GET.
REMOTE_ADDR
7 O endereço IP do host remoto que faz a solicitação. Isso é útil para registro
ou para autenticação.
HOSPEDEIRO REMOTO
O nome totalmente qualificado do host que faz a solicitação. Se essa

8
informação não estiver disponível, o REMOTE_ADDR poderá ser usado para
obter o endereço de infravermelho.
REQUEST_METHOD
9 O método usado para fazer a solicitação. Os métodos mais comuns são GET
e POST.
SCRIPT_FILENAME
10
O caminho completo para o script CGI.
11 SCRIPT_NAME
O nome do script CGI.
NOME DO SERVIDOR
12
O nome do host ou endereço IP do servidor
SERVER_SOFTWARE
13
O nome e a versão do software que o servidor está executando.
Aqui está um pequeno programa CGI para listar todas as variáveis CGI. Clique neste
link para ver o resultado Get Environment
#!/usr/bin/python
import os
print ("Content-type: text/html\r\n\r\n");

print ("<font size=+1>Environment</font><\br>");
for param in os.environ.keys():
print ("<b>%20s</b>: %s<\br>" % (param, os.environ[param]))
Métodos GET e POST

Você deve ter se deparado com muitas situações quando precisar passar algumas
informações do seu navegador para o servidor da Web e, finalmente, para o seu
Programa CGI. Com mais freqüência, o navegador usa dois métodos, dois passam essas
informações para o servidor da web. Esses métodos são o método GET e o método
POST.
Passando informações usando o método GET

O método GET envia as informações do usuário codificadas anexadas à solicitação de
página. A página e as informações codificadas são separadas por? personagem da
seguinte forma -
http://www.test.com/cgi-bin/hello.py?key1=value1&key2=value2
O método GET é o método padrão para passar informações do navegador para o

servidor da Web e produz uma longa cadeia de caracteres que aparece na caixa Local
do seu navegador: Nunca use o método GET se você tiver senha ou outras informações
confidenciais para passar para o servidor. O método GET tem limitação de tamanho:
somente 1024 caracteres podem ser enviados em uma string de solicitação. O método
GET envia informações usando o cabeçalho QUERY_STRING e estará acessível no seu
Programa CGI através da variável de ambiente QUERY_STRING.
Você pode passar informações simplesmente concatenando pares de chave e valor
junto com qualquer URL ou pode usar marcas HTML <FORM> para passar informações
usando o método GET.
Exemplo de URL simples: método Get

Aqui está um URL simples, que passa dois valores para o programa hello_get.py usando
o método GET.
/cgi-bin/hello_get.py?first_name=ZARA&last_name=ALI
Abaixo está o script hello_get.py para manipular a entrada fornecida pelo navegador
da web. Nós vamos usar o módulo cgi , o que facilita o acesso a informações passadas.
#!/usr/bin/python
# Import modules for CGI handling

import cgi, cgitb
# Create instance of FieldStorage

form = cgi.FieldStorage()
# Get data from fields

first_name = form.getvalue('first_name')
last_name = form.getvalue('last_name')
print ("Content-type:text/html\r\n\r\n")
print ("<html>")
print ("<head>")
print ("<title>Hello - Second CGI Program</title>")
print ("</head>")
print ("<body>")
print ("<h2>Hello %s %s</h2>" % (first_name, last_name))
print ("</body>")
print ("</html>")
Isso geraria o seguinte resultado -
Olá ZARA ALI
Formulário Simples Exemplo: Método GET

Este exemplo passa dois valores usando o FORMULÁRIO HTML e o botão enviar. Usamos
o mesmo script CGI hello_get.py para manipular essa entrada.
<form action = "/cgi-bin/hello_get.py" method = "get">

First Name: <input type = "text" name = "first_name"> <br />
Last Name: <input type = "text" name = "last_name" />

<input type = "submit" value = "Submit" />
</form>
Aqui está a saída real do formulário acima, você insere Primeiro e Último Nome e, em
seguida, clica no botão enviar para ver o resultado.
Primeiro nome:
Último nome: Enviar
Passando informações usando o método POST

Um método geralmente mais confiável de passar informações para um programa CGI é
o método POST. Isso empacota as informações exatamente da mesma maneira que os
métodos GET, mas em vez de enviá-las como uma string de texto depois de um? no
URL que ele envia como uma mensagem separada. Esta mensagem vem no script CGI
na forma da entrada padrão.
Abaixo está o mesmo script hello_get.py, que lida com o método GET, bem como com o
método POST.
#!/usr/bin/python

import cgi, cgitb


first_name = form.getvalue('first_name')
last_name = form.getvalue('last_name')
print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"
Vamos retomar o mesmo exemplo acima que passa dois valores usando o FORMULÁRIO
HTML e o botão enviar. Usamos o mesmo script CGI hello_get.py para manipular essa
entrada.
<form action = "/cgi-bin/hello_get.py" method = "post">

First Name: <input type = "text" name = "first_name"><br />
Last Name: <input type = "text" name = "last_name" />

</form>
Aqui está a saída real do formulário acima. Você insere Primeiro e Último Nome e, em
seguida, clica no botão enviar para ver o resultado.
Primeiro nome:
Último nome: Enviar

Passando dados da caixa de seleção para o programa
CGI
Caixas de seleção são usadas quando mais de uma opção é necessária para ser
selecionada.
Aqui está um exemplo de código HTML para um formulário com duas caixas de seleção
-
<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">

<input type = "checkbox" name = "maths" value = "on" /> Maths
<input type = "checkbox" name = "physics" value = "on" /> Physics
<input type = "submit" value = "Select Subject" />
</form>
O resultado deste código é o seguinte formulário -
Matemáticas Física Selecionar Assunto
Abaixo está o script checkbox.cgi para manipular a entrada fornecida pelo navegador
para o botão de caixa de seleção.
#!/usr/bin/python

import cgi, cgitb


if form.getvalue('maths'):
math_flag = "ON"
else:
math_flag = "OFF"
if form.getvalue('physics'):
physics_flag = "ON"
else:
physics_flag = "OFF"
print "<html>"
print "<head>"
print "<title>Checkbox - Third CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> CheckBox Maths is : %s</h2>" % math_flag
print "<h2> CheckBox Physics is : %s</h2>" % physics_flag
print "</body>"
print "</html>"
Passando dados do botão de rádio para o programa

CGI
Botões de rádio são usados quando apenas uma opção é necessária para ser
selecionada.
Aqui está um exemplo de código HTML para um formulário com dois botões de opção -
<form action = "/cgi-bin/radiobutton.py" method = "post" target = "_blank">

<input type = "radio" name = "subject" value = "maths" /> Maths
<input type = "radio" name = "subject" value = "physics" /> Physics
<input type = "submit" value = "Select Subject" />
</form>
Matemáticas Física Selecionar Assunto
Abaixo está o script radiobutton.py para manipular a entrada fornecida pelo navegador
da Web para o botão de opção -
#!/usr/bin/python

import cgi, cgitb


if form.getvalue('subject'):
subject = form.getvalue('subject')
else:
subject = "Not set"
print "<html>"
print "<head>"
print "<title>Radio - Fourth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"
Passando dados da área de texto para o programa CGI

O elemento TEXTAREA é usado quando o texto multilinha deve ser passado para o
Programa CGI.
Aqui está um exemplo de código HTML para um formulário com uma caixa TEXTAREA -
<form action = "/cgi-bin/textarea.py" method = "post" target = "_blank">

<textarea name = "textcontent" cols = "40" rows = "4">
Type your text here...
</textarea>
</form>

Type your text here...
Enviar
Abaixo está o script textarea.cgi para manipular a entrada fornecida pelo navegador da
web -
#!/usr/bin/python

import cgi, cgitb


if form.getvalue('textcontent'):
text_content = form.getvalue('textcontent')
else:
text_content = "Not entered"
print "<html>"
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Entered Text Content is %s</h2>" % text_content
print "</body>"
Transmitindo dados da caixa suspensa para o

programa CGI
Drop Down Box é usado quando temos muitas opções disponíveis, mas apenas um ou
dois serão selecionados.
Aqui está um exemplo de código HTML para um formulário com uma caixa suspensa -
<form action = "/cgi-bin/dropdown.py" method = "post" target = "_blank">

<select name = "dropdown">
<option value = "Maths" selected>Maths</option>
<option value = "Physics">Physics</option>
</select>
<input type = "submit" value = "Submit"/>
</form>
Matemáticas Enviar
Abaixo está o script dropdown.py para manipular a entrada fornecida pelo navegador da
web.
#!/usr/bin/python
import cgi, cgitb


if form.getvalue('dropdown'):
subject = form.getvalue('dropdown')
else:
subject = "Not entered"
print "<html>"
print "<head>"
print "<title>Dropdown Box - Sixth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"
Usando cookies no CGI

O protocolo HTTP é um protocolo sem estado. Para um site comercial, é necessário
manter informações da sessão entre diferentes páginas. Por exemplo, um registro de
usuário termina após a conclusão de várias páginas. Como manter as informações da
sessão do usuário em todas as páginas da web?
Em muitas situações, o uso de cookies é o método mais eficiente de lembrar e rastrear

preferências, compras, comissões e outras informações necessárias para uma melhor
experiência do visitante ou estatísticas do site.
Como funciona?
Seu servidor envia alguns dados para o navegador do visitante na forma de um cookie.
O navegador pode aceitar o cookie. Em caso afirmativo, ele é armazenado como um
registro de texto simples no disco rígido do visitante. Agora, quando o visitante chegar
em outra página do seu site, o cookie estará disponível para recuperação. Uma vez
recuperado, seu servidor sabe / lembra o que foi armazenado.
Cookies são um registro de dados de texto simples de 5 campos de comprimento

variável -
Expira - A data em que o cookie irá expirar. Se estiver em branco, o cookie

expirará quando o visitante sair do navegador.
Domínio - o nome de domínio do seu site.
Caminho - O caminho para o diretório ou página da web que define o cookie.

Isso pode ficar em branco se você quiser recuperar o cookie de qualquer
diretório ou página.
Seguro - Se este campo contiver a palavra "seguro", o cookie só poderá ser
recuperado com um servidor seguro. Se este campo estiver em branco, essa
restrição não existe.
Name = Value - Os cookies são definidos e recuperados na forma de pares de

chave e valor.
Configurando Cookies
É muito fácil enviar cookies para o navegador. Esses cookies são enviados junto com o
cabeçalho HTTP antes para o campo de tipo de conteúdo. Supondo que você deseja
definir UserID e senha como cookies. Definir os cookies é feito da seguinte forma -
#!/usr/bin/python
print "Set-Cookie:UserID = XYZ;\r\n"

print "Set-Cookie:Password = XYZ123;\r\n"
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT";\r\n"
print "Set-Cookie:Domain = www.tutorialspoint.com;\r\n"
print "Set-Cookie:Path = /perl;\n"
...........Rest of the HTML Content....
A partir deste exemplo, você deve ter entendido como definir cookies. Usamos o
cabeçalho HTTP Set-Cookie para definir cookies.
É opcional definir atributos de cookies como Expira, Domínio e Caminho. É notável que
os cookies sejam definidos antes de enviar a linha mágica "Tipo de conteúdo: text /
html \ r \ n \ r \ n .
Recuperando Cookies
É muito fácil recuperar todos os cookies definidos. Os cookies são armazenados na
variável de ambiente CGI HTTP_COOKIE e terão o seguinte formulário -
key1 = value1;key2 = value2;key3 = value3....
Aqui está um exemplo de como recuperar cookies.
#!/usr/bin/python

from os import environ
import cgi, cgitb
if environ.has_key('HTTP_COOKIE'):
for cookie in map(strip, split(environ['HTTP_COOKIE'], ';')):
(key, value ) = split(cookie, '=');
if key == "UserID":
user_id = value
if key == "Password":
password = value
print "User ID = %s" % user_id

print "Password = %s" % password
Isso produz o seguinte resultado para os cookies definidos pelo script acima -
User ID = XYZ
Password = XYZ123
Exemplo de Upload de Arquivo

Para carregar um arquivo, o formulário HTML deve ter o atributo enctype definido como
multipart / form-data . A tag de entrada com o tipo de arquivo cria um botão
"Browse".
<html>
<body>
<form enctype = "multipart/form-data"
action = "save_file.py" method = "post">
<p>File: <input type = "file" name = "filename" /></p>
<p><input type = "submit" value = "Upload" /></p>
</form>
</body>
</html>
Arquivo: Escolher arquivo Nenhum arquivo selecionado
Upload
O exemplo acima foi desativado intencionalmente para salvar as pessoas que enviaram
arquivos em nosso servidor, mas você pode tentar o código acima com o seu servidor.
Aqui está o script save_file.py para lidar com o upload de arquivos -
#!/usr/bin/python
import cgi, os
import cgitb; cgitb.enable()
# Get filename here.

fileitem = form['filename']
# Test if the file was uploaded

if fileitem.filename:
# strip leading path from file name to avoid
# directory traversal attacks
fn = os.path.basename(fileitem.filename)
open('/tmp/' + fn, 'wb').write(fileitem.file.read())
message = 'The file "' + fn + '" was uploaded successfully'
else:
message = 'No file was uploaded'
print """\
Content-Type: text/html\n
<html>
<body>
<p>%s</p>
</body>
</html>
""" % (message,)
Se você executar o script acima no Unix / Linux, então você precisa tomar o cuidado de
substituir o separador de arquivos da seguinte forma, caso contrário, em sua máquina
windows acima da instrução open () deve funcionar bem.
fn = os.path.basename(fileitem.filename.replace("\\", "/" ))
Como levantar uma caixa de diálogo "Download de

arquivo"?
Às vezes, é desejável que você queira dar a opção onde um usuário pode clicar em um
link e ele irá aparecer uma caixa de diálogo "Download de arquivo" para o usuário em
vez de exibir o conteúdo real. Isso é muito fácil e pode ser alcançado através do
cabeçalho HTTP. Este cabeçalho HTTP é diferente do cabeçalho mencionado na seção
anterior.
Por exemplo, se você quiser fazer com que um arquivo FileName seja baixado de um
determinado link, então sua sintaxe é a seguinte -
#!/usr/bin/python
# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";
# Actual File Content will go here.

fo = open("foo.txt", "rb")
str = fo.read();
print str
# Close opend file

fo.close()
Espero que tenha gostado desse tutorial. Se sim, por favor me envie seu feedback em:
Fale Conosco
Python 3 - Acesso ao Banco de Dados MySQL

O padrão Python para interfaces de banco de dados é o DB-API do Python. A maioria
das interfaces de banco de dados Python aderem a esse padrão.
Você pode escolher o banco de dados certo para o seu aplicativo. Python Database API
suporta uma ampla gama de servidores de banco de dados como -
GadFly
mSQL
MySQL
PostgreSQL
Microsoft SQL Server 2000
Informix
Interbase
Oráculo
Sybase
SQLite
Aqui está a lista de interfaces de banco de dados Python disponíveis - Interfaces de

banco de dados Python e APIs . Você deve fazer o download de um módulo de API
do banco de dados separado para cada banco de dados que precisa acessar. Por
exemplo, se você precisar acessar um banco de dados Oracle e um banco de dados
MySQL, faça o download dos módulos de banco de dados Oracle e MySQL.
A API do banco de dados fornece um padrão mínimo para trabalhar com bancos de
dados usando estruturas e sintaxe do Python sempre que possível. Esta API inclui o
seguinte -
Importando o módulo da API.
Adquirindo uma conexão com o banco de dados.
Emitindo instruções SQL e procedimentos armazenados.
Fechando a conexão
O Python tem um suporte embutido para o SQLite. Nesta seção, aprenderíamos todos
os conceitos usando o MySQL. O módulo MySQLdb, uma interface popular com o
MySQL, não é compatível com o Python 3. Em vez disso, usaremos o módulo
PyMySQL .
O que é o PyMySQL?
PyMySQL é uma interface para se conectar a um servidor de banco de dados MySQL do
Python. Ele implementa a API Python Database v2.0 e contém uma biblioteca cliente
MySQL puro-Python. O objetivo do PyMySQL é ser um substituto para o MySQLdb.
Como faço para instalar o PyMySQL?

Antes de continuar, verifique se o PyMySQL está instalado em sua máquina. Basta
digitar o seguinte no seu script Python e executá-lo -
#!/usr/bin/python3
import PyMySQL
Se ele produzir o seguinte resultado, significa que o módulo MySQLdb não está
instalado -
Import PyMySQL
ImportError: No module named PyMySQL
A última versão estável está disponível no PyPI e pode ser instalada com pip -
pip install PyMySQL
Como alternativa (por exemplo, se pip não estiver disponível), um tarball pode ser
baixado do GitHub e instalado com o Setuptools como segue -
$ # X.X is the desired PyMySQL version (e.g. 0.5 or 0.6).

$ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz
$ cd PyMySQL*
$ python setup.py install
$ # The folder PyMySQL* can be safely removed now.
Nota - Certifique-se de ter privilégio de root para instalar o módulo acima.
Conexão de banco de dados

Antes de se conectar a um banco de dados MySQL, certifique-se dos seguintes pontos -
Você criou um banco de dados TESTDB.
Você criou uma tabela EMPLOYEE em TESTDB.
Esta tabela possui os campos FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.
O ID do usuário "testuser" e a senha "test123" estão configurados para acessar

o TESTDB.
O módulo Python PyMySQL está instalado corretamente na sua máquina.
Você passou pelo tutorial do MySQL para entender o MySQL Basics.
Exemplo
A seguir, um exemplo de conexão com o banco de dados MySQL "TESTDB" -
#!/usr/bin/python3
import PyMySQL
# Open database connection

db = PyMySQL.connect("localhost","testuser","test123","TESTDB" )
# prepare a cursor object using cursor() method

cursor = db.cursor()
# execute SQL query using execute() method.

cursor.execute("SELECT VERSION()")
# Fetch a single row using fetchone() method.

data = cursor.fetchone()
print ("Database version : %s " % data)
# disconnect from server
db.close()
Ao executar esse script, ele produz o resultado a seguir.
Database version : 5.5.20-log
Se uma conexão for estabelecida com a origem de dados, um Objeto de Conexão será
retornado e salvo em db para uso posterior, caso contrário, db será definido como
Nenhum. Em seguida, o objeto db é usado para criar um objeto de cursor , que por
sua vez é usado para executar consultas SQL. Finalmente, antes de sair, garante que a
conexão com o banco de dados seja fechada e que os recursos sejam liberados.
Criando tabela de banco de dados

Uma vez estabelecida uma conexão de banco de dados, estamos prontos para criar
tabelas ou registros nas tabelas de banco de dados usando o método de execução do
cursor criado.
Exemplo
Vamos criar uma tabela de banco de dados EMPREGADO -
#!/usr/bin/python3
import PyMySQL


# Drop table if it already exist using execute() method.

cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
# Create table as per requirement

sql = """CREATE TABLE EMPLOYEE (
FIRST_NAME CHAR(20) NOT NULL,
LAST_NAME CHAR(20),
AGE INT,
SEX CHAR(1),
INCOME FLOAT )"""
cursor.execute(sql)

db.close()
Operação INSERIR
A operação INSERT é necessária quando você deseja criar seus registros em uma tabela
de banco de dados.
Exemplo
O exemplo a seguir, executa a instrução SQL INSERT para criar um registro na tabela
EMPLOYEE -
#!/usr/bin/python3
import PyMySQL


# Prepare SQL query to INSERT a record into the database.

sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
# Execute the SQL command
cursor.execute(sql)
# Commit your changes in the database
db.commit()
except:
# Rollback in case there is any error
db.rollback()

db.close()
O exemplo acima pode ser escrito da seguinte maneira para criar consultas SQL
dinamicamente -
#!/usr/bin/python3
import PyMySQL



sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
LAST_NAME, AGE, SEX, INCOME) \
VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
('Mac', 'Mohan', 20, 'M', 2000)
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()

db.close()
Exemplo
O segmento de código a seguir é outra forma de execução na qual você pode transmitir
parâmetros diretamente -
..................................
user_id = "test123"
password = "password"
con.execute('insert into Login values("%s", "%s")' % \

(user_id, password))
..................................
Operação de LEITURA
LEITURA Operação em qualquer banco de dados significa buscar algumas informações
úteis do banco de dados.
Depois que a conexão com o banco de dados for estabelecida, você estará pronto para
fazer uma consulta nesse banco de dados. Você pode usar o método fetchone () para
buscar um único registro ou o método fetchall () para buscar vários valores de uma
tabela de banco de dados.
fetchone () - Ele busca a próxima linha de um conjunto de resultados da

consulta. Um conjunto de resultados é um objeto que é retornado quando um
objeto de cursor é usado para consultar uma tabela.
fetchall () - Ele busca todas as linhas em um conjunto de resultados. Se

algumas linhas já tiverem sido extraídas do conjunto de resultados, ele
recuperará as linhas restantes do conjunto de resultados.
rowcount - Esse é um atributo somente leitura e retorna o número de linhas

que foram afetadas por um método execute ().
Exemplo
O procedimento a seguir consulta todos os registros da tabela EMPLOYEE com salário
superior a 1000 -
#!/usr/bin/python3
import PyMySQL



sql = "SELECT * FROM EMPLOYEE \
WHERE INCOME > '%d'" % (1000)
try:
cursor.execute(sql)
# Fetch all the rows in a list of lists.
results = cursor.fetchall()
for row in results:
fname = row[0]
lname = row[1]
age = row[2]
sex = row[3]
income = row[4]
# Now print fetched result
print ("fname = %s,lname = %s,age = %d,sex = %s,income = %d" % \
(fname, lname, age, sex, income ))
except:
print ("Error: unable to fetch data")

db.close()
Saída
Isso produzirá o seguinte resultado -
fname = Mac, lname = Mohan, age = 20, sex = M, income = 2000
Operação de atualização
ATUALIZAÇÃO Operação em qualquer banco de dados significa atualizar um ou mais
registros, que já estão disponíveis no banco de dados.
O procedimento a seguir atualiza todos os registros que possuem SEX como 'M' . Aqui,
aumentamos o IDADE de todos os machos em um ano.
Exemplo
#!/usr/bin/python3
import PyMySQL


# Prepare SQL query to UPDATE required records

sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
WHERE SEX = '%c'" % ('M')
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()

db.close()
Operação DELETE
A operação DELETE é necessária quando você deseja excluir alguns registros do banco
de dados. A seguir, o procedimento para excluir todos os registros do EMPLOYEE, nos
quais a AGE é maior que 20
Exemplo
#!/usr/bin/python3
import PyMySQL


# Prepare SQL query to DELETE required records

sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()

db.close()
Executando Transações
As transações são um mecanismo que garante a consistência dos dados. As transações
têm as quatro propriedades a seguir -
Atomicidade - Uma transação é concluída ou nada acontece.
Consistência - Uma transação deve começar em um estado consistente e

deixar o sistema em um estado consistente.
Isolamento - Resultados intermediários de uma transação não são visíveis fora

da transação atual.
Durabilidade - Uma vez que uma transação foi confirmada, os efeitos são
persistentes, mesmo após uma falha no sistema.
O Python DB API 2.0 fornece dois métodos para confirmar ou reverter uma transação.
Exemplo
Você já sabe como implementar transações. Aqui está um exemplo semelhante -
# Prepare SQL query to DELETE required records

sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()
Operação COMMIT
Commit é uma operação, que dá um sinal verde ao banco de dados para finalizar as
mudanças e, após essa operação, nenhuma alteração pode ser revertida.
Aqui está um exemplo simples para chamar o método commit .
db.commit()
Operação ROLLBACK
Se você não estiver satisfeito com uma ou mais das alterações e quiser reverter essas
alterações completamente, use o método rollback () .
Aqui está um exemplo simples para chamar o método rollback () .
db.rollback()
Desconectando banco de dados

Para desconectar a conexão do banco de dados, use o método close ().
db.close()
Se a conexão com um banco de dados for fechada pelo usuário com o método close (),
todas as transações pendentes serão revertidas pelo banco de dados. No entanto, em
vez de depender de qualquer um dos detalhes de implementação de nível inferior do
banco de dados, seria melhor que seu aplicativo chamasse commit ou rollback
explicitamente.
Manipulando Erros
Existem muitas fontes de erros. Alguns exemplos são um erro de sintaxe em uma
instrução SQL executada, uma falha de conexão ou a chamada do método de busca
para um identificador de instrução já cancelado ou concluído.
A API do banco de dados define vários erros que devem existir em cada módulo do
banco de dados. A tabela a seguir lista essas exceções.
Sr. Excepção e Descrição

Não.
Aviso
1
Usado para problemas não fatais. Deve subclassificar o StandardError.
2 Erro
Classe base para erros. Deve subclassificar o StandardError.
InterfaceError
3 Usado para erros no módulo de banco de dados, não no próprio banco de

dados. Deve subclassificar o erro.
DatabaseError
4
Usado para erros no banco de dados. Deve subclassificar o erro.
Erro de data
5
Subclasse de DatabaseError que se refere a erros nos dados.
OperationalError
Subclasse de DatabaseError que se refere a erros, como a perda de uma

6
conexão com o banco de dados. Esses erros geralmente estão fora do controle
do script Python.
IntegrityError
7 Subclasse de DatabaseError para situações que danificariam a integridade

relacional, como restrições de exclusividade ou chaves estrangeiras.
Erro interno
8 Subclasse de DatabaseError que se refere aos erros internos do módulo de

banco de dados, como um cursor que não está mais ativo.
ProgrammingError
9 Subclasse de DatabaseError que se refere a erros, como um nome de tabela

inválido e outras coisas que podem ser seguramente atribuídos a você.
NotSupportedError
10 Subclasse de DatabaseError que se refere à tentativa de chamar

funcionalidade não suportada.
Seus scripts Python devem lidar com esses erros, mas antes de usar qualquer uma das
exceções acima, verifique se o seu MySQLdb tem suporte para essa exceção. Você pode
obter mais informações sobre eles lendo a especificação DB API 2.0.
Python 3 - Programação de Rede

O Python fornece dois níveis de acesso aos serviços de rede. Em um nível baixo, você
pode acessar o suporte a soquete básico no sistema operacional subjacente, o que
permite implementar clientes e servidores para protocolos orientados a conexão e sem
conexão.
O Python também possui bibliotecas que fornecem acesso de nível superior a protocolos
de rede específicos no nível do aplicativo, como FTP, HTTP e assim por diante.
Este capítulo dá-lhe uma compreensão sobre o conceito mais famoso em Networking -
Socket Programming.
O que é Sockets?
Soquetes são os pontos finais de um canal de comunicação bidirecional. Soquetes
podem se comunicar dentro de um processo, entre processos na mesma máquina ou
entre processos em diferentes continentes.
Os soquetes podem ser implementados em vários tipos de canais diferentes: soquetes

de domínio Unix, TCP, UDP e assim por diante. A biblioteca de soquetes fornece classes
específicas para manipular os transportes comuns, bem como uma interface genérica
para manipular o restante.
Soquetes tem seu próprio vocabulário -
Sr. Termo e Descrição

Não.
domínio
A família de protocolos usada como mecanismo de transporte. Esses valores

1
são constantes, como AF_INET, PF_INET, PF_UNIX, PF_X25 e assim por
diante.
tipo
O tipo de comunicação entre os dois pontos de extremidade, geralmente

2
SOCK_STREAM para protocolos orientados a conexão e SOCK_DGRAM para
protocolos sem conexão.
protocolo
3 Normalmente zero, isso pode ser usado para identificar uma variante de um
protocolo dentro de um domínio e tipo.
4 nome de anfitrião
O identificador de uma interface de rede -

Uma string, que pode ser um nome de host, um endereço com quatro
pontos ou um endereço IPV6 na notação de dois-pontos (e
possivelmente ponto)
Uma string "<broadcast>", que especifica um endereço

INADDR_BROADCAST.
Uma cadeia de comprimento zero, que especifica INADDR_ANY ou
Um Integer, interpretado como um endereço binário na ordem de

bytes do host.
porta
Cada servidor escuta os clientes que ligam em uma ou mais portas. Uma porta
5
pode ser um número de porta Fixnum, uma cadeia contendo um número de
porta ou o nome de um serviço.
O módulo do soquete
Para criar um socket, você deve usar a função socket.socket () disponível no módulo
socket, que possui a sintaxe geral -
s = socket.socket (socket_family, socket_type, protocol = 0)
socket_family - Isso é AF_UNIX ou AF_INET, conforme explicado

anteriormente.
socket_type - Isso é SOCK_STREAM ou SOCK_DGRAM.
protocolo - Geralmente, é deixado de fora, assumindo o padrão 0.
Depois de ter objeto de soquete , você pode usar as funções necessárias para criar seu
programa de cliente ou servidor. A seguir, a lista de funções necessárias -
Métodos de Soquete do Servidor

Não.
s.bind ()
1 Este método liga o endereço (nome do host, par do número da porta) ao

soquete.
2 s.listen ()
Este método configura e inicia o listener TCP.

s.accept ()
3 Isso aceita passivamente a conexão do cliente TCP, esperando até que a

conexão chegue (bloqueando).
Métodos de Soquete do Cliente

Sr. Não. Método e Descrição
s.connect ()
1
Este método inicia ativamente a conexão do servidor TCP.
Métodos Gerais de Soquete

Não.
s.recv ()
1
Este método recebe mensagem TCP
s.send ()
2
Este método transmite a mensagem TCP
s.recvfrom ()
3
Este método recebe mensagem UDP
s.sendto ()
4
Este método transmite a mensagem UDP
s.close ()
5
Este método fecha o soquete
socket.gethostname ()
6
Retorna o nome do host.
Um servidor simples
Para escrever servidores de Internet, usamos a função de soquete disponível no
módulo de soquete para criar um objeto de soquete. Um objeto de soquete é usado
para chamar outras funções para configurar um servidor de soquete.
Agora chame a função bind (hostname, port) para especificar uma porta para seu
serviço no host fornecido.
Em seguida, chame o método accept do objeto retornado. Esse método aguarda até
que um cliente se conecte à porta especificada e, em seguida, retorna um objeto de
conexão que representa a conexão com esse cliente.
#!/usr/bin/python3 # This is server.py file

import socket
# create a socket object

serversocket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
# get local machine name

host = socket.gethostname()
port = 9999
# bind to the port

serversocket.bind((host, port))
# queue up to 5 requests
serversocket.listen(5)
while True:
# establish a connection
clientsocket,addr = serversocket.accept()
print("Got a connection from %s" % str(addr))
msg = 'Thank you for connecting'+ "\r\n"

clientsocket.send(msg.encode('ascii'))
clientsocket.close()
Um cliente simples
Vamos escrever um programa cliente muito simples que abre uma conexão com uma
determinada porta 12345 e um determinado host. É muito simples criar um cliente de
soquete usando a função de módulo de soquete do Python .
O socket.connect (hosname, port) abre uma conexão TCP para o hostname na porta
. Depois de ter um soquete aberto, você pode ler como qualquer outro objeto de IO.
Quando terminar, lembre-se de fechá-lo, pois você fecharia um arquivo.
Exemplo
O código a seguir é um cliente muito simples que se conecta a um determinado host e
porta, lê qualquer dado disponível do soquete e sai -
#!/usr/bin/python3 # This is client.py file
import socket
# create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# get local machine name

host = socket.gethostname()
port = 9999
# connection to hostname on the port.

s.connect((host, port))
# Receive no more than 1024 bytes

msg = s.recv(1024)
s.close()
print (msg.decode('ascii'))
Agora execute este server.py em segundo plano e execute o client.py acima para ver o
resultado.
# Following would start a server in background.

$ python server.py &
# Once server is started run client as follows:

$ python client.py
Saída
on server terminal
Got a connection from ('192.168.1.10', 3747)
On client terminal
Thank you for connecting
Módulos de Internet Python

Uma lista de alguns módulos importantes em programação de rede / Internet em
Python é fornecida abaixo -
Protocolo Função comum Port No Módulo Python
HTTP paginas web 80 httplib, urllib, xmlrpclib
NNTP Notícias Usenet 119 nntplib
FTP Transferências de arquivos 20 ftplib, urllib
SMTP Enviando email 25 smtplib
POP3 Buscando email 110 poplib
IMAP4 Buscando email 143 imaplib
Telnet Linhas de comando 23 telnetlib

Gopher Transferência de documentos 70 gopherlib, urllib
Por favor, verifique todas as bibliotecas mencionadas acima para trabalhar com os
protocolos FTP, SMTP, POP e IMAP.
Leituras Adicionais
Este foi um começo rápido com a programação de soquete. É um assunto vasto.
Recomenda-se passar pelo seguinte link para encontrar mais detalhes -
Programação de Soquete Unix .
Biblioteca de Soquetes Python e Módulos .
Python 3 - Enviando e-mail usando o SMTP

O SMTP (Simple Mail Transfer Protocol) é um protocolo que manipula o envio de um
email e roteamento de email entre servidores de email.
O Python fornece o módulo smtplib , que define um objeto de sessão do cliente SMTP
que pode ser usado para enviar mensagens para qualquer máquina da Internet com um
daemon de ouvinte SMTP ou ESMTP.
Aqui está uma sintaxe simples para criar um objeto SMTP, que pode ser usado
posteriormente para enviar um e-mail -
import smtplib
smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )
Aqui está o detalhe dos parâmetros -
host - este é o host que está executando o servidor SMTP. Você pode
especificar o endereço IP do host ou um nome de domínio como
tutorialspoint.com. Este é um argumento opcional.
port - Se você está fornecendo argumento de host , então você precisa

especificar uma porta, onde o servidor SMTP está escutando. Normalmente essa
porta seria 25.
local_hostname - Se o seu servidor SMTP estiver sendo executado em sua

máquina local, você poderá especificar apenas a opção localhost .
Um objeto SMTP tem um método de instância chamado sendmail , que é normalmente

usado para fazer o trabalho de enviar uma mensagem. Leva três parâmetros -
O remetente - Uma string com o endereço do remetente.
Os receptores - Uma lista de cadeias, uma para cada destinatário.
A mensagem - Uma mensagem como uma string formatada conforme

especificado nos vários RFCs.
Exemplo
Aqui está uma maneira simples de enviar um e-mail usando o script Python. Tente uma
vez -
#!/usr/bin/python3
import smtplib
sender = 'from@fromdomain.com'
receivers = ['to@todomain.com']
message = """From: From Person <from@fromdomain.com>

To: To Person <to@todomain.com>
Subject: SMTP e-mail test
This is a test e-mail message.

"""
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, message)
print "Successfully sent email"
except SMTPException:
print "Error: unable to send email"
Aqui, você colocou um e-mail básico na mensagem, usando uma aspa tripla, tomando o
cuidado de formatar os cabeçalhos corretamente. Um email requer um cabeçalho De ,
Para e Assunto , separado do corpo do email com uma linha em branco.
Para enviar o email você usa smtpObj para se conectar ao servidor SMTP na máquina
local. Em seguida, use o método sendmail junto com a mensagem, o endereço de e o
endereço de destino como parâmetros (mesmo que os endereços de e para estejam
dentro do próprio e-mail, nem sempre eles são usados para rotear o e-mail).
Se você não estiver executando um servidor SMTP em sua máquina local, poderá usar o
cliente smtplib para se comunicar com um servidor SMTP remoto. A menos que você
esteja usando um serviço de webmail (como o gmail ou o Yahoo! Mail), seu provedor de
e-mail deve fornecer os detalhes do servidor de e-mail de saída que você pode fornecer,
como segue:
mail = smtplib.SMTP('smtp.gmail.com', 587)
Enviando um email em HTML usando o Python

Quando você envia uma mensagem de texto usando Python, todo o conteúdo é tratado
como texto simples. Mesmo se você incluir tags HTML em uma mensagem de texto, ela
será exibida como texto simples e as tags HTML não serão formatadas de acordo com a
sintaxe HTML. No entanto, o Python fornece uma opção para enviar uma mensagem
HTML como mensagem HTML real.
Ao enviar uma mensagem de e-mail, você pode especificar uma versão Mime, um tipo
de conteúdo e um conjunto de caracteres para enviar um e-mail em HTML.
Exemplo
A seguir, um exemplo para enviar o conteúdo HTML como um e-mail. Tente uma vez -
#!/usr/bin/python3
import smtplib
message = """From: From Person <from@fromdomain.com>

To: To Person <to@todomain.com>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test
This is an e-mail message to be sent in HTML format
<b>This is HTML message.</b>

<h1>This is headline.</h1>
"""
try:
smtpObj.sendmail(sender, receivers, message)
except SMTPException:
print "Error: unable to send email"
Enviando Anexos como um E-mail

Para enviar um e-mail com conteúdo misto, é necessário definir o cabeçalho do tipo de
conteúdo como multipartido / misto . Em seguida, o texto e as seções de anexo
podem ser especificados dentro dos limites .
Um limite é iniciado com dois hífens seguidos por um número exclusivo, que não pode
aparecer na parte da mensagem do e-mail. Um limite final indicando a seção final do e-
mail também deve terminar com dois hífens.
Os arquivos anexados devem ser codificados com a função pack ("m") para ter a
codificação base 64 antes da transmissão.
Exemplo
A seguir, um exemplo, que envia um arquivo /tmp/test.txt como um anexo. Tente
uma vez -
#!/usr/bin/python3
import smtplib
import base64
filename = "/tmp/test.txt"
# Read a file and encode it into base64 format

fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent) # base64
sender = 'webmaster@tutorialpoint.com'
reciever = 'amrood.admin@gmail.com'
marker = "AUNIQUEMARKER"
body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person <me@fromdomain.net>
To: To Person <amrood.admin@gmail.com>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)
# Define the message action

part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit
%s
--%s
""" % (body,marker)
# Define the attachment section

part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s
%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3
try:
smtpObj.sendmail(sender, reciever, message)
except Exception:
print ("Error: unable to send email")
Python 3 - Programação Multithread

Executar vários threads é semelhante a executar vários programas diferentes ao
mesmo tempo, mas com os seguintes benefícios -
Vários encadeamentos dentro de um processo compartilham o mesmo espaço

de dados com o encadeamento principal e, portanto, podem compartilhar
informações ou se comunicar entre si com mais facilidade do que se fossem
processos separados.
Às vezes, os threads são chamados de processos leves e não exigem muita

sobrecarga de memória; eles são mais baratos que os processos.
Um segmento tem um começo, uma seqüência de execução e uma conclusão. Ele tem
um ponteiro de instrução que rastreia onde o contexto está sendo executado no
momento.
Pode ser antecipado (interrompido).

Ele pode temporariamente ser colocado em espera (também conhecido como
sleeping) enquanto outros threads estão sendo executados - isso é chamado de
renderização.
Existem dois tipos diferentes de tópicos -
thread do kernel
thread do usuário
Threads de kernel são uma parte do sistema operacional, enquanto os threads de

espaço de usuário não são implementados no kernel.
Existem dois módulos que suportam o uso de threads no Python3 -
_fio
segmentação
O módulo de thread foi "obsoleto" por um longo tempo. Usuários são encorajados a
usar o módulo de threading. Portanto, no Python 3, o módulo "thread" não está mais
disponível. No entanto, ele foi renomeado para "_thread" para compatibilidades
reversas no Python3.
Iniciando um novo thread

Para gerar outro thread, você precisa chamar o seguinte método disponível no módulo
de thread -
_thread.start_new_thread ( function, args[, kwargs] )
Essa chamada de método permite uma maneira rápida e eficiente de criar novos
encadeamentos no Linux e no Windows.
A chamada do método retorna imediatamente e o encadeamento filho é iniciado e

chama a função com a lista de argumentos passada . Quando a função retorna, o
segmento termina.
Aqui, args é uma tupla de argumentos; use uma tupla vazia para chamar a função sem
passar nenhum argumento. O kwargs é um dicionário opcional de argumentos de
palavras-chave.
Exemplo
#!/usr/bin/python3
import _thread
import time
# Define a function for the thread

def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print ("%s: %s" % ( threadName, time.ctime(time.time()) ))
# Create two threads as follows

try:
_thread.start_new_thread( print_time, ("Thread-1", 2, ) )
_thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
print ("Error: unable to start thread")
while 1:
pass
Saída
Thread-1: Fri Feb 19 09:41:39 2016

Thread-2: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:43 2016
Thread-2: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:47 2016
Thread-2: Fri Feb 19 09:41:49 2016
Thread-2: Fri Feb 19 09:41:53 2016
Programa vai em um loop infinito. Você terá que pressionar ctrl-c para parar
Embora seja muito eficaz para o encadeamento de baixo nível, o módulo de

encadeamento é muito limitado em comparação com o módulo de encadernação mais
recente.
O módulo de segmentação
O módulo de threading mais novo incluído no Python 2.4 oferece suporte de alto nível
muito mais poderoso para encadeamentos do que o módulo de encadeamento discutido
na seção anterior.
O módulo de segmentação expõe todos os métodos do módulo de thread e fornece

alguns métodos adicionais -
threading.activeCount () - Retorna o número de objetos de thread que estão

ativos.
threading.currentThread () - Retorna o número de objetos de thread no

controle de thread do chamador.
threading.enumerate () - Retorna uma lista de todos os objetos de thread

atualmente ativos.
Além dos métodos, o módulo de threading possui a classe Thread que implementa o
threading. Os métodos fornecidos pela classe Thread são os seguintes -
run () - O método run () é o ponto de entrada para um thread.
start () - O método start () inicia um thread chamando o método run.
join ([time]) - O join () espera que os encadeamentos terminem.
isAlive () - O método isAlive () verifica se um encadeamento ainda está sendo

executado.
getName () - O método getName () retorna o nome de um segmento.
setName () - O método setName () define o nome de um segmento.
Criando Thread Usando o Módulo Threading

Para implementar um novo thread usando o módulo de threading, você precisa fazer o
seguinte -
Defina uma nova subclasse da classe Thread .
Substitua o método __init __ (self [, args]) para adicionar argumentos

adicionais.
Em seguida, substitua o método run (self [, args]) para implementar o que o

encadeamento deve fazer quando iniciado.
Depois de criar a nova subclasse Thread , você pode criar uma instância dela e, em
seguida, iniciar um novo thread invocando o start () , que, por sua vez, chama o
método run () .
Exemplo
#!/usr/bin/python3
import threading
import time
exitFlag = 0
class myThread (threading.Thread):

def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print ("Starting " + self.name)
print_time(self.name, self.counter, 5)
print ("Exiting " + self.name)
def print_time(threadName, delay, counter):

while counter:
if exitFlag:
threadName.exit()
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
# Start new Threads

thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("Exiting Main Thread")
Resultado
Quando executamos o programa acima, ele produz o seguinte resultado -
Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:00:21 2016
Thread-2: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:23 2016
Thread-2: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:25 2016
Exiting Thread-1
Thread-2: Fri Feb 19 10:00:26 2016
Thread-2: Fri Feb 19 10:00:28 2016
Thread-2: Fri Feb 19 10:00:30 2016
Exiting Thread-2
Exiting Main Thread
Sincronizando Threads
O módulo de threading fornecido com o Python inclui um mecanismo de bloqueio
simples de implementar que permite sincronizar threads. Um novo bloqueio é criado
chamando o método Lock () , que retorna o novo bloqueio.
O método de aquisição (bloqueio) do novo objeto de bloqueio é usado para forçar os

encadeamentos a serem executados de forma síncrona. O parâmetro de bloqueio
opcional permite controlar se o encadeamento aguarda para adquirir o bloqueio.
Se o bloqueio estiver definido como 0, o encadeamento retornará imediatamente com

um valor 0 se o bloqueio não puder ser adquirido e com um 1 se o bloqueio foi
adquirido. Se o bloqueio estiver definido como 1, a thread bloqueia e espera que o
bloqueio seja liberado.
O método release () do novo objeto de bloqueio é usado para liberar o bloqueio quando
não é mais necessário.
Exemplo
#!/usr/bin/python3
import threading
import time

def __init__(self, threadID, name, counter):
self.name = name
self.counter = counter
def run(self):
# Get lock to synchronize threads
threadLock.acquire()
print_time(self.name, self.counter, 3)
# Free lock to release next thread
threadLock.release()
def print_time(threadName, delay, counter):

while counter:
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
threadLock = threading.Lock()
threads = []

# Start new Threads

thread1.start()
thread2.start()
# Add threads to thread list

threads.append(thread1)
threads.append(thread2)
# Wait for all threads to complete

for t in threads:
t.join()
Saída
Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:04:14 2016
Thread-1: Fri Feb 19 10:04:15 2016
Thread-1: Fri Feb 19 10:04:16 2016
Thread-2: Fri Feb 19 10:04:18 2016
Thread-2: Fri Feb 19 10:04:20 2016
Thread-2: Fri Feb 19 10:04:22 2016
Exiting Main Thread
Fila de Prioridade Multithread

O módulo Fila permite criar um novo objeto de fila que pode conter um número
específico de itens. Existem os seguintes métodos para controlar a fila -
get () - O método get () remove e retorna um item da fila.
put () - A put adiciona o item a uma fila.
qsize () - O qsize () retorna o número de itens que estão atualmente na fila.
empty () - O empty () retorna True se a fila estiver vazia; caso contrário, False.
full () - o full () retorna True se a fila estiver cheia; caso contrário, False.
Exemplo
#!/usr/bin/python3
import queue
import threading
import time
exitFlag = 0

def __init__(self, threadID, name, q):
self.name = name
self.q = q
def run(self):
process_data(self.name, self.q)
print ("Exiting " + self.name)
def process_data(threadName, q):

while not exitFlag:
queueLock.acquire()
if not workQueue.empty():
data = q.get()
queueLock.release()
print ("%s processing %s" % (threadName, data))
else:
queueLock.release()
time.sleep(1)
threadList = ["Thread-1", "Thread-2", "Thread-3"]

nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

for tName in threadList:
thread = myThread(threadID, tName, workQueue)
thread.start()
threads.append(thread)
threadID += 1
# Fill the queue

queueLock.acquire()
for word in nameList:
workQueue.put(word)
queueLock.release()
# Wait for queue to empty

while not workQueue.empty():
pass
# Notify threads it's time to exit

exitFlag = 1
# Wait for all threads to complete

for t in threads:
t.join()
Saída
Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread
Python 3 - Processamento XML

XML é uma linguagem de código aberto e portátil que permite aos programadores
desenvolver aplicativos que podem ser lidos por outros aplicativos, independentemente
do sistema operacional e / ou da linguagem de desenvolvimento.
O que é XML?
A XML (Extensible Markup Language) é uma linguagem de marcação muito semelhante
a HTML ou SGML. Isso é recomendado pelo World Wide Web Consortium e disponível
como padrão aberto.
O XML é extremamente útil para rastrear quantidades pequenas a médias de dados

sem exigir um backbone baseado em SQL.
Arquiteturas do XML Parser e APIs

A biblioteca padrão do Python fornece um conjunto mínimo, mas útil, de interfaces para
trabalhar com XML.
As duas APIs mais básicas e amplamente usadas para dados XML são as interfaces SAX
e DOM.
API simples para XML (SAX) - Aqui, você registra retornos de chamada para
eventos de interesse e, em seguida, permite que o analisador prossiga pelo
documento. Isso é útil quando seus documentos são grandes ou você tem
limitações de memória, analisa o arquivo como ele lê a partir do disco e o
arquivo inteiro nunca é armazenado na memória.
API DOM (Document Object Model) - Esta é uma recomendação do World

Wide Web Consortium, na qual o arquivo inteiro é lido na memória e
armazenado em um formulário hierárquico (baseado em árvore) para
representar todos os recursos de um documento XML.
O SAX obviamente não pode processar informações tão rápido quanto o DOM, ao
trabalhar com arquivos grandes. Por outro lado, usar o DOM exclusivamente pode
realmente matar seus recursos, especialmente se usado em muitos arquivos pequenos.
SAX é somente leitura, enquanto o DOM permite alterações no arquivo XML. Como
essas duas APIs diferentes literalmente se complementam, não há motivos para que
você não possa usá-las para projetos grandes.
Para todos os nossos exemplos de código XML, vamos usar um arquivo XML simples
movies.xml como uma entrada -
<collection shelf = "New Arrivals">

<movie title = "Enemy Behind">
<type>War, Thriller</type>
<format>DVD</format>
<year>2003</year>
<rating>PG</rating>
<stars>10</stars>
<description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
<type>Anime, Science Fiction</type>
<year>1989</year>
<rating>R</rating>
<stars>8</stars>
<description>A schientific fiction</description>
</movie>
<movie title = "Trigun">
<type>Anime, Action</type>
<episodes>4</episodes>
<rating>PG</rating>
<stars>10</stars>
<description>Vash the Stampede!</description>
</movie>
<movie title = "Ishtar">
<type>Comedy</type>
<format>VHS</format>
<rating>PG</rating>
<stars>2</stars>
<description>Viewable boredom</description>
</movie>
</collection>
Analisando XML com APIs SAX

SAX é uma interface padrão para análise XML orientada a eventos. Analisar XML com o
SAX geralmente requer que você crie seu próprio ContentHandler, criando uma
subclasse de xml.sax.ContentHandler.
Seu ContentHandler lida com as tags e atributos específicos de seu (s) sabor (es) de
XML. Um objeto ContentHandler fornece métodos para manipular vários eventos de
análise. Seu analisador proprietário chama os métodos ContentHandler enquanto
analisa o arquivo XML.
Os métodos startDocument e endDocument são chamados no início e no final do

arquivo XML. Os caracteres do método (texto) são passados os dados de caractere do
arquivo XML através do texto do parâmetro.
O ContentHandler é chamado no início e no final de cada elemento. Se o analisador não

estiver no modo de espaço de nomes, os métodos startElement (tag, attributes) e
endElement (tag) serão chamados; caso contrário, os métodos correspondentes
startElementNS e endElementNS serão chamados. Aqui, tag é a tag do elemento e os
atributos são um objeto Attributes.
Aqui estão outros métodos importantes para entender antes de prosseguir -
O método make_parser
O método a seguir cria um novo objeto analisador e o retorna. O objeto analisador
criado será do primeiro tipo de analisador, o sistema encontra.
xml.sax.make_parser( [parser_list] )
parser_list - O argumento opcional que consiste em uma lista de analisadores

para usar, na qual todos devem implementar o método make_parser.
O método de análise
O método a seguir cria um analisador SAX e o utiliza para analisar um documento.
xml.sax.parse( xmlfile, contenthandler[, errorhandler])
xmlfile - Este é o nome do arquivo XML para ler.
contenthandler - Este deve ser um objeto ContentHandler.

errorhandler - Se especificado, o errorhandler deve ser um objeto SAX
ErrorHandler.
O método parseString
Há mais um método para criar um analisador SAX e para analisar a cadeia XML
especificada .
xml.sax.parseString(xmlstring, contenthandler[, errorhandler])
xmlstring - Esse é o nome da string XML para ler.
contenthandler - Este deve ser um objeto ContentHandler.
errorhandler - Se especificado, o errorhandler deve ser um objeto SAX

ErrorHandler.
Exemplo
#!/usr/bin/python3
import xml.sax
class MovieHandler( xml.sax.ContentHandler ):

def __init__(self):
self.CurrentData = ""
self.type = ""
self.format = ""
self.year = ""
self.rating = ""
self.stars = ""
self.description = ""
# Call when an element starts

def startElement(self, tag, attributes):
self.CurrentData = tag
if tag == "movie":
print ("*****Movie*****")
title = attributes["title"]
print ("Title:", title)
# Call when an elements ends

def endElement(self, tag):
if self.CurrentData == "type":
print ("Type:", self.type)
elif self.CurrentData == "format":
print ("Format:", self.format)
elif self.CurrentData == "year":
print ("Year:", self.year)
elif self.CurrentData == "rating":
print ("Rating:", self.rating)
elif self.CurrentData == "stars":
print ("Stars:", self.stars)
elif self.CurrentData == "description":
print ("Description:", self.description)
self.CurrentData = ""
# Call when a character is read
def characters(self, content):
if self.CurrentData == "type":
self.type = content
elif self.CurrentData == "format":
self.format = content
elif self.CurrentData == "year":
self.year = content
elif self.CurrentData == "rating":
self.rating = content
elif self.CurrentData == "stars":
self.stars = content
elif self.CurrentData == "description":
self.description = content
if ( __name__ == "__main__"):
# create an XMLReader
parser = xml.sax.make_parser()
# turn off namepsaces
parser.setFeature(xml.sax.handler.feature_namespaces, 0)
# override the default ContextHandler

Handler = MovieHandler()
parser.setContentHandler( Handler )
parser.parse("movies.xml")
Saída
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom
Para obter detalhes completos sobre a documentação da API SAX, consulte as APIs
padrão do Python SAX .
Analisando XML com APIs do DOM

O Document Object Model ("DOM") é uma API de vários idiomas do World Wide Web
Consortium (W3C) para acessar e modificar os documentos XML.
O DOM é extremamente útil para aplicativos de acesso aleatório. O SAX permite apenas
uma visualização de um bit do documento por vez. Se você estiver procurando por um
elemento SAX, não terá acesso a outro.
Aqui está a maneira mais fácil de carregar um documento XML rapidamente e criar um
objeto de minidom usando o módulo xml.dom. O objeto de minidom fornece um
método de analisador simples que cria rapidamente uma árvore DOM a partir do
arquivo XML.
A frase de exemplo chama a função parse (file [, parser]) do objeto minidom para
analisar o arquivo XML, designado por arquivo em um objeto da árvore DOM.
Exemplo
#!/usr/bin/python3
from xml.dom.minidom import parse

import xml.dom.minidom
# Open XML document using minidom parser

DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
print ("Root element : %s" % collection.getAttribute("shelf"))
# Get all the movies in the collection

movies = collection.getElementsByTagName("movie")
# Print detail of each movie.

for movie in movies:
print ("*****Movie*****")
if movie.hasAttribute("title"):
print ("Title: %s" % movie.getAttribute("title"))
type = movie.getElementsByTagName('type')[0]
print ("Type: %s" % type.childNodes[0].data)
format = movie.getElementsByTagName('format')[0]
print ("Format: %s" % format.childNodes[0].data)
rating = movie.getElementsByTagName('rating')[0]
print ("Rating: %s" % rating.childNodes[0].data)
description = movie.getElementsByTagName('description')[0]
print ("Description: %s" % description.childNodes[0].data)
Saída
Root element : New Arrivals

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom
Para obter detalhes completos sobre a documentação da API do DOM, consulte as

APIs padrão do Python DOM .
Python 3 - Programação GUI (Tkinter)

O Python fornece várias opções para o desenvolvimento de interfaces gráficas com o
usuário (GUIs). Os recursos mais importantes estão listados abaixo.
Tkinter - Tkinter é a interface Python para o kit de ferramentas Tk GUI

fornecido com o Python. Nós veríamos essa opção neste capítulo.
wxPython - Esta é uma interface Python de código aberto para o kit de

ferramentas da GUI wxWidgets. Você pode encontrar um tutorial completo
sobre o WxPython aqui .
PyQt - Essa também é uma interface Python para uma biblioteca popular de Qt
de plataforma cruzada. O TutorialsPoint tem um tutorial muito bom sobre o
PyQt aqui .
JPython - O JPython é uma porta Python para Java que fornece aos scripts
Python acesso contínuo às bibliotecas de classes Java na máquina local
http://www.jython.org .
Existem muitas outras interfaces disponíveis, que você pode encontrá-las na rede.
Programação Tkinter
Tkinter é a biblioteca GUI padrão para Python. O Python, quando combinado com o
Tkinter, fornece uma maneira rápida e fácil de criar aplicativos GUI. O Tkinter fornece
uma poderosa interface orientada a objetos para o kit de ferramentas Tk GUI.
Criar uma aplicação GUI usando o Tkinter é uma tarefa fácil. Tudo o que você precisa
fazer é executar as etapas a seguir -
Importe o módulo Tkinter .
Crie a janela principal do aplicativo GUI.
Adicione um ou mais dos widgets mencionados acima ao aplicativo GUI.
Digite o loop de eventos principal para tomar medidas contra cada evento
acionado pelo usuário.
Exemplo
#!/usr/bin/python3
import tkinter # note that module name has changed from Tkinter in Python 2 to tkinter in Pyth
top = tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()
Isso criaria uma janela a seguir -
Widgets Tkinter
O Tkinter fornece vários controles, como botões, rótulos e caixas de texto usados em
um aplicativo GUI. Esses controles são comumente chamados de widgets.
Existem atualmente 15 tipos de widgets no Tkinter. Apresentamos estes widgets, bem

como uma breve descrição na tabela a seguir -
Sr. Operador e Descrição

Não.
Botão
1 O widget Button é usado para exibir botões em seu aplicativo.
Tela de pintura
2 O widget Tela é usado para desenhar formas, como linhas, ovais, polígonos e
retângulos, no aplicativo.
Botão de verificação
3 O widget CheckButton é usado para exibir várias opções como caixas de

seleção. O usuário pode selecionar várias opções por vez.
Entrada
4 O widget Entrada é usado para exibir um campo de texto de linha única para
aceitar valores de um usuário.
Quadro, Armação
5 O widget Quadro é usado como um widget de contêiner para organizar outros

widgets.
Rótulo
6 O widget Label é usado para fornecer uma legenda de linha única para outros
widgets. Também pode conter imagens.
Listbox
7 O widget Caixa de listagem é usado para fornecer uma lista de opções para
um usuário.
Botão de menu
8 O widget Menubutton é usado para exibir menus em seu aplicativo.
Cardápio
9 O widget Menu é usado para fornecer vários comandos para um usuário. Esses
comandos estão contidos no Menubutton.
10 mensagem
O widget Mensagem é usado para exibir campos de texto de múltiplas linhas
para aceitar valores de um usuário.
Botao de radio
11 O widget Radiobutton é usado para exibir várias opções como botões de

opção. O usuário pode selecionar apenas uma opção por vez.
Escala
12 O widget Escala é usado para fornecer um widget de controle deslizante.
Barra de rolagem
13 O widget Barra de rolagem é usado para adicionar recursos de rolagem a

vários widgets, como caixas de listagem.
Texto
14 O widget de texto é usado para exibir texto em várias linhas.
Nível superior
15 O widget Toplevel é usado para fornecer um contêiner de janela separado.
Caixa giratória
16 O widget Spinbox é uma variante do widget Tkinter Entry padrão, que pode
ser usado para selecionar um número fixo de valores.
PanedWindow
17 Um PanedWindow é um widget de contêiner que pode conter qualquer número

de painéis, organizados horizontalmente ou verticalmente.
LabelFrame
18 Um labelframe é um widget de contêiner simples. Seu objetivo principal é

atuar como um espaçador ou contêiner para layouts de janela complexos.
tkMessageBox
19 Este módulo é usado para exibir caixas de mensagem em seus aplicativos.
Atributos padrão
Vejamos como alguns dos atributos comuns, como tamanhos, cores e fontes, são
especificados.
Dimensões
Cores
Fontes
Âncoras
Estilos de alívio
Bitmaps
Cursores
Gerenciamento de geometria
Todos os widgets do Tkinter têm acesso aos métodos específicos de gerenciamento de
geometria, que têm a finalidade de organizar widgets em toda a área do widget pai. O
Tkinter expõe as seguintes classes do gerenciador de geometria: pacote, grade e local.
O método pack () - Esse gerenciador de geometria organiza widgets em

blocos antes de colocá-los no widget pai.
O método grid () - Esse gerenciador de geometria organiza widgets em uma

estrutura semelhante a uma tabela no widget pai.
O método place () - Esse gerenciador de geometria organiza os widgets

colocando-os em uma posição específica no widget pai.
Python 3 - Programação de Extensão com C

Qualquer código que você escreve usando qualquer linguagem compilada como C, C ++
ou Java pode ser integrado ou importado para outro script Python. Este código é
considerado como uma "extensão".
Um módulo de extensão do Python nada mais é do que uma biblioteca C normal. Em

máquinas Unix, essas bibliotecas geralmente terminam em .so (para objeto
compartilhado). Em máquinas Windows, você normalmente vê .dll (para biblioteca
vinculada dinamicamente).
Pré-requisitos para escrita de extensões

Para começar a escrever sua extensão, você precisará dos arquivos de cabeçalho do
Python.
Em máquinas Unix, isso geralmente requer a instalação de um pacote específico

do desenvolvedor, como o python2.5-dev .
Os usuários do Windows obtêm esses cabeçalhos como parte do pacote quando

usam o instalador binário do Python.
Além disso, supõe-se que você tenha um bom conhecimento de C ou C ++ para gravar
qualquer extensão do Python usando a programação C.
Primeiro, olhe para uma extensão do Python

Para sua primeira olhada em um módulo de extensão do Python, você precisa agrupar
seu código em quatro partes -
O arquivo de cabeçalho Python.h .
As funções C que você deseja expor como a interface do seu módulo.
Uma tabela mapeando os nomes de suas funções como desenvolvedores Python

os vê como funções C dentro do módulo de extensão.
Uma função de inicialização.
O arquivo de cabeçalho Python.h

Você precisa incluir o arquivo de cabeçalho Python.h em seu arquivo de origem C, que
lhe dá acesso à API interna do Python usada para conectar seu módulo ao interpretador.
Certifique-se de incluir o Python.h antes de qualquer outro cabeçalho que você possa
precisar. Você precisa seguir os includes com as funções que deseja chamar do Python.
As funções C
As assinaturas da implementação C de suas funções sempre assumem uma das três
formas a seguir -
static PyObject *MyFunction( PyObject *self, PyObject *args );
static PyObject *MyFunctionWithKeywords(PyObject *self,

PyObject *args,
PyObject *kw);
static PyObject *MyFunctionWithNoArgs( PyObject *self );
Cada uma das declarações anteriores retorna um objeto Python. Não existe uma função
void no Python como existe em C. Se você não quer que suas funções retornem um
valor, retorne o equivalente C do valor None do Python . Os cabeçalhos do Python
definem uma macro, Py_RETURN_NONE, que faz isso para nós.
Os nomes das suas funções C podem ser o que você quiser, pois nunca são vistos fora
do módulo de extensão. Eles são definidos como função estática .
Suas funções C geralmente são nomeadas combinando os nomes de módulo e função

do Python juntos, como mostrado aqui -
static PyObject *module_func(PyObject *self, PyObject *args) {

/* Do your stuff here. */
Py_RETURN_NONE;
}
Esta é uma função do Python chamada func dentro do módulo do módulo . Você
colocará ponteiros em suas funções C na tabela de métodos para o módulo que
normalmente vem em seguida no seu código-fonte.
A tabela de mapeamento de métodos

Essa tabela de métodos é uma matriz simples de estruturas PyMethodDef. Essa
estrutura é algo parecido com isso -
struct PyMethodDef {
char *ml_name;
PyCFunction ml_meth;
int ml_flags;
char *ml_doc;
};
Aqui está a descrição dos membros dessa estrutura -
ml_name - Esse é o nome da função que o interpretador Python apresenta

quando é usado em programas Python.
ml_meth - Este é o endereço de uma função que possui qualquer uma das
assinaturas descritas na seção anterior.
ml_flags - Isso informa ao interpretador qual das três assinaturas ml_meth

está usando.
Esse sinalizador geralmente tem um valor de METH_VARARGS.
Esse sinalizador pode ser OR a bit a bit com METH_KEYWORDS se você

quiser permitir argumentos de palavra-chave em sua função.
Isso também pode ter um valor de METH_NOARGS que indica que você
não deseja aceitar nenhum argumento.
ml_doc - Esta é a docstring para a função, que pode ser NULL se você não tiver
vontade de escrever uma.
Essa tabela precisa ser terminada com um sentinela que consiste em valores NULL e 0
para os membros apropriados.
Exemplo
Para a função acima definida, temos a seguinte tabela de mapeamento de método -
static PyMethodDef module_methods[] = {

{ "func", (PyCFunction)module_func, METH_NOARGS, NULL },
{ NULL, NULL, 0, NULL }
};
A função de inicialização
A última parte do seu módulo de extensão é a função de inicialização. Essa função é
chamada pelo interpretador Python quando o módulo é carregado. É necessário que a
função seja denominada init Module , onde Module é o nome do módulo.
A função de inicialização precisa ser exportada da biblioteca que você irá construir. Os
cabeçalhos do Python definem PyMODINIT_FUNC para incluir os encantamentos
apropriados para que isso aconteça no ambiente específico em que estamos
compilando. Tudo o que você precisa fazer é usá-lo ao definir a função.
Sua função de inicialização C geralmente tem a seguinte estrutura geral -
PyMODINIT_FUNC initModule() {
Py_InitModule3(func, module_methods, "docstring...");
}
Aqui está a descrição da função Py_InitModule3 -
func - Esta é a função a ser exportada.
module_methods - Este é o nome da tabela de mapeamento definida acima.
docstring - Este é o comentário que você quer dar em sua extensão.
Colocando tudo isso junto, parece o seguinte -
#include <Python.h>

/* Do your stuff here. */
Py_RETURN_NONE;
}

};
PyMODINIT_FUNC initModule() {
Py_InitModule3(func, module_methods, "docstring...");
}
Exemplo
Um exemplo simples que faz uso de todos os conceitos acima -
#include <Python.h>
static PyObject* helloworld(PyObject* self)

{
return Py_BuildValue("s", "Hello, Python extensions!!");
}
static char helloworld_docs[] =

"helloworld( ): Any message you want to put here!!\n";
static PyMethodDef helloworld_funcs[] = {

{"helloworld", (PyCFunction)helloworld,
METH_NOARGS, helloworld_docs},
{NULL}
};
void inithelloworld(void)
{
Py_InitModule3("helloworld", helloworld_funcs,
"Extension module example!");
}
Aqui, a função Py_BuildValue é usada para construir um valor Python. Salve o código
acima no arquivo hello.c. Nós veríamos como compilar e instalar este módulo para ser
chamado a partir do script Python.
Construindo e Instalando Extensões

O pacote distutils facilita muito a distribuição de módulos Python, tanto Python puro
quanto módulos de extensão, de uma maneira padrão. Os módulos são distribuídos no
formulário de origem, construídos e instalados através de um script de configuração
normalmente chamado setup.py como.
Para o módulo acima, você precisa preparar o seguinte script setup.py -
from distutils.core import setup, Extension

setup(name = 'helloworld', version = '1.0', \
ext_modules = [Extension('helloworld', ['hello.c'])])
Agora, use o seguinte comando, que executaria todas as etapas de compilação e

vinculação necessárias, com os comandos e sinalizadores do compilador e do link
corretos e copiaria a biblioteca dinâmica resultante em um diretório apropriado -
$ python setup.py install
Em sistemas baseados em Unix, você provavelmente precisará executar este comando

como root para ter permissões para gravar no diretório site-packages. Isso geralmente
não é um problema no Windows.
Importando Extensões
Depois de instalar suas extensões, você poderá importar e chamar essa extensão em
seu script Python da seguinte maneira:
Exemplo
#!/usr/bin/python3
import helloworld
print helloworld.helloworld()
Saída
Hello, Python extensions!!
Parâmetros da Função de Passagem

Como você provavelmente desejará definir funções que aceitam argumentos, você pode
usar uma das outras assinaturas para suas funções em C. Por exemplo, a seguinte
função, que aceita um certo número de parâmetros, seria definida assim:

/* Parse args and do something interesting here. */
Py_RETURN_NONE;
}
A tabela de métodos contendo uma entrada para a nova função ficaria assim:

{ "func", module_func, METH_VARARGS, NULL },
};
Você pode usar a função API PyArg_ParseTuple para extrair os argumentos do ponteiro
de um PyObject passado para sua função C.
O primeiro argumento para PyArg_ParseTuple é o argumento args. Este é o objeto que

você estará analisando . O segundo argumento é uma cadeia de formatação que
descreve os argumentos conforme você espera que eles apareçam. Cada argumento é
representado por um ou mais caracteres na string de formatação da seguinte maneira.

int i;
double d;
char *s;
if (!PyArg_ParseTuple(args, "ids", &i, &d, &s)) {

return NULL;
}
/* Do something interesting here. */

Py_RETURN_NONE;
}
Saída
Compilar a nova versão do seu módulo e importá-lo permite chamar a nova função com
qualquer número de argumentos de qualquer tipo -
module.func(1, s = "three", d = 2.0)

module.func(i = 1, d = 2.0, s = "three")
module.func(s = "three", d = 2.0, i = 1)
Você provavelmente pode chegar a mais variações.
A função PyArg_ParseTuple
Aqui está a assinatura padrão para a função PyArg_ParseTuple -
int PyArg_ParseTuple(PyObject* tuple,char* format,...)
Esta função retorna 0 para erros e um valor diferente de 0 para sucesso. Tuple é o
PyObject * que foi o segundo argumento da função C. Aqui o formato é uma cadeia C
que descreve argumentos obrigatórios e opcionais.
Aqui está uma lista de códigos de formato para a função PyArg_ParseTuple -

Código Tipo C Significado
c Caracteres Uma string Python de comprimento 1 se torna um caractere C.
d em dobro Um float de Python se torna um duplo C.
f flutuador Um float do Python se torna um float C.
Eu int Um Python int torna-se um C int.
eu longo Um Python int torna-se um C long.
eu longo longo Um Python int torna-se um C longo
Obtém referência emprestada não-NULL ao argumento do

O PyObject *
Python.
s Caracteres* String Python sem nulos incorporados para C char *.
Qualquer string do Python para o endereço e o comprimento de

s# char * + int
C.
Buffer de segmento único somente leitura para o endereço e o

t# char * + int
comprimento C.
você Py_UNICODE * Unicode do Python sem nulos incorporados para C.
Py_UNICODE * Qualquer endereço e comprimento do Unicode C do Python.

você#
+ int
Ler / gravar buffer de segmento único para o endereço e o

W# char * + int
comprimento de C.
z Caracteres* Como s, também aceita None (define C char * para NULL).
z# char * + int Como s #, também aceita None (define C char * para NULL).
Uma sequência do Python é tratada como um argumento por

(...) conforme ...
item.
| Os argumentos a seguir são opcionais.
Formato final, seguido pelo nome da função para mensagens de

:
erro.
; Formato final, seguido por todo o texto da mensagem de erro.
Valores de retorno
Py_BuildValue recebe uma string de formato muito parecida com a que
PyArg_ParseTuple faz. Em vez de passar os endereços dos valores que você está
construindo, você passa os valores reais. Aqui está um exemplo mostrando como
implementar uma função add -
static PyObject *foo_add(PyObject *self, PyObject *args) {

int a;
int b;
if (!PyArg_ParseTuple(args, "ii", &a, &b)) {

return NULL;
}
return Py_BuildValue("i", a + b);
}
Isto é o que seria se implementado em Python -
def add(a, b):

return (a + b)
Você pode retornar dois valores da sua função da seguinte maneira. Isso seria
capturado usando uma lista em Python.
static PyObject *foo_add_subtract(PyObject *self, PyObject *args) {

int a;
int b;
if (!PyArg_ParseTuple(args, "ii", &a, &b)) {

return NULL;
}
return Py_BuildValue("ii", a + b, a - b);
}
Isto é o que seria se implementado em Python -
def add_subtract(a, b):

return (a + b, a - b)
A função Py_BuildValue
Aqui está a assinatura padrão para a função Py_BuildValue -
PyObject* Py_BuildValue(char* format,...)
Aqui o formato é uma string C que descreve o objeto Python a ser construído. Os
seguintes argumentos de Py_BuildValue são valores C dos quais o resultado é
construído. O resultado do PyObject * é uma nova referência.
A tabela a seguir lista as cadeias de código comumente usadas, das quais zero ou mais
são unidas em um formato de seqüência de caracteres.
Código Tipo C Significado
c Caracteres O AC Char se torna uma string Python de comprimento 1.
d em dobro O AC double torna-se um float do Python.

f flutuador Flutuar AC se torna um float de Python.
Eu int AC int se torna um int de Python.
eu longo AC longo se torna um int de Python.
N PyObject * Passa um objeto Python e rouba uma referência.
O PyObject * Passa um objeto Python e INCREFs como normal.
O& convert + void * Conversão Arbitrária
s Caracteres* C 0-terminado char * para string Python, ou NULL para None.
C char * e comprimento para string Python, ou NULL para

s# char * + int
None.
C-wide, string terminada com nulo para Python Unicode ou

você Py_UNICODE *
NULL para None.
Py_UNICODE * C-wide string e comprimento para Unicode Python, ou NULL

você#
+ int para None.
Ler / gravar buffer de segmento único para o endereço e o

W# char * + int
comprimento de C.
z Caracteres* Como s, também aceita None (define C char * para NULL).
z# char * + int Como s #, também aceita None (define C char * para NULL).
(...) conforme ... Cria tupla do Python a partir de valores C.
[...] conforme ... Cria lista do Python a partir de valores C.
Cria o dicionário Python a partir de valores C, alternando

{...} conforme ...
chaves e valores.
O código {...} cria dicionários a partir de um número par de valores C, alternadamente

chaves e valores. Por exemplo, Py_BuildValue ("{issi}", 23, "zig", "zag", 42) retorna um
dicionário como o {23: 'zig', 'zag': 42} do Python.
 Página anterior Próxima página 

FAQ's Política
© Copyright de Cookies
2018. Todos Contato
os direitos reservados.
Enter email for newsletter vai

Guia Rápido Do Python 3 - 240401 - 232852

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Guia Rápido Do Python 3 - 240401 - 232852

Enviado por

Direitos autorais:

Formatos disponíveis



Python 3 - Guia rápido

 Página anterior Próxima página 

O que é novo no Python 3?

Por exemplo, se quisermos o comportamento de divisão de inteiros do Python 3.x no

from __future__ import division

print "Hello World" #is acceptable in Python 2

print x, # Trailing comma suppresses newline in Python 2

Leitura de entrada do teclado

>>> x = raw_input("something:") # will result NameError

Função xrange () removida

raise IOError, "file error" #This is accepted in Python 2

except Myerror, err: # In Python2

Função next () e método .next ()

gen = (letter for letter in 'Hello World') # creates generator object

Here is a sample Python 2 code (area.py):

def area(x,y = 3.14):

To convert into Python 3 version:

def area(x,y = 3.14): # formal parameters

Python 3 - Visão Geral

O Python é Interpretado - o Python é processado em tempo de execução

Python é interativo - Você pode realmente sentar em um prompt do Python e

O Python é orientado a objeto - o Python suporta o estilo orientado a objeto

O Python é uma linguagem para iniciantes - o Python é uma ótima linguagem

O Python é derivado de muitas outras linguagens, incluindo o shell ABC,

Python é protegido por direitos autorais. Como o Perl, o código-fonte do Python

Enquanto isso, o Python 3.0 foi lançado em 2008. O Python 3 não é

Fácil de aprender - o Python tem poucas palavras-chave, estrutura simples e

Fácil de manter - o código-fonte do Python é bastante fácil de manter.

Uma ampla biblioteca padrão - o tamanho da biblioteca do Python é muito

Portátil - o Python pode ser executado em uma ampla variedade de

Extensível - Você pode adicionar módulos de baixo nível ao interpretador

Bancos de dados - o Python fornece interfaces para todos os principais bancos

Escalável - Python fornece uma melhor estrutura e suporte para programas

Ele fornece tipos de dados dinâmicos de alto nível e suporta a verificação

Suporta coleta automática de lixo.

Python 3 - Configuração do Ambiente

Configuração do ambiente local

As seguintes opções de instalação diferentes estão disponíveis.

Arquivo zip embutido no Windows x86-64

Instalador executável do Windows x86-64

Instalador baseado na web do Windows x86-64

Arquivo zip incorporável do Windows x86

Instalador executável do Windows x86

Instalador baseado na web do Windows x86

No Ubuntu Linux, o Python 3 é instalado usando o seguinte comando do terminal.

$sudo apt-get install python3-minimal

Faça o download do tarball de origem compactada do URL de download do Python -

Extract the tarball

Instalador do Mac OS X de 64 bits / 32 bits - python-3.5.1-macosx10.6.pkg

Instalador i386 / PPC para Mac OS X de 32 bits - python-3.5.1-macosx10.5.pkg

Site Oficial do Python - https://www.python.org/

Você pode baixar a documentação do Python no seguinte site. A documentação está

Site de Documentação Python - www.python.org/doc/

As características importantes são -

O caminho é armazenado em uma variável de ambiente, que é uma sequência

A variável path é nomeada como PATH no Unix ou Path no Windows (o Unix

No Mac OS, o instalador manipula os detalhes do caminho. Para invocar o

No bash shell (Linux) - digite export PYTHONPATH = / usr / local / bin /

Nota - / usr / local / bin / python3 é o caminho do diretório Python.

Definindo Caminho no Windows

No prompt de comando, digite o caminho% path%; C: \ Python e pressione

Nota - C: \ Python é o caminho do diretório Python

from future import division