Pensando Em Python Como Um Cientista Da Computacao

Como pensar como um cientista da Computao usando PythonAllen Downey Jerey Elkner Chris Meyers

Traduo: Equipe do projeto http://pensarpython.incubadora.fapesp.br Edio: Crlisson Galdino

Como pensar como um cientista da Computao usando Python

Copyright (c) 2002 Allen Downey, Jerey Elkner, and Chris Meyers. Edited by Shannon Turlington and Lisa Cutler. Cover design by Rebecca Gimenez. Printing history: April 2002: First edition. Green Tea Press 1 Grove St. P.O. Box 812901 Wellesley, MA 02482 Permission is granted to copy, distribute, and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being Foreword, Preface, and Contributor List, with no Front-Cover Texts, and with no BackCover Texts. A copy of the license is included in the appendix entitled GNU Free Documentation License. The GNU Free Documentation License is available from www.gnu.org or by writing to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

Como pensar como um cientista da Computao usando PythonVerso atual: 1.0 Data de Publicao: 16 de janeiro de 2008 Classificao: Tutorial Autor: Jeffrey Elkner (traduzido pelo http://pensarpython.incubadora.fapesp.br) Publicao: Cyaneus.net

projeto

Pensar

Python

-

#2


ndiceForeword..................................................................5 Apresentao............................................................6 Preface......................................................................7How and why I came to use Python...............................7 Finding a textb o ok........................................................7 Intro ducing programming with Python.........................7 Building a community.....................................................8 4.1 O operador mdulo.................................................27 4.2 Expresses booleanas..............................................27 4.3 Operadores lgicos..................................................27 4.4 Execuo condicional.............................................27 4.5 Execuo alternativa...............................................28 4.6 Condicionais encadeados........................................28 4.7 Condicionais aninhados..........................................28 4.8 A instruo return....................................................28 4.9 Recursividade..........................................................29 4.10 Diagramas de pilha para funes recursivas........29 4.11 Recursividade infinita...........................................30 4.12 Entrada pelo teclado..............................................30 4.13 Glossrio...............................................................30

Prefcio....................................................................9Como e porque eu vim a usar Python.............................9 Encontrando um livro texto............................................9 Introduzindo programao com Python........................10 Construindo uma comunidade......................................10

Contributor List......................................................11 Captulo 5: Funes frutferas................................31 Verso Brasileira....................................................13 5.1 Valores de retorno...................................................31 Captulo 1: O caminho do programa......................14 5.2 Desenvolvimento de programas..............................311.1 A linguagem de programao Python.....................14 5.3 Composio.............................................................32 1.2 O que um programa?............................................15 5.4 Funes booleanas..................................................32 1.3 O que depurao (debugging)?............................15 5.5 Mais recursividade..................................................33 1.3.1 Erros de sintaxe.........................................15 5.6 Voto de confiana (Leap of faith)...........................33 1.3.2 Erros em tempo de execuo (runtime 5.7 Mais um exemplo....................................................34 errors).................................................................15 5.8 Checagem de tipos..................................................34 1.3.3 Erros de semntica....................................15 5.9 Glossrio.................................................................34 1.3.4 Depurao experimental (Debugging).......16 Captulo 6: Iterao................................................36 1.4 Linguagens naturais e linguagens formais.............16 6.1 Reatribuies...........................................................36 1.5 O primeiro programa...............................................17 6.2 O comando while....................................................36 1.6 Glossrio.................................................................17 6.3 Tabelas....................................................................37 Captulo 2: Variveis, expresses e comandos......18 6.4 Tabelas de duas dimenses (ou bi-dimensionais). .38 2.1 Valores e tipos.........................................................18 6.5 Encapsulamento e generalizao............................38 2.2 Variveis.................................................................18 6.6 Mais encapsulamento..............................................38 2.3 Nomes de variveis e palavras reservadas..............18 6.7 Variveis locais.......................................................38 2.4 Comandos................................................................19 6.8 Mais generalizao..................................................39 2.5 Avaliando expresses..............................................19 6.9 Funes...................................................................39 2.6 Operadores e operandos..........................................19 6.10 Glossrio...............................................................40 2.7 Ordem dos operadores............................................20 Captulo 7: Strings.................................................41 2.8 Operaes com strings............................................20 7.1 Um tipo de dado composto.....................................41 2.9 Composio.............................................................20 7.2 Comprimento...........................................................41 2.11 Glossrio...............................................................20 7.3 Travessia e o loop for..............................................41

Captulo 3: Funes...............................................22

7.4 Fatias de strings.......................................................42 3.1 Chamadas de funes..............................................22 7.5 Comparao de strings............................................42 3.2 Converso entre tipos..............................................22 7.6 Strings so imutveis..............................................42 3.3 Coero entre tipos.................................................22 7.7 Uma funo find (encontrar)...................................42 3.4 Funes matemticas..............................................22 7.8 Iterando e contando.................................................43 3.5 Composio.............................................................23 7.9 O mdulo string......................................................43 3.6 Adicionando novas funes....................................23 7.10 Classificao de caracteres...................................43 3.7 Definies e uso......................................................24 7.11 Glossrio...............................................................43 3.8 Fluxo de execuo...................................................24 7.11 Glossrio2.............................................................44 3.9 Parmetros e argumentos........................................24 Captulo 8: Listas...................................................45 3.10 Variveis e parmetros so locais.........................25 8.1 Valores da lista........................................................45 3.11 Diagramas da pilha...............................................25 8.2 Acessado elementos................................................45 3.12 Funes com resultados........................................25 8.3 Comprimento da lista..............................................45 3.13 Glossrio...............................................................26 8.4 Membros de uma lista.............................................46 Captulo 4: Condicionais e recursividade..............27 8.5 Listas e laos for.....................................................46#3


8.6 Operaes em listas.................................................46 13.8 Glossrio...............................................................68 8.7 Fatiamento de listas.................................................46 Captulo 14: Classes e mtodos.............................69 8.8 Listas so mutveis.................................................46 14.1 Caractersticas da orientao a objetos.................69 8.9 Remoo em lista....................................................47 14.2 exibeHora (printTime)..........................................69 8.10 Ojetos e valores.....................................................47 14.3 Um outro exemplo................................................70 8.11 Apelidos................................................................47 14.10 Glossrio.............................................................70 8.12 Clonando listas......................................................48 Captulo 15: Conjuntos de objetos.........................71 8.13 Lista como parmetro...........................................48 15.1 Composio...........................................................71 8.14 Lista aninhadas......................................................48 15.2 Objetos Carta.........................................................71 8.15 Matrizes.................................................................48 15.3 Atributos de classe e o mtodo __str__................71 8.16 Strings e listas.......................................................49 15.4 Comparando cartas................................................72 8.17 Glossrio...............................................................49 15.5 Baralhos.................................................................72 Captulo 9: Tuplas..................................................50 15.6 Imprimindo o baralho...........................................72 9.1 Mutabilidade e tuplas..............................................50 15.7 Embaralhando.......................................................73 9.2 Atribuies de tupla................................................50 15.8 Removendo e distribuindo cartas.........................73 9.3 Tuplas como valores de retorno..............................50 15.9 Glossrio...............................................................74 9.4 Nmeros aleatrios.................................................50 Capitulo 16: Herana.............................................75 9.5 Lista de nmeros aleatrios....................................51 16.1 Herana.................................................................75 9.6 Contando.................................................................51 16.2 Uma mo de cartas................................................75 9.7 Vrios intervalos.....................................................51 16.3 Dando as cartas.....................................................75 9.8 Uma soluo em um s passo.................................52 16.4 Exibindo a mao.....................................................76 9.9 Glossrio.................................................................52 16.5 A classe JogoDeCartas..........................................76 Captulo 10: Dicionrios........................................54 16.6 Classe MaoDeMico...............................................76 10.1 Operaes dos Dicionrios...................................54 16.7 Classe Mico...........................................................77 10.2 Mtodos dos Dicionrios......................................54 16.8 Glossrio...............................................................78 10.3 Aliasing (XXX) e Copiar......................................55 Captulo 17: Listas encadeadas..............................79 10.4 Matrizes Esparsas..................................................55 17.1 Referncias Embutidas..........................................79 10.5 Hint........................................................................55 17.2 A classe No (Node)...............................................79 10.6 Inteiros Longos.....................................................56 17.3 Listas como Colees...........................................79 10.7 Contando Letras....................................................56 17.4 Listas e Recorrncia..............................................80 10.8 Glossrio...............................................................56 17.5 Listas Infinitas.......................................................80 Captulo 11: Arquivos e excees..........................58 17.6 O Teorema da Ambigidade Fundamental...........80 Arquivos e excees......................................................58 17.7 Modificando Listas...............................................81 11.1 Arquivos texto.......................................................58 17.8 Envoltrios e Ajudadores......................................81 11.2 Gravando variveis...............................................59 17.9 A Classe ListaLigada............................................81 11.3 Diretrios...............................................................60 17.10 Invariantes...........................................................82 11.4 Pickling.................................................................60 17.11 Glossrio.............................................................82 11.5 Excees................................................................60 Captulo 18: Pilhas.................................................83 11.6 Glossrio...............................................................61 18.1 Tipos abstratos de dados.......................................83 Captulo 12: Classes e objetos...............................62 18.2 O TAD Pilha.........................................................83 12.1 Tipos compostos definidos pelo usurio..............62 18.3 Implementando pilhas com listas de Python........83 12.2 Atributos................................................................62 18.4 Empilhando e desempilhando...............................83 12.3 Instncias como parmetros..................................63 18.5 Usando uma pilha para avaliar expresses ps12.4 O significado de "mesmo"....................................63 fixas...............................................................................84 12.5 Retngulos.............................................................63 18.6 Anlise sinttica....................................................84 12.6 Instancias como valores retornados......................64 18.7 Avaliando em ps-fixo..........................................84 12.7 Objetos so mutveis............................................64 18.8 Clientes de fornecedores.......................................84 12.8 Copiando...............................................................64 18.9 Glossrio...............................................................85 12.9 Glossrio...............................................................65 Captulo 19: Filas...................................................86 Captulo 13: Classes e funes..............................66 19.1 Um TDA Fila........................................................86 13.1 Horario..................................................................66 19.2 Fila encadeada.......................................................86 13.2 Funes Puras.......................................................66 19.3 Caractersticas de performance.............................86 13.3 Modificadores.......................................................66 19.4 Fila encadeada aprimorada...................................86 13.4 O que melhor ?...................................................67 19.5 Fila por prioridade.................................................87 13.5 Desenvolvimento Prototipado versus 19.6 A classe Golfer......................................................88 Desenvolvimento Planejado..........................................67 19.7 Glossrio...............................................................88 13.6 Generalizao........................................................67 Captulo 20: rvores..............................................89 13.7 Algoritmos.............................................................68 20.1 Construindo rvores..............................................89#4


20.2 Percorrendo rvores..............................................89 20.3 rvores de expresses...........................................89 20.4 Percurso de rvores...............................................90 20.5 Construindo uma rvore de expresso..................90 20.6 Manipulando erros................................................92 20.7 A rvore dos animais............................................92 20.8 Glossrio...............................................................93

GNU Free Documentation License........................940. PREAMBLE ............................................................94 1. APPLICABILITY AND DEFINITIONS ................94

2. VERBATIM COPYING ..........................................95 3. COPYING IN QUANTITY .....................................95 4. MODIFICATIONS ..................................................95 5. COMBINING DOCUMENTS .................................96 6. COLLECTIONS OF DOCUMENTS ......................96 7. AGGREGATION WITH INDEPENDENT WORKS . 96 8. TRANSLATION ......................................................96 9. TERMINATION ......................................................96 10. FUTURE REVISIONS OF THIS LICENSE.........96 How to use this License for your documents......96

#5


Foreword

By David Beazley As an educator, researcher, and book author, I am delighted to see the completion of this book. Python is a fun and extremely easy-to-use programming language that has steadily gained in popularity over the last few years. Developed over ten years ago by Guido van Rossum, Pythons simple syntax and overall feel is largely derived from ABC, a teaching language that was developed in the 1980s. However, Python was also created to solve real problems and it borrows a wide variety of features from programming languages such as C++, Java, Modula-3, and Scheme. Because of this, one of Pythons most remarkable features is its broad appeal to professional software developers, scientists, researchers, artists, and educators.

Despite Pythons appeal to many dierent communities, you may still wonder why Python? or why teach programming with Python? Answering these questions is no simple taskespecially when popular opinion is on the side of more masochistic alternatives such as C++ and Java. In reading Jereys preface, I am struck by his However, I think the most direct answer is that programming comments that Python allowed him to see a higher level of in Python is simply a lot of fun and more productive. success and a lower level of frustration and that he was able When I teach computer science courses, I want to move faster with better results. Although these comments to cover important concepts in addition to making the material refer to his introductory course, I sometimes use Python for interesting and engaging to students. Unfortunately, there is a these exact same reasons in advanced graduate level computer tendency for introductory programming courses to focus far science courses at the University of Chicago. In these courses, too much attention on mathematical abstraction and for I am constantly faced with the daunting task of covering a lot students to be come frustrated with annoying problems related of dicult course material in a blistering nine week quarter. to low-level details of syntax, compilation, and the Although it is certainly possible for me to inict a lot of pain enforcement of seemingly arcane rules. Although such and suering by using a language like C++, I have often found abstraction and formalism is important to professional this approach to be counterproductive especially when the software engineers and students who plan to continue their course is about a topic unrelated to just programming. I nd study of computer science, taking such an approach in an that using Python allows me to better focus on the actual topic introductory course mostly succeeds in making computer at hand while allowing students to complete substantial class science boring. When I teach a course, I dont want to have a pro jects. room of uninspired students. I would much rather see them Although Python is still a young and evolving trying to solve interesting problems by exploring dierent language, I believe that it has a bright future in education. This ideas, taking unconventional approaches, breaking the rules, book is an important step in that direction. and learning from their mistakes. In doing so, I dont want to waste half of the semester trying to sort out obscure syntax David Beazley problems, unintelligible compiler error messages, or the University of Chicago several hundred ways that a program might generate a general protection fault. Author of the Python Essential Reference

One of the reasons why I like Python is that it provides a really nice balance between the practical and the conceptual. Since Python is interpreted, beginners can pick up the language and start doing neat things almost immediately without getting lost in the problems of compilation and linking. Furthermore, Python comes with a large library of modules that can be used to do all sorts of tasks ranging from web-programming to graphics. Having such a practical focus is a great way to engage students and it allows them to complete significant pro jects. However, Python can also serve as an excellent foundation for introducing important computer science concepts. Since Python fully supports procedures and classes, students can be gradually introduced to topics such as procedural abstraction, data structures, and ob ject-oriented programmingall of which are applicable to later courses on Java or C++. Python even borrows a number of features from functional programming languages and can be used to introduce concepts that would be covered in more detail in courses on Scheme and Lisp.

Foreword #6


ApresentaoTraduo do captulo anterior, que foi mantido por ter sido marcado como seo invariante pelo autor original.Como educador, pesquisador e autor de livros, regozija-me ver completo este trabalho. Python uma linguagem de programao divertida e extremamente fcil de usar que tem ganho forte popularidade nestes ltimos poucos anos. Desenvolvida dez anos atrs por Guido van Rossun, a sintaxe simples do Python e seu sentido geral so grandemente derivados do ABC, uma linguagem didtica que foi desenvolvida nos anos 80. Entretanto, Python tambm foi criado para solucionar problemas reais e tomou emprestado uma grande quantidade de caractersticas de linguagens de programao como C++, Java, Modula-3 e Scheme. Por causa disso, uma das mais notveis caractersticas do Python o grande apelo que tem junto a desenvolvedores profissionais de software, cientistas, pesquisadores, artistas e educadores. que ele oferece um equilbrio realmente bom entre o lado prtico e o lado conceitual. Sendo Python interpretado, os iniciantes podem pegar a linguagem e comear a fazer coisas legais quase imediatamente sem se perderem em problemas de compilao e ligao. Alm disso, Python vem com uma grande biblioteca de mdulos que podem ser utilizados para fazer todo tipo de tarefa, desde a programao para a web at grficos. Com tal enfoque prtico temos uma bela maneira de alcanar o engajamento dos alunos e permitir que eles finalizem projetos significativos. Entretanto, Python tambm pode servir de excelente embasamento para a introduo de conceitos importantes em cincia da computao. J que Python suporta plenamente procedimentos (procedures) e classes, os alunos podem ser gradualmente introduzidos a tpicos como abstrao procedural, estruturas de dados, e programao orientada a objetos ? todos aplicveis em cursos posteriores de Java ou C++. Python ainda toma emprestado certas caractersticas de linguagens de programao funcionais e pode ser usado para introduzir conceitos cujos detalhes poderiam ser aprofundados em cursos de Scheme e Lisp.

A Despeito deste apelo do Python junto s mais variadas comunidades, voc pode ainda estar pensando ?por que Python?? ou ?por que ensinar programao com Python??. Responder estas perguntas no uma tarefa fcil ? especialmente se a opinio pblica est do lado de alternativas mais masoquistas como C++ e Java. Entretanto, eu acho que a resposta mais direta que programar com Lendo o prefcio de Jeffrey, fiquei Python um bocado divertido e mais produtivo. impressionado com seu comentrio de que Python o fez ver um ?maior nvel de sucesso e um menor nvel de frustrao? o Quando ministro cursos de cincias da que lhe permitiu ?progredir mais depressa com resultados computao, o que desejo cobrir conceitos importantes alm melhores?. Embora estes comentrios refiram-se aos seus de tornar a matria interessante e os alunos participativos. cursos introdutrios, eu s vezes uso Python exatamente pelas Infelizmente, existe uma tendncia entre os cursos mesmas razes em cursos avanados de ps-graduao em introdutrios de programao a focar ateno demais em cincia da computao na Universidade de Chicago. Nestes abstraes matemticas, e de frustrao entre os alunos com cursos, enfrento constantemente a assustadora tarefa de cobrir problemas enfadonhos e inoportunos relacionados a detalhes muitos tpicos difceis em um rapidssimo trimestre de nove de sintaxe em baixo nvel, compilao e a imposio de regras semanas. Embora me seja possvel inflingir um bocado de dor que aparentemente s um expert pode compreender. Embora e sofrimento pelo uso de uma linguagem como C++, tenho alguma abstrao e formalismo sejam importantes para percebido muitas vezes que este enfoque contraproducente ? engenheiros profissionais de software e estudantes que especialmente quando o curso sobre um tpico no planejam continuar seus estudos em cincias da computao, relacionado apenas com ?programar?. Acho que usar Python escolher tal abordagem em um curso introdutrio faz da me permite um melhor foco no tpico em questo, enquanto cincia da computao algo entediante. Quando ministro um permite que os alunos completem projetos substanciais em curso, no desejo uma sala cheia de alunos sem inspirao. classe. Em vez disso, preferiria muito mais v-los tentando solucionar problemas interessantes explorando idias diferentes, Embora Python seja ainda uma linguagem trilhando caminhos no convencionais, quebrando regras, e jovem e em evoluo, acredito que tem um futuro brilhante em aprendendo a partir de seus erros. Fazendo assim, no educao. Este livro um passo importante nessa direo. pretendo desperdiar metade de um semestre tentando explicar David Beazley problemas obscuros de sintaxe, mensagens ininteligveis de compiladores ou as vrias centenas de maneiras pelas quais Universidade de Chicago um programa pode gerar uma falha geral de proteo. Autor de Python Essencial Reference Uma das razes pelas quais eu gosto de Python

Apresentao #7


Preface

By Je Elkner

for.

This book owes its existence to the collaboration made possible by the Internet and the free software movement. Its three authorsa college professor, a Finding a textb o ok high school teacher, and a professional programmerhave yet to meet face to face, but we have been able to work closely Having decided to use Python in both of my introductory together and have been aided by many wonderful folks who computer science classes the following year, the most pressing have donated their time and energy to helping make this book problem was the lack of an available textbook. better. Free content came to the rescue. Earlier in the We think this book is a testament to the benets year, Richard Stallman had introduced me to Allen Downey. and future possibilities of this kind of collaboration, the Both of us had written to Richard expressing an interest in framework for which has been put in place by Richard developing free educational content. Allen had already written Stallman and the Free Software Foundation. a rst-year computer science textbook, How to Think Like a Computer Scientist. When I read this book, I knew immediately that I wanted to use it in my class. It was the clearest and most helpful computer science text I had seen. It How and why I came to use Python emphasized the processes of thought involved in programming rather than the features of a particular language. Reading it In 1999, the College Boards Advanced Placement (AP) immediately made me a better teacher. Computer Science exam was given in C++ for the rst time. As in many high schools throughout the country, the decision How to Think Like a Computer Scientist was not to change languages had a direct impact on the computer just an excellent book, but it had been released under a GNU science curriculum at Yorktown High School in Arlington, public license, which meant it could be used freely and Virginia, where I teach. Up to this point, Pascal was the modied to meet the needs of its user. Once I decided to use language of instruction in both our rst-year and AP courses. Python, it occurred to me that I could translate Allens original In keeping with past practice of giving students two years of Java version of the book into the new language. While I would exposure to the same language, we made the decision to not have been able to write a textbook on my own, having switch to C++ in the rst-year course for the 1997-98 school Allens book to work from made it possible for me to do so, at year so that we would be in step with the College Boards the same time demonstrating that the cooperative development change for the AP course the following year. model used so well in software could also work for educational content. Two years later, I was convinced that C++ was a poor choice to use for introducing students to computer Working on this book for the last two years has science. While it is certainly a very powerful programming been rewarding for both my students and me, and my students language, it is also an extremely dicult language to learn and played a big part in the process. Since I could make instant teach. I found myself constantly ghting with C++s dicult changes whenever someone found a spelling error or dicult syntax and multiple ways of doing things, and I was losing passage, I encouraged them to look for mistakes in the book many students unnecessarily as a result. Convinced there had by giving them a bonus point each time they made a to be a better language choice for our rst-year class, I went suggestion that resulted in a change in the text. This had the looking for an alternative to C++. double benet of encouraging them to read the text more carefully and of getting the text thoroughly reviewed by its I needed a language that would run on the most important critics, students using it to learn computer machines in our Linux lab as well as on the Windows and science. Macintosh platforms most students have at home. I wanted it to be free and available electronically, so that students could For the second half of the book on ob jectuse it at home regardless of their income. I wanted a language oriented programming, I knew that someone with more real that was used by professional programmers, and one that had programming experience than I had would be needed to do it an active developer community around it. It had to support right. The book sat in an unnished state for the better part of both procedural and ob ject-oriented programming. And most a year until the free software community once again provided importantly, it had to be easy to learn and teach. When I the needed means for its completion. investigated the choices with these goals in mind, Python I received an email from Chris Meyers stood out as the best candidate for the job. expressing interest in the book. Chris is a professional I asked one of Yorktowns talented students, programmer who started teaching a programming course last Matt Ahrens, to give Python a try. In two months he not only year using Python at Lane Community College in Eugene, learned the language but wrote an application called pyTicket Oregon. The prospect of teaching the course had led Chris to that enabled our sta to report technology problems via the the book, and he started helping out with it immediately. By Web. I knew that Matt could not have nished an application the end of the school year he had created a companion project of that scale in so short a time in C++, and this on our Website at http://www.ibiblio.org/obp called Python accomplishment, combined with Matts positive assessment of for Fun and was working with some of my most advanced Python, suggested that Python was the solution I was looking students as a master teacher, guiding them beyond where I Preface #8

Como pensar como um cientista da Computao usando Python could take them. Thus, the idea of a variable is bound up with the hardware of the machine. The powerful and fundamental concept of a variable is already dicult enough for beginning students (in both computer science and algebra). Bytes and addresses do not help the matter. In Python a variable is a name that refers to a thing. This is a far more intuitive concept for beginning students and is much closer to the meaning of variable that they learned in their math courses. I had much less diculty teaching variables this year than I did in the past, and I spent less time helping students with problems using them.

Intro ducing programming with PythonThe process of translating and using How to Think Like a Computer Scientist for the past two years has conrmed Pythons suitability for teaching beginning students. Python greatly simplies programming examples and makes important programming ideas easier to teach.

Another example of how Python aids in the The rst example from the text illustrates this teaching and learning of programming is in its syntax for point. It is the traditional hello, world program, which in the functions. My students have always had a great deal of C++ version of the book looks like this: diculty understanding functions. The main problem centers around the dierence between a function denition and a #include function call, and the related distinction between a parameter void main() and an argument. Python comes to the rescue with syntax that { is nothing short of beautiful. Function denitions begin with cout >>, Mas as vantagens so enormes. Primeiro, que o sinal usado pelo interpretador para indicar que ele est muito mais fcil programar em uma linguagem de alto nvel. pronto. No exemplo anterior, digitamos print 1 + 1 e o mais rpido escrever programas em uma linguagem de alto interpretador respondeu 2. nvel; eles so mais curtos e mais fceis de ler e mais Voc tambm pode escrever um programa em provvel que estejam corretos. Segundo, as linguagens de alto um arquivo e usar o interpretador para executar o contedo nvel so portveis, o que significa que podem rodar em desse arquivo. Um arquivo como este chamado de script. diferentes tipos de computador, com pouca ou nenhuma Por exemplo, usamos um editor de texto para criar um arquivo modificao. Programas em baixo nvel s podem rodar em chamado leticia.py com o seguinte contedo: um nico tipo de computador e precisam ser re-escritos para print 1 + 1 rodar em outro tipo. Por conveno, arquivos que contenham Devido a essas vantagens, quase todos os programas em Python tm nomes que terminam com .py. programas so escritos em linguagens de alto nvel. As de baixo nvel so utilizadas somente para umas poucas Para executar o programa, temos de dizer ao aplicaes especializadas. interpretador o nome do script: Captulo 1: O caminho do programa #16

Como pensar como um cientista da Computao usando Python$ python leticia.py 2

(runtime errors) e erros de semntica. Distinguir os trs tipos ajuda a localiz-los mais rpido:

Em outros ambientes de desenvolvimento, os detalhes da execuo de programas podem ser diferentes. 1.3.1 Erros de sintaxe Alm disso, a maioria dos programas so mais interessantes Python s executa um programa se ele estiver sintaticamente do que esse... correto; caso contrrio, o processo falha e retorna uma A maioria dos exemplos neste livro so mensagem de erro. Sintaxe se refere estrutura de um executados a partir da linha de comando. Trabalhar com a programa e s regras sobre esta estrutura. Por exemplo, em linha de comando conveniente no desenvolvimento e portugus, uma frase deve comear com uma letra maiscula testagem de programas, porque voc pode digitar os e terminar com um ponto. programas e execut-los imediatamente. Uma vez que voc esta frase contm um erro de sintaxe. Assim tem um programa que funciona, deve guard-lo em um script, como esta de forma a poder execut-lo ou modific-lo no futuro.

1.2 O que um programa?Um programa uma seqncia de instrues que especificam como executar uma computao. A computao pode ser algo matemtico, como solucionar um sistema de equaes ou encontrar as razes de um polinmio, mas tambm pode ser uma computao simblica, como buscar e substituir uma palavra em um documento ou (estranhamente) compilar um programa.

Para a maioria dos leitores, uns errinhos de sintaxe no chegam a ser um problema significativo e por isso que conseguimos ler a poesia moderna de e. e. cummings sem cuspir mensagens de erro. Python no to indulgente. Se o seu programa tiver um nico erro de sintaxe em algum lugar, o interpretador Python vai exibir uma mensagem de erro e vai terminar - e o programa no vai rodar. Durante as primeiras semanas da sua carreira como programador, voc provavelmente perder um bocado de tempo procurando erros de sintaxe. Conforme for ganhando experincia, entretanto, cometer menos erros e os localizar mais rpido.

Os detalhes so diferentes em diferentes 1.3.2 Erros em tempo de execuo (runtime errors) linguagens, mas algumas instrues bsicas aparecem em praticamente todas as linguagens: O segundo tipo de erro o erro de runtime, ou erro em tempo de execuo, assim chamado porque s aparece quando voc entrar Pegar dados do teclado, de um arquivo roda o programa. Esses erros so tambm conhecidos como ou de algum outro dispositivo. excees, porque normalmente indicam que alguma coisa sair Mostrar dados na tela ou enviar dados excepcional (e ruim) aconteceu. para um arquivo ou outro dispositivo. Erros de runtime so raros nos programas operaes matemticas simples que voc vai ver nos primeiros captulos - ento, vai calcular Executar demorar um pouco at voc se deparar com um erro desse bsicas, como adio e multiplicao. tipo. executar Checar certas condies e executar a condicionalmente seqncia apropriada de instrues. 1.3.3 Erros de semntica repetir Executar alguma ao repetidamente, O terceiro tipo de erro o erro de semntica (mais normalmente com alguma variao. comumente chamado erro de lgica). Mesmo que o seu Acredite se quiser: isso praticamente tudo. programa tenha um erro de semntica, ele vai rodar com Todos os programas que voc j usou, no importa quo sucesso, no sentido de que o computador no vai gerar complicados, so feitos de instrues mais ou menos nenhuma mensagem de erro. S que o programa no vai fazer parecidas com essas. Assim, poderamos definir programao a coisa certa, vai fazer alguma outra coisa. Especificamente, como o processo de dividir uma tarefa grande e complexa em aquilo que voc tiver dito para ele fazer. sub-tarefas cada vez menores, at que as sub-tarefas sejam O problema que o programa que voc simples o suficiente para serem executadas com uma dessas escreveu no aquele que voc queria escrever. O significado instrues bsicas. do programa (sua semntica ou lgica) est errado. Identificar Isso pode parecer um pouco vago, mas vamos erros semnticos pode ser complicado, porque requer que voltar a esse tpico mais adiante, quando falarmos sobre voc trabalhe de trs para frente, olhando a sada do programa algoritmos. e tentando imaginar o que ele est fazendo.

1.3 O que depurao (debugging)?

1.3.4 Depurao experimental (Debugging)

Uma das habilidades mais importantes que voc vai adquirir a de depurar. Embora possa ser frustrante, depurar uma das Programar um processo complicado e, como feito por partes intelectualmente mais ricas, desafiadoras e seres humanos, freqentemente conduz a erros. Por mero interessantes da programao. capricho, erros em programas so chamados de bugs e o processo de encontr-los e corrigi-los chamado de De certa maneira, a depurao como um depurao (debugging). trabalho de detetive. Voc se depara com pistas, e tem que deduzir os processos e eventos que levaram aos resultados Trs tipos de erro podem acontecer em um que aparecem. programa: erros de sintaxe, erros em tempo de execuo Captulo 1: O caminho do programa #17

Como pensar como um cientista da Computao usando Python Depurar tambm como uma cincia experimental. Uma vez que voc tem uma idia do que est errado, voc modifica o seu programa e tenta de novo. Se a sua hiptese estava correta, ento voc consegue prever o resultado da modificao e fica um passo mais perto de um programa que funciona. Se a sua hiptese estava errada, voc tem que tentar uma nova. Como Sherlock Holmes mostrou, "Quando voc tiver eliminado o impossvel, aquilo que restou, ainda que improvvel, deve ser a verdade." (Arthur Conan Doyle, O signo dos quatro). mesmo modo, frmulas moleculares devem ter ndices subscritos colocados depois do nome do elemento, no antes. Faa este exerccio: crie o que parea ser uma frase bem estruturada em portugus com "tokens" irreconhecveis dentro dela. Depois escreva outra frase com todos os "tokens" vlidos, mas com uma estrutura invlida.

Quando voc l uma frase em portugus ou uma expresso em uma linguagem formal, voc tem de imaginar como a estrutura da frase (embora, em uma linguagem Para algumas pessoas, programao e natural, voc faa isso inconscientemente). Este processo depurao so a mesma coisa. Ou seja, programar o chamado parsing (anlise sinttica). processo de gradualmente depurar um programa, at que ele Por exemplo, quando voc ouve a frase, "Caiu a faa o que voc quer. A idia comear com um programa ficha", entende que "a ficha" o sujeito e "caiu" o verbo. que faa alguma coisa e ir fazendo pequenas modificaes, Uma vez que voc analisou a frase, consegue entender o seu depurando-as conforme avana, de modo que voc tenha significado, ou a semntica da frase. Assumindo que voc sempre um programa que funciona. saiba o que uma ficha e o que significa cair, voc entender Por exemplo, o Linux um sistema operacional o sentido geral dessa frase. que contm milhares de linhas de cdigo, mas comeou como Muito embora as linguagens formais e as um programa simples, que Linus Torvalds usou para explorar naturais tenham muitas caractersticas em comum -- tokens, o chip Intel 80386. De acordo com Larry Greenfield, "Um dos estrutura, sintaxe e semntica -- existem muitas diferenas: primeiros projetos de Linus Torvalds foi um programa que deveria alternar entre imprimir AAAA e BBBB. Isso depois ambigidade As linguagens naturais esto cheias de evoluiu at o Linux". (The Linux User's Guide Verso Beta 1) ambigidades, que as pessoas contornam usando pistas contextuais e outras Captulos posteriores faro mais sugestes informaes. J as linguagens formais so sobre depurao e outras prticas de programao. desenvolvidas para serem quase ou totalmente desprovidas de ambigidade, o que significa que qualquer expresso tem 1.4 Linguagens naturais e linguagens formais precisamente s um sentido, independentemente do contexto. Linguagens naturais so as linguagens que as pessoas falam, redundncia Para compensar a ambigidade e reduzir como o portugus, o ingls e o espanhol. Elas no foram mal-entendidos, emprega-se muita projetadas pelas pessoas (muito embora as pessoas tentem redundncia nas linguagens naturais, o que colocar alguma ordem nelas); elas evoluram naturalmente. freqentemente as torna prolixas. As linguagens formais so menos redundantes e Linguagens formais so linguagens que foram mais concisas. projetadas por pessoas, para aplicaes especficas. Por exemplo, a notao que os matemticos usam uma literalidade As linguagens naturais esto cheias de linguagem formal, que particularmente boa em denotar expresses idiomticas e metforas. Se eu relaes entre nmeros e smbolos. Os qumicos usam uma digo "Caiu a ficha", possvel que no exista linguagem formal para representar a estrutura qumica das ficha nenhuma, nem nada que tenha cado. molculas. E, mais importante: Nas linguagens formais, no h sentido ambguo. Linguagens de programao so linguagens formais que foram desenvolvidas para expressar Pessoas que crescem falando uma linguagem computaes. natural -- ou seja, todo mundo - muitas vezes tm dificuldade de se acostumar com uma linguagem formal. De certa As linguagens formais tendem a ter regras maneira, a diferena entre linguagens formais e naturais estritas quanto sintaxe. Por exemplo, 3 + 3 = 6 uma como a diferena entre poesia e prosa, porm mais acentuada: expresso matemtica sintaticamente correta, mas 3=+6$ no . H2O um nome qumico sintaticamente correto, mas 2Zz poesia As palavras so usadas pela sua sonoridade, no . alm de seus sentidos, e o poema como um todo cria um efeito ou uma reao emocional. As regras de sintaxe so de dois tipos, um A ambigidade no apenas freqente, mas na relacionado aos tokens, outro estrutura. "Tokens" so os maioria das vezes, proposital. elementos bsicos da linguagem, como as palavras, nmeros, e elementos qumicos. Um dos problemas com 3=+6$ que $ prosa O sentido literal das palavras mais no um token vlido em linguagem matemtica (pelo menos importante, e a estrutura contribui mais para o at onde sabemos). Do mesmo modo, 2Zz invlida porque significado. A prosa mais fcil de analisar do no existe nenhum elemento cuja abreviatura seja Zz. que a poesia, mas ainda muitas vezes ambgua. O segundo tipo de erro de sintaxe est relacionado estrutura de uma expresso -- quer dizer, ao programas O significado de um programa de computador modo como os tokens esto arrumados. A expresso 3=+6$ exato e literal, e pode ser inteiramente estruturalmente invlida, porque voc no pode colocar um entendido pela anlise de seus tokens e de sua sinal de "mais" imediatamente aps um sinal de "igual". Do estrutura. Captulo 1: O caminho do programa #18

Como pensar como um cientista da Computao usando Python Aqui vo algumas sugestes para a leitura de programas (e de outras linguagens formais). Primeiro, lembrese de que linguagens formais so muito mais densas do que linguagens naturais, por isso, mais demorado l-las. A estrutura, tambm, muito importante, logo, geralmente no uma boa idia ler de cima para baixo, da esquerda para a direita. Em vez disso, aprenda a analisar o programa na sua cabea, identificando os tokens e interpretando a estrutura. Finalmente, os detalhes so importantes. Pequenas coisas, como, erros ortogrficos e m pontuao, com as quais voc pode se safar nas linguagens naturais, podem fazer uma grande diferena em uma linguagem formal. baixo nvel de um s vez, em preparao para uma execuo posterior. cdigo fonte Um programa em uma linguagem de alto (source code) nvel, antes de ter sido compilado. cdigo objeto A sada do compilador, depois que ele (object code) traduziu o programa. executvel Um outro nome para cdigo objeto que (executable) est pronto para ser executado. script Um programa guardado em um arquivo (normalmente um que ser interpretado). programa Conjunto de instrues que especifica (program) uma computao. algoritmo Processo geral para soluo de uma certa (algorithm) categoria de problemas. bug Erro em um programa. depurao O processo de encontrar e remover (debugging) qualquer um dos trs tipos de erros de programao. sintaxe (syntax) A estrutura de um programa. erro de sintaxe Erro em um programa, que torna (syntax error) impossvel a anlise sinttica (logo, tambm impossvel a interpretao). erro em tempo Erro que no ocorre at que o programa de execuo seja executado, mas que impede que o (runtime error) programa continue. exceo Um outro nome para um erro em tempo (exception) de execuo ou erro de runtime. erro de Erro em um programa, que o leva a fazer semntica algo diferente do que pretendia o (semantic error) programador. semntica O significado de um programa. (semantics) linguagem Qualquer lngua falada pelos seres que tenha evoludo natural (natural humanos language) naturalmente. linguagem Qualquer linguagem desenvolvida pelas formal (formal pessoas para propsitos especficos, tais language) como, a representao de idias matemticas ou programas de computadores; todas as linguagens de programao so linguagens formais. tomo (token) Um elemento bsico da estrutura sinttica de um programa, anlogo a uma palavra em uma linguagem natural. anlise sinttica Examinar um programa e analisar sua (parse) estrutura sinttica. comando print Instruo que leva o interpretador (`print` Python a apresentar um valor na tela. statement)

1.5 O primeiro programaTradicionalmente, o primeiro programa escrito em uma nova linguagem de programao chamado de "Al, Mundo!" porque tudo que ele faz apresentar as palavras "Al, Mundo!". Em Python, ele assim:print "Al, Mundo!"

Isso um exemplo de um comando print, que, na realidade, no "imprime" nada em papel. Ele apresenta o valor na tela. Neste caso, o resultado so as palavras:Al, Mundo!

As aspas no programa marcam o comeo e o fim do valor; elas no aparecem no resultado final. Algumas pessoas julgam a qualidade de uma linguagem de programao pela simplicidade do programa "Al, Mundo!". Por esse padro, Python se sai to bem quanto possvel.

1.6 Glossriosoluo de O processo de formular um problema, problemas encontrar uma soluo e expressar esta (problem soluo. solving) linguagem de Uma linguagem de programao como alto nvel (high- Python: projetada para ser fcil para os level language) seres humanos a utilizarem. linguagem de Uma linguagem de programao que baixo nvel (low- concebida para ser fcil para um level language) computador, tal como a linguagem de mquina ou a linguagem montagem (assembly language) portabilidade Propriedade que um programa tem, de (portability) rodar em mais de um tipo de computador. interpretar Executar um programa escrito em uma (interpret) linguagem de alto nvel, traduzindo-o uma linha de cada vez. compilar Traduzir todo um programa escrito em (compile) uma linguagem de alto nvel para uma de

Captulo 1: O caminho do programa #19


Captulo 2: Variveis, expresses e comandos

2.1 Valores e tipos

2.2 Variveis

O valor (por exemplo, letras e nmeros) uma das coisas Uma das caractersticas mais poderosas de uma linguagem de fundamentais que um programa manipula. Os valores que j programao a habilidade de manipular variveis. Uma vimos at agora foram o 2 (como resultado, quando varivel um nome que se refere a um valor. adicionamos 1 + 1) e "Al, Mundo!". O comando de atribuio cria novas variveis e Esses valores pertencem a tipos diferentes: 2 d a elas valores: um inteiro, e "Al, Mundo!" uma string, assim chamada porque "string", em ingls, quer dizer seqncia, srie, cadeia >>> mensagem = "E a, Doutor?" (de caracteres), ou neste caso, "srie de letras". Voc (e o >>> n = 17 interpretador) consegue identificar strings porque elas >>> pi = 3.14159 Este exemplo faz trs atribuies. A primeira aparecem entre aspas. atribui a string "E a, Doutor?" a uma nova varivel chamada O comando print tambm funciona com inteiros: mensagem. A segunda d o valor inteiro 17 a n, e a terceira atribui o nmero de ponto flutuante 3.14159 varivel >>> print 4 chamada pi. 4 Se voc estiver em dvida sobre qual o tipo de Uma maneira comum de representar variveis no papel escrever o nome delas com uma seta apontando um determinado valor, o interpretador pode revelar: para o valor da varivel. Esse tipo de figura chamado de >>> type("Al, Mundo!") diagrama de estado porque mostra em que estado cada varivel est (pense nisso como o estado de esprito da >>> type(17) varivel). O diagrama a seguir mostra o resultado das instrues de atribuio: Nenhuma surpresa: strings pertencem ao tipo string e inteiros pertencem ao tipo int. Menos obviamente, nmeros com um ponto decimal pertencem a um tipo chamado float, porque estes nmeros so representados em um formato chamado ponto flutuante1:>>> type(3.2)

O que dizer de valores como "17" e "3.2"? Eles parecem nmeros, mas esto entre aspas, como strings:>>> type("17") >>> type("3.2")

variveis:

O comando print tambm funciona com

Eles so strings.

Ao digitar um nmero grande, tentador usar pontos entre grupos de trs dgitos, assim: 1.000.000. Isso no funciona porque Python usa o ponto como separador decimal. Usar a vrgula, como se faz em ingls, resulta numa expresso Em cada um dos casos, o resultado o valor da vlida, mas no no nmero que queramos representar: varivel. Variveis tambm tm tipo; novamente, podemos perguntar ao interpretador quais so eles: >>> print 1,000,0001 0 0

>>> print mensagem E a, Doutor? >>> print n 17 >>> print pi 3.14159

No nada do que se esperava! Python interpreta 1,000,000 como uma tupla, algo que veremos no Captulo 9. Por hora, lembre-se apenas de no colocar vrgulas nos nmeros.

>>> type(mensagem) >>> type(n) >>> type(pi)

ela se refere.1 N.T.: Observe o uso de ponto no lugar da vrgula para separar a parte inteira da parte fracionria.

O tipo de uma varivel o tipo do valor ao qual

Captulo 2: Variveis, expresses e comandos #20

Como pensar como um cientista da Computao usando Pythonprint 2

2.3 Nomes de variveis e palavras reservadasOs programadores geralmente escolhem nomes significativos para suas variveis -- eles documentam para o qu a varivel usada.

produz a sada:1 2

Nomes de variveis podem ser arbitrariamente longos. Eles podem conter tanto letras quanto nmeros, mas tm de comear com uma letra. Embora seja vlida a utilizao de letras maisculas, por conveno, no usamos. 2.5 Avaliando expresses Se voc o fizer, lembre-se de que maisculas e minsculas so diferentes. Bruno e bruno so variveis diferentes. Uma expresso uma combinao de valores, variveis e O caractere para sublinhado ( _ ) pode aparecer operadores. Se voc digitar uma expresso na linha de em um nome. Ele muito utilizado em nomes com mltiplas comando, o interpretador avalia e exibe o resultado: palavras, tal como em meu_nome ou preco_do_cha_na_china. >>> 1 + 1 Se voc der a uma varivel um nome invlido, causar um erro de sintaxe:>>> 76trombones = "grande parada" SyntaxError: invalid syntax >>> muito$ = 1000000 SyntaxError: invalid syntax >>> class = "Ciencias da Computacao 101" SyntaxError: invalid syntax 2

produz sada.

Novamente, o comando de atribuio no

Embora expresses contenham valores, variveis e operadores, nem toda expresso contm todos estes elementos. Um valor por si s considerado uma expresso, do mesmo modo que uma varivel:>>> 17 17 >>> x 2

76trombones invlida porque no comea com Avaliar uma expresso no exatamente a uma letra. muito$ invlida porque contm um caractere mesma coisa que imprimir um valor: ilegal, o cifro. Mas o que est errado com class? Ocorre que class uma das palavras reservadas em Python. Palavras reservadas definem as regras e a estrutura da linguagem e no podem ser usadas como nomes de variveis. Python tem 29 palavras reservadas:and assert break class continue def del elif else except exec finally for from global if import in is lambda not or pass print raise return try while yield >>> mensagem = "E a, Doutor?" >>> mensagem 'E a, Doutor?' >>> print mensagem E a, Doutor?

Quando Python exibe o valor de uma expresso, usa o mesmo formato que voc usaria para entrar com o valor. No caso de strings, isso significa que as aspas so includas [#]_. Mas o comando print imprime o valor da expresso, que, neste caso, o contedo da string.

Num script, uma expresso sozinha um Pode ser til ter essa lista mo. Se o comando vlido, porm sem efeito. O script: interpretador acusar erro sobre um de seus nomes de varivel 17 e voc no souber porqu, veja se o nome est na lista.

2.4 ComandosUm comando uma instruo que o interpretador Python pode executar. Vimos at agora dois tipos de comandos: de exibio (print) e de atribuio.

3.2 "Al, Mundo!" 1 + 1

no produz qualquer sada. Como voc mudaria o "script" para exibir os valores destas quatro expresses?

Quando voc digita um comando na linha de comando, o Python o executa e mostra o resultado, se houver Operadores so smbolos especiais que representam um. O resultado de um comando print a exibio de um computaes como adio e multiplicao. Os valores que o valor. Comandos de atribuio no produzem um resultado operador usa so chamados operandos. visvel. Todas as expresses seguintes so vlidas em Um script normalmente contm uma seqncia Python e seus significados so mais ou menos claros: de comandos. Se houver mais de um comando, os resultados aparecero um de cada vez, conforme cada comando seja 20+32 hora-1 hora*60+minuto minuto/60 5**2 \ executado. Por exemplo, o "script":print 1 x = 2 (5+9)*(15-7)

2.6 Operadores e operandos

Em Python, os smbolos +, -, / e o uso de parnteses para agrupamento tm o mesmo significado que em matemtica. O asterisco (*) o smbolo para multiplicao e


Como pensar como um cientista da Computao usando Python ** o smbolo para potenciao.

Quando um nome de varivel aparece no lugar de um operando, ele substitudo pelo valor da varivel, antes De maneira geral, voc no pode executar operaes da operao ser executada. matemticas em strings, ainda que as strings se paream com Adio, subtrao, multiplicao e potenciao nmeros. O que segue invlido (assumindo que mensagem fazem o que se espera, mas voc pode ficar surpreso com a do tipo string): diviso. A operao seguinte tem um resultado inesperado: mensagem-1 "Al"/123 mensagem*"Al" "15"+2 Interessante o operador +, que funciona com strings, embora ele no faa exatamente o que voc poderia esperar. Para strings, o operador + representa concatenao, O valor de minuto 59 e, em aritmtica que significa juntar os dois operandos ligando-os pelos convencional, 59 dividido por 60 0,98333, no 0. A razo extremos. Por exemplo: para a discrepncia que Python est realizando uma diviso fruta = "banana" inteira. assada = " com canela">>> minuto = 59 >>> minuto/60 0

2.8 Operaes com strings

Quando ambos os operandos so inteiros, o print fruta + assada A sada deste programa banana com canela. O resultado tem de ser tambm um inteiro e, por conveno, a diviso inteira sempre arredonda para baixo, mesmo em casos espao antes da palavra com parte da string e necessrio para produzir o espao entre as strings concatenadas. como este, em que o inteiro seguinte est muito prximo: O operador * tambm funciona com strings; ele realiza repetio. Por exemplo, "Legal"*3 "LegalLegaLegal". Um dos operadores tem que ser uma De novo, o resultado arredondado para baixo, mas agora pelo menos a resposta aproximadamente correta. string; o outro tem que ser um inteiro. A alternativa usar a diviso em ponto flutuante, o que Por um lado, esta interpretao de + e * faz veremos no captulo 3. sentido pela analogia entre adio e multiplicao. Assim como 4*3 equivale a 4+4+4, no de estranhar que "Legal"*3 seja o mesmo que "Legal"+"Legal"+"Legal". Por outro lado, uma diferena significativa separa concatenao e repetio de 2.7 Ordem dos operadores adio e multiplicao. Voc saberia mencionar uma propriedade da adio e da multiplicao que no ocorre na Quando mais de um operador aparece em uma expresso, a concatenao e na repetio? ordem de avaliao depende das regras de precedncia. Python segue as mesmas regras de precedncia para seus operadores matemticos que a matemtica. O acrnimo PEMDAS uma maneira prtica de lembrar a ordem das 2.9 Composio operaes: Parnteses tm a mais alta precedncia e podem ser At agora, vimos os elementos de um programa -- variveis, usados para forar uma expresso a ser avaliada na expresses, e instrues ou comandos -- isoladamente, sem ordem que voc quiser. J que expresses entre mencionar como combin-los. parnteses so avaliadas primeiro, 2 * (3-1) 4, e Uma das caractersticas mais prticas das (1+1)**(5-2) 8. Voc tambm pode usar parnteses linguagens de programao a possibilidade de pegar para tornar uma expresso mais fcil de ler, como em pequenos blocos e combin-los numa composio. Por (minuto * 100) / 60, ainda que isso no altere o exemplo, ns sabemos como somar nmeros e sabemos como resultado. exibi-los; acontece que podemos fazer as duas coisas ao Exponenciao ou potenciao tem a prxima mesmo tempo: precedncia mais alta, assim 2**1+1 3 e no 4, e >>> print 17 + 3 3*1**3 3 e no 27. 20>>> minuto*100/60 98

Multiplicao e Diviso tm a mesma precedncia, que mais alta do que a da Adio e da Subtrao, que tambm tm a mesma precedncia. Assim 2*3-1 d 5 em vez de 4, e 2/3-1 -1, no 1 (lembre-se de que na diviso inteira, 2/3=0).

Operadores com a mesma precedncia so avaliados da esquerda para a direita. Assim, na expresso print "Nmero de minutos desde a meia-noite: ", \ minuto*100/60, a multiplicao acontece primeiro, hora*60+minuto resultando em 5900/60, o que se transforma Esta possibilidade pode no parecer muito produzindo 98. Se as operaes tivessem sido impressionante agora, mas voc ver outros exemplos em que avaliadas da direita para a esquerda, o resultado a composio torna possvel expressar computaes poderia ter sido 59*1, que 59, que est errado. complexas de modo limpo e conciso. Ateno: Existem limites quanto ao lugar onde voc pode usar certos tipos de expresso. Por exemplo, o lado Captulo 2: Variveis, expresses e comandos #22

Na realidade, a soma tem que acontecer antes da impresso, assim, as aes no esto na realidade acontecendo ao mesmo tempo. O ponto que qualquer expresso envolvendo nmeros, strings, e variveis pode ser usada dentro de um comando print. Voc j tinha visto um exemplo disto:

Como pensar como um cientista da Computao usando Python esquerdo de um comando de atribuio tem que ser um nome de varivel, e no uma expresso. Assim, o seguinte no vlido: minuto+1 = hora. comandos compostos, de forma a representar computaes complexas de forma concisa. comentrio Informao em um programa dirigida a (comment) outros programadores (ou qualquer pessoa que esteja lendo o cdigo fonte) e que no tem efeito na execuo do programa.

2.11 Glossriovalor (value) Um nmero ou string (ou outra coisa que ainda vamos conhecer) que pode ser atribuda a uma varivel ou computada em uma expresso. tipo (type) Um conjunto de valores. O tipo de um valor determina como ele pode ser usado em expresses. At agora, os tipos vistos so: inteiros (tipo int), nmeros em pontoflutuante (tipo float) e strings (tipo string). ponto- Formato para representar nmeros que flutuante possuem partes fracionrias. (floating-point) varivel Nome que se refere a um valor. (variable) comando Trecho de cdigo que representa uma (statement) instruo ou ao. At agora, os comandos vistos foram de atribuio e exibio. atribuio Comando que atribui um valor a uma (assignment) varivel. diagrama de Representao grfica de um conjunto de estado (state variveis e os valores aos quais elas se diagram) referem. palavra-chave Palavra reservada usada pelo compilador (keyword) para analisar o programa; voc no pode usar palavras-chave como if, def, e while como nomes de variveis. operador Smbolo especial que representa uma (operator) computao simples, como adio, multiplicao ou concatenao de strings. operando Um dos valores sobre o qual o operador (operand) opera. expresso Combinao de variveis, operadores e (expression) valores, que representa um resultado nico. avaliar Simplificar uma expresso atravs da (evaluate) realizao de operaes, para produzir um valor nico. diviso inteira Operao que divide um inteiro por outro e (integer resulta em um inteiro. A diviso inteira division) resulta no nmero de vezes que o numerador divisvel pelo denominador e descarta qualquer resto. regras de O conjunto de regras que governa a ordem precedncia em que expresses envolvendo mltiplos (rules of operadores e operandos so avaliadas. precedence) concatenar Juntar dois operandos lado a lado. (concatenate) composio Habilidade de combinar expresses e (composition) comandos simples em expresses e





Captulo 3: Funes

3.1 Chamadas de funesVoc j viu um exemplo de uma chamada de funo:>>> type('32')

string:

Finalmente, a funo str converte para o tipo

>>> str(32) '32' >>> str(3.14149) '3.14149'

O nome da funo type e ela exibe o tipo de um valor ou varivel. O valor ou varivel, que chamado de argumento da funo, tem que vir entre parnteses. comum se dizer que uma funo 'recebe' um valor e 'retorna' um resultado. O resultado chamado de valor de retorno. Em vez de imprimir um valor de retorno, podemos atribui-lo a uma varivel:>>> bia = type('32') >>> print bia

Pode parecer curioso que Python faa distino entre o valor inteiro 1 e o valor em ponto flutuante 1.0. Eles podem representar o mesmo nmero, mas pertencem a tipos diferentes. A razo que eles so representados de modo diferente dentro do computador.

3.3 Coero entre tipos

Agora que podemos converter entre tipos, temos outra maneira de lidar com a diviso inteira. Voltando ao exemplo Como outro exemplo, a funo id recebe um do captulo anterior, suponha que queiramos calcular a frao valor ou uma varivel e retorna um inteiro, que atua como um de hora que j passou. A expresso mais bvia, minuto / 60, identificador nico para aquele valor: faz aritmtica inteira, assim, o resultado sempre 0, mesmo aos 59 minutos passados da hora. >>> id(3)134882108 >>> bia = 3 >>> bia(beth) 134882108

Uma soluo converter minuto para ponto flutuante e fazer a diviso em ponto flutuante:>>> minuto = 59 >>> float(minuto) / 60 0.983333333333

Todo valor tem um id, que um nmero nico relacionado ao local onde ele est guardado na memria do Opcionalmente, podemos tirar vantagem das computador. O id de uma varivel o id do valor a qual ela se regras de converso automtica entre tipos, chamada de refere. coero de tipos. Para os operadores matemticos, se qualquer operando for um float, o outro automaticamente convertido para float:

3.2 Converso entre tipos

Python prov uma coleo de funes nativas que convertem valores de um tipo em outro. A funo int recebe um valor e o converte para inteiro, se possvel, ou, se no, reclama:>>> int('32') 32 >>> int('Al') ValueError: invalid literal for int() : Al

>>> minuto = 59 >>> minuto / 60.0 0.983333333333

Fazendo o denominador um float, foramos o Python a fazer a diviso em ponto flutuante.

3.4 Funes matemticas

int tambm pode converter valores em ponto flutuante para inteiro, mas lembre que isso trunca a parte Em matemtica, voc provavelmente j viu funes como seno (sin) e log, e aprendeu a resolver expresses como sin(pi/ fracionria: 2) e log(1/x). Primeiro voc resolve e expresso entre >>> int(3.99999) parnteses (o argumento). Por exemplo, pi/2 3 aproximadamente 1,571, e 1/x 0.1 (se x for 10,0). A voc avalia a funo propriamente dita, seja procurando numa tabela ou realizando vrios clculos. O sin A funo float converte inteiros e strings em de 1,571 1 e o log de 0,1 -1 (assumindo que log indica o nmeros em ponto flutuante: logaritmo na base 10).>>> float(32) 32.0 >>> float('3.14159') 3.14159 >>> int(-2.3) -2

Este processo pode ser aplicado repetidamente para avaliar expresses mais complicadas, como log(1/sin(pi/2)). Primeiro voc avalia o argumento na funo mais interna, depois avalia a funo e assim por diante. Captulo 3: Funes #25

Como pensar como um cientista da Computao usando Python Python tem um mdulo matemtico que prov a No contexto de programao, funo uma maioria das funes matemticas mais familiares. Um mdulo seqncia nomeada de instrues ou comandos, que realizam um arquivo que contm uma coleo de funes uma operao desejada. Esta operao especificada numa relacionadas agrupadas juntas. definio de funo. At agora, as funes que usamos neste livro so pr-definidas e suas definies no foram Antes de podermos usar as funes contidas em apresentadas. Isso demonstra que podemos usar funes sem um mdulo, temos de import-lo: ter que nos preocupar com os detalhes de suas definies.>>> import math

Para chamar uma das funes, temos que especificar o nome do mdulo e o nome da funo, separados por um ponto. Esse formato chamado de notao de ponto:>>> decibel = math.log10(17.0) >>> angulo = 1.5 >>> altura = math.sin(angulo)

A sintaxe para uma definio de funo :def NOME( LISTA DE PARAMETROS ) : COMANDOS

A primeira instruo atribui a decibel o Uma funo pode ter quantos comandos forem logaritmo de 17 na base 10. Existe tambm uma funo necessrios, mas eles precisam ser endentados a partir da chamada log, que pega o logaritmo na base e. margem esquerda. Nos exemplos deste livro, usaremos uma A terceira instruo encontra o seno do valor da endentao de dois espaos. varivel angulo. sin e as outras funes trigonomtricas (cs, As primeiras funes que vamos mostrar no tan, etc.) recebem argumentos em radianos. Para converter de tero parmetros, ento, a sintaxe ter esta aparncia: graus em radianos, divida por 360 e multiplique por 2*pi. Por exemplo, para encontrar o seno de 45 graus, primeiro calcule def novaLinha(): o ngulo em radianos e depois ache o seno: print Esta funo chamada de novaLinha. Os parnteses vazios indicam que ela no tem parmetros. Contm apenas um nico comando, que gera como sada um caractere de nova linha (isso o que acontece quando voc A constante pi tambm parte do mdulo math. usa um comando print sem qualquer argumento). Se voc sabe geometria, pode checar o resultado anterior A sintaxe para a chamada desta nova funo a comparando-o com a raiz quadrada de dois dividido por dois: mesma sintaxe para as funes nativas:>>> graus = 45 >>> angulo = graus * 2 * math.pi / 360.0 >>> math.sin(angulo) 0.707106781187 >>> math.sqrt(2) / 2.0 0.707106781187 print 'Primeira Linha.' novaLinha() print 'Segunda Linha.'

Voc pode usar o nome que quiser para as funes que criar, exceto as palavras reservadas do Python. A lista de parmetros especifica que informao, se houver alguma, voc tem que fornecer para poder usar a nova funo.

3.5 Composio

A sada deste programa :Primeira Linha.

Do mesmo modo como nas funes matemticas, as funes Segunda Linha. do Python podem ser compostas, o que significa que voc Observe o espao extra entre as duas linhas. E pode usar uma expresso como parte de outra. Por exemplo, voc pode usar qualquer expresso como um argumento para se quisssemos mais espao entre as linhas? Poderamos chamar a mesma funo repetidamente: uma funo:>>> x = math.cos(angulo + pi/2)

Esta instruo toma o valor de pi, divide-o por 2, e soma o resultado ao valor de angulo. A soma ento passada como um argumento para a funo cos.

Voc tambm pode pegar o resultado de uma Ou poderamos escrever uma nova funo funo e pass-lo como um argumento para outra: chamada tresLinhas, que produzisse trs novas linhas:>>> x = math.exp(math.log(10.0))

print 'Primeira Linha.' novaLinha() novaLinha() novaLinha() print 'Segunda Linha.'

Esta instruo encontra o logaritmo base e de 10 e ento eleva e quela potncia. O resultado atribudo a x.

def tresLinhas() : novaLinha() novaLinha() novaLinha() print 'Primeira Linha.' tresLinhas() print 'Segunda Linha.'

3.6 Adicionando novas funes

At aqui, temos utilizado somente as funes que vm com Esta funo contm trs comandos, todos com Python, mas tambm possvel adicionar novas funes. Criar novas funes para resolver seus prprios problemas uma recuo de dois espaos a partir da margem esquerda. J que o das coisas mais teis de uma linguagem de programao de prximo comando no est endentado, Python reconhece que ele no faz parte da funo. propsito geral.

Captulo 3: Funes #26

Como pensar como um cientista da Computao usando Python Algumas coisas que devem ser observadas sobre este programa: 1.

3.8 Fluxo de execuo

Voc pode chamar o mesmo procedimento Para assegurar que uma funo esteja definida antes do seu repetidamente. Isso muito comum, alm de til. primeiro uso, preciso saber em que ordem os comandos so 2. Voc pode ter uma funo chamando outra funo; executados, o que chamado de fluxo de execuo. neste caso tresLinhas chama novaLinha. A execuo sempre comea com o primeiro Pode no estar claro, at agora, de que vale o comando do programa. Os comandos so executados um de esforo de criar novas funes - existem vrias razes, mas cada vez, pela ordem, de cima para baixo. este exemplo demonstra duas delas: As definies de funo no alteram o fluxo de execuo do programa, mas lembre-se que comandos dentro Criar uma nova funo permite que voc coloque nome em um grupo de comandos. As funes podem da funo no so executados at a funo ser chamada. simplificar um programa ao ocultar uma computao Embora no seja comum, voc pode definir uma funo complexa por trs de um simples comando cujo nome dentro de outra. Neste caso, a definio mais interna no pode ser uma palavra em portugus, em vez de algum executada at que a funo mais externa seja chamada. cdigo misterioso. Chamadas de funo so como um desvio no fluxo de execuo. Em vez de ir para o prximo comando, o Criar uma nova funo pode tornar o programa menor, por eliminar cdigo repetido. Por exemplo, fluxo salta para a primeira linha da funo chamada, executa um atalho para 'imprimir' nove novas linhas todos os comandos l e ento volta atrs para retomar de onde havia deixado. consecutivas chamar tresLinhas trs vezes. Parece muito simples, at a hora em que voc Como exerccio, escreva uma funo chamada noveLinhas que use tresLinhas para imprimir nove linhas lembra que uma funo pode chamar outra. Enquanto estiver em branco. Como voc poderia imprimir vinte e sete novas no meio de uma funo, o programa poderia ter de executar os comandos em uma outra funo. Mas enquanto estivesse linhas? executando esta nova funo, o programa poderia ter de executar ainda outra funo!

3.7 Definies e uso

Felizmente, Python adepto de monitorar a posio onde est, assim, cada vez que uma funo se Reunindo os fragmentos de cdigo da Seo 3.6, o programa completa, o programa retoma de onde tinha parado na funo que a chamou. Quando chega ao fim do programa, ele completo fica assim: termina.def novaLinha() : print def tresLinhas() : novaLinha() novaLinha() novaLinha() print 'Primeira Linha.' tresLinhas() print 'Segunda Linha.'

Qual a moral dessa histria srdida? Quando voc ler um programa, no o leia de cima para baixo. Em vez disso, siga o fluxo de execuo.

3.9 Parmetros e argumentos

Algumas das funes nativas que voc j usou requerem argumentos, aqueles valores que controlam como a funo faz seu trabalho. Por exemplo, se voc quer achar o seno de um Esse programa contm duas definies de nmero, voc tem que indicar qual nmero . Deste modo, sin funes: novaLinha e tresLinhas. Definies de funes so recebe um valor numrico como um argumento. executadas como quaisquer outros comandos, mas o efeito Algumas funes recebem mais de um criar a nova funo. Os comandos dentro da definio da argumento. Por exemplo, pow recebe dois argumentos, a base funo no so executados at que a funo seja chamada, e o expoente. Dentro da funo, os valores que lhe so logo, a definio da funo no gera nenhuma sada. passados so atribudos a variveis chamadas parmetros. Como voc j deve ter imaginado, preciso Veja um exemplo de uma funo definida pelo criar uma funo antes de poder execut-la. Em outras usurio, que recebe um parmetro: palavras, a definio da funo tem que ser executada antes def imprimeDobrado(bruno): que ela seja chamada pela primeira vez. Como exerccio, mova as ltimas trs linhas Esta funo recebe um nico argumento e o deste programa para o topo, de modo que a chamada da funo aparea antes das definies. Rode o programa e veja atribui a um parmetro chamado bruno. O valor do parmetro (a essa altura, no sabemos qual ser) impresso duas vezes, que mensagem de erro voc ter. seguido de uma nova linha. Estamos usando bruno para Tambm a ttulo de exerccio, comece com a mostrar que o nome do parmetro deciso sua, mas claro que verso que funciona do programa e mova a definio de melhor escolher um nome que seja mais ilustrativo. novaLinha para depois da definio de tresLinhas. O que A funo imprimeDobrado funciona para acontece quando voc roda este programa? qualquer tipo que possa ser impresso:print bruno, bruno


Como pensar como um cientista da Computao usando Python>>> imprimeDoobrado('Spam') Spam Spam >>> imprimeDobrado(5) 5 5 >>> imprimeDobrado(3.14159) 3.14159 3.14159

Quando a funo concatDupla termina, a varivel concat destruda. Se tentarmos imprimi-la, teremos um erro:>>> print concat NameError: concat

Parmetros so sempre locais. Por exemplo, fora Na primeira chamada da funo, o argumento da funo imprimeDobrado, no existe alguma coisa chamada uma string. Na segunda, um inteiro. Na terceira um float. bruno. Se voc tentar utiliz-la, Python vai reclamar. As mesmas regras de composio que se aplicam a funes nativas tambm se aplicam s funes definidas pelo usurio, assim, podemos usar qualquer tipo de 3.11 Diagramas da pilha expresso como um argumento para imprimeDobrado:>>> imprimeDobrado('Spam'*4) SpamSpamSpamSpam SpamSpamSpamSpam >>> imprimeDobrado(math.cos(math.pi)) -1.0 -1.0

Para entender que variveis podem ser usadas aonde, s vezes til desenhar um diagrama da pilha. Como os diagramas de estado, diagramas da pilha mostram o valor de cada varivel, mas tambm a funo qual cada varivel pertence.

Como acontece normalmente, a expresso Cada funo representada por um frame avaliada antes da execuo da funo, assim imprimeDobrado (quadro). Um frame uma caixa com o nome de uma funo imprime SpamSpamSpamSpam SpamSpamSpamSpam em vez ao lado dela e os parmetros e variveis da funo dentro dela. de 'Spam'*4 'Spam'*4. O diagrama de pilha para o exemplo anterior tem a seguinte Como exerccio, escreva um chamada a aparncia: imprimeDobrado que imprima 'Spam'*4 'Spam'*4. Dica: strings podem ser colocadas tanto entre aspas simples quanto duplas e o tipo de aspas que no for usado para envolver a string pode ser usado dentro da string, como parte dela. argumento: Tambm podemos usar uma varivel como

>>> miguel = 'Eric, the half a bee.' >>> imprimeDobrado(miguel) Eric, the half a bee. Eric, the half a bee.

N.T.: "Eric, the half a bee" uma msica do grupo humorstico britnico Monty Python. A linguagem Python foi batizada em homenagem ao grupo e, por isso, os A ordem da pilha mostra o fluxo de execuo. programadores gostam de citar piadas deles em seus imprimeDobrado foi chamado por concatDupla, e exemplos. concatDupla foi chamado por __main__ (principal), que um nome especial para a funo mais no topo. Quando voc cria Repare numa coisa importante: o nome da uma varivel fora de qualquer funo, ela pertence varivel que passamos como um argumento (miguel) no tem __main__. nada a ver com o nome do parmetro (bruno). No importa de que modo o valor foi chamado de onde veio (do 'chamador'); Cada parmetro se refere ao mesmo valor que o aqui, em imprimeDobrado, chamamos a todo mundo de bruno. seu argumento correspondente. Assim, parte1 tem o mesmo valor de canto1, parte2 tem o mesmo valor de canto2 e bruno tem o mesmo valor de concat.

3.10 Variveis e parmetros so locais

Se um erro acontece durante uma chamada de funo, Python imprime o nome da funo, e o nome da Quando voc cria uma varivel local dentro de uma funo, funo que a chamou, e o nome da funo que chamou a que ela s existe dentro da funo e voc no pode us-la fora de chamou, percorrendo todo o caminho de volta a __main__. l. Por exemplo: Por exemplo, se tentssemos acessar concat de def concatDupla(parte1, parte2) dentro de imprimeDobrado, teramos um NameError:concat = parte1 + parte2 imprimeDobrado(concat)

Esta funo recebe dois argumentos, concatenaos, e ento imprime o resultado duas vezes. Podemos chamar a funo com duas strings:>>> canto1 = 'Pie Jesu domine, ' >>> canto2 = 'dona eis requiem. ' >>> concatDupla(canto1, canto2) Pie Jesu domine, Dona eis requiem. Pie Jesu domine, \ Dona eis requiem.

Traceback (innermost last): File "teste.py", line 13, in __main__ concatDupla(canto1, canto2) File "teste.py", line 5, in concatDupla imprimeDobrado(concat) File "teste.py", line 9, in imprimeDobrado print concat NameError: concat

Esta lista de funes chamada de traceback. Ela mostra em qual arquivo de programa o erro ocorreu, em que linha, e quais funes estavam sendo executadas naquele


Como pensar como um cientista da Computao usando Python momento. Mostra tambm a linha de cdigo que causou o erro. Note a similaridade entre o traceback e o diagrama da pilha; no coincidncia. podem ou no retornar valores. definio de Comando que cria uma nova funo, funo especificando seu nome, parmetros e (function comandos que ela executa. definition) fluxo de A ordem na qual os comandos so execuo (flow executados durante a execuo do of execution) programa. parmetro Nome usado numa funo para referir-se (parameter) ao valor passado como argumento. varivel local Varivel definida dentro da funo. Uma (local variable) varivel local s pode ser usada dentro da funo onde foi definida. diagrama da Representao grfica da pilha de funes, pilha (stack suas variveis e os valores aos quais elas diagram) se referem. frame Retngulo no diagrama da pilha que representa uma chamada de funo. Contm as variveis locais e os parmetros da funo. traceback Lista de funes que esto em execuo, impressa quando um erro de execuo ocorre.

3.12 Funes com resultadosA essa altura, voc deve ter percebido que algumas das funes que estamos usando, tais como as funes matemticas, produzem resultados. Outras funes, como novaLinha, executam uma ao, mas no retornam um valor. O que levanta algumas questes: 1. O que acontece se voc chama uma funo e no faz nada com o resultado (por exemplo, no atribui o resultado a uma varivel ou o usa como parte de uma expresso maior)? O que acontece se voc usa uma funo que no produz resultado em uma expresso tal como novaLinha() + 7? Voc pode escrever funes que produzem resultados, ou est preso a funes como novaLinha e imprimeDobrado?

2.

3.

A resposta para a terceira questo afirmativa e ns vamos fazer isso no Captulo 5. A ttulo de exerccio, responda as outras duas questes testando-as. Se tiver dvida sobre o que vlido ou invlido em Python, tente buscar a resposta perguntando ao interpretador.

3.13 Glossriochamada de Comando que executa uma funo. funo Consiste do nome da funo seguido de (function call) uma lista de argumentos entre parnteses. argumento Valor fornecido a uma funo quando ela (argument) chamada. Este valor atribudo ao parmetro correspondente na funo. valor de O resultado da funo. Se uma chamada retorno (return de funo usada como expresso, o value) valor de retorno o valor da expresso. converso de Comando explcito que pega um valor de tipo (type um tipo e devolve o valor correspondente conversion) em outro tipo. coercividade de Uma converso de tipo que ocorre tipo (type automaticamente, de acordo com as regras coercion) de coercividade do Python. mdulo Arquivo que contm uma coleo de (module) funes e classes relacionadas entre si. notao de A sintaxe para chamar uma funo que ponto (dot est em outro mdulo, especificando o notation) nome do mdulo, seguido por um ponto (.) e o nome da funo. funo Seqncia de comandos nomeada, que (function) realiza alguma tarefa til. As funes podem ou no receber parmetros e Captulo 3: Funes #29




Captulo 4: Condicionais e recursividade

4.1 O operador mduloO operador mdulo trabalha com inteiros (e expresses que tm inteiros como resultado) e produz o resto da diviso do primeiro pelo segundo. Em Python, o operador mdulo um smbolo de porcentagem (%). A sintaxe a mesma que a de outros operadores:>>> >>> 2 >>> >>> 1 quociente = 7 / 3 print quociente resto = 7 % 3 print resto

4.3 Operadores lgicosExistem trs operadores lgicos: and, or, not (e, ou, no). A semntica (significado) destes operadores similar aos seus significados em ingls (ou portugus). Por exemplo, x > 0 and x < 10 verdadeiro somente se x for maior que 0 e menor que 10. n%2 == 0 or n%3 == 0 verdadeiro se qualquer das condies for verdadeira, quer dizer, se o nmero n for divisvel por 2 ou por 3. Finalmente, o operador lgico not nega uma expresso booleana, assim, not(x > y) verdadeiro se (x > y) for falso, quer dizer, se x for menor ou igual a y.

A rigor, os operandos de operadores lgicos O operador mdulo se revela deveriam ser expresses booleanas, mas Python no muito surpreendentemente til. Por exemplo, voc pode checar se rigoroso. Qualquer nmero diferente de zero interpretado um nmero divisvel por outro - se x % y d zero, ento x como verdadeiro (True): divisvel por y. Voc tambm pode extrair o algarismo ou algarismos mais direita de um nmero. Por exemplo, x % 10 resulta o algarismo mais direita de x (na base 10). Similarmente, x % 100 resulta nos dois dgitos mais direita.>>> >>> 1 >>> >>> 0 x = 5 x and 1 y = 0 y and 1

Ento, 7 dividido por 3 2 e o resto 1.

4.2 Expresses booleanasUma expresso booleana uma expresso que verdadeira (true) ou falsa (false). Em Python, uma expresso que verdadeira tem o valor 1, e uma expresso que falsa tem o valor 0.

Em geral, esse tipo de coisa no considerado de bom estilo. Se voc precisa comparar um valor com zero, deve faz-lo explicitamente.

4.4 Execuo condicional

O operador == compara dois valores e produz Para poder escrever programas teis, quase sempre precisamos da habilidade de checar condies e mudar o comportamento uma expresso booleana: do programa de acordo com elas. As instrues condicionais >>> 5 == 5 nos do essa habilidade. A forma mais simples a instruo if True (se):print "x positivo" No primeiro comando, os dois operadores so A expresso booleana depois da instruo if iguais, ento a expresso avalia como True (verdadeiro); no segundo comando, 5 no igual a 6, ento temos False (falso). chamada de condio. Se ela verdadeira (true), ento a instruo endentada executada. Se no, nada acontece. O operador == um dos operadores de Assim como outras instrues compostas, a comparao; os outros so: instruo if constituda de um cabealho e de um bloco de x != y # x diferente de y instrues: x x x x > y < y >= y >> 5 == 6 False if x > 0

Embora esses operadores provavelmente sejam familiares a voc, os smbolos em Python so diferentes dos smbolos da matemtica. Um erro comum usar um sinal de igual sozinho (=) em vez de um duplo (==). Lembre-se de que = um operador de atribuio e == um operador de comparao. Tambm no existem coisas como =< ou =>.

O cabealho comea com uma nova linha e termina com dois pontos (:). Os comandos ou instrues endentados que seguem so chamados de bloco. A primeira instruo no endentada marca o fim do bloco. Um bloco de comandos dentro de um comando composto ou inst

Documents

Pensando Em Python Como Um Cientista Da Computacao