Definição de nutrição. Introdução à programação Python. Linguagem de alto nível de uso geral

Pitão- linguagem de programação poderosa e fácil de aprender. Ele fornece estruturas de dados de alto nível convenientes e uma abordagem simples, porém eficaz, para programação orientada a objetos. Pitão linguagem interpretada. Para executar programas escritos, é necessário o interpretador CPython. O interpretador python e uma grande biblioteca padrão estão disponíveis gratuitamente como fonte e arquivos binários para todas as principais plataformas no site oficial Pitão http://www.python.org e pode ser redistribuído sem restrições. Além disso, o site contém distribuições e links para vários módulos de terceiros e documentação detalhada.
A linguagem tem uma sintaxe clara e consistente, modularidade e escalabilidade pensadas, para que o código-fonte escrito em Pitão programas são fáceis de ler. Desenvolvedores de idiomas Pitão aderir a uma certa filosofia de programação chamada "O Zen do Python". Seu texto é gerado pelo interpretador usando o comando import this:

>>> importe este The Zen of Python, de Tim Peters Bonito é melhor que feio. Explícito é melhor que implícito. Simples é melhor que complexo. Complexo é melhor que complexo. Plano é melhor do que aninhado. Esparso é melhor do que denso. A legibilidade conta. Casos especiais não são especiais o suficiente para quebrar as regras. Embora a praticidade supere a pureza. Os erros nunca devem passar em silêncio. A menos que explicitamente silenciados. Diante da ambiguidade, recuse a tentação de adivinhar. Deve haver um - e de preferência apenas um - - maneira óbvia de fazer isso. Embora essa maneira possa não ser óbvia no início, a menos que você seja holandês. Agora é melhor do que nunca. Embora nunca seja melhor do que *agora*. Se a implementação for difícil de explicar, é uma má ideia. Se a implementação for fácil de explicar, pode ser uma boa ideia. Namespaces são uma ótima ideia -- vamos fazer mais!

Na tradução fica assim:

• Bonito é melhor que feio.
• Explícito é melhor que implícito.
• Simples é melhor que complexo.
• Complicado é melhor do que confuso.
• Plano é melhor do que aninhado.
• Esparso é melhor do que denso.
• A legibilidade importa.
• Ocasiões especiais não são especiais o suficiente para quebrar as regras.
• Ao mesmo tempo, a praticidade é mais importante do que a impecabilidade.
• Os erros nunca devem ser silenciados.
• Se eles não forem explicitamente silenciados.
• Quando confrontado com ambiguidade, resista à tentação de adivinhar.
• Deve haver uma - e de preferência apenas uma - maneira óbvia de fazer isso.
• Embora possa não ser óbvio no início se você não for holandês.
• Agora é melhor do que nunca.
• Embora nunca seja muitas vezes melhor do que agora.
• Se a implementação é difícil de explicar, a ideia é ruim.
• Se a implementação for fácil de explicar, a ideia provavelmente é boa.
• Os namespaces são ótimos! Vamos fazer mais deles!

Pitão- uma linguagem de programação em desenvolvimento ativo, novas versões são lançadas aproximadamente a cada dois anos e meio. Por esse e outros motivos, Pitão não há ANSI, ISO ou outros padrões oficiais, o CPython cumpre seu papel.

História da criação da língua

O desenvolvimento da linguagem Python foi iniciado no final da década de 1980 por um funcionário do Dutch CWI Institute. O sistema operacional distribuído Amoeba precisava de uma linguagem de script extensível para a qual Guido van Rossum criou o Python. A nova linguagem emprestou alguns dos desenvolvimentos da linguagem ABC, que era focada no ensino de programação. Em fevereiro de 1991, Guido publicou o código-fonte no grupo de notícias alt.sources. O nome da língua não veio de um tipo de réptil. O autor nomeou a linguagem em homenagem ao popular programa de televisão britânico dos anos 1970, Monty Python's Flying Circus. No entanto, as cabeças de cobra representam o emblema da língua. Após extensos testes, a primeira versão do Python 3.0 foi lançada. Ambos os ramos de desenvolvimento são suportados atualmente (Python 3.xe 2.x).

Python foi criado sob a influência de muitas linguagens de programação: Modula-3, C, C++, Smalltalk, Lisp, Fortran, Java, Miranda, Icon. Apesar do Python ter uma sintaxe bastante distinta, um dos princípios de design dessa linguagem é o princípio da menor surpresa.

Biblioteca padrão

A rica biblioteca padrão é uma das atrações do Python. Existem ferramentas para trabalhar com muitos protocolos de rede e formatos de Internet. Existem módulos para trabalhar com expressões regulares, codificações de texto, formatos multimídia, protocolos criptográficos, arquivos. Além da biblioteca padrão, existem muitas bibliotecas que fornecem uma interface para todas as chamadas do sistema em diferentes plataformas.
Para Python, foi adotada a especificação de interface de programação de banco de dados DB-API 2 e desenvolvidos pacotes correspondentes a esta especificação para acesso a diversos SGBDs: Oracle, MySQL, PostgreSQL, Sybase, Firebird (Interbase), Informix, Microsoft SQL Server e SQLite.
A biblioteca NumPy para trabalhar com arrays multidimensionais permite obter um desempenho de cálculos científicos comparável a pacotes especializados. O SciPy usa o NumPy e fornece acesso a uma ampla variedade de algoritmos matemáticos. Numarray é especialmente projetado para operações com grandes volumes de dados científicos.
Python fornece uma API C simples e conveniente para escrever seus próprios módulos em C e C++. Uma ferramenta como o SWIG permite que você obtenha quase automaticamente ligações para usar bibliotecas C/C++ no código Python. A ferramenta de biblioteca padrão ctypes permite que programas Python acessem diretamente bibliotecas dinâmicas escritas em C. Existem módulos que permitem incorporar código C/C++ diretamente em arquivos de origem Python, criando extensões em tempo real.
Python e a grande maioria de suas bibliotecas são gratuitas e vêm em código-fonte. Além disso, ao contrário de muitos sistemas abertos, a licença não restringe o uso do Python no desenvolvimento comercial de forma alguma e não impõe outras obrigações além da atribuição de direitos autorais.

Formulários

Python é uma linguagem estável e difundida. É usado em muitos projetos e em várias capacidades: como linguagem de programação principal ou para criar extensões e integrar aplicativos. Um grande número de projetos foi implementado em Python e também é usado ativamente para criar protótipos para programas futuros. Python é usado por muitas grandes empresas.
Python com os pacotes NumPy, SciPy e MatPlotLib é usado ativamente como um ambiente universal para cálculos científicos como substituto para os pacotes comerciais especializados comuns Matlab, IDL, etc.
Programas gráficos 3D profissionais, como Houdini e Nuke, usam Python para estender os recursos padrão dos programas.

Fontes

Apresentações

Trabalho de casa

Preparar mensagens:

• Python como ferramenta para cientistas
• Python e Ruby (comparação)
• python e web
• Criando aplicativos de janela com Python e bibliotecas gráficas (wxPython, PyQt, PyGTK, etc.)

Era uma vez, em um fórum fechado, tentei ensinar Python. Em geral, as coisas pararam lá. Senti pena das lições escritas e decidi publicá-las para o público em geral. Enquanto o primeiro, o mais simples. Fica mais interessante, mas talvez não seja interessante. Em geral, este post será um balão de ensaio, se você gostar, vou divulgá-lo ainda mais.

Python para iniciantes. Capítulo primeiro. "Do que estamos falando"

Apenas no caso, um pouco de "evangelismo" chato. Quem está cansado disso, pode pular alguns parágrafos.
Python (pronuncia-se "Python" e não "python") é uma linguagem de script desenvolvida por Guido van Rossum como uma linguagem simples que é fácil de aprender para um iniciante.
Hoje em dia, Python é uma linguagem amplamente utilizada que é usada em muitas áreas:
- Desenvolvimento de software aplicativo (por exemplo, utilitários linux yum, pirut, system-config-*, cliente Gajim IM e muitos outros)
- Desenvolvimento de aplicações web (o servidor Zope Application mais poderoso e o CMS Plone desenvolvido em sua base, com base no qual, por exemplo, o site da CIA funciona, e muitos frameworks para o desenvolvimento rápido de aplicativos Plones, Django, TurboGears e muitos outros)
- Use como uma linguagem de script incorporada em muitos jogos, e não apenas (no pacote de escritório OpenOffice.org, editor Blender 3d, Postgre DBMS)
- Uso em cálculos científicos (com pacotes SciPy e numPy para cálculos e PyPlot para plotagem, Python se torna quase comparável a pacotes como MatLab)

E esta certamente não é uma lista completa de projetos usando essa linguagem maravilhosa.

1. O próprio interpretador, você pode obtê-lo aqui (http://python.org/download/).
2. Ambiente de desenvolvimento. Não é necessário para começar, e o IDLE incluído na distribuição é adequado para iniciantes, mas para projetos sérios você precisa de algo mais sério.
Para Windows eu uso o maravilhoso e leve PyScripter (http://tinyurl.com/5jc63t), para Linux eu uso o Komodo IDE.

Embora para a primeira lição, apenas o shell interativo do próprio Python seja suficiente.

Basta executar python.exe. O prompt de entrada não demorará muito, é assim:

Você também pode escrever programas em arquivos com a extensão py, em seu editor de texto favorito, que não adiciona seus caracteres de marcação ao texto (nenhum Word serve). Também é desejável que este editor seja capaz de fazer "guias inteligentes" e não substituir espaços por um caractere de tabulação.
Para executar arquivos para execução, você pode clicar neles 2 vezes. Se a janela do console fechar muito rápido, insira a seguinte linha no final do programa:

Em seguida, o intérprete aguardará que a tecla enter seja pressionada no final do programa.

Ou associe arquivos py em Far com Python e abra pressionando enter.

Finalmente, você pode usar um dos muitos IDEs Python úteis que fornecem recursos de depuração e realce de sintaxe e muitas outras "conveniências".

Um pouco de teoria.

Para começar, Python é uma linguagem fortemente tipada dinamicamente. O que isto significa?

Existem linguagens com tipagem forte (pascal, java, c, etc.), nas quais o tipo de uma variável é determinado antecipadamente e não pode ser alterado, e existem linguagens com tipagem dinâmica (python, ruby, vb ), em que o tipo de uma variável é interpretado dependendo do valor atribuído.
As linguagens tipadas dinamicamente podem ser divididas em 2 tipos. Strict, que não permite conversão de tipo implícita (Pyton) e não-strict, que realiza conversões de tipo implícita (por exemplo, VB, na qual você pode adicionar facilmente a string "123" e o número 456).
Tendo lidado com a classificação do Python, vamos tentar "brincar" um pouco com o interpretador.

>>> a = b = 1 >>> a, b (1, 1) >>> b = 2 >>> a, b (1, 2) >>> a, b = b, a >>> a , b (2, 1)

Assim, vemos que a atribuição é realizada usando o sinal =. Você pode atribuir um valor a várias variáveis ​​de uma só vez. Quando você informa ao interpretador o nome de uma variável interativamente, ele gera seu valor.

A próxima coisa que você precisa saber é como as unidades algorítmicas básicas são construídas - ramificações e loops. Para começar, precisamos de uma pequena ajuda. Em Python, não há delimitador de bloco de código especial, seu papel é desempenhado por recuo. Ou seja, o que está escrito com a mesma indentação é um bloco de comando. A princípio pode parecer estranho, mas depois de um pouco de adaptação, você entende que essa medida "forçada" permite que você obtenha um código bem legível.
Então condições.

A condição é especificada usando uma instrução if que termina com ":". As condições alternativas que serão atendidas se o primeiro teste "falhar" são fornecidas pela instrução elif. Finalmente, o else especifica a ramificação que será executada se nenhuma das condições corresponder.
Observe que, após digitar if, o interpretador indica com o prompt "..." que está aguardando a continuação da entrada. Para dizer a ele que terminamos, você deve inserir uma string vazia.

(Por algum motivo, o exemplo com branches quebra a marcação no Habré, apesar das danças com as tags pre e code. Desculpe o transtorno, joguei aqui pastebin.com/f66af97ba, se alguém me disser o que está errado, eu vou seja muito grato)

ciclos.

O caso mais simples de um loop é o loop while. Ele recebe uma condição como parâmetro e é executado enquanto for verdadeiro.
Aqui está um pequeno exemplo.

>>> x = 0 >>> enquanto x<=10: ... print x ... x += 1 ... 0 1 2 ........... 10

Observe que, como print x e x+=1 são escritos com a mesma indentação, eles são considerados o corpo do loop (lembra do que eu disse sobre blocos? ;-)).

O segundo tipo de loop em Python é o loop for. É semelhante ao loop foreach em outras linguagens. Sua sintaxe é convencionalmente a seguinte.

Para variável na lista:
equipes

A variável será atribuída por sua vez a todos os valores da lista (na verdade, pode haver não apenas uma lista, mas também qualquer outro iterador, mas não nos incomodaremos com isso por enquanto).

Aqui está um exemplo simples. A lista será uma string, que nada mais é do que uma lista de caracteres.

>>> x = "Olá, Python!" >>> for char in x: ... print char ... H e l ........... !

Assim, podemos decompor a string em caracteres.
O que fazer se precisarmos de um loop que se repete um certo número de vezes? Muito simples, a função de alcance virá em socorro.

Na entrada, leva de um a três parâmetros, na saída retorna uma lista de números, que podemos “percorrer” com a instrução for.

Aqui estão alguns exemplos de uso da função range que explicam o papel de seus parâmetros.

>>> intervalo(10) >>> intervalo(2, 12) >>> intervalo(2, 12, 3) >>> intervalo(12, 2, -2)

E um pequeno exemplo com um ciclo.

>>> para x no intervalo(10): ... print x ... 0 1 2 ..... 9

Saída de entrada

A última coisa que você precisa saber antes de começar a usar o Python completamente é como ele lida com E/S.

Para saída, é usado o comando print, que imprime todos os seus argumentos em formato legível.

Para entrada do console, é usada a função raw_input(prompt), que exibe um prompt e aguarda a entrada do usuário, retornando o que o usuário digitou como seu valor.

X = int(raw_input ("Digite um número:")) print "O quadrado deste número é ", x * x

Atenção! Apesar da existência da função input() de uma ação semelhante, não é recomendável usá-la em programas, pois o intérprete tenta executar expressões sintáticas inseridas usando-a, o que é uma séria falha de segurança no programa.

Isso é tudo para a primeira lição.

Trabalho de casa.

1. Escreva um programa para calcular a hipotenusa de um triângulo retângulo. O comprimento das pernas é solicitado ao usuário.
2. Escreva um programa para encontrar as raízes de uma equação quadrática em termos gerais. Os coeficientes são solicitados ao usuário.
3. Escreva um programa para exibir a tabuada de multiplicação pelo número M. A tabela é compilada de M * a a M * b, onde M, a, b são solicitados ao usuário. A saída deve estar em uma coluna, um exemplo por linha no seguinte formato (por exemplo):
5 x 4 = 20
5 x 5 = 25
E assim por diante.

Introdução

Em conexão com o rápido desenvolvimento atualmente observado da computação pessoal, há uma mudança gradual nos requisitos para linguagens de programação. As linguagens interpretadas começam a desempenhar um papel cada vez mais importante, pois o crescente poder dos computadores pessoais começa a fornecer velocidade suficiente para a execução de programas interpretados. E a única vantagem significativa das linguagens de programação compiladas é o código de alta velocidade que elas criam. Quando a velocidade de execução do programa não é crítica, a escolha mais adequada é uma linguagem interpretada, como uma ferramenta de programação mais simples e flexível.

Nesse sentido, é de particular interesse considerar a relativamente nova linguagem de programação Python (python), que foi criada por seu autor Guido van Rossum no início dos anos 90.

Informações gerais sobre Python. Vantagens e desvantagens

Python é uma linguagem de programação interpretada e orientada a objetos nativamente. É extremamente simples e contém um pequeno número de palavras-chave, mas é muito flexível e expressivo. É uma linguagem de nível superior que Pascal, C++ e, claro, C, o que é alcançado principalmente devido às estruturas de dados de alto nível incorporadas (listas, dicionários, tuplas).

Vantagens da linguagem.
A vantagem inquestionável é que o interpretador Python é implementado em quase todas as plataformas e sistemas operacionais. A primeira dessas linguagens foi C, mas seus tipos de dados podiam ocupar diferentes quantidades de memória em diferentes máquinas, e isso serviu como um obstáculo para escrever um programa verdadeiramente portátil. Python não tem essa desvantagem.

A próxima característica importante é a extensibilidade da linguagem, que é de grande importância, e, como escreve o próprio autor, a linguagem foi concebida justamente como extensível. Isso significa que há espaço para melhoria da linguagem por todos os programadores interessados. O interpretador é escrito em C e o código fonte está disponível para qualquer manipulação. Se necessário, você pode inseri-lo em seu programa e usá-lo como um shell embutido. Ou, escrevendo suas adições ao Python em C e compilando o programa, você obtém um interpretador "estendido" com novos recursos.

A próxima vantagem é a presença de um grande número de módulos plug-in que fornecem vários recursos adicionais. Tais módulos são escritos em C e no próprio Python e podem ser desenvolvidos por todos os programadores suficientemente habilidosos. Os seguintes módulos são exemplos:

• Python numérico - recursos matemáticos avançados, como manipulação de vetores e matrizes inteiras;
• Tkinter - construção de aplicativos usando uma interface gráfica de usuário (GUI) baseada na interface Tk amplamente usada no X-Windows;
• OpenGL - uso da extensa biblioteca de modelagem gráfica de objetos bidimensionais e tridimensionais Open Graphics Library da Silicon Graphics Inc. Esse padrão é suportado, entre outras coisas, em sistemas operacionais comuns como Microsoft Windows 95 OSR 2, 98 e Windows NT 4.0.

Falhas de linguagem.
A única desvantagem observada pelo autor é a velocidade de execução relativamente baixa do programa Python, devido à sua interpretabilidade. No entanto, em nossa opinião, isso é mais do que compensado pelas vantagens da linguagem ao escrever programas que não são muito críticos para a velocidade de execução.

Visão geral do recurso

1. Python, ao contrário de muitas linguagens (Pascal, C++, Java, etc.), não requer declarações de variáveis. Eles são criados no local de sua inicialização, ou seja, na primeira vez que uma variável recebe um valor. Isso significa que o tipo da variável é determinado pelo tipo do valor atribuído. A esse respeito, o Python se assemelha ao Basic.
O tipo de variável não é imutável. Qualquer atribuição a ela é correta, e isso apenas leva ao fato de que o tipo da variável se torna o tipo do novo valor atribuído.

2. Em linguagens como Pascal, C, C++ a organização de listas apresentou algumas dificuldades. Para implementá-los, era preciso estudar bem os princípios de trabalhar com ponteiros e memória dinâmica. E mesmo com uma boa qualificação, um programador, cada vez reimplementando os mecanismos de criação, trabalho e destruição de listas, poderia facilmente cometer erros sutis. Diante disso, foram criadas algumas ferramentas para trabalhar com listas. Por exemplo, Delphi Pascal tem uma classe TList que implementa listas; STL (Standard Template Library) foi desenvolvido para C++, contendo estruturas como vetores, listas, conjuntos, dicionários, pilhas e filas. No entanto, tais facilidades não estão disponíveis em todas as linguagens e suas implementações.

Uma das características distintivas do Python é a presença de tais estruturas embutidas na própria linguagem como tuplas(tupla) listas(lista) e dicionários(dicionário), que às vezes são chamados cartas(mapa). Vamos considerá-los com mais detalhes.

1. Tupla . É um pouco uma reminiscência de uma matriz: consiste em elementos e tem um comprimento estritamente definido. Os elementos podem ter qualquer valor - constantes simples ou objetos. Ao contrário de uma matriz, os elementos de uma tupla não são necessariamente homogêneos. E o que distingue uma tupla de uma lista é que a tupla não pode ser modificada, ou seja, não podemos atribuir algo novo ao i-ésimo elemento da tupla e não podemos adicionar novos elementos. Assim, uma tupla pode ser chamada de constante de lista. Sintaticamente, uma tupla é especificada por uma listagem separada por vírgulas de todos os elementos, todos entre parênteses:

(1, 2, 5, 8)
(3.14, 'cadeia', -4)
Todos os elementos são indexados do zero. Para obter o i-ésimo elemento, você precisa especificar o nome da tupla seguido pelo índice i entre colchetes. Exemplo:
t = (0, 1, 2, 3, 4)
imprima t, t[-1], t[-3]
Resultado: 0 4 2
Assim, uma tupla poderia ser chamada de vetor constante se seus elementos fossem sempre homogêneos.
2. Lista . Um bom exemplo particular de uma lista é uma string Turbo Pascal. Os elementos de uma string são caracteres únicos, seu comprimento não é fixo, é possível excluir elementos ou, ao contrário, inseri-los em qualquer lugar da string. Os elementos da lista podem ser objetos arbitrários, não necessariamente do mesmo tipo. Para criar uma lista, basta listar seus elementos separados por vírgulas, colocando tudo isso entre colchetes:


['cadeia de caracteres', (0,1,8), ]
Ao contrário de uma tupla, as listas podem ser modificadas à vontade. Os elementos são acessados ​​da mesma maneira que nas tuplas. Exemplo:
l = ]
imprima l, l, l[-2], l[-1]
Resultado: 1 s (2,8) 0
3. Dicionário . Reminiscente do tipo registro (registro) em Pascal ou estruturas (estrutura) em C. No entanto, em vez do esquema "campo de registro" - "valor", "chave" - ​​"valor" é usado aqui. Um dicionário é um conjunto de pares "chave"-"valor". Aqui a "chave" é uma constante de qualquer tipo (mas são usadas principalmente strings), serve para nomear (índice) algum valor correspondente a ela (que pode ser alterado).

Um dicionário é criado listando seus elementos (pares de valores-chave separados por dois pontos), separados por vírgulas e colocando tudo entre chaves. Para ter acesso a um determinado valor, é necessário escrever a chave correspondente entre colchetes após o nome do dicionário. Exemplo:
d = ("a": 1, "b": 3, 5: 3,14, "nome": "João")
d["b"] = d
imprima d["a"], d["b"], d, d["nome"]
Resultado: 1 3,14 3,14 João
Para adicionar um novo par "chave"-"valor", basta atribuir o valor correspondente ao elemento com a nova chave:
d["novo"] = "novo valor"
imprimir d
Resultado: ("a":1, "b":3, 5:3.14, "name":"João", "novo":"novo valor")

3. Ao contrário de Pascal, C, C++, Python não suporta ponteiros, memória dinâmica e aritmética de endereço. Nisso é semelhante ao Java. Como você sabe, os ponteiros são uma fonte de erros sutis e trabalhar com eles está mais relacionado à programação em um nível baixo. Para maior confiabilidade e simplicidade, eles não foram incluídos no Python.

4. Uma das características do Python é como uma variável é atribuída a outra, ou seja, quando em ambos os lados do operador " = " são variáveis.

Seguindo Timothy Budd (), chamaremos semântica de ponteiro o caso em que a atribuição leva apenas à atribuição de uma referência (ponteiro), ou seja, a nova variável torna-se apenas outro nome denotando o mesmo local de memória que a variável antiga. Neste caso, uma mudança no valor denotado pela nova variável levará a uma mudança no valor da antiga, pois eles realmente significam a mesma coisa.

Quando a atribuição leva à criação de um novo objeto (aqui, um objeto no sentido de um pedaço de memória para armazenar um valor de algum tipo) e copiar o conteúdo da variável atribuída para ele, chamaremos este caso copiar semântica. Assim, se a semântica de cópia estiver em vigor, as variáveis ​​em ambos os lados do sinal "=" significarão dois objetos independentes com o mesmo conteúdo. E aqui, uma mudança subsequente em uma variável não afetará a outra de forma alguma.

A atribuição em Python funciona assim: if atribuível o objeto é uma instância de tipos como números ou strings, então a semântica de cópia se aplica, mas se o lado direito é uma instância de uma classe, lista, dicionário ou tupla, então a semântica de ponteiro se aplica. Exemplo:
a = 2; b = a; b = 3
print " copiar semântica: a=", a, "b=", b
um = ; b = a; b = 3
print " semântica do ponteiro: a=", a, "b=", b
Resultado:
copiar semântica: a= 2 b= 3
semântica do ponteiro: a= b=

Para aqueles de vocês que querem saber do que se trata, vou dar uma visão diferente da tarefa em Python. Se em linguagens como Basic, Pascal, C / C ++ lidamos com variáveis ​​e constantes de "capacidade" armazenadas nelas (numérico, caractere, string - não importa), e a operação de atribuição significava "entrar" no constante na variável atribuída, então em Python já temos que trabalhar com variável-"nomes" e os objetos nomeados por eles. (Observe alguma analogia com Prolog?) O que é um objeto em Python? Isso é tudo que pode receber um nome: números, strings, listas, dicionários, instâncias de classe (que são chamadas de objetos em Object Pascal), as próprias classes (!), funções, módulos, etc. Assim, ao atribuir um objeto a uma variável, a variável se torna seu "nome", e o objeto pode ter qualquer número desses "nomes" e todos eles não dependem um do outro.

Agora, os objetos são divididos em modificáveis ​​(mutáveis) e imutáveis. Mutável - aqueles que podem alterar seu "conteúdo interno", por exemplo, listas, dicionários, instâncias de classe. E imutável - como números, tuplas, strings (sim, strings também; você pode atribuir a uma variável uma nova string obtida da antiga, mas a própria string antiga não pode ser modificada).

Então, se escrevermos um = ; b = a; b = 3, o Python interpreta isso como:

dê ao objeto uma "lista" " nome uma ;

dê a este objeto outro nome - b ;

modifique o elemento nulo do objeto.

Essa é a semântica "pseudo" de ponteiros.

E a última coisa a dizer sobre isso: embora não seja possível alterar a estrutura da tupla, os componentes mutáveis ​​contidos nela ainda estão disponíveis para modificação:

T = (1, 2, , "string") t = 6 # não permitido del t # também um erro t = 0 # válido, agora o terceiro componente é uma lista t = "S" # erro: strings não são mutáveis

5. Muito original é a forma como os operadores são agrupados em Python. Pascal usa parênteses para isso. começo-fim, em C, C++, Java - chaves (), em Basic, terminações de fechamento de construções de linguagem são usadas (NEXT, WEND, END IF, END SUB).
Na linguagem Python, tudo é muito mais simples: a seleção de um bloco de instruções é realizada deslocando o grupo selecionado por um ou mais espaços ou caracteres de tabulação para a direita em relação ao cabeçalho da estrutura à qual esse bloco se referirá. Por exemplo:

if x > 0: imprima ‘ x > 0 ’ x = x - 8 else: imprima ‘ x<= 0 ’ x = 0 Assim, um bom estilo de escrever programas, que é exigido pelos professores de Pascal, C ++, Java, etc., é adquirido aqui desde o início, porque simplesmente não funciona de maneira diferente.

Descrição do idioma. Estruturas de controle

Tratamento de exceções

tentar: <оператор1> [exceto[<исключение> [, <переменная>] ]: <оператор2>] [senão <оператор3>]	Executado<оператор1>se ocorrer uma exceção<исключение>, então<оператор2>. Se um<исключение>tem um valor, é atribuído<переменной>. Em caso de conclusão bem sucedida<оператора1>, realizado<оператор3>.
tentar: <оператор1> finalmente: <оператор2>	Executado<оператор1>. Se nenhuma exceção foi lançada, então<оператор2>. Por outro lado,<оператор2>e uma exceção é lançada imediatamente.
levantar <исключение> [<значение>]	Lança uma exceção<исключение>com parâmetro<значение>.

As exceções são apenas strings. Exemplo:

My_ex = 'bad index' try: if bad: raise my_ex, bad except my_ex, value: print ' Error ', value

Declaração de função

Declaração de Classe

Classe cMyClass: def __init__(self, val): self.value = val # def printVal (self): print ' value = ', self.value # # end cMyClass obj = cMyClass (3.14) obj.printVal() obj.value = "(!LANG: string agora" obj.printVal () !} Resultado:
valor = 3,14
valor = string agora

Operadores para todos os tipos de sequências (listas, tuplas, strings)

Operadores para listas (lista)

s[i] = x	O i-ésimo elemento de s é substituído por x.
s = t	parte dos elementos de s de i a j-1 é substituída por t (t também pode ser uma lista).
del s	remove a parte s (o mesmo que s = ).
s.append(x)	adiciona o elemento x ao final de s.
s.count(x)	retorna o número de elementos de s igual a x.
s.index(x)	retorna o menor i tal que s[i]==x.
s.inserir(i,j)	a parte de s, começando no i-ésimo elemento, é deslocada para a direita e s[i] é atribuído a x.
s.remover(x)	mesmo que del s[ s.index(x) ] - remove o primeiro elemento de s igual a x.
s.reverse()	escreve a string na ordem inversa
ordenar()	classifica a lista em ordem crescente.

Operadores de dicionários

Objetos de arquivo

Criado por função interna abrir()(ver descrição abaixo). Por exemplo: f = open('mydan.dat','r').
Métodos:

Outros elementos de linguagem e funções integradas

=	atribuição.
imprimir [ < c1 > [, < c2 >]* [, ] ]	valores de saída< c1 >, < c2 >à saída padrão. Coloca um espaço entre os argumentos. Se não houver vírgula no final da lista de argumentos, ela salta para uma nova linha.
abs(x)	retorna o valor absoluto de x.
Aplique( f , <аргументы>)	chama a função (ou método) f com< аргументами >.
chr(i)	retorna uma única cadeia de caracteres com código ASCII i.
cmp(x, y)	retorna um valor negativo, zero ou positivo se, respectivamente, x<, ==, или >do que y.
divmod(a,b)	retorna uma tupla (a/b, a%b), onde a/b é um div b (a parte inteira do resultado da divisão), a%b é um mod b (o restante da divisão).
avaliação(ões)	retorna o objeto dado em s como uma string. S pode conter qualquer estrutura de linguagem. S também pode ser um objeto de código, por exemplo: x = 1 ; incr_x = eval("x+1") .
flutuar(x)	retorna um valor real igual ao número x.
hex(x)	retorna uma string contendo a representação hexadecimal do número x.
entrada(<строка>)	exibe<строку>, lê e retorna um valor da entrada padrão.
int(x)	retorna o valor inteiro de x.
lente)	retorna o comprimento (número de elementos) do objeto.
longo(x)	retorna um valor do tipo inteiro longo x.
máximo(s), min(ns)	retorna o maior e o menor dos elementos de uma sequência s (ou seja, s é uma string, lista ou tupla).
out(x)	retorna uma string contendo uma representação do número x.
abrir(<имя файла>, <режим>='r' )	retorna um objeto de arquivo aberto para leitura.<режим>= 'w' - aberto para escrita.
ordem(c)	retorna o código de caractere ASCII (sequência de comprimento 1) c.
po (x, y)	retorna x elevado a y.
variar (<начало>, <конец>, <шаг>)	retorna uma lista de inteiros maiores ou iguais<начало>e menor que<конец>gerado com um determinado<шагом>.
raw_input( [ <текст> ] )	exibe<текст>para a saída padrão e lê uma string da entrada padrão.
rodada (x, n=0)	retorna um x real arredondado para a enésima casa decimal.
str (<объект>)	retorna uma representação de string<объекта>.
modelo(<объект>)	retorna o tipo do objeto. Por exemplo: if type(x) == type(''): print ' this is a string '
xrange (<начало>, <конец>, <шаг>)	semelhante ao intervalo, mas apenas simula uma lista sem criar uma. Usado em um loop for.

Funções especiais para trabalhar com listas

filtro(<функция>, <список>)	retorna uma lista desses elementos<спиcка>, para qual<функция>assume o valor "verdadeiro".
mapa(<функция>, <список>)	se aplica<функцию>a cada elemento<списка>e retorna uma lista de resultados.
reduzir( f , <список>, [, <начальное значение> ] )	retorna o valor obtido por "redução"<списка>função f. Isso significa que existe alguma variável interna p, que é inicializada<начальным значением>, então, para cada elemento<списка>, a função f é chamada com dois parâmetros: p e o elemento<списка>. O resultado retornado por f é atribuído a p. Depois de iterar sobre tudo<списка>reduzir retornos p. Usando esta função, você pode, por exemplo, calcular a soma dos elementos de uma lista: def func (red, el): return red+el sum = reduce (func, , 0) # now sum == 15
lambda [<список параметров>] : <выражение>	Uma função "anônima" que não possui nome próprio e é escrita no local de sua chamada. Aceita os parâmetros especificados em<списке параметров>, e retorna um valor<выражения>. Usado para filtrar, reduzir, mapear. Por exemplo: >>>filtro de impressão (lambda x: x>3, ) >>>imprimir mapa (lambda x: x*2, ) >>>p=reduce (lambda r, x: r*x, , 1) >>> imprimir página 24

Importando módulos

Módulo matemático padrão

Variáveis: pi, e.
Funções(semelhante às funções da linguagem C):

acos(x)	dinheiro(x)	ldexp(x,y)	sqrt(x)
asin(x)	exp(x)	log(x)	bronzeado(x)
atan(x)	fabs(x)	sinh(x)	frexp(x)
atan2(x,y)	andar (x)	pow(x,y)	modf(x)
teto(x)	fmod(x,y)	pecado(x)
cos(x)	log10(x)	tanh(x)

módulo string

Funções:

Conclusão

Devido à simplicidade e flexibilidade da linguagem Python, ela pode ser recomendada para usuários (matemáticos, físicos, economistas, etc.) que não são programadores, mas que utilizam informática e programação em seu trabalho.
Programas em Python são desenvolvidos em média de uma vez e meia a duas (e às vezes duas a três) vezes mais rápido do que em linguagens compiladas (C, C++, Pascal). Portanto, a linguagem pode ser de grande interesse para programadores profissionais que desenvolvem aplicativos que não são críticos para a velocidade de execução, bem como programas que usam estruturas de dados complexas. Em particular, o Python provou-se bem no desenvolvimento de programas para trabalhar com gráficos, gerando árvores.

Literatura

1. Budd T. Programação orientada a objetos. - São Petersburgo: Peter, 1997.
2. Guido van Rossum. Tutorial Python. (www.python.org)
3. Chris Hoffman. Uma Referência Rápida do Python. (www.python.org)
4. Guido van Rossum. Referência da Biblioteca Python. (www.python.org)
5. Guido van Rossum. Manual de referência do Python. (www.python.org)
6. Guido van Rossum. Workshop de programação em Python. (http://sultan.da.ru)

(Tradução)

Um artigo foi publicado no site Poromenos "Stuff, no qual, de forma concisa, eles falam sobre os fundamentos da linguagem Python. Eu ofereço a você uma tradução deste artigo. A tradução não é literal. Tentei explicar de forma mais detalhe alguns pontos que podem não estar claros.

Se você está pensando em aprender Python, mas não consegue encontrar um tutorial adequado, este artigo será de grande ajuda para você! Em pouco tempo, você poderá se familiarizar com o básico da linguagem Python. Embora este artigo geralmente se baseie no fato de você já ter experiência em programação, espero que até mesmo os iniciantes achem este material útil. Leia cada parágrafo com atenção. Devido à concisão do material, alguns tópicos são considerados superficialmente, mas contêm todo o material necessário.

Propriedades básicas

Python não requer declaração explícita de variáveis, é uma linguagem orientada a objetos (variável var não é equivalente a Var ou VAR são três variáveis ​​diferentes).

Sintaxe

Primeiro, vale a pena notar um recurso interessante do Python. Ele não contém colchetes de operador (begin..end em pascal ou (..) em C), em vez disso os blocos são recuados: espaços ou tabulações, e a entrada no bloco de instruções é realizada por dois pontos. Comentários de linha única começam com o sinal de sustenido "#", comentários de várias linhas começam e terminam com três aspas duplas """" .

Para atribuir um valor a uma variável, o sinal "=" é usado e para comparação - "==". Para aumentar o valor de uma variável, ou adicionar a uma string, utiliza-se o operador "+=", e para diminuir - "-=". Todas essas operações podem interagir com a maioria dos tipos, incluindo strings. Por exemplo

>>>minhavar=3

>>> minhavar += 2

>>> minhavar -= 1

"""Este é um comentário de várias linhas

Strings entre três aspas duplas são ignoradas"""

>>> minhastring = "Olá"

>>> minhastring += "mundo."

>>> imprimir minha string

Olá Mundo.

# A próxima linha muda

Valores de variáveis ​​em lugares. (Apenas uma linha!)

>>> minhavar, minhastring = minhastring, minhavar

Estruturas de dados

Python contém estruturas de dados como listas (listas), tuplas (tuplas) e dicionários (dicionários). Listas são semelhantes a arrays unidimensionais (mas você pode usar uma lista que inclui listas - um array multidimensional), tuplas são listas imutáveis, dicionários também são listas, mas índices podem ser de qualquer tipo, não apenas numéricos. "Matrizes" em Python podem conter dados de qualquer tipo, ou seja, uma matriz pode conter dados numéricos, string e outros tipos. Arrays começam no índice 0 e o último elemento pode ser acessado no índice - 1. Você pode atribuir funções a variáveis ​​e usá-las de acordo.

>>> sample = , ("a", "tuple")] #Uma lista consiste em um inteiro, outra lista e uma tupla

>>> mylist = ["List item 1", 2, 3.14] #Esta lista contém uma string, um inteiro e uma fração

>>> minhalista = "Lista o item 1 novamente" #Altera o primeiro (zero) elemento da lista minhalista

>>> minhalista[-1] = 3.14 #Altera o último elemento da lista

>>> mydict = ("Chave 1": "Valor 1", 2:3, "pi": 3.14) #Cria um dicionário, com índices numéricos e inteiros

>>> mydict["pi"] = 3.15 #Altera a entrada do dicionário no índice "pi".

>>> mytuple = (1, 2, 3) #Define a tupla

>>> myfunction = len #Python permite que você declare sinônimos de função dessa maneira

>>> imprimir minhafunção(minhalista)

Você pode usar parte de uma matriz especificando o primeiro e o último índice separados por dois pontos ":". Nesse caso, você obterá uma parte do array, do primeiro índice ao segundo, inclusive. Se o primeiro elemento não for especificado, a contagem começará do início da matriz e, se o último elemento não for especificado, a matriz será lida até o último elemento. Valores negativos determinam a posição do elemento a partir do final. Por exemplo:

>>> minhalista = ["Lista item 1", 2, 3.14]

>>> print minhalista[:] #Ler todos os elementos do array

["Item de lista 1", 2, 3.1400000000000001]

>>> print minhalista #Lê o zero e o primeiro elemento do array.

["Item de lista 1", 2]

>>> print mylist[-3:-1] #Leitura de elementos de zero (-3) a segundo (-1) (não incluso)

["Item de lista 1", 2]

>>> print mylist #Lendo elementos do primeiro ao último

Cordas

Strings em Python separados por aspas duplas """ ou aspas simples """. Aspas simples podem estar presentes entre aspas duplas ou vice-versa. Por exemplo, a linha "Ele disse "olá"!" será exibido como "Ele disse olá!". Se você precisar usar uma string de várias linhas, essa string deve começar e terminar com três aspas duplas """"". Você pode substituir elementos de uma tupla ou dicionário no modelo de string. O sinal de porcentagem "%" entre o string e a tupla substitui os caracteres na string "%s" por elemento de uma tupla. Os dicionários permitem que você insira um elemento em um determinado índice em uma string. Para fazer isso, use a construção "%(index)s" em a string. Nesse caso, em vez de "%(index)s", o valor do dicionário sob o índice fornecido será substituído pelo índice.

>>>print "Nome: %s\nNúmero: %s\nString: %s" % (myclass.name, 3, 3 * "-")

Nome: Poromenos

Número 3

corda: ---

strString = """Este texto está localizado

em várias linhas

>>> print "Este %(verbo)s é um %(substantivo)s." %("substantivo": "teste", "verbo": "é")

Isto é um teste.

Operadores

As instruções while, if , for compõem as instruções de movimento. Não há análogo da instrução select, então você deve ignorar o if . A instrução for compara variável e lista. Para obter uma lista de dígitos antes de um número - use o intervalo ( ). Aqui está um exemplo usando operadores

rangelist = range(10) #Obtém uma lista de dez dígitos (de 0 a 9)

>>> imprimir lista de intervalo

for number in rangelist: #Enquanto o número da variável (que aumenta em um a cada vez) está na lista...

# Verifica se a variável está incluída

# números em uma tupla de números (3, 4, 7, 9)

Se o número estiver em (3, 4, 7, 9): #Se o número estiver em (3, 4, 7, 9)...

# A operação "break" fornece

# sai do loop a qualquer momento

Parar

senão:

# "continuar" "rola"

# ciclo. Isso não é necessário aqui, pois após esta operação

# em qualquer caso, o programa volta a processar o loop

Continuar

senão:

# "outro" é opcional. Condição atendida

# a menos que o loop tenha sido quebrado com "break".

Passe # Não faça nada

if rangelist == 2:

Imprimir "O segundo item (as listas são baseadas em 0) é 2"

elif rangelist == 3:

Imprimir "O segundo item (as listas são baseadas em 0) é 3"

senão:

Imprimir "Não sei"

while rangelist == 1:

Passar

Funções

Usado para declarar uma função palavra-chave "def". Os argumentos da função são especificados entre parênteses após o nome da função. Você pode especificar argumentos opcionais dando a eles um valor padrão. As funções podem retornar tuplas, nesse caso os valores de retorno devem ser separados por vírgulas. A palavra-chave lambda é usada para declarar funções elementares.

# arg2 e arg3 são argumentos opcionais, eles assumem o valor declarado por padrão,

# a menos que você dê a eles um valor diferente ao chamar a função.

def minhafunção(arg1, arg2 = 100, arg3 = "teste"):

Retorna arg3, arg2, arg1

#A função é chamada com o valor do primeiro argumento - "Argumento 1", o segundo - por padrão e o terceiro - "Argumento nomeado".

>>>ret1, ret2, ret3 = minhafunção("Argumento 1", arg3 = "Argumento nomeado")

# ret1, ret2 e ret3 pegam os valores "Argumento nomeado", 100, "Argumento 1" respectivamente

>>> imprimir ret1, ret2, ret3

Argumento nomeado 100 Argumento 1

# O seguinte é equivalente a def f(x): return x + 1

funçãovar = lambda x: x + 1

>>> print functionvar(1)

Aulas

A linguagem Python é limitada em herança múltipla em classes. Variáveis ​​internas e métodos de classe internos começam com dois sublinhados "__" (por exemplo, "__myprivatevar"). Também podemos atribuir um valor a uma variável de classe de fora. Exemplo:

classMinhaclasse:

Comum = 10

Def __init__(self):

Auto.minha variável = 3

Def minhafunção(self, arg1, arg2):

Retorna self.myvariable

# Aqui declaramos a classe Myclass. A função __init__ é chamada automaticamente quando as classes são inicializadas.

>>> classinstance = Myclass() # Inicializamos a classe e myvariable está definida como 3 conforme declarado no método de inicialização

>>> classinstance.myfunction(1, 2) #Método minhafunção da classe Minhaclasse retorna o valor da variável minhavariável

# A variável comum é declarada em todas as classes

>>> classinstance2 = Minhaclasse()

>>> classinstance.common

>>> classinstance2.common

# Portanto, se alterarmos seu valor na classe Minhaclasse mudará

# e seus valores em objetos inicializados pela classe Myclass

>>>Minhaclasse.comum = 30

>>> classinstance.common

>>> classinstance2.common

# Aqui não alteramos a variável de classe. Em vez disso

# declaramos no objeto e atribuímos um novo valor

>>> classinstance.common = 10

>>> classinstance.common

>>> classinstance2.common

>>>Minhaclasse.comum = 50

# Agora alterar a variável de classe não afetará

# objetos variáveis ​​desta classe

>>> classinstance.common

>>> classinstance2.common

# A classe a seguir é uma subclasse de Myclass

# herdando suas propriedades e métodos, quem quer que a classe possa

# ser herdado de várias classes, neste caso a entrada

# assim: class Otherclass(Minhaclasse1, Minhaclasse2, MinhaclasseN)

class Outraclasse(Minhaclasse):

Def __init__(self, arg1):

Auto.minha variável = 3

Imprimir argumento1

>>> classinstance = Otherclass("hello")

olá

>>> classinstance.myfunction(1, 2)

# Esta classe não possui a propriedade de teste, mas podemos

# declara tal variável para o objeto. E

# esta variável será apenas um membro da classinstance.

>>> classinstance.test = 10

>>>classinstance.test

Exceções

Exceções em Python têm uma estrutura try -except:

defsomefunction():

tentar:

# Divisão por zero gera um erro

10 / 0

Exceto ZeroDivisionError:

# Mas o programa não "Executa uma operação ilegal"

# A trata o bloco de exceção correspondente ao erro "ZeroDivisionError"

Imprima "Opa, inválido."

>>> fnexcept()

Ops, inválido.

Importar

Bibliotecas externas podem ser incluídas usando o procedimento de importação, onde é o nome da biblioteca incluída. Você também pode usar o comando "from import" para poder usar a função da biblioteca:

import random #Import a biblioteca "random"

from time import clock #E ao mesmo tempo a função "clock" da biblioteca "time"

randomint = random.randint(1, 100)

>>> imprimir randomint

Trabalhando com o sistema de arquivos

Python tem muitas bibliotecas embutidas. Neste exemplo, tentaremos armazenar uma estrutura de lista em um arquivo binário, lê-la e armazenar a string em um arquivo de texto. Para transformar a estrutura de dados, usaremos a biblioteca padrão "picle":

importar picles

minhalista = ["Isto", "é", 4, 13327]

# Abra o arquivo C:\binary.dat para escrita. Símbolo "r"

# impede que caracteres especiais sejam substituídos (como \n, \t, \b, etc.).

meuarquivo = arquivo(r"C:\binary.dat", "w")

pickle.dump(minhalista, meuarquivo)

meuarquivo.fechar()

meuarquivo = arquivo(r"C:\text.txt", "w")

myfile.write("Esta é uma string de amostra")

meuarquivo.fechar()

meuarquivo = arquivo(r"C:\text.txt")

>>> imprimir meuarquivo.read()

"Esta é uma string de amostra"

meuarquivo.fechar()

#Abre o arquivo para leitura

meuarquivo = arquivo(r"C:\binary.dat")

lista carregada = pickle.load(meuarquivo)

meuarquivo.fechar()

>>>imprimir lista carregada

["Isto", "é", 4, 13327]

Peculiaridades

• As condições podem ser combinadas. 1 < a < 3 выполняется тогда, когда а больше 1, но меньше 3.
• Use a operação "del" para limpar variáveis ​​ou elementos de array.
• Python oferece grandes oportunidades para trabalhar com listas. Você pode usar instruções de declaração de estrutura de lista. A instrução for permite definir os elementos da lista em uma determinada sequência e if - permite selecionar elementos por condição.

>>> lst1 =

>>> lst2=

>>> imprimir

>>> imprimir

# O operador "any" retorna true se, embora

# se uma das condições nele incluídas for atendida.

>>> qualquer(i % 3 para i in )

Verdadeiro

# O procedimento a seguir conta o número

# itens correspondentes na lista

>>> soma(1 para i em se i == 3)

>>> do lst1

>>> imprimir lst1

>>> do lst1

• Variáveis ​​globais são declarados fora das funções e podem ser lidos sem nenhuma declaração. Mas se você precisar alterar o valor de uma variável global de uma função, precisará declará-la no início da função com a palavra-chave "global", caso contrário, o Python declarará a variável disponível apenas para isso função.

número = 5

def minhafunc():

# Saídas 5

imprimir número

defina outrafunc():

# Isso lança uma exceção porque a variável global a

# não foi chamado de uma função. Python neste caso cria

# variável de mesmo nome dentro desta função e acessível

# apenas para operadores desta função.

imprimir número

Número = 3

def aindaoutrafunc():

número global

# E somente a partir desta função o valor da variável é alterado.

Número = 3

Epílogo

Obviamente, este artigo não abrange todos os recursos do Python. Espero que este artigo o ajude se você quiser continuar aprendendo essa linguagem de programação.

Benefícios do Python

• A velocidade de execução de programas escritos em Python é muito alta. Isso ocorre porque as principais bibliotecas Python
  são escritos em C++ e as tarefas levam menos tempo para serem concluídas do que em outras linguagens de alto nível.
• Nesse sentido, você pode escrever seus próprios módulos para Python em C ou C++
• Nas bibliotecas padrão do Python você pode encontrar ferramentas para trabalhar com e-mail, protocolos
  Internet, FTP, HTTP, bancos de dados, etc.
• Scripts escritos com Python são executados na maioria dos sistemas operacionais modernos. Essa portabilidade permite que o Python seja usado em uma ampla variedade de aplicativos.
• Python é adequado para qualquer solução de programação, seja programas de escritório, aplicativos da web, aplicativos de GUI, etc.
• Milhares de entusiastas de todo o mundo trabalharam no desenvolvimento do Python. Podemos dever o suporte de tecnologias modernas nas bibliotecas padrão precisamente ao fato de que o Python estava aberto a todos.