├── .github └── workflows │ └── build_spell.yml ├── .gitignore ├── LICENSE ├── Makefile ├── README.rst ├── new_words_spell_checker.txt ├── requirements.txt └── source ├── boas_praticas.rst ├── calculadora.rst ├── condicionais.rst ├── conf.py ├── contribuidores.rst ├── controle.rst ├── desafios_controle.rst ├── desafios_string.rst ├── desafios_variaveis.rst ├── dicionarios.rst ├── epilogo.rst ├── exercicios.rst ├── exercicios_calculadora_expressoes.rst ├── exercicios_calculadora_operadores.rst ├── exercicios_controle.rst ├── exercicios_dicionario.rst ├── exercicios_funcoes.rst ├── exercicios_input.rst ├── exercicios_listas.rst ├── exercicios_repeticao.rst ├── exercicios_string.rst ├── exercicios_variaveis.rst ├── funcoes.rst ├── hello_world.rst ├── images ├── H4l_mass_v3.png ├── cluster.jpg ├── exemplo_sol.png ├── ide_Atom.png ├── ide_pycharm.png ├── ide_spyder.png ├── ide_vsc.png ├── idle1.png ├── idle2.png ├── idle3.png ├── idle4.png ├── idle5.png ├── idle6.png ├── indices.png ├── install1.png ├── ipython.png ├── leds.jpg ├── logo.png ├── logo_small.png ├── python_shell.png ├── recursion.png ├── sobre │ ├── bar01.jpg │ ├── bar02.jpg │ ├── caipyras01.jpg │ ├── caipyras02.jpg │ ├── caipyras03.jpg │ ├── caipyras04.jpg │ ├── curso01.jpg │ ├── curso02.jpg │ ├── curso03.jpg │ ├── curso04.jpg │ ├── dojo01.jpg │ ├── dojo02.jpg │ ├── palestras01.jpg │ ├── palestras02.jpg │ ├── sprint01.jpg │ └── sprint02.jpg └── thesims4.jpg ├── index.rst ├── input.rst ├── instalacao.rst ├── introducao.rst ├── lambda.rst ├── listas.rst ├── prefacio.rst ├── range.rst ├── repeticao.rst ├── sobre_grupy.rst ├── strings.rst └── variaveis.rst /.github/workflows/build_spell.yml: -------------------------------------------------------------------------------- 1 | name: Build and spell check 2 | 3 | on: [pull_request, push] 4 | 5 | jobs: 6 | build: 7 | runs-on: ubuntu-latest 8 | steps: 9 | - uses: actions/checkout@v2 10 | - name: Set up Python 11 | uses: actions/setup-python@v2 12 | with: 13 | python-version: 3.9 14 | - name: Install dependencies 15 | run: | 16 | sudo apt update 17 | sudo apt install -y texlive-latex-recommended \ 18 | texlive-fonts-recommended \ 19 | texlive-latex-extra \ 20 | texlive-lang-portuguese \ 21 | latexmk \ 22 | hunspell \ 23 | hunspell-pt-br \ 24 | enchant-2 \ 25 | python3-enchant 26 | - name: Install pydependencies 27 | run: pip install -r requirements.txt 28 | - name: Build HTML 29 | run: SPHINXOPTS="-t instructors -nWT" make html 30 | - name: Build PDF 31 | run: SPHINXOPTS="-t instructors -nWT" make latexpdf 32 | - name: Spell check 33 | run: sphinx-build -b spelling -nW source/ build/ 34 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | #####=== IPythonNotebook ===##### 2 | # Temporary data 3 | .ipynb_checkpoints/ 4 | 5 | #####=== Vim ===##### 6 | [._]*.s[a-w][a-z] 7 | [._]s[a-w][a-z] 8 | *.un~ 9 | Session.vim 10 | .netrwhist 11 | *~ 12 | 13 | #####=== Python ===##### 14 | # Virtual envs 15 | venv 16 | .venv 17 | 18 | # Byte-compiled / optimized / DLL files 19 | __pycache__/ 20 | *.py[cod] 21 | *$py.class 22 | 23 | # C extensions 24 | *.so 25 | 26 | # Distribution / packaging 27 | .Python 28 | env/ 29 | build/ 30 | develop-eggs/ 31 | dist/ 32 | downloads/ 33 | eggs/ 34 | .eggs/ 35 | lib/ 36 | lib64/ 37 | parts/ 38 | sdist/ 39 | var/ 40 | *.egg-info/ 41 | .installed.cfg 42 | *.egg 43 | 44 | # PyInstaller 45 | # Usually these files are written by a python script from a template 46 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 47 | *.manifest 48 | *.spec 49 | 50 | # Installer logs 51 | pip-log.txt 52 | pip-delete-this-directory.txt 53 | 54 | # Unit test / coverage reports 55 | htmlcov/ 56 | .tox/ 57 | .coverage 58 | .coverage.* 59 | .cache 60 | nosetests.xml 61 | coverage.xml 62 | *,cover 63 | 64 | # Translations 65 | *.mo 66 | *.pot 67 | 68 | # Django stuff: 69 | *.log 70 | 71 | # Sphinx documentation 72 | _build/ 73 | 74 | # PyBuilder 75 | target/ 76 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License 2 | 3 | By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License (Public License). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions. 4 | 5 | Section 1 – Definitions. 6 | 7 | Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image. 8 | Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License. 9 | BY-NC-SA Compatible License means a license listed at creativecommons.org/compatiblelicenses, approved by Creative Commons as essentially the equivalent of this Public License. 10 | Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights. 11 | Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements. 12 | Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material. 13 | License Elements means the license attributes listed in the name of a Creative Commons Public License. The License Elements of this Public License are Attribution, NonCommercial, and ShareAlike. 14 | Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License. 15 | Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license. 16 | Licensor means the individual(s) or entity(ies) granting rights under this Public License. 17 | NonCommercial means not primarily intended for or directed towards commercial advantage or monetary compensation. For purposes of this Public License, the exchange of the Licensed Material for other material subject to Copyright and Similar Rights by digital file-sharing or similar means is NonCommercial provided there is no payment of monetary compensation in connection with the exchange. 18 | Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them. 19 | Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world. 20 | You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning. 21 | 22 | Section 2 – Scope. 23 | 24 | License grant. 25 | Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to: 26 | reproduce and Share the Licensed Material, in whole or in part, for NonCommercial purposes only; and 27 | produce, reproduce, and Share Adapted Material for NonCommercial purposes only. 28 | Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions. 29 | Term. The term of this Public License is specified in Section 6(a). 30 | Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material. 31 | Downstream recipients. 32 | Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License. 33 | Additional offer from the Licensor – Adapted Material. Every recipient of Adapted Material from You automatically receives an offer from the Licensor to exercise the Licensed Rights in the Adapted Material under the conditions of the Adapter’s License You apply. 34 | No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material. 35 | No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i). 36 | 37 | Other rights. 38 | Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise. 39 | Patent and trademark rights are not licensed under this Public License. 40 | To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties, including when the Licensed Material is used other than for NonCommercial purposes. 41 | 42 | Section 3 – License Conditions. 43 | 44 | Your exercise of the Licensed Rights is expressly made subject to the following conditions. 45 | 46 | Attribution. 47 | 48 | If You Share the Licensed Material (including in modified form), You must: 49 | retain the following if it is supplied by the Licensor with the Licensed Material: 50 | identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated); 51 | a copyright notice; 52 | a notice that refers to this Public License; 53 | a notice that refers to the disclaimer of warranties; 54 | a URI or hyperlink to the Licensed Material to the extent reasonably practicable; 55 | indicate if You modified the Licensed Material and retain an indication of any previous modifications; and 56 | indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License. 57 | You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information. 58 | If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable. 59 | ShareAlike. 60 | 61 | In addition to the conditions in Section 3(a), if You Share Adapted Material You produce, the following conditions also apply. 62 | The Adapter’s License You apply must be a Creative Commons license with the same License Elements, this version or later, or a BY-NC-SA Compatible License. 63 | You must include the text of, or the URI or hyperlink to, the Adapter's License You apply. You may satisfy this condition in any reasonable manner based on the medium, means, and context in which You Share Adapted Material. 64 | You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, Adapted Material that restrict exercise of the rights granted under the Adapter's License You apply. 65 | 66 | Section 4 – Sui Generis Database Rights. 67 | 68 | Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material: 69 | 70 | for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database for NonCommercial purposes only; 71 | if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material, including for purposes of Section 3(b); and 72 | You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database. 73 | 74 | For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights. 75 | 76 | Section 5 – Disclaimer of Warranties and Limitation of Liability. 77 | 78 | Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You. 79 | To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You. 80 | 81 | The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability. 82 | 83 | Section 6 – Term and Termination. 84 | 85 | This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically. 86 | 87 | Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates: 88 | automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or 89 | upon express reinstatement by the Licensor. 90 | For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License. 91 | For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License. 92 | Sections 1, 5, 6, 7, and 8 survive termination of this Public License. 93 | 94 | Section 7 – Other Terms and Conditions. 95 | 96 | The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed. 97 | Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License. 98 | 99 | Section 8 – Interpretation. 100 | 101 | For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License. 102 | To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions. 103 | No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor. 104 | Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority. 105 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # Minimal makefile for Sphinx documentation 2 | # 3 | 4 | # You can set these variables from the command line. 5 | # SPHINXOPTS = 6 | SPHINXBUILD = python -msphinx 7 | SPHINXPROJ = CursoIntrodutriodePython 8 | SOURCEDIR = source 9 | BUILDDIR = build 10 | 11 | # Put it first so that "make" without argument is like "make help". 12 | help: 13 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 14 | 15 | .PHONY: help Makefile 16 | 17 | # Run doctests 18 | test: 19 | @$(SPHINXBUILD) -b doctest -n "$(SOURCEDIR)" "$(BUILDDIR)" 20 | 21 | # Run spellcheck 22 | check: 23 | @$(SPHINXBUILD) -b spelling -n "$(SOURCEDIR)" "$(BUILDDIR)" 24 | 25 | # Catch-all target: route all unknown targets to Sphinx using the new 26 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). 27 | %: Makefile 28 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 29 | -------------------------------------------------------------------------------- /README.rst: -------------------------------------------------------------------------------- 1 | Python Course 2 | ============= 3 | 4 | .. image:: https://readthedocs.org/projects/curso-python/badge/?version=latest 5 | :target: https://readthedocs.org/projects/curso-python/builds/ 6 | :alt: Documentation Status 7 | 8 | .. image:: https://github.com/grupy-sanca/curso-python/actions/workflows/build_spell.yml/badge.svg 9 | :target: https://github.com/grupy-sanca/curso-python/actions/workflows/build_spell.yml?query=branch%3Amaster 10 | :alt: Documentation Status 11 | 12 | This repo contains the material for the Introductory Python course created by grupy-sanca. 13 | 14 | All the material is in pt-br. 15 | 16 | Check the material `online here `_. 17 | 18 | Find us in `Facebook `_, 19 | `Telegram `_, 20 | `Discord `_, 21 | `Instagram `_, 22 | `Linkedin `_, 23 | `Meetup `_ and 24 | `YouTube `_ 25 | 26 | 27 | How to use locally 28 | ------------------ 29 | 30 | 1. Install requirements: 31 | 32 | .. code:: sh 33 | 34 | $ python -m venv env 35 | $ source env/bin/activate 36 | $ pip install -Ur requirements.txt 37 | 38 | You also need `enchant `_, 39 | `pyenchant `_ and a pt-br dictionary 40 | (e.g. `hunspell-pt-br `_) for spell checker. 41 | 42 | .. code:: sh 43 | 44 | # On macOS 45 | $ brew update && brew install enchant 46 | $ export PYENCHANT_LIBRARY_PATH=/opt/homebrew/lib/libenchant-2.dylib 47 | # On Debian based distros (linux Mint, Ubuntu...) 48 | $ sudo apt update && sudo apt install enchant-2 python3-enchant hunspell hunspell-pt-br 49 | 50 | 2. Run the following command to generate the material in HTML: 51 | 52 | .. code:: sh 53 | 54 | $ make html 55 | 56 | Another option is to produce a pdf using latex: 57 | 58 | .. code:: sh 59 | 60 | $ make latexpdf 61 | 62 | 3. To see the material locally open the page ``build/html/index.html`` 63 | in your favorite browser or the file ``build/latex/CursoIntrodutoriodePython.pdf`` 64 | in your favorite pdf viewer. 65 | 66 | 4. To run the spell checker: 67 | 68 | .. code:: sh 69 | 70 | $ sphinx-build -b spelling -nW source/ build/ 71 | 72 | 5. To run doctest: 73 | 74 | .. code:: sh 75 | 76 | $ sphinx-build -b doctest -n source/ build/ 77 | 78 | How to generate instructor's guide 79 | ---------------------------------- 80 | 81 | To generate the HTML: 82 | 83 | .. code:: sh 84 | 85 | $ SPHINXOPTS="-t instructors" make html 86 | 87 | To generate the PDF: 88 | 89 | .. code:: sh 90 | 91 | $ SPHINXOPTS="-t instructors" make latexpdf 92 | 93 | Or both together: 94 | 95 | .. code:: sh 96 | 97 | $ SPHINXOPTS="-t instructors" make latexpdf html 98 | 99 | LaTeX dependencies 100 | ------------------ 101 | 102 | To generate the PDF, you need a modern LaTeX installation like ``texlive``. To 103 | install the minimum packages on ArchLinux (btw): 104 | 105 | .. code:: sh 106 | 107 | $ sudo pacman -Syu texlive-{bin,core,latexextra} 108 | 109 | How to contribute 110 | ----------------- 111 | 112 | Fork this repo, make your changes and open a Pull Request. 113 | 114 | Don't forget to add your name to ``source/contribuidores.rst``. Please, keep the 115 | list in alphabetical order. 116 | 117 | 118 | LICENSE 119 | ------- 120 | 121 | This material is licensed under `Creative Commons CC-BY-NC-SA 4.0 License 122 | `_ 123 | -------------------------------------------------------------------------------- /new_words_spell_checker.txt: -------------------------------------------------------------------------------- 1 | Abelindo 2 | Alanderson 3 | Alonzo 4 | Amazon 5 | Arduino 6 | Bhāskara 7 | Bitcoin 8 | booliana 9 | booliano 10 | break 11 | bug 12 | Caipyra 13 | Church 14 | cluster 15 | Code 16 | Coding 17 | coffee 18 | Commons 19 | CompartilhaIgual 20 | Covid 21 | Creative 22 | criptomoedas 23 | Davinir 24 | Debian 25 | Demival 26 | Disqus 27 | Django 28 | Dojo 29 | Dropbox 30 | email 31 | Enivaldo 32 | Ethereum 33 | Facebook 34 | Geographic 35 | Google 36 | grupy 37 | grupy-sanca 38 | hashrate 39 | Hello 40 | History 41 | indentação 42 | Instagram 43 | Interpolation 44 | IPython 45 | Joilson 46 | Josefson 47 | Karoline 48 | Krissia 49 | listona 50 | Mac 51 | Meetup 52 | Microsoft 53 | Miky 54 | Mozilla 55 | Nakamine 56 | National 57 | network 58 | NãoComercial 59 | Perl 60 | Pylestras 61 | Python 62 | pythonistas 63 | Rondinelly 64 | Rossum 65 | Science 66 | SEnC 67 | Shell 68 | Sims 69 | source 70 | Spotify 71 | Sprint 72 | Sprints 73 | sprints 74 | Spyder 75 | String 76 | Studio 77 | TDD 78 | Technology 79 | Telegram 80 | The 81 | websites 82 | Wikipedia 83 | Windows 84 | workshop 85 | workshops 86 | World 87 | Yahoo 88 | tab 89 | tabs 90 | docstrings 91 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | sphinx>=4.2.0 2 | sphinxcontrib-spelling>=4.2.1 3 | # Fixed version on sphinx-rtd-theme, since >=1.0.0 is fairly new and have some issues. 4 | # See: https://github.com/grupy-sanca/curso-python/pull/108#issuecomment-950395761 for details 5 | sphinx-rtd-theme==0.5.2 6 | sphinxext-opengraph==0.8.2 7 | -------------------------------------------------------------------------------- /source/boas_praticas.rst: -------------------------------------------------------------------------------- 1 | Boas práticas de programação 2 | ============================ 3 | 4 | Uma situação comum para programadores é ler e contribuir com códigos feitos por outras pessoas, por isso a importância da padronização da escrita. 5 | Convenções de escrita de código viabilizam que diversos contribuidores sigam um mesmo padrão, deixando o código mais legível. 6 | As convenções de escrita de código para Python são regidas pela PEP8, disponível em https://peps.python.org/pep-0008/. 7 | Aqui apresentamos algumas convenções básicas para você de início já sair programando como um profissional ;-) 8 | 9 | Nome de funções e variáveis 10 | --------------------------- 11 | **Nome de variáveis** devem receber nomes em letra minúscula com palavras separadas por '_' (*underscore*) caso seja necessário facilitar a leitura. 12 | 13 | **Nomes de funções** seguem o mesma convenção que nomes de funções. 14 | 15 | .. doctest:: 16 | 17 | >>> def soma(numero1, numero2) 18 | ... return numero1 + numero2 19 | 20 | 21 | O uso misturado, ou seja, no qual uma palavra com letras minúsculas é seguido de uma com a primeira letra maiúscula, 22 | é permitido para caso em que o código pré-existente já esteja escrito desta forma, mantendo-se a compatibilidade. 23 | 24 | .. doctest:: 25 | 26 | >>> casoMisto = 20 27 | 28 | 29 | Indentação 30 | ---------- 31 | 32 | A orientação é utilizar 4 espaços por nível de indentação. 33 | Alguns códigos utilizam tab no lugar de espaços. O recomendável é evitar esta prática a menos que se esteja trabalhando em um código antigo em que a indentação já foi feita por tab. A mistura de tabs e espaços **não** deve ser realizada. 34 | 35 | Tamanho da linha 36 | ---------------- 37 | O limite recomendável é 79 caracteres para o código e 72 para comentários e docstrings. 38 | Limitar o tamanho da linha permite que o código seja visualizado melhor na janela, sem quebras e necessidade de 'rolar' para enxergar o que está escrito. 39 | 40 | Quebra de linha em operações 41 | ---------------------------- 42 | No Python é permitido quebrar linhas antes ou depois do operador matemático. O importante é manter a consistência. 43 | Se começar com um padrão siga até o final do código. 44 | 45 | .. doctest:: 46 | 47 | >>> feira = (banana 48 | + abacate 49 | + laranja 50 | + alface) 51 | 52 | >>> feira = (banana + 53 | abacate + 54 | laranja + 55 | alface) 56 | 57 | -------------------------------------------------------------------------------- /source/calculadora.rst: -------------------------------------------------------------------------------- 1 | Python como calculadora 2 | ======================= 3 | 4 | Operadores matemáticos 5 | ---------------------- 6 | 7 | A linguagem Python possui operadores que utilizam símbolos especiais para representar 8 | operações de cálculos, assim como na matemática: 9 | 10 | 11 | - Soma (:math:`+`) 12 | 13 | .. doctest:: 14 | 15 | >>> 2 + 3 16 | 5 17 | 18 | Para utilizar números decimais, use o *ponto* no lugar de vírgula: 19 | 20 | .. doctest:: 21 | 22 | >>> 3.2 + 2.7 23 | 5.9 24 | 25 | - Subtração (:math:`-`) 26 | 27 | .. doctest:: 28 | 29 | >>> 6 - 4 30 | 2 31 | 32 | .. doctest:: 33 | 34 | >>> 7 - 8 35 | -1 36 | 37 | - Multiplicação (:math:`*`) 38 | 39 | .. doctest:: 40 | 41 | >>> 7 * 8 42 | 56 43 | 44 | .. doctest:: 45 | 46 | >>> 2 * 2 * 2 47 | 8 48 | 49 | - Divisão (:math:`/`) 50 | 51 | .. doctest:: 52 | 53 | >>> 100 / 20 54 | 5.0 55 | 56 | .. doctest:: 57 | 58 | >>> 10 / 3 59 | 3.3333333333333335 60 | 61 | E se fizermos uma divisão por zero? 62 | 63 | .. doctest:: 64 | 65 | >>> 2 / 0 66 | Traceback (most recent call last): 67 | File "", line 1, in 68 | ZeroDivisionError: division by zero 69 | 70 | Como não existe um resultado para a divisão pelo número zero, o Python 71 | interrompe a execução do programa (no caso a divisão) e mostra o erro que 72 | aconteceu, ou seja, ``"ZeroDivisionError: divison by zero"``. 73 | 74 | 75 | - Divisão inteira (:math:`//`) 76 | 77 | .. doctest:: 78 | 79 | >>> 10 // 3 80 | 3 81 | >>> 666 // 137 82 | 4 83 | >>> 666 / 137 84 | 4.861313868613139 85 | 86 | 87 | - Resto da divisão (:math:`\%`) 88 | 89 | .. doctest:: 90 | 91 | >>> 10 % 2 92 | 0 93 | >>> 10 % 3 94 | 1 95 | >>> 666 % 137 96 | 118 97 | 98 | 99 | Agora que aprendemos os operadores aritméticos básicos podemos seguir 100 | adiante. Como podemos calcular :math:`2^{10}`? O jeito mais óbvio seria 101 | multiplicar o número dois dez vezes: 102 | 103 | .. doctest:: 104 | 105 | >>> 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 106 | 1024 107 | 108 | Porém, isso não é muito prático, pois há um operador específico para isso, chamado de *potenciação/exponenciação*: :math:`**` 109 | 110 | .. doctest:: 111 | 112 | >>> 2 ** 10 113 | 1024 114 | 115 | .. doctest:: 116 | 117 | >>> 10 ** 3 118 | 1000 119 | 120 | .. doctest:: 121 | 122 | >>> (10 ** 800 + 9 ** 1000) * 233 123 | 407254001651377825050774086265365912933271559572398924650169906751889900030955189004916347478470698880616885512201849445183728845558993514870858509087817789576388584560964682795896403435448681980001360244790530805842737419978616650940647045809688543958807077794866143976192872389017280782837244051514550016751431331392474612723898201318251801288569103581859710953756463227568553903785400053293756105145991925711692828410365978814157929143646138367222515290495329841814490874087309733954914817582614165290441834984054374534909954119315442169415884429645515258867781282214407424938115130906555866837546110340314133204645184212592152733050063403478054121909337278892530383627259086060904403894148963384111173869448637825223750221720739904084905206403076141255284819817001128530851921214720479861908207168928806625713775441834487646542035428141369478170696522098960677314242891140325390964310295889079588950798788612324634050495786532200848059999839607732520233 124 | 125 | E a *raiz quadrada*? 126 | 127 | Lembrando que :math:`\sqrt{x} = x^\frac{1}{2}`, então podemos calcular a raiz 128 | quadrada do seguinte modo: 129 | 130 | .. doctest:: 131 | 132 | >>> 4 ** 0.5 133 | 2.0 134 | 135 | Mas a maneira recomendada para fazer isso é usar a função ``sqrt()`` da 136 | biblioteca ``math``: 137 | 138 | .. doctest:: 139 | 140 | >>> import math 141 | >>> math.sqrt(16) 142 | 4.0 143 | 144 | Na primeira linha do exemplo importamos, da biblioteca padrão do Python, o 145 | módulo ``math`` e então usamos a sua função ``sqrt`` para calcular 146 | :math:`\sqrt{16}` 147 | 148 | E se precisarmos utilizar o número :math:`\pi`? 149 | 150 | .. doctest:: 151 | 152 | >>> math.pi 153 | 3.141592653589793 154 | 155 | Não esqueça que é preciso ter executado ``import math`` antes de usar as funções 156 | e constantes dessa biblioteca. 157 | 158 | Exercícios 159 | ---------- 160 | 161 | .. include:: exercicios_calculadora_operadores.rst 162 | 163 | 164 | Expressões Numéricas 165 | -------------------- 166 | 167 | Agora que já aprendemos diversos operadores, podemos combiná-los e resolver 168 | problemas mais complexos: 169 | 170 | .. doctest:: 171 | 172 | >>> 3 + 4 * 2 173 | 11 174 | 175 | .. doctest:: 176 | 177 | >>> 7 + 3 * 6 - 4 ** 2 178 | 9 179 | 180 | .. doctest:: 181 | 182 | >>> (3 + 4) * 2 183 | 14 184 | 185 | .. doctest:: 186 | 187 | >>> (8 / 4) ** (5 - 2) 188 | 8.0 189 | 190 | Quando mais de um operador aparece em uma expressão, a ordem de avaliação 191 | depende das regras de precedência. 192 | 193 | O Python segue as mesmas regras de precedência da matemática. 194 | O acrônimo **PEMDAS** ajuda a lembrar essa ordem: 195 | 196 | .. spelling:word-list:: 197 | arênteses 198 | xponenciação 199 | ultiplicação 200 | ivisão 201 | dição 202 | ubtração 203 | 204 | #. **P**\ arênteses 205 | 206 | #. **E**\ xponenciação 207 | 208 | #. **M**\ ultiplicação e **D**\ ivisão (mesma precedência) 209 | 210 | #. **A**\ dição e **S**\ ubtração (mesma precedência) 211 | 212 | Notação Científica 213 | ------------------ 214 | 215 | Notação científica em Python usa a letra ``e`` como sendo a 216 | potência de 10: 217 | 218 | .. doctest:: 219 | 220 | >>> 10e6 221 | 10000000.0 222 | >>> 1e6 223 | 1000000.0 224 | >>> 1e-5 225 | 1e-05 226 | 227 | Também pode ser usada a letra ``E`` maiúscula: 228 | 229 | .. doctest:: 230 | 231 | >>> 1E6 232 | 1000000.0 233 | 234 | 235 | Pontos Flutuantes 236 | ----------------- 237 | 238 | Uma consideração importante sobre pontos flutuantes (números decimais). Por exemplo: 239 | 240 | .. doctest:: 241 | 242 | >>> 0.1 243 | 0.1 244 | 245 | É importante perceber que este valor, em um sentido real na máquina, não é exatamente 1/10. Está arredondando a exibição do valor real da máquina. 246 | 247 | .. doctest:: 248 | 249 | >>> format(0.1, '.50f') 250 | '0.10000000000000000555111512312578270211815834045410' 251 | 252 | Veja que somente após a 18ª casa que há diferença. Isso é mais dígitos do que a maioria das pessoas acham úteis, então o Python mantém o número de dígitos gerenciáveis exibindo um valor arredondado 253 | 254 | Este fato se torna aparente assim que você tenta fazer aritmética com esses valores 255 | 256 | .. doctest:: 257 | 258 | >>> 0.1 + 0.2 259 | 0.30000000000000004 260 | 261 | >>> 0.7 - 0.2 262 | 0.49999999999999994 263 | 264 | Note que isso é da mesma natureza do ponto flutuante binário, não é um bug no Python e muito menos um bug no seu código. Você verá o mesmo tipo de coisa em todos os idiomas que suportam a aritmética de ponto flutuante de seu hardware (embora alguns idiomas possam não exibir a diferença por padrão ou em todos os modos de saída). 265 | 266 | Os erros de representação referem-se ao fato de que a maioria das frações decimais não podem ser representadas exatamente como frações binárias (base 2). Essa é a principal razão pela qual o Python (ou Perl, C, C++, Java, Fortran e muitos outros) geralmente não exibe o número decimal exato que é esperado. 267 | 268 | O valor de 1/10 não é exatamente representável como uma fração binária. Quase todas as máquinas atualmente (considerando após novembro de 2000) usam aritmética de ponto flutuante `IEEE-754`_, e quase todas as plataformas mapeiam pontos flutuantes do Python para a `"dupla precisão"` IEEE-754, que contêm 53 bits de precisão. Portanto, na entrada, o computador se esforça para converter 0.1 na fração mais próxima possível da forma ``J/2 ** N``, onde ``J`` é um inteiro contendo exatamente 53 bits. 269 | 270 | .. _IEEE-754: https://pt.wikipedia.org/wiki/IEEE_754 271 | 272 | Exercícios 273 | ---------- 274 | 275 | .. include:: exercicios_calculadora_expressoes.rst 276 | 277 | 278 | Sobre Comentários 279 | ----------------- 280 | 281 | Caso precise explicar alguma coisa feita no código, é possível escrever um texto 282 | (que não será executado), que ajuda a entender ou lembrar o que foi feito. 283 | Esse texto é chamado de comentário, e para escrever um basta utilizar o 284 | caractere ``#``. Exemplo: 285 | 286 | .. doctest:: 287 | 288 | >>> 3 + 4 # será lido apenas o cálculo, do # para frente o interpretador do Python irá ignorar! 289 | 7 290 | 291 | .. doctest:: 292 | 293 | >>> # Aqui vai um código só com comentários! Posso falar o que quiser que não será interpretado, lalala, la-le-li-lo-lu. A job we hate to buy things we don't need. 294 | 295 | 296 | Comparações 297 | ----------- 298 | 299 | Os operadores de comparação em Python são: 300 | 301 | ======== =============== 302 | Operação Significado 303 | ======== =============== 304 | < menor que 305 | <= menor igual que 306 | > maior que 307 | >= maior igual que 308 | == igual 309 | != diferente 310 | ======== =============== 311 | 312 | .. doctest:: 313 | 314 | >>> 2 < 10 315 | True 316 | >>> 2 > 11 317 | False 318 | >>> 10 > 10 319 | False 320 | >>> 10 >= 10 321 | True 322 | >>> 42 == 24 323 | False 324 | >>> 666 != 137 325 | True 326 | >>> 8**2 == 60 + 4 327 | True 328 | >>> 100 != 99 + 3 329 | True 330 | -------------------------------------------------------------------------------- /source/condicionais.rst: -------------------------------------------------------------------------------- 1 | ============ 2 | Condicionais 3 | ============ 4 | 5 | O tipo de dado booliano (``bool``) refere-se a uma unidade lógica sobre a qual 6 | podemos realizar operações, particularmente úteis para o controle de fluxo de um 7 | programa. 8 | 9 | A unidade booliana assume apenas 2 valores: Verdadeiro (``True``) e Falso (``False``). 10 | 11 | .. note:: 12 | 13 | Essa estrutura binária é a forma com a qual o computador opera (0 e 1). 14 | 15 | .. doctest:: 16 | 17 | >>> True 18 | True 19 | >>> type(False) 20 | 21 | 22 | Qualquer expressão lógica retornará um valor booliano: 23 | 24 | .. doctest:: 25 | 26 | >>> 2 < 3 27 | True 28 | >>> 2 == 5 29 | False 30 | 31 | Os operadores lógicos utilizados em programação são: 32 | 33 | * ``>``: maior a, por exemplo 5 > 3 34 | * ``<``: menor a 35 | * ``>=``: maior ou igual a 36 | * ``<=``: menor ou igual a 37 | * ``==``: igual a 38 | * ``!=``: diferente de 39 | 40 | Para realizar operações com expressões lógicas, existem: 41 | 42 | * ``and`` (e): opera segundo a seguinte tabela: 43 | ========== ========== ========== 44 | Valor 1 Valor 2 Resultado 45 | ========== ========== ========== 46 | Verdadeiro Verdadeiro Verdadeiro 47 | Verdadeiro Falso Falso 48 | Falso Verdadeiro Falso 49 | Falso Falso Falso 50 | ========== ========== ========== 51 | * ``or`` (ou): 52 | ========== ========== ========== 53 | Valor 1 Valor 2 Resultado 54 | ========== ========== ========== 55 | Verdadeiro Verdadeiro Verdadeiro 56 | Verdadeiro Falso Verdadeiro 57 | Falso Verdadeiro Verdadeiro 58 | Falso Falso Falso 59 | ========== ========== ========== 60 | * ``not`` (não): 61 | ========== ========== 62 | Valor Resultado 63 | ========== ========== 64 | Verdadeiro Falso 65 | Falso Verdadeiro 66 | ========== ========== 67 | 68 | .. doctest:: 69 | 70 | >>> 10 > 3 and 2 == 4 71 | False 72 | 73 | >>> 10 > 3 or 2 == 4 74 | True 75 | 76 | >>> not not not 1 == 1 77 | False 78 | 79 | Assim como os operadores aritméticos, os operadores boolianos também 80 | possuem uma ordem de prioridade: 81 | 82 | * ``not`` tem maior prioridade que ``and`` que tem maior prioridade 83 | que ``or``: 84 | 85 | .. doctest:: 86 | 87 | >>> not False and True or False 88 | True 89 | -------------------------------------------------------------------------------- /source/conf.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | # 4 | import os 5 | import datetime 6 | # import sys 7 | # sys.path.insert(0, os.path.abspath('.')) 8 | 9 | 10 | # -- General configuration ------------------------------------------------ 11 | 12 | # If your documentation needs a minimal Sphinx version, state it here. 13 | # 14 | # needs_sphinx = '1.0' 15 | 16 | # Add any Sphinx extension module names here, as strings. They can be 17 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom 18 | # ones. 19 | extensions = [ 20 | 'sphinx.ext.todo', 21 | 'sphinx.ext.mathjax', 22 | 'sphinx.ext.doctest', 23 | 'sphinxext.opengraph', 24 | 'sphinxcontrib.spelling' 25 | ] 26 | 27 | # Add any paths that contain templates here, relative to this directory. 28 | templates_path = ['_templates'] 29 | 30 | # The suffix(es) of source filenames. 31 | # You can specify multiple suffix as a list of string: 32 | # 33 | # source_suffix = ['.rst', '.md'] 34 | source_suffix = '.rst' 35 | 36 | # The master toctree document. 37 | master_doc = 'index' 38 | 39 | # General information about the project. 40 | project = 'Curso Introdutório de Python' 41 | copyright = '2017-{}, (CC BY-NC-SA 4.0) Grupy-Sanca'.format(datetime.datetime.now().year) 42 | author = 'Grupy-Sanca' 43 | 44 | # The version info for the project you're documenting, acts as replacement for 45 | # |version| and |release|, also used in various other places throughout the 46 | # built documents. 47 | # 48 | # The short X.Y version. 49 | version = '2.5.2' 50 | # The full version, including alpha/beta/rc tags. 51 | release = version 52 | 53 | today_fmt = '%d de %B de %Y' 54 | 55 | # The language for content autogenerated by Sphinx. Refer to documentation 56 | # for a list of supported languages. 57 | # 58 | # This is also used if you do content translation via gettext catalogs. 59 | # Usually you set "language" from the command line for these cases. 60 | language = 'pt_BR' 61 | 62 | # List of patterns, relative to source directory, that match files and 63 | # directories to ignore when looking for source files. 64 | # This patterns also effect to html_static_path and html_extra_path 65 | exclude_patterns = [] 66 | 67 | # The name of the Pygments (syntax highlighting) style to use. 68 | pygments_style = 'sphinx' 69 | highlight = 'python3' 70 | highlight_language = highlight 71 | 72 | # If true, `todo` and `todoList` produce output, else they produce nothing. 73 | todo_include_todos = True 74 | 75 | # OpenGraph metadata (see https://github.com/wpilibsuite/sphinxext-opengraph#options) 76 | ogp_site_name = project + ' | ' + author 77 | ogp_site_url = 'https://curso.grupysanca.com.br/pt/latest/' 78 | ogp_image = ogp_site_url + '_images/caipyras01.jpg' 79 | 80 | # spell checker stuff 81 | spelling_lang = language 82 | spelling_show_suggestions = True 83 | spelling_word_list_filename = '../new_words_spell_checker.txt' 84 | 85 | # -- Options for HTML output ---------------------------------------------- 86 | 87 | on_rtd = os.environ.get('READTHEDOCS', None) == 'True' 88 | 89 | # The theme to use for HTML and HTML Help pages. See the documentation for 90 | # a list of builtin themes. 91 | # 92 | if not on_rtd: 93 | html_theme = 'sphinx_rtd_theme' 94 | 95 | # Theme options are theme-specific and customize the look and feel of a theme 96 | # further. For a list of options available for each theme, see the 97 | # documentation. 98 | # 99 | # html_theme_options = {} 100 | 101 | # Add any paths that contain custom static files (such as style sheets) here, 102 | # relative to this directory. They are copied after the builtin static files, 103 | # so a file named "default.css" will overwrite the builtin "default.css". 104 | # html_static_path = ['_static'] 105 | 106 | html_logo = 'images/logo_small.png' 107 | 108 | html_title = project + ' | ' + author 109 | 110 | # -- Options for HTMLHelp output ------------------------------------------ 111 | 112 | # Output file base name for HTML help builder. 113 | htmlhelp_basename = 'CursoIntrodutoriodePythonDoc' 114 | 115 | 116 | # -- Options for LaTeX output --------------------------------------------- 117 | 118 | # Overwrite release to not appear in the cover page 119 | release = '' 120 | 121 | latex_elements = { 122 | # The paper size ('letterpaper' or 'a4paper'). 123 | # 'papersize': 'letterpaper', 124 | 125 | # The font size ('10pt', '11pt' or '12pt'). 126 | # 'pointsize': '10pt', 127 | 128 | # remove blank pages (between the title page and the TOC, etc.) 129 | #'classoptions': ',openany,oneside', 130 | 131 | # Babel translation to pb-BR 132 | 'babel': '\\usepackage[brazil]{babel}', 133 | 134 | 'releasename': '', 135 | 136 | # Additional stuff for the LaTeX preamble. 137 | # 138 | 'preamble': r""" 139 | \usepackage[section]{placeins} 140 | \makeatletter 141 | \fancypagestyle{normal}{ 142 | \fancyhf{} 143 | \fancyfoot[LE,RO]{{\py@HeaderFamily\thepage}} 144 | \fancyfoot[LO]{{\py@HeaderFamily\nouppercase{\rightmark}}} 145 | \fancyfoot[RE]{{\py@HeaderFamily\nouppercase{\leftmark}}} 146 | \fancyhead[LE,RO]{{\py@HeaderFamily \@title, grupy-sanca, CC BY-NC-SA 4.0}} 147 | \renewcommand{\headrulewidth}{0.4pt} 148 | \renewcommand{\footrulewidth}{0.4pt} 149 | } 150 | \makeatother 151 | """, 152 | 153 | # Latex figure (float) alignment 154 | # 155 | # 'figure_align': 'htbp', 156 | } 157 | 158 | # Grouping the document tree into LaTeX files. List of tuples 159 | # (source start file, target name, title, 160 | # author, documentclass [howto, manual, or own class]). 161 | latex_documents = [ 162 | (master_doc, 'CursoIntrodutoriodePython.tex', 'Curso Introdutório de Python', 163 | 'Grupy-Sanca', 'manual'), 164 | ] 165 | 166 | latex_logo = 'images/logo.png' 167 | 168 | latex_show_pagerefs = True 169 | 170 | latex_show_urls = 'footnote' 171 | 172 | # -- Options for Epub output ---------------------------------------------- 173 | 174 | # Bibliographic Dublin Core info. 175 | epub_title = project 176 | epub_author = author 177 | epub_publisher = author 178 | epub_copyright = copyright 179 | 180 | # The unique identifier of the text. This can be a ISBN number 181 | # or the project homepage. 182 | # 183 | # epub_identifier = '' 184 | 185 | # A unique identification for the text. 186 | # 187 | # epub_uid = '' 188 | 189 | # A list of files that should not be packed into the epub file. 190 | epub_exclude_files = ['search.html'] 191 | -------------------------------------------------------------------------------- /source/contribuidores.rst: -------------------------------------------------------------------------------- 1 | .. spelling:word-list:: marcelomiky 2 | 3 | Contribuidores 4 | ============== 5 | 6 | Esse material não existiria se não fosse pela contribuição de várias pessoas. 7 | Agradecemos o esforço de todo mundo que escreveu parte do material, que 8 | contribuiu com ideias ou críticas, e a todos que estudaram e aprenderam Python 9 | conosco. 10 | 11 | Lista de pessoas que contribuíram com a criação deste material: 12 | 13 | - Alex Soares Prestes 14 | - Ana Carolina Rodrigues 15 | - Guilherme Martins 16 | - Heitor de Bittencourt 17 | - Juliana Karoline 18 | - Lucas Carvalho 19 | - Luiz Menezes 20 | - Luiz Fernando S. E. Santos 21 | - Marcel T. Nakamine 22 | - Marcelo Miky Mine (Telegram: @marcelomiky / email: marcelo.mine@gmail.com) 23 | - Pablo Pizutti 24 | - Thiago Ferreira 25 | - Tiago Martins 26 | - Víctor Cora Colombo 27 | - Yara Torres de Souza -------------------------------------------------------------------------------- /source/controle.rst: -------------------------------------------------------------------------------- 1 | Estruturas de controle 2 | ====================== 3 | 4 | As estruturas de controle servem para decidir quais blocos de código serão 5 | executados. 6 | 7 | Exemplo: 8 | | Se estiver nublado: 9 | | Levarei guarda-chuva 10 | | Senão: 11 | | Não levarei 12 | 13 | .. note:: 14 | 15 | Na linguagem Python, a indentação (espaço dado antes de uma linha) é 16 | utilizada para demarcar os blocos de código, e são obrigatórios quando 17 | se usa estruturas de controle. 18 | 19 | .. doctest:: 20 | 21 | >>> a = 7 22 | >>> if a > 3: 23 | ... print("estou no if") 24 | ... else: 25 | ... print("cai no else") 26 | ... 27 | estou no if 28 | 29 | Também é possível checar mais de uma condição com o ``elif``. É a abreviatura 30 | para ``else if``. Ou seja, se o ``if`` for falso, testa outra condição antes do 31 | ``else``: 32 | 33 | .. doctest:: 34 | 35 | >>> valor_entrada = 10 36 | >>> if valor_entrada == 1: 37 | ... print("a entrada era 1") 38 | ... elif valor_entrada == 2: 39 | ... print("a entrada era 2") 40 | ... elif valor_entrada == 3: 41 | ... print("a entrada era 3") 42 | ... elif valor_entrada == 4: 43 | ... print("a entrada era 4") 44 | ... else: 45 | ... print("o valor de entrada não era esperado em nenhum if") 46 | ... 47 | o valor de entrada não era esperado em nenhum if 48 | 49 | Note que quando uma condição for verdadeira, aquele bloco de código é executado 50 | e as demais condições (``elif`` e ``else``) são puladas: 51 | 52 | .. doctest:: 53 | 54 | >>> a = 1 55 | >>> if a == 1: 56 | ... print("é 1") 57 | ... elif a >= 1: 58 | ... print("é maior ou igual a 1") 59 | ... else: 60 | ... print("é qualquer outra coisa") 61 | ... 62 | é 1 63 | 64 | 65 | Exercícios 66 | ---------- 67 | 68 | .. include:: exercicios_controle.rst 69 | -------------------------------------------------------------------------------- /source/desafios_controle.rst: -------------------------------------------------------------------------------- 1 | #. Escreva um programa que, dados 3 números diferentes (a, b e c), encontre o 2 | menor deles. 3 | 4 | #. Dado 3 valores inteiros lidos do teclado: A, B e C, retorne a soma deles. 5 | Porém, caso algum desses valores seja 13, então ele não conta para a soma, e 6 | os valores a sua direita também não. 7 | 8 | Por exemplo: 9 | | 1, 2, 3 -> 6 10 | | 1, 2, 13 -> 3 11 | | 1, 13, 3 -> 1 12 | | 13, 2, 3 -> 0 -------------------------------------------------------------------------------- /source/desafios_string.rst: -------------------------------------------------------------------------------- 1 | #. Por que o seguinte código retorna uma *string* vazia? 2 | 3 | .. doctest:: 4 | 5 | >>> texto = "No alto da montanha havia uma rosa" 6 | >>> texto[0:-1:-1] 7 | '' 8 | 9 | .. note:: 10 | 11 | .. doctest:: 12 | 13 | >>> texto = "No alto da montanha havia uma rosa" 14 | >>> texto[0:-1] 15 | 'No alto da montanha havia uma ros -------------------------------------------------------------------------------- /source/desafios_variaveis.rst: -------------------------------------------------------------------------------- 1 | .. spelling:word-list:: yver 2 | 3 | #. Joilson está aprendendo Arduino. Ele quer ligar LEDs nas saídas digitais 4 | do Arduino. Cada pino fornece :math:`5\, V`. Joilson sabe que tem que ligar 5 | um resistor em série com o LED para não queimar. Calcule o valor do 6 | resistor que deve ser ligado para cada um desses LEDs, sabendo que a corrente 7 | de operação de cada um dos LEDs é de :math:`20\, mA`: 8 | 9 | - LED vermelho: opera em :math:`2.0\, V` 10 | 11 | - LED verde: opera em :math:`3.2\, V` 12 | 13 | - LED roxo: opera em :math:`3.7\, V` 14 | 15 | Lembre-se que a voltagem é a corrente multiplicada pela resistência: 16 | 17 | .. math:: 18 | 19 | V = R I 20 | 21 | .. only:: instructors 22 | 23 | Exemplo de solução: 24 | 25 | .. code-block:: python3 26 | 27 | >>> V_vermelho = 2 28 | >>> V_verde = 3.2 29 | >>> V_roxo = 3.7 30 | >>> V_arduino = 5 31 | >>> I = 20e-3 32 | >>> R_vermelho = (V_arduino - V_vermelho) / I 33 | >>> R_verde = (V_arduino - V_verde) / I 34 | >>> R_roxo = (V_arduino - V_roxo) / I 35 | >>> print(R_vermelho, R_verde, R_roxo) 36 | 150.0, 89.99999999999999, 64.99999999999999 37 | 38 | #. D3yver50n resolveu minerar criptomoedas. Ele decidiu minerar *Ethereum* e viu 39 | que :math:`1\, ETH = \$687.86` e :math:`\$1 = \mathbb{R}\$3.59`. Ele comprou 40 | o seguinte computador: 41 | 42 | - 5 placas de vídeo: GTX1080 TI, cada uma por R$5270,90 43 | 44 | - 1 placa mãe: ASRock H110 Pro, por R$920 45 | 46 | - 1 fonte: 1600 W, por R$2299,90 47 | 48 | - 1 HD: 1 TB, SATA3, 7200 RPM por R$208,90 49 | 50 | - 2 pentes de memória: 4 GB, DDR4, 2400 MHZ, cada um por R$259,90 51 | 52 | - 1 CPU: Intel Core i5-8500 por R$899,90 53 | 54 | E resolveu montar usando uma estante de madeira e dois tijolos, para refrigerar 55 | melhor: 56 | 57 | .. figure:: images/cluster.jpg 58 | :align: center 59 | :width: 70% 60 | 61 | Essas GPUs (placas de vídeo) conseguem minerar Ethereum a uma taxa de :math:`\approx 27 Mh/s` 62 | (mega hash / s = :math:`10^6` hash / s). Cada bloco minerado dá uma recompensa 63 | de 3 ETH. Considere a dificuldade da rede de :math:`3.29 \cdot 10^{15}`, 64 | o *block time* médio de :math:`15.44\, s`. 65 | 66 | Para calcular quantos dólares por segundo ele vai ganhar com esse computador, 67 | D3yver50n fez as seguintes contas: 68 | 69 | .. math:: 70 | 71 | ETH / s = \mathrm{cluster\_ratio} \frac{recompensa}{\mathrm{block\_time}} 72 | 73 | O cluster_ratio é calculado como: 74 | 75 | .. math:: 76 | 77 | \mathrm{cluster\_ratio} = n_\mathrm{GPU} \frac{\mathrm{GPU\_hashrate}}{\mathrm{network\_hashrate}} 78 | 79 | onde :math:`n_\mathrm{GPU}` é o número de placas de vídeo que ele tem. 80 | O network_hashrate é calculado como: 81 | 82 | .. math:: 83 | 84 | \mathrm{network\_hashrate} = \frac{\mathrm{dificuldade}}{\mathrm{block\_time}} 85 | 86 | a. Calcule quantos ETH por segundo D3yver50n vai ganhar com esse PC. 87 | 88 | b. Calcule quantos dólares por segundo ele vai ganhar. 89 | 90 | c. Calcule quanto ele vai pagar de energia elétrica por segundo para manter 91 | esse computador ligado, sabendo que o custo de energia elétrica é de 92 | :math:`0.008 \mathrm{ centavos} / kW`. 93 | 94 | d. Após um mês, quantos ETH ele vai ganhar? Isso equivale a quantos reais? 95 | Quanto de energia elétrica ele vai gastar? Deu lucro ou prejuízo? 96 | 97 | e. Se ele teve lucro, após quanto tempo ele ganha o dinheiro que investiu 98 | no computador de volta? 99 | 100 | 101 | .. only:: instructors 102 | 103 | Exemplo de solução: 104 | 105 | .. code-block:: python3 106 | 107 | # item a - ETH / s 108 | GPU_hashrate = 27e6 # Hash/s 109 | n_GPU = 5 110 | difficulty = 3.29e15 111 | block_time = 15.44 112 | reward = 3 113 | 114 | network_hashrate = difficulty / block_time 115 | cluster_ratio = n_GPU * GPU_hashrate / network_hashrate 116 | ETH_s = cluster_ratio * reward / block_time 117 | print("ETH / s: ", ETH_s) 118 | 119 | # item b - dólar / s 120 | ETH = 687.86 # 1 ETH = 687.86 USD 121 | dólar_s = ETH_s * ETH 122 | print("USD / s: ", dólar_s) 123 | 124 | # item c - energia elétrica 125 | kW = 0.008 / 100 # 1 kW = R$0.00008 126 | potência = 1.6 / .8 # potência da fonte / eficiência dela :P convertida pra kW 127 | energia_s = potência * kW 128 | print("R$ de energia / s: ", energia_s) 129 | 130 | # item d - tudo isso depois de um mês 131 | mês = 30 * 24 * 60 * 60 # 1 mês em segundos 132 | dólar = 3.25 133 | 134 | ETH_mês = ETH_s * mês 135 | dólar_mês = dólar_s * mês 136 | reais_mês = dólar_mês * dólar 137 | energia_mês = energia_s * mês 138 | profit = reais_mês - energia_mês 139 | print("ETH / mês: ", ETH_mês) 140 | print("USD / mês: ", dólar_mês) 141 | print("R$ / mês: ", reais_mês) 142 | print("R$ energia / mês: ", energia_mês) 143 | print("Lucro (R$) / mês: ", profit) 144 | print("") 145 | 146 | # item e - tempo pra recuperar o investimento 147 | GTX = 5270.90 148 | mobo = 920.00 149 | PSU = 2299.90 150 | HD = 208.90 151 | ram = 259.90 152 | CPU = 899.90 153 | custo_total = 5 * GTX + mobo + PSU + HD + 2 * ram + CPU 154 | print("Custo do hardware (R$): ", custo_total) 155 | 156 | tempo = custo_total / profit 157 | print("Tempo para recuperar investimento (em meses): ", tempo) 158 | 159 | .. code-block:: bash 160 | 161 | $ python eth.py 162 | ETH / s: 1.231003039513678e-07 163 | USD / s: 8.467577507598785e-05 164 | R$ de energia / s: 0.00016 165 | ETH / mês: 0.3190759878419453 166 | USD / mês: 219.4796089969605 167 | R$ / mês: 713.3087292401217 168 | R$ energia / mês: 414.72 169 | Lucro (R$) / mês: 298.58872924012167 170 | 171 | Custo do hardware (R$): 31203.000000000004 172 | Tempo para recuperar investimento (em meses): 104.50160017562789 173 | -------------------------------------------------------------------------------- /source/dicionarios.rst: -------------------------------------------------------------------------------- 1 | .. _section_dicionario: 2 | 3 | Dicionários 4 | =========== 5 | 6 | Dicionário é uma coleção de itens (chamados ``chaves``) e seus respectivos significados (chamados de ``valores``): 7 | 8 | {chave: valor} 9 | 10 | Cada chave do dicionário deve ser única! Ao contrário de *listas*, *dicionários*, não podem ter chaves repetidas. 11 | 12 | .. note:: As chaves devem ser únicas. 13 | 14 | Declaração 15 | ---------- 16 | 17 | Declaramos um dicionário colocando entre chaves ``{}`` cada chave e o seu respectivo valor, da seguinte forma: 18 | 19 | .. doctest:: 20 | 21 | >>> telefones = {"ana": 123456, "yudi": 40028922, "julia": 4124492} 22 | >>> telefones 23 | {'ana': 123456, 'yudi': 40028922, 'julia': 4124492} 24 | 25 | No caso acima, a chave ``"ana"``, por exemplo, está relacionada ao valor ``123456``. Cada par chave-valor é separado por uma vírgula ``,`` . 26 | 27 | Função ``dict()`` 28 | ----------------- 29 | 30 | A função ``dict()`` constrói um dicionário. Existem algumas formas de usá-la: 31 | 32 | - Com uma lista de listas: 33 | 34 | .. doctest:: 35 | 36 | >>> lista1 = ["brigadeiro", "leite condensado, achocolatado"] 37 | >>> lista2 = ["omelete", "ovos, azeite, condimentos a gosto"] 38 | >>> lista3 = ["ovo frito", "ovo, óleo, condimentos a gosto"] 39 | >>> lista_receitas = [lista1, lista2, lista3] 40 | >>> print(lista_receitas) 41 | [['brigadeiro', 'leite condensado, achocolatado'], ['omelete', 'ovos, azeite, condimentos a gosto'], ['ovo frito', 'ovo, óleo, condimentos a gosto']] 42 | >>> receitas = dict(lista_receitas) 43 | >>> print(receitas) 44 | {'brigadeiro': 'leite condensado, achocolatado', 'omelete': 'ovos, azeite, condimentos a gosto', 'ovo frito': 'ovo, óleo, condimentos a gosto'} 45 | 46 | 47 | - Atribuindo os valores diretamente: 48 | 49 | .. doctest:: 50 | 51 | >>> constantes = dict(pi=3.14, e=2.7, alpha=1/137) 52 | >>> print(constantes) 53 | {'pi': 3.14, 'e': 2.7, 'alpha': 0.0072992700729927005} 54 | 55 | Neste caso, o nome das chaves deve ser um identificador válido. As mesmas regras de :ref:`nomes de variáveis ` se aplicam. 56 | 57 | - Usando as chaves ``{}``: 58 | 59 | .. doctest:: 60 | 61 | >>> numerinhos = dict({"um": 1, "dois": 2, "três": 3}) 62 | >>> print(numerinhos) 63 | {'um': 1, 'dois': 2, 'três': 3} 64 | 65 | E nesse caso se não houvesse a função ``dict()``, o resultado seria exatamente o mesmo... 66 | 67 | Chaves 68 | ------ 69 | 70 | Acessamos um determinado valor do dicionário através de sua chave: 71 | 72 | .. doctest:: 73 | 74 | >>> capitais = {"SP": "São Paulo", "AC": "Rio Branco", "TO": "Palmas", "RJ": "Rio de Janeiro", "SE": "Aracaju", "MG": "Belo Horizonte"} 75 | >>> capitais["MG"] 76 | 'Belo Horizonte' 77 | 78 | Até o momento, usamos apenas *strings*, mas podemos colocar todo tipo de coisa dentro dos dicionários, incluindo listas e até mesmo outros dicionários: 79 | 80 | .. doctest:: 81 | 82 | >>> numeros = {"primos": [2, 3, 5], "pares": [0, 2, 4], "ímpares": [1, 3, 5]} 83 | >>> numeros["ímpares"] 84 | [1, 3, 5] 85 | 86 | Mesmo que os pares chave-valor estejam organizados na ordem que foram colocados, não podemos acessá-los por *índices* como faríamos em listas: 87 | 88 | .. doctest:: 89 | 90 | >>> numeros[2] 91 | Traceback (most recent call last): 92 | File "", line 1, in 93 | KeyError: 2 94 | 95 | O mesmo erro ocorre se tentarmos colocar uma chave que não pertence ao dicionário: 96 | 97 | .. doctest:: 98 | 99 | >>> numeros["negativos"] 100 | Traceback (most recent call last): 101 | File "", line 1, in 102 | KeyError: 'negativos' 103 | 104 | Assim como os valores não precisam ser do tipo *string*, o mesmo vale para as chaves: 105 | 106 | .. doctest:: 107 | 108 | >>> numeros_por_extenso = {2: "dois", 1: "um", 3: "três", 0: "zero"} 109 | >>> numeros_por_extenso[0] 110 | 'zero' 111 | >>> numeros_por_extenso[2] 112 | 'dois' 113 | 114 | .. note:: 115 | 116 | Listas e outros dicionários *não* podem ser usados como chaves por serem de tipos *mutáveis*. 117 | 118 | Adicionando e removendo elementos 119 | --------------------------------- 120 | 121 | Podemos alterar o valor relacionado a uma chave da seguinte forma: 122 | 123 | .. doctest:: 124 | 125 | >>> pessoa = {"nome": "Cleiton", "idade": 34, "família": {"mãe": "Maria", "pai": "Enzo"}} 126 | >>> pessoa["idade"] 127 | 34 128 | >>> pessoa["idade"] = 35 129 | >>> pessoa["idade"] 130 | 35 131 | 132 | Para adicionar um elemento novo à um dicionário, podemos simplesmente fazer o seguinte: 133 | 134 | .. doctest:: 135 | 136 | >>> meses = {1: "Janeiro", 2: "Fevereiro", 3: "Março"} 137 | >>> meses[4] = "Abril" 138 | >>> meses 139 | {1: "Janeiro", 2: "Fevereiro", 3: "Março", 4: "Abril"} 140 | 141 | Aqui nos referimos a uma chave que *não* está no dicionário e associamos um valor a ela. Desta forma, *adicionando* esse conjunto chave-valor ao dicionário. 142 | 143 | Removemos um conjunto chave-elemento de um dicionário com o comando ``del``: 144 | 145 | .. doctest:: 146 | 147 | >>> meses 148 | {1: "Janeiro", 2: "Fevereiro", 3: "Março", 4: "Abril"} 149 | >>> del(meses[4]) 150 | >>> meses 151 | {1: "Janeiro", 2: "Fevereiro", 3: "Março"} 152 | 153 | Para apagar *todos* os elementos de um dicionário, usamos o método ``clear``: 154 | 155 | .. doctest:: 156 | 157 | >>> lixo = {"plástico": ["garrafa", "copinho", "canudo"], "papel": ["folha amassada", "guardanapo"], "orgânico": ["batata", "resto do bandeco", "casca de banana"]} 158 | >>> lixo 159 | {"plástico": ["garrafa", "copinho", "canudo"], "papel": ["folha amassada", "guardanapo"], "organico": ["batata", "resto do bandeco", "casca de banana"]} 160 | >>> lixo.clear() 161 | >>> lixo 162 | {} 163 | 164 | 165 | Unindo Dicionários 166 | ------------------ 167 | 168 | Para versões anteriores a 3.9 do Python, use o método ``.update()`` para 169 | colocar o conteúdo de um segundo dicionário no original: 170 | 171 | .. doctest:: 172 | 173 | >>> comodos1 = {'casa': 1, 'quartos': 2, 'banheiros': 2} 174 | >>> comodos2 = {'cozinha': 1, 'quintal': 1} 175 | >>> comodos1.update(comodos2) 176 | >>> print(comodos1) 177 | {'casa': 1, 'quartos': 2, 'banheiros': 2, 'cozinha': 1, 'quintal': 1} 178 | 179 | A partir da versão 3.9 do Python, é possível unificar dois dicionários com o 180 | operador ``|`` (barra vertical ou *pipe* -- em inglês): 181 | 182 | .. doctest:: 183 | 184 | >>> comodos1 = {'casa': 1, 'quartos': 2, 'banheiros': 2} 185 | >>> comodos2 = {'cozinha': 1, 'quintal': 1} 186 | >>> casa = comodos1 | comodos2 187 | >>> print(casa) 188 | {'casa': 1, 'quartos': 2, 'banheiros': 2, 'cozinha': 1, 'quintal': 1} 189 | >>> print(comodos1) 190 | {'casa': 1, 'quartos': 2, 'banheiros': 2} 191 | 192 | Note que o ``.update`` altera o ``comodos1`` sem retornar nada enquanto o ``|`` 193 | retorna e cria um novo array sem alterar o ``comodos1``. 194 | 195 | 196 | Função ``list()`` 197 | ----------------- 198 | 199 | A função ``list()`` recebe um conjunto de objetos e retorna uma lista. Ao passar um dicionário, ela retorna uma lista contendo todas as suas *chaves*: 200 | 201 | .. doctest:: 202 | 203 | >>> institutos_uspsc = {"IFSC": "Instituto de Física de São Carlos", "ICMC": "Instituto de Ciências Matemáticas e de Computação", "EESC": "Escola de Engenharia de São Carlos", "IAU": "Instituto de Arquitetura e Urbanismo", "IQSC": "Instituto de Química de São Carlos"} 204 | >>> list(institutos_uspsc) 205 | ['IQSC', 'IFSC', 'ICMC', 'IAU', 'EESC'] 206 | 207 | Função ``len()`` 208 | ---------------- 209 | 210 | A função ``len()`` retorna o número de elementos ("tamanho") do objeto passado para ela. No caso de uma lista, fala quantos elementos há. No caso de dicionários, retorna o *número de chaves* contidas nele: 211 | 212 | .. doctest:: 213 | 214 | >>> institutos_uspsc 215 | {'IQSC': 'Instituto de Química de São Carlos', 'IFSC': 'Instituto de Física de São Carlos', 'ICMC': 'Instituto de Ciências Matemáticas e de Computação', 'IAU': 'Instituto de Arquitetura e Urbanismo', 'EESC': 'Escola de Engenharia de São Carlos'} 216 | >>> len(institutos_uspsc) 217 | 5 218 | 219 | Você pode contar o número de elementos na lista gerada pela função ``list()`` para conferir: 220 | 221 | .. doctest:: 222 | 223 | >>> len(list(institutos_uspsc)) 224 | 5 225 | 226 | Método ``get()`` 227 | ---------------- 228 | 229 | O método ``get(chave, valor)`` pode ser usado para retornar o valor associado à respectiva chave! O segundo parâmetro ```` é opcional e indica o que será retornado caso a chave desejada *não* esteja no dicionário: 230 | 231 | .. doctest:: 232 | 233 | >>> institutos_uspsc.get("IFSC") 234 | 'Instituto de Física de São Carlos' 235 | 236 | Dá para ver que ele é muito parecido com fazer assim: 237 | 238 | .. doctest:: 239 | 240 | >>> institutos_uspsc["IFSC"] 241 | 'Instituto de Física de São Carlos' 242 | 243 | Mas ao colocarmos uma chave que não está no dicionário: 244 | 245 | .. doctest:: 246 | 247 | >>> institutos_uspsc.get("Poli", "Não tem!") 248 | 'Não tem!' 249 | >>> institutos_uspsc["Poli"] 250 | Traceback (most recent call last): 251 | File "", line 1, in 252 | KeyError: 'Poli' 253 | 254 | Alguns métodos 255 | -------------- 256 | 257 | - O método ``items()`` pode ser comparado com o *inverso* da função ``dict()``: 258 | 259 | .. doctest:: 260 | 261 | >>> pessoa = {"nome": "Enzo", "RA": 242334, "curso": "fiscomp"} 262 | >>> pessoa.items() 263 | dict_items([('curso', 'fiscomp'), ('nome', 'Enzo'), ('RA', 242334)]) 264 | 265 | Usando a função ``list()`` nesse resultado, obtemos: 266 | 267 | .. doctest:: 268 | 269 | >>> pessoa.items() 270 | dict_items([('curso', 'fiscomp'), ('nome', 'Enzo'), ('RA', 242334)]) 271 | >>> itens = list(pessoa.items()) 272 | >>> itens 273 | [('curso', 'fiscomp'), ('nome', 'Enzo'), ('RA', 242334)] 274 | 275 | Experimente usar a função ``dict()`` na lista ``itens``! 276 | 277 | - O método ``values()`` nos retorna os *valores* do dicionário: 278 | 279 | .. doctest:: 280 | 281 | >>> pessoa.values() 282 | dict_values(['fiscomp', 'Enzo', 242334]) 283 | >>> valores = list(pessoa.values()) 284 | >>> valores 285 | ['fiscomp', 'Enzo', 242334] 286 | 287 | - O método ``keys()`` nos retorna as *chaves* do dicionário: 288 | 289 | .. doctest:: 290 | 291 | >>> pessoa.keys() 292 | dict_keys(['curso', 'nome', 'RA']) 293 | >>> chaves = list(pessoa.keys()) 294 | >>> chaves 295 | ['curso', 'nome', 'RA'] 296 | 297 | Repare que nesse último obtemos o mesmo que se tivéssemos usado a função ``list()``: 298 | 299 | .. doctest:: 300 | 301 | >>> list(pessoa) 302 | ['curso', 'nome', 'RA'] 303 | 304 | Ordem dos elementos 305 | ------------------- 306 | 307 | Dicionários não tem sequência dos seus elementos. As listas têm. Dicionários mapeiam um valor a uma chave. Veja este exemplo: 308 | 309 | .. doctest:: 310 | 311 | >>> numerinhos = dict({"um": 1, "dois": 2, "três": 3}) 312 | >>> numeritos = {"três": 3, "dois": 2, "um": 1} 313 | >>> numerinhos == numeritos 314 | True 315 | >>> numeritos 316 | {'três': 3, 'dois': 2, 'um': 1} 317 | >>> numerinhos 318 | {'um': 1, 'dois': 2, 'três': 3} 319 | 320 | Vemos que ``numerinhos`` e ``numeritos`` têm as mesmas chaves com os mesmos valores e por isso são iguais. Mas quando imprimimos cada um, a ordem que aparece é a que os itens foram inseridos. 321 | 322 | .. note:: 323 | 324 | A partir da versão 3.7 do Python, a ordem das chaves no dicionário é 325 | garantida como sendo a ordem de inserção. 326 | 327 | Está no dicionário? 328 | ------------------- 329 | 330 | Podemos checar se uma chave está ou não em um dicionário utilizando o comando ``in``. 331 | Voltando para o dicionário que contem os institutos da USP São Carlos: 332 | 333 | .. doctest:: 334 | 335 | >>> institutos_uspsc 336 | {'IQSC': 'Instituto de Química de São Carlos', 'IFSC': 'Instituto de Física de São Carlos', 'ICMC': 'Instituto de Ciências Matemáticas e de Computação', 'IAU': 'Instituto de Arquitetura e Urbanismo', 'EESC': 'Escola de Engenharia de São Carlos'} 337 | >>> "IFSC" in institutos_uspsc 338 | True 339 | >>> "ESALQ" in institutos_uspsc 340 | False 341 | 342 | E checamos se uma chave *não está* no dicionário com o comando ``not in``: 343 | 344 | .. doctest:: 345 | 346 | >>> institutos_uspsc 347 | {'IQSC': 'Instituto de Química de São Carlos', 'IFSC': 'Instituto de Física de São Carlos', 'ICMC': 'Instituto de Ciências Matemáticas e de Computação', 'IAU': 'Instituto de Arquitetura e Urbanismo', 'EESC': 'Escola de Engenharia de São Carlos'} 348 | >>> "IFSC" not in institutos_uspsc 349 | False 350 | >>> "ESALQ" not in institutos_uspsc 351 | True 352 | 353 | 354 | Remove e Retorna pares chave/valor 355 | ---------------------------------- 356 | 357 | Com o método ``popitem()`` é possível remover, de forma arbitrária, itens de um dicionário e retorna-o na forma de um 358 | par chave/valor. Este método pode ser útil para algoritmos que utilizam dicionários como uma lista de atividades. 359 | Por exemplo, uma relação de clientes para realizar ligações: 360 | 361 | .. doctest:: 362 | 363 | >>> clientes_para_ligar = { 364 | "Ateneu": 55449090, 365 | "Bielzinho": 54549090, 366 | "Charlinho": 44559090, 367 | "Deividy": 45459090} 368 | 369 | >>> clientes_para_ligar.popitem() 370 | ('Deividy', 45459090) 371 | 372 | >>> clientes_para_ligar 373 | {'Ateneu': 55449090, 'Bielzinho': 54549090, 'Charlinho': 44559090} # Repare que o Deividy saiu do dicionário 374 | 375 | >>> clientes_para_ligar.popitem() 376 | ('Bielzinho', 54549090) 377 | 378 | >>> clientes_para_ligar.popitem() 379 | ('Charlinho', 44559090) 380 | 381 | >>> clientes_para_ligar.popitem() 382 | ('Ateneu', 55449090) 383 | 384 | >>> clientes_para_ligar.popitem() 385 | Traceback (most recent call last): 386 | File "", line 1, in 387 | KeyError: 'popitem(): dictionary is empty' 388 | 389 | >>> clientes_para_ligar 390 | {} 391 | 392 | Esta última chamada do ``popitem()`` retorna um erro, pois o dicionário está vazio. 393 | 394 | 395 | Exercícios 396 | ---------- 397 | 398 | .. include:: exercicios_dicionario.rst 399 | 400 | 401 | Sumário 402 | -------- 403 | 404 | .. csv-table:: 405 | :header: "Operação", "Descrição" 406 | :widths: auto 407 | :delim: ; 408 | 409 | ``telefones = {"Ana": 123456, "yudi": 654321}`` ; Cria um dicionário com duas chaves, usando ``{}`` 410 | ``telefones = dict(Ana=123456, yudi=654321)`` ; Cria um dicionário com duas chaves, usando o método ``dict()`` 411 | ``telefones = dict((("Ana", 123456), ("yudi", 654321)))`` ; Cria um dicionário com duas chaves a partir de uma lista de tuplas 412 | ``telefones["Ana"] # Retorna 123456`` ; Acessa o valor do telefone da chave "Ana" 413 | ``telefone["thiago"] = 9876543`` ; Adiciona mais um telefone na lista 414 | ``del telefone["thiago"]`` ; Remove um telefone do dicionário 415 | ``telefone.clear()`` ; Remove todos os elementos de um dicionário 416 | ``dict1.update(dict2)`` ; Para versões anteriores a 3.9 do Python, use o método ``.update()`` para colocar o conteúdo de um segundo dicionário no original 417 | ``dict1 | dict2`` ; A partir da versão 3.9 do Python, é possível unificar dois dicionários com o operador ``|`` (barra vertical ou pipe – em inglês) 418 | ``list(telefones) # Retorna ["Ana", "yudi"]`` ; Obtém as chaves de um dicionário 419 | ``telefones.keys() # Retorna ("Ana", "yudi")`` ; Obtém as chaves de um dicionário 420 | ``len(telefones)`` ; Retorna a quantidade de chaves no dicionário 421 | ``telefones.get("João", "N/A")`` ; Retorna o valor associado à chave ``João`` ou ``N/A`` caso a chave não exista. 422 | ``telefones.items()`` ; Retorna uma lista de tuplas contendo a chave e o valor de cada item do dicionário 423 | ``telefones.values()`` ; Retorna uma lista com apenas os valores dos dicionários 424 | ``"Ana" in telefones`` ; Verifica se a chave "Ana" existe no dicionário 425 | ``telefones.popitem()`` ; Remove e retorna a última chave do dicionário -------------------------------------------------------------------------------- /source/epilogo.rst: -------------------------------------------------------------------------------- 1 | Epílogo 2 | ======= 3 | 4 | Parabéns, você chegou ao fim desse curso! Agora você sabe o básico de 5 | programação e como usar Python e suas estruturas. Mas não acaba aí. Segue uma 6 | lista de sugestões do que estudar para continuar na área: 7 | 8 | - Estrutura de dados 9 | - Orientação a Objetos 10 | - Testes de software 11 | - Versionamento de software 12 | -------------------------------------------------------------------------------- /source/exercicios.rst: -------------------------------------------------------------------------------- 1 | Exercícios e Desafios! 2 | ====================== 3 | 4 | Neste capítulo estão listados todos os exercícios apresentados no curso e 5 | também alguns desafios a mais! 6 | 7 | Calculadora 8 | ----------- 9 | 10 | Operadores Matemáticos 11 | ~~~~~~~~~~~~~~~~~~~~~~ 12 | 13 | .. include:: exercicios_calculadora_operadores.rst 14 | 15 | Expressões Numéricas 16 | ~~~~~~~~~~~~~~~~~~~~ 17 | 18 | .. include:: exercicios_calculadora_expressoes.rst 19 | 20 | 21 | Variáveis 22 | --------- 23 | 24 | .. include:: exercicios_variaveis.rst 25 | 26 | Desafios 27 | ~~~~~~~~ 28 | 29 | .. include:: desafios_variaveis.rst 30 | 31 | 32 | Strings 33 | ------- 34 | 35 | .. include:: exercicios_string.rst 36 | 37 | Desafios 38 | ~~~~~~~~ 39 | 40 | .. include:: desafios_string.rst 41 | 42 | 43 | Teclado 44 | ------- 45 | 46 | .. include:: exercicios_input.rst 47 | 48 | 49 | Listas 50 | ------ 51 | 52 | .. include:: exercicios_listas.rst 53 | 54 | Dicionários 55 | ----------- 56 | 57 | .. include:: exercicios_dicionario.rst 58 | 59 | Estruturas de Controle 60 | ---------------------- 61 | 62 | .. include:: exercicios_controle.rst 63 | 64 | Desafios 65 | ~~~~~~~~ 66 | 67 | .. include:: desafios_controle.rst 68 | 69 | 70 | Estruturas de repetição 71 | ----------------------- 72 | 73 | .. include:: exercicios_repeticao.rst 74 | 75 | 76 | Funções 77 | ------- 78 | 79 | .. include:: exercicios_funcoes.rst 80 | -------------------------------------------------------------------------------- /source/exercicios_calculadora_expressoes.rst: -------------------------------------------------------------------------------- 1 | 2 | #. Quantos segundos há em 3 horas, 23 minutos e 17 segundos? 3 | 4 | #. Se você correr 65 quilômetros em 3 horas, 23 minutos e 17 segundos, qual 5 | é a sua velocidade média em m/s? 6 | 7 | .. only:: instructors 8 | 9 | Exemplo de solução: 10 | 11 | .. code-block:: python3 12 | 13 | >>> 3*60*60 + 23*60 + 17 # calculando o tempo total em segundos 14 | 12197 15 | >>> 65*1000 / 12197 # calculando a velocidade em m/s 16 | 5.329179306386816 17 | 18 | #. Resolva essa expressão: 19 | 20 | .. math:: 21 | 22 | \frac{100 - 413 \cdot (20 - 5 \times 4)}{5} 23 | 24 | .. only:: instructors 25 | 26 | Exemplo de solução: 27 | 28 | .. code-block:: python3 29 | 30 | >>> (100-413*(20-5*4))/5 31 | 20 32 | 33 | #. Enivaldo quer ligar três capacitores, de valores: 34 | 35 | - :math:`C_1 = 10 \, \mu F` 36 | - :math:`C_2 = 22 \, \mu F` 37 | - :math:`C_3 = 6.8\, \mu F` 38 | 39 | Se ele ligar os três em paralelo, a capacitância resultante é a soma: 40 | 41 | .. math:: 42 | 43 | C_p = C_1 + C_2 + C_3 44 | 45 | Se ele ligar os três em série, a capacitância resultante é: 46 | 47 | .. math:: 48 | 49 | \frac{1}{C_s} = \frac{1}{C_1} + \frac{1}{C_2} + \frac{1}{C_3} 50 | 51 | Ou seja: 52 | 53 | .. math:: 54 | 55 | C_s = \frac{1}{\frac{1}{C_1} + \frac{1}{C_2} + \frac{1}{C_3}} 56 | 57 | Qual é o valor resultante em cada um desses casos? 58 | 59 | .. only:: instructors 60 | 61 | Exemplo de solução: 62 | 63 | .. code-block:: python3 64 | 65 | >>> 10 + 22 + 0.8 # em paralelo, resposta em µF 66 | 32.8 67 | >>> 1 / (1 / 10 + 1 / 22 + 1 / 0.8) # em série, resposta em µF 68 | 0.7166123778501629 69 | >>> 1 / (1 / 10e-6 + 1 / 22e-6 + 1 / 0.8e-6) # em série, resposta em F 70 | 7.166123778501629e-07 71 | 72 | #. Você e os outros integrantes da sua república (Joca, Moacir, Demival e 73 | Jackson) foram no supermercado e compraram alguns itens: 74 | 75 | - 75 latas de cerveja: R\$ 2,20 cada (da ruim ainda, pra fazer o dinheiro render) 76 | 77 | - 2 pacotes de macarrão: R\$ 8,73 cada 78 | 79 | - 1 pacote de Molho de tomate: R\$ 3,45 80 | 81 | - 420g Cebola: R\$ 5,40/kg 82 | 83 | - 250g de Alho: R\$ 30/kg 84 | 85 | - 450g de pães franceses: R\$ 25/kg 86 | 87 | Calcule quanto ficou para cada um. 88 | 89 | .. only:: instructors 90 | 91 | Exemplo de solução: 92 | 93 | .. code-block:: python3 94 | 95 | >>> 75*2.2 + 2*8.73 + 3.45 + 0.42*5.4 + 0.25*30 + 0.45*25 # calculando o total da compra 96 | 206.928 97 | >>> 206.928/4 # dividindo o total entre os integrantes da republica 98 | 51.732 99 | 100 | #. Krissia gosta de bolinhas de queijo. Ela quer saber quantas bolinhas de 101 | queijo dá para colocar dentro de um pote de sorvete de :math:`2\, L`. Ela 102 | pensou assim: 103 | 104 | *Um pote de sorvete tem dimensões 15 cm x 10 cm x 13 cm. 105 | Uma bolinha de queijo é uma esfera de raio r = 1.2 cm. 106 | O fator de empacotamento ideal é 0.74, mas o pote de sorvete tem 107 | tamanho comparável às bolinhas de queijo, aí tem efeitos de borda, então 108 | o fator deve ser menor. Mas as bolinhas de queijo são razoavelmente 109 | elásticas, então empacota mais. Esse valor parece razoável.* 110 | 111 | Sabendo que o volume de uma esfera de raio :math:`r` é 112 | :math:`V = \frac{4}{3} \pi r^3`, o volume do pote de sorvete é 113 | :math:`V = x \cdot y \cdot z` e o fator de empacotamento é a fração de volume 114 | ocupado pelas bolinhas de queijo. Ou seja, :math:`74 \%` do pote de sorvete 115 | vai ser ocupado pelas bolinhas de queijo. 116 | 117 | Ajude a Krissia descobrir quantas bolinhas de queijo cabem no pote de sorvete! 118 | 119 | .. only:: instructors 120 | 121 | Exemplo de solução: 122 | 123 | .. code-block:: python3 124 | 125 | >>> from math import pi, floor 126 | >>> 15 * 10 * 13 * 0.74 / (4 / 3 * pi * 1.2**3) 127 | 199.35814486250436 128 | >>> floor(15 * 10 * 13 * 0.74 / (4 / 3 * pi * 1.2**3)) 129 | 199 -------------------------------------------------------------------------------- /source/exercicios_calculadora_operadores.rst: -------------------------------------------------------------------------------- 1 | #. Calcule o resto da divisão de 10 por 3. 2 | 3 | #. Calcule a tabuada do 13. 4 | 5 | #. Davinir não gosta de ir às aulas. Mas ele é obrigado a comparecer a pelo 6 | menos 75% delas. Ele quer saber quantas aulas pode faltar, sabendo que tem 7 | duas aulas por semana, durante quatro meses. Ajude o Davinir! 8 | 9 | .. note:: 10 | 11 | Um mês tem quatro semanas. 12 | 13 | .. only:: instructors 14 | 15 | Exemplo de solução: 16 | 17 | .. code-block:: python3 18 | 19 | >>> 4 * 4 * 2 * 0.25 # 4 meses * 4 semanas/mês * 2 aulas/semana * 25% 20 | 8.0 21 | 22 | #. Calcule a área de um círculo de raio :math:`r = 2`. 23 | 24 | Lembrete: a área de um círculo de raio :math:`r` é: 25 | 26 | .. math:: 27 | 28 | A_\circ = \pi \, r^2 29 | 30 | .. only:: instructors 31 | 32 | Exemplo de solução: 33 | 34 | .. code-block:: python3 35 | 36 | >>> import math 37 | >>> math.pi * 2**2 38 | 12.566370614359172 -------------------------------------------------------------------------------- /source/exercicios_controle.rst: -------------------------------------------------------------------------------- 1 | #. Escreva um programa que, dados 2 números diferentes (a e b), encontre o menor 2 | deles. 3 | 4 | .. only:: instructors 5 | 6 | Exemplo de solução: 7 | 8 | .. code-block:: python3 9 | 10 | >>> a = 10 11 | >>> b = 8 12 | >>> if a < b: 13 | ... print("a é o menor") 14 | ... else: 15 | ... print("b é o menor") 16 | ... 17 | b é o menor 18 | 19 | #. Para doar sangue é necessário [1]_: 20 | 21 | - Ter entre 16 e 69 anos. 22 | - Pesar mais de 50 kg. 23 | - Estar descansado (ter dormido pelo menos 6 horas nas últimas 24 horas). 24 | 25 | Faça um programa que pergunte a idade, o peso e quanto dormiu nas últimas 26 | 24 h para uma pessoa e diga se ela pode doar sangue ou não. 27 | 28 | .. only:: instructors 29 | 30 | Exemplo de solução: 31 | 32 | .. code-block:: python3 33 | 34 | >>> idade = int(input("Qual a sua idade? ")) 35 | >>> peso = float(input("Qual o seu peso? ")) 36 | >>> horas_de_sono = int(input("Quantas horas dormiu nas ultimas 24h? ")) 37 | >>> if idade >= 16 and idade <= 69 and peso > 50 and horas_de_sono >= 6: 38 | ... print("você pode doar sangue") 39 | ... else: 40 | ... print("você não pode doar sangue") 41 | ... 42 | 43 | #. Considere uma equação do segundo grau 44 | :math:`f(x) = a \cdot x^2 + b \cdot x + c`. 45 | A partir dos coeficientes, determine se a equação possui duas raízes reais, 46 | uma, ou se não possui. 47 | 48 | **Dica:** :math:`\Delta = b^2 - 4 \cdot a \cdot c` : se delta é maior que 0, 49 | possui duas raízes reais; se delta é 0, possui uma raiz; caso delta seja 50 | menor que 0, não possui raiz real 51 | 52 | .. only:: instructors 53 | 54 | Exemplo de solução: 55 | 56 | .. code-block:: python3 57 | 58 | >>> a = float(input("Qual o valor de a? ")) 59 | >>> b = float(input("Qual o valor de b? ")) 60 | >>> c = float(input("Qual o valor de c? ")) 61 | >>> delta = b**2 - 4*a*c 62 | >>> if delta > 0: 63 | ... print("A equação possui duas raizes") 64 | ... elif delta == 0: 65 | ... print("A equação possui uma raiz") 66 | ... else: 67 | ... print("A equação não possui raiz real") 68 | ... 69 | 70 | #. Leia dois números e efetue a adição. Caso o valor somado seja maior que 20, 71 | este deverá ser apresentado somando-se a ele mais 8; caso o valor somado seja 72 | menor ou igual a 20, este deverá ser apresentado subtraindo-se 5. 73 | 74 | .. only:: instructors 75 | 76 | Exemplo de solução: 77 | 78 | .. code-block:: python3 79 | 80 | >>> a = float(input("Qual o primeiro valor? ")) 81 | >>> b = float(input("Qual o segundo valor? ")) 82 | >>> if a+b > 20: 83 | ... print(a+b+8) 84 | ... else: 85 | ... print(a+b-5) 86 | ... 87 | 88 | #. Leia um número e imprima a raiz quadrada do número caso ele seja positivo ou 89 | igual a zero e o quadrado do número caso ele seja negativo. 90 | 91 | .. only:: instructors 92 | 93 | Exemplo de solução: 94 | 95 | .. code-block:: python3 96 | 97 | >>> a = float(input("Digite um numero? ")) 98 | >>> if a >= 0: 99 | ... print(a**0.5) 100 | ... else: 101 | ... print(a**2) 102 | ... 103 | 104 | 105 | #. Leia um número inteiro entre 1 e 12 e escreva o mês correspondente. Caso o 106 | usuário digite um número fora desse intervalo, deverá aparecer uma mensagem 107 | informando que não existe mês com este número. 108 | 109 | #. Um supermercado está tendo muitos problemas com a validade de seus produtos 110 | e pediu sua ajuda com esse problema. Faça um programa que leia o dia, o mês e o 111 | ano da data atual e de validade de um produto, e imprima se o produto já está vencido 112 | ou não. 113 | 114 | 115 | .. [1] Para mais informações sobre doação de sangue, acesse 116 | http://www.prosangue.sp.gov.br/artigos/requisitos_basicos_para_doacao.html -------------------------------------------------------------------------------- /source/exercicios_dicionario.rst: -------------------------------------------------------------------------------- 1 | #. Faça um dicionário com as 5 pessoas mais perto de você, tendo o nome como chave e a cor da camisa que está usando como valor. 2 | 3 | #. Crie um dicionário vazio ``semana = {}`` e o complete com uma chave para cada dia da semana, tendo como seu valor uma lista com as aulas que você tem nesse dia (sábado e domingo recebem listas vazias, ou você tem aula?). 4 | 5 | #. Crie um dicionário vazio ``filmes = {}``. Utilize o nome de um filme como chave. E, como valor, *outro* dicionário contendo o ``vilão`` e o ``ano`` em que o filme foi lançado. Preencha 5 filmes. 6 | 7 | .. only:: instructors 8 | 9 | Exemplo de solução: 10 | 11 | .. doctest:: 12 | 13 | >>> filmes = {} 14 | >>> filmes["Vingadores"] = {"Vilão": "Thanos", "Ano": 2019} 15 | >>> filmes["O Náufrago"] = {"Vilão": "A Ilha (?)", "Ano": 2000} 16 | >>> filmes["E O Vento Levou"] = {"Vilão": "O vento", "Ano": 1939} 17 | >>> filmes 18 | {'Vingadores': {'Vilão': 'Thanos', 'Ano': 2019}, 'O Náufrago': {'Vilão': 'A Ilha (?)', 'Ano': 2000}, 'E O Vento Levou': {'Vilão': 'O vento', 'Ano': 1939}} 19 | -------------------------------------------------------------------------------- /source/exercicios_funcoes.rst: -------------------------------------------------------------------------------- 1 | .. spelling:word-list:: IPv Thr Asn His Arg píxeis 2 | 3 | #. Faça uma função que determina se um número é par ou ímpar. Use o ``%`` para 4 | determinar o resto de uma divisão. Por exemplo: ``3 % 2 = 1`` e ``4 % 2 = 0`` 5 | 6 | .. only:: instructors 7 | 8 | Exemplo de solução: 9 | 10 | .. code-block:: python3 11 | 12 | def par_ou_impar(numero): 13 | if numero % 2 == 0: 14 | print("É par!") 15 | else: 16 | print("É ímpar!") 17 | 18 | #. Faça uma função que calcule a área de um círculo. Insira o raio como argumento. 19 | 20 | **Dica:** faça a importação de ``math`` e use :math:`\pi` de lá. 21 | 22 | .. math:: 23 | 24 | A = \pi R^2 25 | 26 | #. Crie uma função que receba um valor de temperatura em Fahrenheit e transforme 27 | em Celsius. 28 | 29 | Relembrar é viver: 30 | 31 | .. math:: 32 | 33 | \frac{C}{5} = \frac{F - 32}{9} 34 | 35 | #. Utilizando a função anterior, faça a impressão da temperatura, em graus Celsius, de 0 °C a 100 °C, e todos os valores correspondentes em Fahrenheit. 36 | 37 | #. Receba uma lista com números inteiros e devolva um número inteiro correspondente à soma dos números recebidos. 38 | 39 | #. Receba uma lista com números inteiros. Verifique se a lista possui números repetidos, caso possua, exclua-os e retorne a lista alterada. 40 | 41 | #. Alanderson quer saber se um endereço IP é válido. Faça um programa para 42 | ajudar Alanderson a testar se um endereço é válido. 43 | 44 | Para isso, a entrada deve ser um endereço IP (digitado pelo usuário) e o 45 | programa deve escrever na tela se é válido ou não. Um endereço IPv4 é 46 | composto por 4 números inteiros entre 0 e 255, separados por um ponto. 47 | 48 | Por exemplo, o endereço ``123.123.123.123`` é válido, mas ``666.123.k.3`` 49 | não é. 50 | 51 | .. only:: instructors 52 | 53 | Exemplo de solução: 54 | 55 | .. code-block:: python3 56 | 57 | ip = input('Qual IP você quer testar, Alanderson?\t') 58 | 59 | numeros = ip.split('.') 60 | valido = True 61 | 62 | if len(numeros) != 4: 63 | valido = False 64 | else: 65 | for numero in numeros: 66 | if int(numero) > 255 or int(numero) < 0: 67 | valido = False 68 | 69 | if valido: 70 | print('Æ carai! Esse IP é supimpa!') 71 | else: 72 | print('Poxa Alanderson, esse IP não é válido') 73 | 74 | #. Crie uma função que receba 3 valores e calcula as raízes da fórmula de 75 | Bhāskara. 76 | 77 | .. math:: 78 | 79 | x = \frac{-b \pm \sqrt{b^2 - 4 \cdot a \cdot c}}{2 \cdot a} 80 | 81 | **Dica:** raiz quadrada é ``sqrt()``, importando ``math``: ``math.sqrt()`` 82 | 83 | Faça um teste com ``bhaskara(1, -4, -5)`` e o programa deve obter as raízes: 84 | (5.0, -1.0) 85 | 86 | #. Escreva uma função que receba um valor de comprimento em centímetros e o 87 | transforme em polegadas. 88 | 89 | **Dica:** :math:`1 pol = 2.54 cm`. 90 | 91 | #. Escreva uma função que receba as dimensões de uma fotografia em centímetros 92 | (por exemplo 10 x 15 cm) e a densidade de píxeis da impressora (por exemplo 93 | 300 dpi), e retorne a resolução (por exemplo 2.1 mega píxeis) mínima 94 | necessária para imprimir aquela foto. 95 | 96 | A densidade de píxeis da impressora diz quantos píxeis são impressos a cada 97 | *polegada*. Por exemplo: 300 dpi (*dots per inch*, ou *pontos por polegada*) 98 | significa que em uma polegada em linha reta da imagem há 300 píxeis. 99 | 100 | .. only:: instructors 101 | 102 | Exemplo de solução: 103 | 104 | .. code-block:: python3 105 | 106 | def cm_para_polegadas(x): 107 | return x/2.54 108 | 109 | def megapixeis(x, y, dpi): 110 | x = cm_para_polegadas(x) 111 | y = cm_para_polegadas(y) 112 | return (x * dpi) * (y * dpi) / 1e6 113 | 114 | #. Dada a função: :math:`y = 5x + 2`, determine os valores de :math:`y` para 115 | :math:`x` entre -10 a +10, onde :math:`x` é inteiro 116 | 117 | #. Escreva uma função chamada ``has_duplicates`` que tome uma lista e retorne 118 | ``True`` se houver algum elemento que apareça mais de uma vez. Ela não deve 119 | modificar a lista original. 120 | 121 | #. Duas palavras são um “par inverso” se uma for o contrário da outra. Escreva 122 | uma função que dado duas palavras, retorne ``True`` caso sejam. 123 | 124 | #. Escreva uma função que imprime todos os números primos entre 1 e 50 125 | 126 | **Dica:** um número é primo se ele for divisível apenas por 1 e ele mesmo, 127 | use o operador ``%`` (resto da divisão) para isso. 128 | 129 | #. Duas palavras são anagramas se você puder soletrar uma rearranjando as letras da outra. 130 | Escreva uma função chamada ``is_anagram`` que tome duas strings e retorne ``True`` se forem anagramas ou 131 | ``False`` caso contrário. 132 | 133 | #. Escreva uma função que retorne uma lista com todas as chaves de um dicionário 134 | que contém um certo valor. 135 | 136 | Por exemplo, se o dicionário for 137 | ``{'a': 1, 'b': 2, 'c': 1, 'd': 4}``, a função deve retornar ``['a', 'c']`` 138 | caso procure pelo valor ``1``; ``[]`` caso procure pelo valor ``666``. 139 | 140 | .. only:: instructors 141 | 142 | Exemplo de solução: 143 | 144 | .. doctest:: 145 | 146 | >>> numeritos = {"três": 3, "dois": 2, "um": 1, "um ao quadrado": 1, "zero mais um": 1} 147 | >>> def acha_chaves(d, valor): 148 | ... chaves = [] 149 | ... for k, v in d.items(): 150 | ... if v == valor: 151 | ... chaves.append(k) 152 | ... return chaves 153 | ... 154 | >>> acha_chaves(numeritos, 9) 155 | [] 156 | >>> acha_chaves(numeritos, 1) 157 | ['um', 'um ao quadrado', 'zero mais um'] 158 | 159 | #. Escreva uma função que dado um número, calcule o fatorial desse número. 160 | Por exemplo, fatorial de 5: 161 | 162 | .. math:: 163 | 164 | 5! = 5 \cdot 4 \cdot 3 \cdot 2 \cdot 1 = 120 165 | 166 | #. João quer montar um painel de LEDs contendo diversos números. 167 | Ele não possui muitos LEDs, e não tem certeza se conseguirá montar o número desejado. 168 | Considerando a configuração dos LEDs dos números, faça um algoritmo que ajude João a descobrir a quantidade de LEDs necessário para montar o valor. 169 | 170 | .. figure:: images/leds.jpg 171 | :align: center 172 | :width: 35% 173 | 174 | Exemplos de entrada e saída: 175 | 176 | - ``115380`` —> 27 177 | - ``2819311`` —> 29 178 | - ``23456`` —> 25 179 | - ``000`` —> 18 180 | 181 | .. only:: instructors 182 | 183 | Exemplo de solução: 184 | 185 | .. code-block:: python3 186 | 187 | """ 188 | >>> count_leds(1) 189 | 2 190 | >>> count_leds(5) 191 | 5 192 | >>> count_leds(115380) 193 | 27 194 | >>> count_leds(2819311) 195 | 29 196 | >>> count_leds(111) 197 | 6 198 | >>> count_leds(0) 199 | 6 200 | >>> count_leds('00') 201 | 12 202 | >>> count_leds('001') 203 | 14 204 | >>> count_leds('000') 205 | 18 206 | >>> count_leds('0002') 207 | 23 208 | >>> count_leds(777) 209 | 9 210 | """ 211 | def count_leds(number): 212 | number_leds = {1: 2, 2: 5, 3: 5, 4: 4, 5: 5, 6: 6, 7: 3, 8: 7, 9: 6, 0: 6} 213 | number_str = str(number) 214 | 215 | sum_led = 0 216 | 217 | for i in number_str: 218 | sum_led += number_leds[int(i)] 219 | 220 | return sum_led 221 | 222 | #. Crie uma função que aproxima a função matemática seno, utilizando a seguinte 223 | equação: 224 | 225 | .. math:: 226 | 227 | \sin(x) = \sum_{n=0}^{\infty} \frac{(-1)^n}{(2n+1)!} x^{2n+1} 228 | 229 | Essa é a expansão em *Série de Taylor* da função. Note que esta é uma série 230 | infinita! A sua função deve truncar a série em algum momento, ou seja, sua 231 | função vai calcular uma aproximação para o seno de um ângulo: 232 | 233 | .. math:: 234 | 235 | \sin(x) \approx \sum_{n=0}^{N} \frac{(-1)^n}{(2n+1)!} x^{2n+1} = \sum_{n=0}^{N} a_n = S_N 236 | 237 | Note que, quanto maior o valor de N, melhor é a aproximação. Mas isso tem um 238 | custo: maior vai ser o número de termos nessa série e consequentemente, maior 239 | o tempo de execução desse código. 240 | 241 | Uma possibilidade é estipular previamente uma *precisão* a ser atingida pelo 242 | código. Ou seja, definimos o desvio máximo :math:`\epsilon` que nossa 243 | aproximação tem com relação ao valor exato! Isso é feito comparando dois termos 244 | consecutivos da série: se a diferença :math:`\delta` entre eles (em valor 245 | absoluto!) for menor que :math:`\epsilon`, atingimos a precisão desejada: 246 | 247 | .. math:: 248 | 249 | \delta = | S_N - S_{N-1} | 250 | 251 | Implemente, então, uma função que receba como argumentos: 252 | 253 | * :math:`x`: o ângulo (em radianos!!). 254 | 255 | * :math:`N_\mathrm{max}`: o número máximo de iterações. 256 | 257 | * :math:`\epsilon`: a precisão da aproximação. 258 | 259 | e calcule uma aproximação para :math:`\sin(x)` usando duas condições de parada: 260 | número máximo de termos na série é :math:`N_\mathrm{max}` *e* precisão 261 | :math:`\epsilon`. Ou seja, sua aproximação terá no máximo :math:`N_\mathrm{max}` 262 | termos, mas pode ter menos termos caso a precisão desejada seja atingida ( 263 | :math:`\delta < \epsilon`). 264 | 265 | .. only:: instructors 266 | 267 | Exemplo de solução: 268 | 269 | .. code-block:: python3 270 | 271 | import math 272 | 273 | def seno(x, Nmax = 137, eps = 1e-8): 274 | n = 0 275 | diff = 42 * eps 276 | soma = 0 277 | 278 | while(n <= Nmax and abs(diff) > eps): 279 | termo = (-1)**n * x**(2*n + 1) / fatorial(2*n + 1) 280 | soma += termo 281 | 282 | diff = termo 283 | n += 1 284 | 285 | return soma 286 | 287 | 288 | def fatorial(N): 289 | fat = 1 290 | while(N > 1): 291 | fat = fat * N 292 | N -= 1 293 | 294 | return fat 295 | 296 | 297 | for i in range(1, 200): 298 | alpha = i * math.pi / 180 # converte o angulo pra radiano 299 | 300 | approx = seno(alpha) 301 | error = abs(approx - math.sin(alpha)) # erro dessa aproximação 302 | 303 | print(approx, error) 304 | 305 | 306 | 307 | #. Calcule :math:`\pi` usando um método de Monte Carlo. 308 | 309 | Monte Carlo é uma classe de métodos para resolver problemas usando 310 | estatística. Aqui você vai implementar uma função usando um desses algoritmos 311 | para calcular o número :math:`\pi`. 312 | 313 | Dado um círculo de raio :math:`R` dentro de um quadrado de lados :math:`2R`, 314 | a razão entre a área do círculo para a área do quadrado é: 315 | 316 | .. math:: 317 | 318 | \frac{A_\bigcirc}{A_\square} = \frac{\pi R^2}{4 R^2} = \frac{\pi}{4} 319 | 320 | Ou seja, se você escolher aleatoriamente um ponto dentro do quadrado, a 321 | probabilidade dele cair dentro do círculo é de :math:`\pi / 4`. Se você 322 | escolher :math:`N` pontos aleatórios dentro do quadrado, cerca de 323 | :math:`N \pi / 4` estarão dentro do círculo. 324 | 325 | Então, basta escolher pontos aleatórios dentro do quadrado e ver se estão 326 | dentro do círculo 327 | 328 | Um ponto :math:`(x, y)` está dentro do círculo se 329 | :math:`x^2 + y^2 \leq R^2`. 330 | 331 | Faça uma função que receba como argumento um número :math:`N` de pontos 332 | :math:`(x, y)` (aleatórios) a serem sorteados. Dentro dessa função, você 333 | deve fazer um laço que sorteie esses :math:`N` pontos e veja quantos estão 334 | dentro do círculo. Se :math:`M` pontos caírem dentro do círculo, então a 335 | probabilidade de um ponto aleatório estar dentro do círculo é 336 | aproximadamente :math:`M / N`. Então, podemos estimar :math:`\pi` como: 337 | 338 | .. math:: 339 | 340 | \pi \approx \frac{4 M}{N} 341 | 342 | Para sortear um número aleatório entre :math:`a` e :math:`b` utilize a 343 | função ``uniform(a, b)`` do módulo ``random``. Exemplo: 344 | 345 | 346 | .. doctest:: 347 | 348 | >>> import random 349 | >>> random.uniform(1, 2) # número aleatório entre 1 e 2 350 | 1.8740445361226983 351 | 352 | Perceba que ao executar a função ``pi()`` várias vezes seguidas, o 353 | resultado é sempre diferente. Então faça um laço para calcular ``pi()`` 354 | :math:`K` vezes, salve os resultados em uma lista e calcule o valor médio 355 | e o desvio padrão. 356 | 357 | .. only:: instructors 358 | 359 | Exemplo de solução: 360 | 361 | .. code-block:: python3 362 | 363 | import random 364 | 365 | def pi_(N = 10000, R = 1): 366 | M = 0 367 | for i in range(N): 368 | x, y = random.uniform(-R, R), random.uniform(-R, R) 369 | 370 | if (x**2 + y**2 < R**2): 371 | M += 1 372 | 373 | return 4 * M / N 374 | 375 | def pi(N = 10000, R = 1, K = 100): 376 | pis = [] 377 | 378 | for i in range(K): 379 | pis.append(pi_(N, R)) 380 | 381 | import statistics # since python 3.4 :) 382 | return statistics.mean(pis), statistics.variance(pis) 383 | 384 | print(pi()) 385 | 386 | #. Crie uma função que recebe uma palavra. Retorne as letras únicas para a construção desta palavra e a quantidade de cada letra utilizada. 387 | 388 | Exemplo de entradas e saídas: 389 | 390 | .. code-block:: python3 391 | 392 | >>> letras_e_quantidades("casa") 393 | {'c': 1, 'a': 2, 's': 1} 394 | 395 | >>> letras_e_quantidades("abracadabra") 396 | {'r': 2, 'd': 1, 'a': 5, 'c': 1, 'b': 2} 397 | 398 | 399 | .. only:: instructors 400 | 401 | Exemplo de solução: 402 | 403 | .. code-block:: python3 404 | 405 | def count_letters(string): 406 | 407 | unique_letters = set(string) 408 | counter = 0 409 | dict_letter = {} 410 | 411 | for i in unique_letters: 412 | for j in string: 413 | if i == j: 414 | counter += 1 415 | dict_letter[i] = counter 416 | counter = 0 417 | 418 | return dict_letter 419 | 420 | #. Tanto cadeias DNA quanto RNA são sequências de *nucleotídeos*. O DNA é 421 | formado por: adenina (*A*), citosina (*C*), guanina (*G*) e timina (*T*). E 422 | o RNA é formado por: adenina (*A*), citosina (*C*), guanina (*G*) e uracila 423 | (*U*). 424 | 425 | Dada uma cadeia de DNA, o RNA transcrito é formado substituindo um 426 | nucleotídeo pelo seu complemento: 427 | 428 | - G -> C 429 | - C -> G 430 | - T -> A 431 | - A -> U 432 | 433 | Implemente uma função que receba uma cadeia de DNA como *string* e retorne 434 | a o RNA complementar. 435 | 436 | 437 | #. Implemente uma função que conte quantas vezes um certo nucleotídeo aparece 438 | em uma cadeia de DNA. Para isso, sua função deve receber uma *string* 439 | representando o DNA e outra representando o nucleotídeo. Caso aquele 440 | nucleotídeo ou o DNA não seja válido, retorne ``None``. 441 | 442 | Nesse exercício, considere como inválido se um nucleotídeo não for ``A``, 443 | ``C``, ``G`` ou ``T``. 444 | 445 | 446 | #. O RNA é o responsável por levar as informações contidas no DNA para fora do núcleo da célula, para então ser feita a codificação para as bases púricas: *U*, *A*, *C* e *G*. Quando arranjadas em sequência de trincas (chamadas *códons*), formam um *polipeptídeo*, cadeia de aminoácido. O final de uma cadeia é determinado por um dos seguintes códons: ``UGA``, ``UAA`` ou ``UAG``. 447 | 448 | A tabela a seguir mostra alguns códons e qual aminoácido codifica: 449 | 450 | ============= ========== 451 | Códon RNA Aminoácido 452 | ============= ========== 453 | UAU Ile 454 | UGU Thr 455 | UUG Asn 456 | UCG Ser 457 | GUG His 458 | GCU Arg 459 | CAU Val 460 | ============= ========== 461 | 462 | Por exemplo:: 463 | 464 | TATTCGCATTGA 465 | DNA -> |||||||||||| 466 | ATAAGCGTAACT 467 | 468 | RNA -> UAUUCGCAUUGA 469 | 470 | Códons RNA -> UAU UCG CAU UGA 471 | 472 | Polipeptídeo -> Ile-Ser-Val 473 | 474 | Faça uma função cuja entrada seja uma string com tamanho múltiplo de 3 que representa o RNA. A saída deverá ser uma string com o nome de cada aminoácido separado por hífen, que representa o polipeptídeo. 475 | 476 | **Dica:** faça um dicionário para trocar os códons por aminoácidos. 477 | 478 | **Dica2:** faça uma lista para facilitar a saída. 479 | 480 | Exemplos de entradas e saídas: 481 | 482 | .. code-block:: python3 483 | 484 | >>> polipeptideo("UAUGCUCAUCAUUAUUCGUAG") 485 | "Ile-Arg-Val-Val-Ile-Ser" 486 | 487 | >>> polipeptideo("GCUUAUUCGCAUGCUUCGGCUGCUUAG") 488 | "Arg-Ile-Ser-Val-Arg-Ser-Arg-Arg" 489 | 490 | >>> polipeptideo("CAUUCGGUGGCUUCGGUGUGUCAUUCGCAUUAG") 491 | "Val-Ser-His-Arg-Ser-His-Thr-Val-Ser-Val" 492 | 493 | >>> polipeptideo("GCUCAUUGUUGUUUGCAUUGUGUGGCUGUGCAUUUGUAG") 494 | "Arg-Val-Thr-Thr-Asn-Val-Thr-His-Arg-His-Val-Asn" 495 | 496 | .. only:: instructors 497 | 498 | Exemplo de solução: 499 | 500 | .. code-block:: python3 501 | 502 | # Função recebe uma string com o RNA codificado 503 | def polipeptideo(rna): 504 | # dicionario de tradução dos codons para aminoacidos 505 | dictcodons = {'UAU': 'Ile', 'UGU': 'Thr', 'UUG': 'Asn', 'UCG': 'Ser', 'GUG': 'His', 506 | 'GCU': 'Arg', 'CAU': 'Val', 'UGA': False, 'UAA': False, 'UAG': False} 507 | # iterador 508 | i = 0 509 | # cria a lista que irá receber os aminoacidos 510 | polipep = [] 511 | # seleciona a trinca ou codon 512 | codon = rna[i:i+3] 513 | 514 | # loop onde a condição de parada é o será false 515 | while dictcodons[codon]: 516 | # adiciona o aminoacido a lista polipep 517 | polipep.append(dictcodons[codon]) 518 | # soma 3 ao iterador 519 | i = i + 3 520 | # seleciona o proximo codon 521 | codon = rna[i:i+3] 522 | 523 | # retorna uma string com a união da lista polipep com hifens entre os itens 524 | return '-'.join(polipep) 525 | 526 | rna = "UUGUGUUGUUAUUUGGCUUAUCAUUGA" 527 | print('>>>', rna) 528 | proteina = polipeptideo(rna) 529 | print(proteina) 530 | 531 | .. only:: instructors 532 | 533 | Outro exemplo de solução: 534 | 535 | .. code-block:: python3 536 | 537 | # dict de códon -> aminoácido 538 | aminoacidos = {'UAU': 'Ile', 539 | 'UGU': 'Thr', 540 | 'UUG': 'Asn', 541 | 'UCG': 'Ser', 542 | 'GUG': 'His', 543 | 'GCU': 'Arg', 544 | 'CAU': 'Val'} 545 | 546 | terminators = ['UGA', 'UAA', 'UAG'] 547 | 548 | # retorna cadeia de aminoacidos para uma seq de RNA 549 | def polipeptideo(RNA): 550 | cadeia = [] 551 | for codon in [RNA[i:i+3] for i in range(0, len(RNA), 3)]: 552 | if codon in terminators: 553 | break 554 | cadeia.append(aminoacidos[codon]) 555 | 556 | return cadeia 557 | 558 | print(*polipeptideo("UAUGCUCAUCAUUAUUCGUAG"), sep='-') 559 | print(*polipeptideo("GCUUAUUCGCAUGCUUCGGCUGCUUAG"), sep='-') 560 | print(*polipeptideo("CAUUCGGUGGCUUCGGUGUGUCAUUCGCAUUAG"), sep='-') 561 | print(*polipeptideo("GCUCAUUGUUGUUUGCAUUGUGUGGCUGUGCAUUUGUAG"), sep='-') 562 | -------------------------------------------------------------------------------- /source/exercicios_input.rst: -------------------------------------------------------------------------------- 1 | #. Leia um nome pelo teclado e imprima ``"Olá, !"`` 2 | 3 | #. Leia outro nome pelo teclado e imprima: 4 | 5 | .. code-block:: bash 6 | 7 | roubou pão na cassa do ! 8 | ficou triste e com fome, 9 | porque o bandejão estava fechado. 10 | 11 | #. Leia uma frase pelo teclado e a imprima ao contrário. 12 | 13 | Por exemplo, se a frase for ``"Manjo muito de Python!"``, a saída deverá 14 | ser ``'!nohtyP ed otium ojnaM'``. -------------------------------------------------------------------------------- /source/exercicios_listas.rst: -------------------------------------------------------------------------------- 1 | #. Crie uma lista com o nome das 3 pessoas mais próximas. 2 | 3 | #. Crie três listas, uma lista de cada coisa a seguir: 4 | 5 | * frutas 6 | * docinhos de festa (não se esqueça de brigadeiros!!) 7 | * ingredientes de feijoada 8 | 9 | Lembre-se de salvá-las em alguma variável! 10 | 11 | a. Agora crie uma lista que contém essas três listas. 12 | 13 | Nessa lista de listas (vou chamar de *listona*): 14 | 15 | b. você consegue acessar o elemento *brigadeiro*? 16 | 17 | c. Adicione mais *brigadeiros* à segunda lista de listona. O que aconteceu 18 | com a lista de *docinhos de festa*? 19 | 20 | d. Adicione bebidas ao final da *listona*, mas sem criar uma lista! 21 | 22 | #. Utilizando o ``del``, remova todos os elementos da lista criada anteriormente 23 | até a lista ficar vazia. 24 | 25 | #. Faça uma lista de compras do mês, não se esqueça de comprar produtos de 26 | limpeza e sorvete! 27 | 28 | Agora "vá ao mercado" e delete apenas os produtos de limpeza da lista. 29 | 30 | Agora "vá à sorveteria" e se empanturre de sorvete e tire o sorvete da lista. 31 | 32 | #. Dado uma lista de números, faça com que os números sejam ordenados e, em seguida, inverta a ordem da lista usando *slicing*. 33 | -------------------------------------------------------------------------------- /source/exercicios_repeticao.rst: -------------------------------------------------------------------------------- 1 | #. Calcule a tabuada do 13. 2 | 3 | #. Ler do teclado uma lista com 5 inteiros e imprimir o menor valor. 4 | 5 | #. Ler do teclado uma lista com 5 inteiros e imprimir ``True`` se a lista 6 | estiver ordenada de forma crescente ou False caso contrário. 7 | 8 | #. Exiba em ordem decrescente todos os números de 500 até 10. 9 | 10 | #. Ler do teclado 10 números e imprima a quantidade de números entre 10 e 50. 11 | 12 | #. Ler do teclado a idade e o sexo de 10 pessoas, calcule e imprima: 13 | 14 | a) idade média das mulheres 15 | 16 | #) idade média dos homens 17 | 18 | #) idade média do grupo 19 | 20 | #. Calcule o somatório dos números de 1 a 100 e imprima o resultado. 21 | 22 | #. Receba dois números inteiros correspondentes à largura e altura. Devolva uma cadeia de caracteres ``#`` que representa um retângulo com as medidas fornecidas. 23 | 24 | #. Ler do teclado um número inteiro e imprimir se ele é primo ou não. 25 | 26 | #. Um restaurante que enfrenta problemas com sua capacidade de clientes pediu sua ajuda para fazer um programa 27 | para saber quando eles atingem sua capacidade máxima. Faça um programa que leia um número inteiro da capacidade 28 | máxima do restaurante, e depois pergunte e leia a quantidade de clientes que chegaram até ocupar toda a capacidade 29 | do restaurante e quando lotar imprima na tela "Restaurante lotado, não há mais mesas disponíveis". 30 | 31 | #. O grupy-sanca tem uma fixação com números primos, e é uma tradição marcar seus 32 | eventos em horas e minutos que sejam números primos, como por exemplo 19:31. 33 | 34 | Você ficou responsável por marcar o próximo Pylestras, e, seguindo a tradição, 35 | gostaria de marcar o evento para um horário cuja hora e minuto sejam números primos. 36 | 37 | Para escolher a melhor opção, você gostaria de saber todos os horários que 38 | satisfazem esta condição! 39 | 40 | Crie um programa que imprime no formato ``HH:MM`` todos os horários cuja hora e 41 | minuto são números primos. 42 | 43 | .. note:: Zero não é um número primo e divisões por zero podem estragar suas contas! 44 | 45 | .. only:: instructors 46 | 47 | Exemplo de solução: 48 | 49 | .. code-block:: python3 50 | 51 | horas = 24 52 | minutos = 60 53 | 54 | for hora in range(horas): 55 | hora_primo = 0 56 | for divisor in range(1, hora): 57 | if hora % divisor == 0: 58 | hora_primo += 1 59 | if hora_primo == 1: 60 | for minuto in range(minutos): 61 | minuto_primo = 0 62 | for divisor in range(1, minuto): 63 | if minuto % divisor == 0: 64 | minuto_primo += 1 65 | if minuto_primo == 1: 66 | print(f"{hora}:{minuto}") 67 | 68 | #. As reuniões mais memoráveis do grupy-sanca são, sem dúvidas, os PyBares! 69 | Quando finalmente foi decretado o final da pandemia de Covid-19, pythonistas 70 | de São Carlos e região se reuniram para comemorar, e a comemoração foi tanta, 71 | que neste momento estão com dificuldades de listar quais atividades e 72 | eventos são organizados pelo grupo, sem repetirem as já listadas. 73 | 74 | Como programar já é a sua especialidade, você resolveu escrever um programa para sanar este 75 | pequeno problema. Seu programa deve ler um número N que determina quantos eventos 76 | e atividades foram elencados (que pode ter itens repetidos), e, em seguida, 77 | N nomes de atividades e eventos organizados pelo grupy-sanca e imprimir uma 78 | lista ordenada alfabeticamente e sem itens repetidos. 79 | 80 | Dica: utilize o operador ``in`` para testar se uma entrada já está na lista, 81 | e o método ``sort`` para ordená-la. Também pode ser útil utilizar o método 82 | ``strip`` no seu ``input`` para evitar que espaços em branco interfiram nas suas 83 | comparações. 84 | 85 | .. only:: instructors 86 | 87 | Exemplo de solução: 88 | 89 | .. code-block:: python3 90 | 91 | tentativas = int(input("Digite o número de atividades elencadas: ")) 92 | atividades = [] 93 | for i in range(tentativas): 94 | palpite_atual = input(f"Digite o nome da {i+1}ª atividade: ").strip() 95 | if palpite_atual not in atividades: 96 | atividades.append(palpite_atual) 97 | atividades.sort() 98 | print("Atividades sem repetição e ordenadas:") 99 | print("\n".join(atividades)) 100 | 101 | #. Uma das atividades preferidas do grupy-sanca é o Coding Dojo. 102 | Coding Dojo é uma atividade colaborativa onde pessoas se reúnem a fim de 103 | resolver desafios de programação juntas, programando em pares, e utilizando 104 | a metodologia de desenvolvimento orientada a testes (TDD). A pessoa na posição 105 | do piloto programará por 5 minutos, orientada pela pessoa na posição de copiloto, 106 | e ao final deste tempo, o piloto voltará para a plateia, o copiloto será promovido a piloto 107 | e uma pessoa da plateia tomará a posição de copiloto. 108 | 109 | plateia -> copiloto -> piloto -> plateia 110 | 111 | Você está responsável pela organização do Coding Dojo de hoje, e, para garantir 112 | que todas as pessoas participarão da atividade da forma mais justa possível, 113 | você resolveu criar um programa que imprimirá o nome de cada dupla que representará 114 | copiloto e piloto em cada rodada. 115 | 116 | Você pegou no Meetup uma lista com N nomes de participantes, a duração do evento 117 | é de 2 horas, e cada rodada dura 5 minutos. Caso você chegue ao final da lista e 118 | o tempo ainda não tiverem passado as 2h do Coding Dojo, você começará de novo. 119 | 120 | .. note:: Utilize o operador de resto da divisão (``%``) para iterar circularmente sobre a lista. 121 | 122 | .. only:: instructors 123 | 124 | Exemplo de solução: 125 | 126 | .. code-block:: python3 127 | 128 | num_participantes = int(input("Digite o número de participantes: ")) 129 | participantes = [] 130 | for participante_atual in range(num_participantes): 131 | participantes.append(input(f"Digite o nome da {participante_atual+1}ª pessoa da lista: ").strip()) 132 | rodadas = 2 * 60 // 5 # duas horas vezes sessenta minutos divididos por 5 minutos cada rodada 133 | print("Distribuição:") 134 | for rodada in range(rodadas): 135 | piloto = participantes[rodada % num_participantes] 136 | copiloto = participantes[(rodada+1) % num_participantes] 137 | print(f"piloto: {piloto}\t copiloto: {copiloto}") 138 | -------------------------------------------------------------------------------- /source/exercicios_string.rst: -------------------------------------------------------------------------------- 1 | 2 | #. Dada a frase ``Python é muito legal.``, use fatiamento para dar nome às 3 | variáveis contendo cada palavra. O resultado final deve ser: 4 | 5 | .. code-block:: python3 6 | 7 | >>> frase = "Python é muito legal." 8 | # resolução do problema aqui 9 | >>> palavra1 10 | "Python" 11 | >>> palavra2 12 | "é" 13 | >>> palavra3 14 | "muito" 15 | >>> palavra4 16 | "legal" 17 | 18 | #. Qual o tamanho dessa frase? E qual o tamanho de cada palavra? 19 | 20 | #. Agora que conhecemos atribuição múltipla e o método ``str.split()`` 21 | refaça os dois exercícios anteriores usando essas técnicas. 22 | 23 | #. Use *slicing* (mais especificamente o passo do fatiamento) para inverter a 24 | string "Python". -------------------------------------------------------------------------------- /source/exercicios_variaveis.rst: -------------------------------------------------------------------------------- 1 | #. Supondo que a cotação do dólar esteja em :math:`\mathrm{R}\$\, 3{,}25`, 2 | salve esse valor em uma variável e utilize-o para calcular quanto você 3 | teria ao cambiar :math:`\mathrm{R}\$\, 65{,}00` para dólares. 4 | 5 | #. Abelindo é um professor muito malvado. Ele quer decidir como reprovar 6 | Rondinelly, que tirou 8.66, 5.35, 5 e 1, respectivamente, nas provas 7 | P1, P2, P3 e P4. Para isso, ele pode calcular a nota final usando média 8 | aritmética (M.A.), média geométrica (M.G.) ou média harmônica (M.H.). 9 | 10 | .. math:: 11 | 12 | M.A. = \frac{P_1 + P_2 + P_3 + P_4}{4} 13 | 14 | .. math:: 15 | 16 | M.G. = \sqrt[4]{|P_1 P_2 P_3 P_4|} 17 | 18 | .. math:: 19 | 20 | M.H. = \frac{4}{\frac{1}{P_1} + \frac{1}{P_2} + \frac{1}{P_3} + \frac{1}{P_4}} 21 | 22 | Qual dessas médias dá a maior nota pra Rondinelly? E qual das médias dá 23 | a pior nota? 24 | 25 | .. only:: instructors 26 | 27 | Exemplo de solução: 28 | 29 | .. code-block:: python3 30 | 31 | >>> p1 = 8.66 32 | >>> p2 = 5.35 33 | >>> p3 = 5 34 | >>> p4 = 1 35 | >>> MA = (p1 + p2 + p3 + p4) / 4 36 | >>> MG = (p1 * p2 * p3 * p4)**(1/4) 37 | >>> MH = 4 / (1/p1 + 1/p2 + 1/p3 + 1/p4) 38 | >>> print(MA, MG, MH) 39 | 5.0024999999999995 3.901309628628489 2.662425726074314 40 | 41 | #. Josefson deseja fazer compras na China. Ela quer comprar 42 | um celular de :math:`\mathrm{USD}\, 299{,}99`, 43 | uma chaleira de :math:`\mathrm{USD}\, 23{,}87`, 44 | um gnomo de jardim de :math:`\mathrm{USD}\, 66{,}66` e 45 | 6 adesivos de unicórnio de :math:`\mathrm{USD}\, 1{,}42` cada um. O frete 46 | de tudo isso para a cidade de Rolândia, no Paraná, ficou em 47 | :math:`\mathrm{USD}\, 12{,}34`. 48 | 49 | a. Calcule o valor total da compra em dólares. 50 | 51 | b. Usando o mesmo valor do dólar do exercício anterior, calcule o preço 52 | final em Reais. Lembre-se que o valor do *IOF* é de :math:`6{,}38 \, \%`. 53 | 54 | c. Quanto ela pagou apenas de *IOF*? 55 | 56 | .. only:: instructors 57 | 58 | Exemplo de solução: 59 | 60 | .. code-block:: python3 61 | 62 | >>> dolar = 3.25 63 | >>> celular = 299.99 64 | >>> chaleira = 23.87 65 | >>> gnomo = 66.66 66 | >>> unicórnio = 1.42 67 | >>> frete = 12.34 68 | >>> total_dolares = celular + chaleira + gnomo + 6 * unicórnio 69 | >>> total_dolares_comfrete = celular + chaleira + gnomo + 6 * unicórnio + frete 70 | >>> IOF = 6.38 / 100 71 | >>> total_reais = total_dolares_comfrete * dolar * (1 + IOF) 72 | >>> imposto = total_dolares_comfrete * dolar * IOF 73 | 74 | >>> total_dolares 75 | 399.03999999999996 76 | >>> total_dolares_comfrete 77 | 411.37999999999994 78 | >>> total_reais # item b 79 | 1422.284643 80 | >>> imposto # item c 81 | 85.29964299999999 82 | 83 | 84 | #. O grupy-sanca organizará o sexto Caipyra em 2022, e você faz parte da 85 | Comissão de Organização! Serão quatro dias de evento: um de tutoriais, 86 | dois de palestras, e um de sprints. Você ficou responsável por uma tarefa 87 | deliciosa: o coffee break! 88 | 89 | Participantes consomem um copo de 200ml de quentão e 11 paçoquinhas **por dia**. 90 | Cada paçoquinha custa :math:`\mathrm{R}\$\, 0{,}37` e cada copo de quentão custa 91 | :math:`\mathrm{R}\$\, 0{,}79`. 92 | 93 | Quanto custará o coffee break do Caipyra considerando que teremos 94 | um recorde de 300 participantes neste ano? 95 | 96 | 97 | .. only:: instructors 98 | 99 | Exemplo de solução: 100 | 101 | .. code-block:: python3 102 | 103 | >>> quentao = 0.79 104 | >>> pacoquinha = 0.37 105 | >>> participantes = 300 106 | >>> dias = 4 107 | >>> total = (quentao + pacoquinha * 11) * participantes * dias 108 | >>> total 109 | 5832.0 110 | -------------------------------------------------------------------------------- /source/funcoes.rst: -------------------------------------------------------------------------------- 1 | ======= 2 | Funções 3 | ======= 4 | 5 | Função é uma sequência de instruções que executa uma operação de computação. Ao definir uma função, você especifica o nome e a sequência de instruções. Depois, pode utilizar (“chamar”) a função pelo nome. 6 | 7 | A ideia é similar às funções matemáticas! Mas funções em uma linguagem de programação não realizam necessariamente apenas cálculos. 8 | 9 | Vimos o ``type()``, um exemplo de função: 10 | 11 | .. doctest:: 12 | 13 | >>> type(23) 14 | 15 | 16 | >>> type('textinho') 17 | 18 | 19 | Definindo funções 20 | ----------------- 21 | 22 | Se quisermos uma função que ainda não existe em Python, temos que 23 | *definí-la*. 24 | 25 | Criando uma função simples:: 26 | 27 | def NOME_DA_FUNÇÃO(LISTA DE PARÂMETROS): 28 | COMANDOS 29 | 30 | .. warning:: 31 | 32 | Coloque os dois pontos após definir a função! 33 | 34 | .. note:: 35 | Faça a indentação nas linhas abaixo da definição da função! 36 | 37 | .. doctest:: 38 | 39 | >>> def soma(): 40 | ... print(1 + 1) 41 | ... 42 | >>> soma() 43 | 2 44 | 45 | >>> def soma(): 46 | ... return 1 + 1 47 | ... 48 | >>> soma() 49 | 2 50 | 51 | Qual a diferença entre utilizar ``print()`` e ``return()`` aqui em cima?!? 52 | 53 | .. doctest:: 54 | 55 | >>> def imprime_letra(): 56 | ... print("If you didn't care what happened to me. And I didn't care for you") 57 | ... 58 | >>> imprime_letra() 59 | If you didn't care what happened to me. And I didn't care for you 60 | 61 | >>> type(imprime_letra) 62 | 63 | 64 | >>> def repete_letra(): 65 | ... imprime_letra() 66 | ... imprime_letra() 67 | ... 68 | >>> repete_letra() 69 | If you didn't care what happened to me. And I didn't care for you 70 | If you didn't care what happened to me. And I didn't care for you 71 | 72 | Funções com argumentos 73 | ---------------------- 74 | 75 | Queremos somar ``3`` com um número qualquer que insiro na função. Bora lá: 76 | 77 | .. doctest:: 78 | 79 | >>> def soma_valor(x): 80 | ... return 3 + x 81 | ... 82 | >>> soma_valor(5) 83 | 8 84 | 85 | >>> z = soma_valor(10) 86 | >>> z 87 | 13 88 | 89 | Que sem graça! Quero somar dois números quaisquer! 90 | 91 | .. doctest:: 92 | 93 | >>> def soma_dois_numeros(x, y): 94 | ... return x + y 95 | ... 96 | >>> soma_dois_numeros(7, 4) 97 | 11 98 | 99 | Tenho dificuldade com a tabuada do 7! Ajude-me! 100 | 101 | .. doctest:: 102 | 103 | >>> def tabuada_do_7(): 104 | ... for i in range(11): 105 | ... print (7 * i) 106 | ... 107 | >>> tabuada_do_7() 108 | 0 109 | 7 110 | 14 111 | 21 112 | 28 113 | 35 114 | 42 115 | 49 116 | 56 117 | 63 118 | 70 119 | 120 | Mai tá legal isso! Quero a tabuada do 1 ao 10 agora! Bora! 121 | 122 | .. doctest:: 123 | 124 | >>> def tabuadas(): 125 | ... for i in range(1, 11): 126 | ... for j in range(1, 11): 127 | ... print("{} * {} = {}".format(i, j, i * j)) 128 | ... 129 | >>> tabuadas() 130 | 1 * 1 = 1 131 | 1 * 2 = 2 132 | 1 * 3 = 3 133 | 1 * 4 = 4 134 | 1 * 5 = 5 135 | 1 * 6 = 6 136 | 1 * 7 = 7 137 | 1 * 8 = 8 138 | 1 * 9 = 9 139 | 1 * 10 = 10 140 | 2 * 1 = 2 141 | 2 * 2 = 4 142 | 2 * 3 = 6 143 | 2 * 4 = 8 144 | 2 * 5 = 10 145 | 2 * 6 = 12 146 | 2 * 7 = 14 147 | 2 * 8 = 16 148 | 2 * 9 = 18 149 | 2 * 10 = 20 150 | 3 * 1 = 3 151 | 3 * 2 = 6 152 | 3 * 3 = 9 153 | 3 * 4 = 12 154 | 3 * 5 = 15 155 | 3 * 6 = 18 156 | 3 * 7 = 21 157 | 3 * 8 = 24 158 | 3 * 9 = 27 159 | 3 * 10 = 30 160 | 4 * 1 = 4 161 | 4 * 2 = 8 162 | 4 * 3 = 12 163 | 4 * 4 = 16 164 | 4 * 5 = 20 165 | 4 * 6 = 24 166 | 4 * 7 = 28 167 | 4 * 8 = 32 168 | 4 * 9 = 36 169 | 4 * 10 = 40 170 | 5 * 1 = 5 171 | 5 * 2 = 10 172 | 5 * 3 = 15 173 | 5 * 4 = 20 174 | 5 * 5 = 25 175 | 5 * 6 = 30 176 | 5 * 7 = 35 177 | 5 * 8 = 40 178 | 5 * 9 = 45 179 | 5 * 10 = 50 180 | 6 * 1 = 6 181 | 6 * 2 = 12 182 | 6 * 3 = 18 183 | 6 * 4 = 24 184 | 6 * 5 = 30 185 | 6 * 6 = 36 186 | 6 * 7 = 42 187 | 6 * 8 = 48 188 | 6 * 9 = 54 189 | 6 * 10 = 60 190 | 7 * 1 = 7 191 | 7 * 2 = 14 192 | 7 * 3 = 21 193 | 7 * 4 = 28 194 | 7 * 5 = 35 195 | 7 * 6 = 42 196 | 7 * 7 = 49 197 | 7 * 8 = 56 198 | 7 * 9 = 63 199 | 7 * 10 = 70 200 | 8 * 1 = 8 201 | 8 * 2 = 16 202 | 8 * 3 = 24 203 | 8 * 4 = 32 204 | 8 * 5 = 40 205 | 8 * 6 = 48 206 | 8 * 7 = 56 207 | 8 * 8 = 64 208 | 8 * 9 = 72 209 | 8 * 10 = 80 210 | 9 * 1 = 9 211 | 9 * 2 = 18 212 | 9 * 3 = 27 213 | 9 * 4 = 36 214 | 9 * 5 = 45 215 | 9 * 6 = 54 216 | 9 * 7 = 63 217 | 9 * 8 = 72 218 | 9 * 9 = 81 219 | 9 * 10 = 90 220 | 10 * 1 = 10 221 | 10 * 2 = 20 222 | 10 * 3 = 30 223 | 10 * 4 = 40 224 | 10 * 5 = 50 225 | 10 * 6 = 60 226 | 10 * 7 = 70 227 | 10 * 8 = 80 228 | 10 * 9 = 90 229 | 10 * 10 = 100 230 | 231 | 232 | Argumento padrão 233 | ~~~~~~~~~~~~~~~~~ 234 | 235 | Em alguns casos é conveniente deixar um valor padrão para algum (ou alguns) 236 | argumento(s) de uma função. Por exemplo, imagina uma função que soma dois ou 237 | três números: 238 | 239 | .. doctest:: 240 | 241 | >>> def soma_numeros(x, y, z=0): 242 | ... return x + y + z 243 | ... 244 | >>> soma_numeros(1, 2, 3) 245 | 6 246 | >>> soma_numeros(4, 5) 247 | 9 248 | 249 | Assim podemos usar a mesma função `soma_numeros` para somar dois ou três 250 | argumentos. Basta definir o valor do argumento na definição da função. Isso só 251 | é permitido para os últimos argumentos, ou seja, todos os argumentos à direita 252 | de um argumento padrão devem também ser um argumento padrão. Por exemplo: 253 | 254 | .. doctest:: 255 | 256 | # argumento 'normal' depois de um padrão 257 | >>> def soma_numeros(x, y=0, z): 258 | ... return x + y + z 259 | ... 260 | Traceback (most recent call last): 261 | File "", line 1 262 | SyntaxError: non-default argument follows default argument 263 | 264 | >>> def soma_numeros(x, y=0, z=0): 265 | ... return x + y + z 266 | ... 267 | >>> soma_numeros(1, 2, 3) 268 | 6 269 | 270 | É possível também utilizar o retorno de uma função diretamente como argumento de outra. 271 | Por exemplo, o resultado da função acima como argumento de uma outra função qualquer. No caso estamos utilizando 272 | a mesma função. Assim: 273 | 274 | .. doctest:: 275 | 276 | >>> def soma_numeros(x, y): 277 | ... return x + y 278 | ... 279 | >>> soma_numeros(1, soma_numeros(3, 4)) 280 | 8 281 | 282 | O retorno de `soma_numeros(3, 4)` é 7. Ao utilizar este valor como argumento da função `soma_numeros(1, 7)`, o retorno 283 | é 8. 284 | 285 | Recursão 286 | -------- 287 | 288 | Este conceito é uma técnica de programação que envolve "chamar" a mesma função repetidas vezes até chegar na solução. 289 | 290 | .. note:: 291 | 292 | Confira sua função recursiva para evitar de cair em um `loop` infinito! 293 | 294 | Para que a função seja aplicada diversas vezes, o retorno da função deve conter a própria função. Por exemplo: 295 | 296 | .. doctest:: 297 | 298 | >>> def fatorial(n): 299 | ... if n == 1: 300 | ... return 1 301 | ... else: 302 | ... return n * fatorial(n-1) 303 | ... 304 | >>> fatorial(3) 305 | 6 306 | 307 | Vamos entender o que está sendo feito aqui. 308 | 309 | O cálculo do fatorial de um número, por exemplo, o fatorial de 3 (ou 3!), é: 310 | 311 | 3! = 3 * 2 * 1 312 | 313 | Por definição: 314 | 315 | - 1! = 1 316 | - 0! = 1 317 | 318 | Então, para obter 3! pela função que escrevemos, o 3 entra como argumento e é analisado no ``if`` e "cai" no 319 | ``else``, por não ser igual a 1. 320 | 321 | Aqui é que a magia acontece! O retorno desta função será 3 multiplicado pela função ``fatorial`` (sendo utilizada 322 | pela segunda vez) que irá fazer o cálculo com 2 agora como argumento. Da mesma forma, cai no `else` e 323 | multiplica o valor de 2 pelo ``fatorial(1)``. Agora esta função "cai" no ``if`` e retorna 1. Ao retornar o valor 1 na 324 | função anterior (``factorial(2)``), é feito o produto de 2 por 1 que resulta em 2. Este valor 2 é utilizado no retorno 325 | da função anterior à esta (``factorial(3)``), sendo o retorno de 3 por 2, que resulta em 6. 326 | 327 | Aqui uma ilustração para compreender estas etapas [1]_: 328 | 329 | .. figure:: images/recursion.png 330 | :align: center 331 | :width: 70% 332 | 333 | Exercícios 334 | ---------- 335 | 336 | .. include:: exercicios_funcoes.rst 337 | 338 | 339 | .. [1] ``_ 340 | -------------------------------------------------------------------------------- /source/hello_world.rst: -------------------------------------------------------------------------------- 1 | Hello World 2 | =========== 3 | 4 | É muito comum, ao apresentar uma nova linguagem, começar com um exemplo simples que mostra 5 | na tela as palavras `Hello World`. Para não perder o costume, antes de adentrar 6 | o mundo do Python, vamos ver como outras linguagens de programação implementam 7 | esse exemplo: 8 | 9 | C 10 | ~ 11 | 12 | .. code-block:: C 13 | 14 | #include 15 | 16 | int main(int argc, char *argv[]){ 17 | printf("Hello, World!\n"); 18 | return 0; 19 | } 20 | 21 | 22 | Java 23 | ~~~~ 24 | 25 | .. code-block:: java 26 | 27 | public class Hello { 28 | public static void main(String[] args) { 29 | System.out.println("Hello, World!"); 30 | } 31 | } 32 | 33 | É obrigatório que o código acima esteja em um arquivo chamado `Hello.java` 34 | 35 | 36 | Pascal 37 | ~~~~~~ 38 | 39 | .. code-block:: pascal 40 | 41 | program HelloWorld; 42 | 43 | begin 44 | writeln('Hello, World!'); 45 | end. 46 | 47 | 48 | Python 49 | ~~~~~~ 50 | 51 | Vamos ver como é o *Hello World* em Python. Para isso, abra o `shell` do 52 | Python e digite o texto abaixo (não esqueça de apertar `enter` no final): 53 | 54 | .. doctest:: 55 | 56 | >>> print("Hello, World!") 57 | Hello, World! 58 | 59 | Em programação, é muito comum utilizar a palavra `imprimir` (ou `print`, em 60 | inglês) como sinônimo de mostrar algo na tela. 61 | 62 | 63 | Função ``print()`` 64 | ~~~~~~~~~~~~~~~~~~ 65 | 66 | ``print()`` é uma função nativa do Python. Basta colocar algo dentro dos 67 | parênteses que o Python se encarrega de fazer a magia de escrever na tela :) 68 | 69 | Erros comuns 70 | ------------ 71 | 72 | Usar a letra `P` maiúscula ao invés de minúscula: 73 | 74 | .. doctest:: 75 | 76 | >>> Print("Hello, World!") 77 | Traceback (most recent call last): 78 | ... 79 | NameError: name 'Print' is not defined 80 | 81 | Esquecer de abrir e fechar aspas no texto que é passado para a função 82 | ``print()``: 83 | 84 | .. code-block:: bash 85 | 86 | >>> print(Hello, World!) 87 | Traceback (most recent call last): 88 | ... 89 | SyntaxError: invalid syntax 90 | 91 | Esquecer de abrir ou fechar as aspas: 92 | 93 | .. doctest:: 94 | 95 | >>> print("Hello, World!) 96 | Traceback (most recent call last): 97 | ... 98 | SyntaxError: EOL while scanning string literal 99 | 100 | Começar com aspas simples e terminar com aspas duplas ou vice-versa: 101 | 102 | .. doctest:: 103 | 104 | >>> print('Hello, World!") 105 | Traceback (most recent call last): 106 | ... 107 | SyntaxError: EOL while scanning string literal 108 | 109 | Usar espaço ou tabulação (``tab``) antes do ``print()``: 110 | 111 | .. doctest:: 112 | 113 | >>> print('Hello, World!') 114 | Traceback (most recent call last): 115 | ... 116 | IndentationError: unexpected indent 117 | 118 | >>> print('Hello, World!') 119 | Traceback (most recent call last): 120 | ... 121 | IndentationError: unexpected indent 122 | 123 | Mas, e se eu precisar usar aspas dentro do texto a ser mostrado na tela? Bem, Caso queira imprimir 124 | aspas duplas, envolva tudo com aspas simples e use aspas duplas na parte desejada: 125 | 126 | .. doctest:: 127 | 128 | >>> print('Python é legal! Mas não o "legal" como dizem pra outras coisas') 129 | Python é legal! Mas não o "legal" como dizem pra outras coisas 130 | 131 | Caso deseje imprimir aspas simples, faça o contrário (envolva com aspas duplas e use aspas simples onde necessário): 132 | 133 | .. doctest:: 134 | 135 | >>> print("Python é legal! Mas não o 'legal' como dizem pra outras coisas") 136 | Python é legal! Mas não o 'legal' como dizem pra outras coisas 137 | 138 | E como faz para imprimir um texto em várias linhas? Bom, para isso precisamos 139 | lembrar de um caractere especial, a *quebra de linha*: `\\n`. Esse `\\n` é um 140 | caractere especial que significa *aqui acaba a linha, o que vier depois deve 141 | ficar na linha de baixo*. Por exemplo: 142 | 143 | .. doctest:: 144 | 145 | >>> print('Olha esse textão sobre aspas simples e duplas.\nIsso aqui é aspas duplas: "\nIsso aqui é aspas simples: \'') 146 | Olha esse textão sobre aspas simples e duplas. 147 | Isso aqui é aspas duplas: " 148 | Isso aqui é aspas simples: ' 149 | -------------------------------------------------------------------------------- /source/images/H4l_mass_v3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/H4l_mass_v3.png -------------------------------------------------------------------------------- /source/images/cluster.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/cluster.jpg -------------------------------------------------------------------------------- /source/images/exemplo_sol.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/exemplo_sol.png -------------------------------------------------------------------------------- /source/images/ide_Atom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/ide_Atom.png -------------------------------------------------------------------------------- /source/images/ide_pycharm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/ide_pycharm.png -------------------------------------------------------------------------------- /source/images/ide_spyder.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/ide_spyder.png -------------------------------------------------------------------------------- /source/images/ide_vsc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/ide_vsc.png -------------------------------------------------------------------------------- /source/images/idle1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/idle1.png -------------------------------------------------------------------------------- /source/images/idle2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/idle2.png -------------------------------------------------------------------------------- /source/images/idle3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/idle3.png -------------------------------------------------------------------------------- /source/images/idle4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/idle4.png -------------------------------------------------------------------------------- /source/images/idle5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/idle5.png -------------------------------------------------------------------------------- /source/images/idle6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/idle6.png -------------------------------------------------------------------------------- /source/images/indices.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/indices.png -------------------------------------------------------------------------------- /source/images/install1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/install1.png -------------------------------------------------------------------------------- /source/images/ipython.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/ipython.png -------------------------------------------------------------------------------- /source/images/leds.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/leds.jpg -------------------------------------------------------------------------------- /source/images/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/logo.png -------------------------------------------------------------------------------- /source/images/logo_small.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/logo_small.png -------------------------------------------------------------------------------- /source/images/python_shell.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/python_shell.png -------------------------------------------------------------------------------- /source/images/recursion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/recursion.png -------------------------------------------------------------------------------- /source/images/sobre/bar01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/bar01.jpg -------------------------------------------------------------------------------- /source/images/sobre/bar02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/bar02.jpg -------------------------------------------------------------------------------- /source/images/sobre/caipyras01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/caipyras01.jpg -------------------------------------------------------------------------------- /source/images/sobre/caipyras02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/caipyras02.jpg -------------------------------------------------------------------------------- /source/images/sobre/caipyras03.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/caipyras03.jpg -------------------------------------------------------------------------------- /source/images/sobre/caipyras04.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/caipyras04.jpg -------------------------------------------------------------------------------- /source/images/sobre/curso01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/curso01.jpg -------------------------------------------------------------------------------- /source/images/sobre/curso02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/curso02.jpg -------------------------------------------------------------------------------- /source/images/sobre/curso03.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/curso03.jpg -------------------------------------------------------------------------------- /source/images/sobre/curso04.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/curso04.jpg -------------------------------------------------------------------------------- /source/images/sobre/dojo01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/dojo01.jpg -------------------------------------------------------------------------------- /source/images/sobre/dojo02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/dojo02.jpg -------------------------------------------------------------------------------- /source/images/sobre/palestras01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/palestras01.jpg -------------------------------------------------------------------------------- /source/images/sobre/palestras02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/palestras02.jpg -------------------------------------------------------------------------------- /source/images/sobre/sprint01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/sprint01.jpg -------------------------------------------------------------------------------- /source/images/sobre/sprint02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/sobre/sprint02.jpg -------------------------------------------------------------------------------- /source/images/thesims4.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/grupy-sanca/curso-python/43b513628a9f692e0e6634ac120ca2bfd79c86ca/source/images/thesims4.jpg -------------------------------------------------------------------------------- /source/index.rst: -------------------------------------------------------------------------------- 1 | Curso Introdutório de Python 2 | ============================ 3 | 4 | .. include:: prefacio.rst 5 | 6 | .. toctree:: 7 | :maxdepth: 2 8 | :caption: Conteúdo: 9 | :name: Índice 10 | 11 | introducao 12 | sobre_grupy 13 | instalacao 14 | hello_world 15 | calculadora 16 | variaveis 17 | strings 18 | input 19 | listas 20 | dicionarios 21 | condicionais 22 | controle 23 | repeticao 24 | funcoes 25 | lambda 26 | boas_praticas 27 | exercicios 28 | epilogo 29 | contribuidores 30 | -------------------------------------------------------------------------------- /source/input.rst: -------------------------------------------------------------------------------- 1 | Lendo valores do teclado 2 | ======================== 3 | 4 | Em Python também é possível ler do teclado as informações digitadas pelo 5 | usuário. E isso é feito por meio da função embutida ``input()`` da seguinte 6 | forma: 7 | 8 | .. testsetup:: input_single 9 | 10 | def input(text): 11 | print(text + '10') 12 | return '10' 13 | 14 | .. doctest:: input_single 15 | 16 | >>> valor_lido = input("digite um valor: ") 17 | digite um valor: 10 18 | 19 | >>> type(valor_lido) # deve-se notar que o valor lido é SEMPRE do tipo string 20 | 21 | 22 | A função ``input()`` "termina" de ser executada quando pressionamos *enter*. 23 | 24 | .. note:: O valor lido é sempre do tipo string. 25 | 26 | Mas, como realizar operações com os valores lidos? 27 | 28 | .. doctest:: input_single 29 | 30 | >>> valor_lido + 10 # para trabalhar com esse valor, é preciso converter para o tipo correto 31 | Traceback (most recent call last): 32 | ... 33 | TypeError: must be str, not int 34 | 35 | Para poder fazer isso pode-se usar os operadores ``int()`` e ``float(),`` que 36 | converte o valor lido para o tipo de dado esperado: 37 | 38 | .. testsetup:: input_convert 39 | 40 | def gen(): 41 | yield '10' 42 | yield '1.5' 43 | 44 | values = gen() 45 | 46 | def input(text): 47 | value = next(values) 48 | print(text + value) 49 | return value 50 | 51 | .. doctest:: input_convert 52 | 53 | >>> valor_lido = int(input("digite um valor inteiro: ")) 54 | digite um valor inteiro: 10 55 | 56 | >>> type(valor_lido) 57 | 58 | 59 | >>> valor_lido + 10 60 | 20 61 | 62 | >>> valor_lido = float(input("digite um valor decimal: ")) 63 | digite um valor decimal: 1.5 64 | 65 | >>> valor_lido - 1 66 | 0.5 67 | 68 | Tudo o que for digitado no teclado, até pressionar a tecla *enter*, será 69 | capturado pela função ``input()``. Isso significa que podemos ler palavras 70 | separadas por um espaço, ou seja, uma frase inteira: 71 | 72 | .. testsetup:: input_frase 73 | 74 | def input(): 75 | frase = 'Rosas são vermelhas, violetas são azuis, girassóis são legais.' 76 | print(frase) 77 | return frase 78 | 79 | .. doctest:: input_frase 80 | 81 | >>> frase = input() 82 | Rosas são vermelhas, violetas são azuis, girassóis são legais. 83 | >>> frase 84 | 'Rosas são vermelhas, violetas são azuis, girassóis são legais.' 85 | 86 | 87 | Exercícios 88 | ---------- 89 | 90 | .. include:: exercicios_input.rst 91 | -------------------------------------------------------------------------------- /source/instalacao.rst: -------------------------------------------------------------------------------- 1 | .. _intro-instalacao: 2 | 3 | Guia de Instalação do Python 4 | ============================ 5 | 6 | Linux 7 | ----- 8 | 9 | Provavelmente você já tem o Python instalado e configurado. Para ter certeza 10 | que ele está instalado e descobrir qual versão, abra um terminal e execute o 11 | comando: 12 | 13 | .. code-block:: bash 14 | 15 | $ python --version 16 | 17 | Se o resultado do comando for ``Python 3.6.5`` (ou alguma versão igual ou 18 | superior a ``3.5``) o Python já está instalado corretamente. 19 | 20 | Caso o resultado do comando anterior tenha sido ``Python 2.7.13`` (ou qualquer 21 | versão do ``Python 2``) tente rodar o seguinte comando, pois seu computador 22 | pode ter ambas versões ``2`` e ``3`` instaladas: 23 | 24 | .. code-block:: bash 25 | 26 | $ python3 --version 27 | 28 | Caso tenha aparecido a mensagem ``bash: python: command not found``, você pode 29 | instalá-lo da seguinte maneira: 30 | 31 | No Ubuntu e Debian 32 | ~~~~~~~~~~~~~~~~~~ 33 | 34 | .. code-block:: bash 35 | 36 | $ sudo apt install python3 37 | 38 | No ArchLinux 39 | ~~~~~~~~~~~~ 40 | 41 | .. code-block:: bash 42 | 43 | $ sudo pacman -Sy python 44 | 45 | 46 | Mac OS X 47 | -------- 48 | 49 | Obtenha o instalador na sessão de downloads para `Mac OS X do Python`_. Clique 50 | duas vezes no ``Python.mpkg`` para abrir o instalador. 51 | 52 | Para ter certeza que ele está instalado e descobrir qual versão, abra um 53 | terminal e execute o comando: 54 | 55 | .. code-block:: bash 56 | 57 | $ python --version 58 | Python 3.6.5 59 | 60 | .. _Mac OS X do Python: https://www.python.org/downloads/ 61 | 62 | 63 | Windows 64 | ------- 65 | 66 | Obtenha o arquivo de instalação última versão compatível com a arquitetura do 67 | seu computador no `site oficial do Python`_. O arquivo ``x86`` provavelmente 68 | funcionará para todos computadores. 69 | 70 | A seguir, execute o instalador e uma imagem similar a essa aparecerá: 71 | 72 | .. figure:: images/install1.png 73 | :align: center 74 | :width: 80% 75 | 76 | Deve ser selecionada a opção ``Add Python 3.6 to PATH`` e depois continuar a 77 | instalação até o fim. 78 | 79 | .. _site oficial do Python: https://www.python.org/downloads/ 80 | 81 | 82 | Ambientes de Desenvolvimento 83 | ============================ 84 | 85 | Há diversos programas para desenvolvermos códigos, alguns são mais bonitinhos, 86 | outros são mais poderosos, alguns são mais simples, outros são mais amigáveis. 87 | Dê uma olhada nesta seção e escolha o que você achar mais interessante. Somente 88 | você pode responder à pergunta "Qual o melhor ambiente de desenvolvimento para 89 | *mim*?" 90 | 91 | IDE (*Integrated Development Environment* - Ambiente de Desenvolvimento Integrado, em português) 92 | é um editor de texto que possui ferramentas e recursos que facilitam a vida do programador. 93 | Entre as ferramentas e recursos, podemos citar: 94 | 95 | - Identificar quais variáveis foram declaradas. 96 | - Identificar erros no código. 97 | - Personalizar o ambiente de trabalho. 98 | - Ocultar parte do código para melhor visualização. 99 | 100 | Ambientes gráficos 101 | ------------------ 102 | 103 | ATOM 104 | ~~~~ 105 | 106 | O programa ATOM é um IDE *open-source* que apresenta diversos pacotes para personalizar. 107 | 108 | .. figure:: images/ide_Atom.png 109 | :align: center 110 | :width: 80% 111 | 112 | No site oficial do `ATOM `_, você encontrará um link para a Documentação do programa. 113 | Na documentação, é possível acessar o `manual `_ que mostrará passo a passo como instalar o programa (tanto para Windows como para Linux). 114 | 115 | Caso você tenha alguma dúvida, é aconselhável entrar na seção de `discusão `_. Nessa página, você encontrará respostas para diversas dúvidas, e possivelmente, para a sua. 116 | 117 | IDLE 118 | ~~~~ 119 | 120 | Para usuários Windows é recomendado utilizar o ``IDLE``. Ele é composto pelo interpretador do Python e um editor de texto para criar programas, e já vem junto com o Python. 121 | Após seguir o :ref:`intro-instalacao`, o menu inicial deve estar da seguinte 122 | forma: 123 | 124 | 125 | .. figure:: images/idle1.png 126 | :align: center 127 | :width: 80% 128 | 129 | Ao abrir o `IDLE (Python 3.X)`, aparecerá uma janela como na 130 | imagem abaixo: 131 | 132 | .. figure:: images/idle2.png 133 | :align: center 134 | :width: 80% 135 | 136 | No ``IDLE`` é possível digitar comandos para o interpretador do Python e, também, 137 | é possível criar e digitar em um arquivo. Para fazer isso, no menu clique em 138 | ``File`` -> ``New File`` (Ou pressione as teclas ``Ctrl`` + ``N`` juntas) 139 | 140 | .. figure:: images/idle3.png 141 | :align: center 142 | :width: 80% 143 | 144 | Para rodar um programa, clique em ``Run`` -> ``Run Module`` (Ou aperte a tecla ``F5``) 145 | 146 | .. figure:: images/idle4.png 147 | :align: center 148 | :width: 80% 149 | 150 | Caso o arquivo ainda não tenha sido salvo, é necessário salvá-lo antes de 151 | executá-lo. Não esqueça de prefixar o nome do arquivo com ``.py`` 152 | (extensão do Python): 153 | 154 | .. figure:: images/idle5.png 155 | :align: center 156 | :width: 80% 157 | 158 | Após isso, o resultado da execução do código deve aparecer na janela anterior do ``IDLE``: 159 | 160 | .. figure:: images/idle6.png 161 | :align: center 162 | :width: 80% 163 | 164 | PyCharm 165 | ~~~~~~~~~~~~~~~~~~ 166 | Esta IDE é voltada especificamente para a linguagem Python. No `site oficial `_ é possível encontrar orientações para realizar o download e instalação (Linux, Mac, Windows). 167 | 168 | .. figure:: images/ide_pycharm.png 169 | :align: center 170 | :width: 80% 171 | 172 | É desenvolvido pela empresa tcheca JetBrains. Fornece análise de código, um depurador gráfico, teste de unidade integrado, integração com sistemas de controle de versão, ambiente virtual e suporta o desenvolvimento da Web com o Django, bem como Data Science com o Anaconda (`Wikipedia `_). 173 | 174 | Spyder 175 | ~~~~~~ 176 | 177 | O Spyder é uma IDE perfeita para quem utiliza o Python para Ciência de Dados, especialmente porque vem incluso no *Anaconda*, um pacote de várias bibliotecas e ferramentas voltadas para essa área. 178 | 179 | .. figure:: images/ide_spyder.png 180 | :align: center 181 | :width: 80% 182 | 183 | Ele possui uma interface simples, com uma tabela de variáveis para fácil inspeção dos valores de cada variável no programa durante sua depuração. 184 | 185 | A melhor forma de instalá-lo é pela instalação do `Anaconda `_. Novamente, recomenda-se utilizar essa forma de instalação apenas para quem deseja utilizar todos os pacotes inclusos no Anaconda, e não apenas o Spyder. 186 | 187 | Visual Studio Code 188 | ~~~~~~~~~~~~~~~~~~ 189 | 190 | O Visual Studio Code por si só é um editor de texto criado pela Microsoft que apresenta diversos pacotes para personalizá-lo da forma que você precisa. 191 | 192 | .. figure:: images/ide_vsc.png 193 | :align: center 194 | :width: 80% 195 | 196 | No site oficial do `Visual Studio Code `_, você encontrará um link para a Documentação do programa. 197 | 198 | Na documentação, é possível acessar o `manual de Python `_ que mostra todos as funcionalidades que o programa possui relacionadas a Python. 199 | 200 | Para um passo-a-passo da instalação, você pode encontrar os detalhes de cada sistema operacional `nesta página do manual `_. 201 | 202 | Linha de comando 203 | ---------------- 204 | 205 | Existe também a possibilidade de trabalhar sem um ambiente gráfico, utilizando apenas a *interface de linha de comando*. 206 | 207 | Python Shell 208 | ~~~~~~~~~~~~ 209 | 210 | Se você instalou corretamente o Python, você tem à sua disposição um interpretador interativo, popularmente conhecido como *o Shell do Python*. 211 | 212 | Se você utiliza Linux ou Mac, basta abrir um terminal e digitar ``python``. Caso utilize Windows, deverá existir uma pasta no menu *iniciar* chamada ``Python 3.7`` (ou ``Python 3.6``) que permite abrir o interpretador. Caso tenha sucesso, você deverá encontrar algo similar a esta imagem: 213 | 214 | .. figure:: images/python_shell.png 215 | :align: center 216 | 217 | Para sair do Python, digite ``quit()``. Isso encerra a seção interativa e te retorna ao terminal (ou fecha a tela preta, no caso do Windows). 218 | 219 | Note que, ao entrar no interpretador, a primeira linha começa com ``Python 3.7.2``. Essa é a versão utilizada do Python. Neste curso utilizamos a versão ``3.6`` ou mais recente. Caso a versão que aparecer em seu interpretador seja ``2.7.6``, encerre a seção e tente o comando ``python3`` para utilizar a versão ``3`` do Python. 220 | 221 | IPython 222 | ~~~~~~~ 223 | 224 | `IPython`_ é um Shell alternativo para o Python, bem poderoso. E colorido também, ao contrário do ``shell`` nativo do Python. 225 | 226 | .. figure:: images/ipython.png 227 | :align: center 228 | 229 | .. _IPython: https://ipython.org 230 | -------------------------------------------------------------------------------- /source/introducao.rst: -------------------------------------------------------------------------------- 1 | .. spelling:word-list:: Electronic Arts 2 | 3 | Introdução 4 | ========== 5 | 6 | O que é *Python*? 7 | ----------------- 8 | 9 | *Python* é uma *linguagem de programação*. Isso significa basicamente duas coisas: 10 | 11 | 1. existem regras que determinam como as palavras são dispostas, já que é uma *linguagem*; 12 | 13 | 2. o texto descreve *instruções* para o computador realizar tarefas. 14 | 15 | Ou seja, podemos escrever um documento - que chamamos de *código fonte* - em Python para o computador ler e realizar nossos desejos e tarefas. Python tem algumas características interessantes: 16 | 17 | * é *interpretada*, ou seja, o interpretador do Python executa o código fonte diretamente, traduzindo cada trecho para instruções de máquina; 18 | 19 | * é de *alto nível*, ou seja, o interpretador se vira com detalhes técnicos do computador. Assim, desenvolver um código é mais simples do que em linguagens de *baixo nível*, nas quais o programador deve se preocupar com detalhes da máquina; 20 | 21 | * é de *propósito geral*, ou seja, podemos usar Python para desenvolver programas em diversas áreas. Ao contrário de linguagens de domínio específico, que são especializadas e atendem somente a uma aplicação específica; 22 | 23 | * tem *tipos dinâmicos*, ou seja, o interpretador faz a magia de descobrir o que é cada variável. 24 | 25 | Por essas e várias outras características, Python se torna uma linguagem simples, bela, legível e amigável. É uma linguagem utilizada por diversas empresas, como Wikipedia, Google, Yahoo!, CERN, NASA, Facebook, Amazon, Instagram, Spotify... [1]_ 26 | 27 | O desenvolvimento de Python começou no final da década de 1980, por Guido van Rossum. Ele decidiu usar esse nome porque estava lendo um roteiro de *Monty Python*, um grupo de comédia inglês da década de 1970. A documentação oficial do Python contém muitas referências aos filmes e personagens desse grupo. 28 | 29 | Um resumo das versões desta linguagem: 30 | 31 | - Versão 1.0 foi publicada em Janeiro de 1994. 32 | 33 | - Versão 2.0 foi publicada em Outubro de 2000. 34 | 35 | - Versão 3.0 foi publicada em Dezembro de 2008. 3.9 é a versão mais recente. 36 | 37 | 38 | Exemplos 39 | -------- 40 | 41 | Vamos ver alguns exemplos sobre o uso de Python no mundo real. 42 | 43 | BitTorrent 44 | ~~~~~~~~~~ 45 | 46 | O protocolo *Torrent* é muito utilizado para transferir quantidades grandes de dados para diversos computadores. O primeiro programa a implementar esse protocolo foi desenvolvido inteiramente em Python, pela *BitTorrent, Inc.*! [2]_ 47 | 48 | 49 | Django 50 | ~~~~~~ 51 | 52 | *Django* é um conjunto de pacotes para desenvolvimento web. E é baseado em Python :) 53 | 54 | Um objetivo de Django é desenvolver facilmente websites complexos e que lidam com bancos de dados grandões. Alguns sites desenvolvidos em Django: Instagram, The Washington Times, Disqus, Mozilla, National Geographic. [6]_ 55 | 56 | 57 | Dropbox 58 | ~~~~~~~ 59 | 60 | O popular serviço de armazenamento de dados em Nuvem *Dropbox* tem diversas partes da infraestrutura feita em Python. [5]_ O aplicativo para computadores é feito em Python e grande parte da infra estrutura dos servidores deles também é! 61 | 62 | 63 | Estudo sobre erupções solares 64 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 65 | 66 | Não somente a indústria utiliza Python, muitos pesquisadores utilizam em diversas áreas científicas. 67 | 68 | É possível de modo bem simples estudar as erupções solares desde 1992 até hoje. O Observatório Real da Bélgica tem um banco de dados sobre o número de manchas solares, e disponibilizam online para estudos. [4]_ Veja como é o código para visualizar a atividade solar desde 01/01/1992 em cada parte (norte e sul) do Sol: 69 | 70 | .. code-block:: python3 71 | 72 | import pandas as pd # isso aqui gerencia os dados 73 | import matplotlib.pyplot as plt # isso aqui permite fazer gráficos 74 | 75 | # pega os dados solares de WDC-SILSO, Royal Observatory of Belgium, Brussels 76 | sun = pd.read_table('http://sidc.oma.be/silso/INFO/sndhemcsv.php', sep=';', encoding="ISO-8859-1", header=None) 77 | 78 | # faz o gráfico de cada hemisfério do sol 79 | fig = plt.figure() 80 | plt.scatter(sun[3], sun[5], label='Norte', alpha=0.5) 81 | plt.scatter(sun[3], sun[6], label='Sul', alpha=0.5) 82 | 83 | plt.title("Atividade solar diária\n") 84 | plt.ylabel('Número de manchas solares') 85 | plt.xlabel('Ano') 86 | plt.legend(loc='upper right') 87 | 88 | plt.show() 89 | 90 | E o resultado desse código é a seguinte imagem: 91 | 92 | .. figure:: images/exemplo_sol.png 93 | :align: center 94 | :width: 80% 95 | 96 | Erupções solares desde 1992, separadas por hemisférios (norte e sul) do Sol. 97 | 98 | Física de Partículas 99 | ~~~~~~~~~~~~~~~~~~~~ 100 | 101 | O premio Nobel de 2013 em Física foi para os cientistas que estudaram como as partículas elementares adquirem massa, conhecido como *Mecanismo de Higgs*. [7]_ Uma nova partícula foi descoberta em 2012: o *Bóson de Higgs*. Você pode ler todos os detalhes super técnicos neste artigo `aqui `_ que os cientistas do CERN publicaram. 102 | 103 | Caso você esteja interessado apenas na parte computacional, você pode refazer toda a análise dos dados experimentais utilizando Python! Existe uma `apostila online`_ que ensina passo a passo como obter os dados experimentais e simulações teóricas para reproduzir o gráfico a seguir. 104 | 105 | .. figure:: images/H4l_mass_v3.png 106 | :align: center 107 | :width: 80% 108 | 109 | Reprodução dos resultados científicos publicados em 2012 sobre a descoberta do Bóson de Higgs. Gráfico obtido com o código publicado na `apostila online`_, que utiliza dados públicos do experimento CMS, no CERN. 110 | 111 | .. _apostila online: https://github.com/cms-opendata-education/cms-jupyter-materials-english/blob/master/Exercises-with-open-data/Advanced/Hunting-the-Higgs-4leptons.ipynb 112 | 113 | The Sims 4 114 | ~~~~~~~~~~ 115 | 116 | O jogo *The Sims 4* tem partes feitas em Python [3]_. Isso permite o desenvolvimento de *mods* para o jogo em Python \\o/ 117 | 118 | .. figure:: images/thesims4.jpg 119 | :align: center 120 | :width: 35% 121 | 122 | Capa do jogo The Sims 4, da Electronic Arts. 123 | 124 | 125 | .. [1] Lista compilada pela página da `Wikipedia sobre Python `_, em inglês. 126 | 127 | .. [2] ``_ 128 | 129 | .. [3] ``_ 130 | 131 | .. [4] ``_ 132 | 133 | .. [5] ``_ 134 | 135 | .. [6] ``_ 136 | 137 | .. [7] ``_ 138 | -------------------------------------------------------------------------------- /source/lambda.rst: -------------------------------------------------------------------------------- 1 | Função Lambda 2 | ============= 3 | 4 | A função lambda tem origem no lambda cálculo, inicialmente desenvolvido pelo matemático Alonzo Church. No Python é também chamada de função anônima e seu uso permite a criação rápida de funções sem que seja necessário nomeá-las. Uma função lambda pode receber n números de argumentos, mas possui uma única expressão. 5 | 6 | No Python tem a forma: lambda : 7 | 8 | Como exemplo, a soma de três variáveis x, y e z utilizando-se o comando *lambda* fica da seguinte forma: 9 | 10 | .. doctest:: 11 | 12 | >>> lambda x,y,z: x+y+z 13 | 14 | No exemplo abaixo mostramos como uma mesma função pode ser escrita de duas formas, utilizando-se o comando *def* ou *lambda*. 15 | 16 | .. doctest:: 17 | 18 | >>> def duplica(x): 19 | ... return 2*x 20 | >>> duplica(5) 21 | 10 22 | >>> duplica = lambda x: 2*x 23 | >>> duplica(5) 24 | 10 25 | 26 | Lambda e funções 27 | ---------------- 28 | 29 | O uso do lambda pode ser realizado dentro de outras funções. 30 | No caso abaixo a função *multiplica* retorna uma outra função definida pela expressão lambda. 31 | Passando-se o valor 3, é retornado uma função que realiza a multiplicação por 3: 32 | f(x) = 3x. 33 | 34 | .. doctest:: 35 | 36 | >>> def multiplica(n): 37 | ... return lambda x: n*x 38 | >>> multiplica(3) 39 | .(x)> 40 | >>> triplica = multiplica(3) 41 | >>> triplica(10) 42 | 30 43 | >>> quadruplica = multiplica(4) 44 | >>> quadruplica(10) 45 | 40 46 | 47 | Lambda e strings 48 | ---------------- 49 | 50 | Assim como ocorre em funções criadas pelo comando *def*, outros métodos do Python podem ser utilizados na expressão da função *lambda*. 51 | Abaixo mostramos alguns exemplos com manipulação de strings associado ao uso do *lambda*. 52 | 53 | .. doctest:: 54 | 55 | >>> letra_maiuscula = lambda string: string[0].upper() + string[1:] 56 | >>> letra_maiuscula('maria') 57 | 'Maria' 58 | >>> inverte = lambda string: string[::-1] 59 | >>> inverte('EDUARDO') 60 | 'ODRAUDE' 61 | -------------------------------------------------------------------------------- /source/listas.rst: -------------------------------------------------------------------------------- 1 | .. _section_listas: 2 | 3 | Listas 4 | ====== 5 | 6 | Listas são estruturas de dados capazes de armazenar múltiplos elementos. 7 | 8 | Declaração 9 | ---------- 10 | 11 | Para a criação de uma lista, basta colocar os elementos separados por vírgulas dentro de colchetes ``[]``, como no exemplo abaixo: 12 | 13 | .. doctest:: 14 | 15 | >>> nomes_frutas = ["maçã", "banana", "abacaxi"] 16 | >>> nomes_frutas 17 | ['maçã', 'banana', 'abacaxi'] 18 | 19 | >>> numeros = [2, 13, 17, 47] 20 | >>> numeros 21 | [2, 13, 17, 47] 22 | 23 | A lista pode conter elementos de tipos diferentes: 24 | 25 | .. doctest:: 26 | 27 | >>> ['lorem ipsum', 150, 1.3, [-1, -2]] 28 | ['lorem ipsum', 150, 1.3, [-1, -2]] 29 | 30 | >>> vazia = [] 31 | >>> vazia 32 | [] 33 | 34 | Outra possibilidade de criar uma lista vazia: 35 | 36 | .. doctest:: 37 | 38 | >>> outra_lista_vazia = list() 39 | >>> outra_lista_vazia 40 | [] 41 | 42 | Índices 43 | ------- 44 | 45 | Assim como nas *strings*, é possível acessar separadamente cada item de uma 46 | lista a partir de seu índice: 47 | 48 | .. doctest:: 49 | 50 | >>> lista = [100, 200, 300, 400, 500] 51 | >>> lista[0] # os índices sempre começam em 0 52 | 100 53 | 54 | >>> lista[2] 55 | 300 56 | 57 | >>> lista[4] # último elemento 58 | 500 59 | 60 | >>> lista[-1] # outra maneira de acessar o último elemento 61 | 500 62 | 63 | Conforme visto anteriormente, ao utilizar um índice negativo os elementos são acessados de trás pra frente, a partir do final da lista: 64 | 65 | .. doctest:: 66 | 67 | >>> lista[-2] # penúltimo elemento 68 | 400 69 | 70 | >>> lista[-3] # terceiro 71 | 300 72 | 73 | >>> lista[-4] # segundo 74 | 200 75 | 76 | >>> lista[-5] # primeiro 77 | 100 78 | 79 | Ou pode-se acessar através de *slices* (fatias), como nas :ref:`strings `: 80 | 81 | .. doctest:: 82 | 83 | >>> lista[2:4] # da posição 2 até a 4 (não inclusa) 84 | [300, 400] 85 | 86 | >>> lista[:3] # até a posição 3 (não incluso) 87 | [100, 200, 300] 88 | 89 | >>> lista[2:] # da posição 2 até o final 90 | [300, 400, 500] 91 | 92 | >>> lista[:] # do começo até o final 93 | [100, 200, 300, 400, 500] 94 | 95 | Tentar acessar uma posição inválida de uma lista causa um erro: 96 | 97 | .. doctest:: 98 | 99 | >>> lista[10] 100 | Traceback (most recent call last): 101 | ... 102 | IndexError: list index out of range 103 | 104 | >>> lista[-10] 105 | Traceback (most recent call last): 106 | ,,, 107 | IndexError: list index out of range 108 | 109 | Podemos avaliar se os elementos estão na lista com a palavra ``in``: 110 | 111 | .. doctest:: 112 | 113 | >>> lista_estranha = ['duas palavras', 42, True, ['batman', 'robin'], -0.84, 'hipófise'] 114 | >>> 42 in lista_estranha 115 | True 116 | 117 | >>> 'duas palavras' in lista_estranha 118 | True 119 | 120 | >>> 'dominó' in lista_estranha 121 | False 122 | 123 | >>> 'batman' in lista_estranha[3] # note que o elemento com índice 3 também é uma lista 124 | True 125 | 126 | É possível obter o tamanho da lista utilizando o método ``len()``: 127 | 128 | .. doctest:: 129 | 130 | >>> len(lista) 131 | 5 132 | 133 | >>> len(lista_estranha) 134 | 6 135 | 136 | >>> len(lista_estranha[3]) 137 | 2 138 | 139 | Removendo itens da lista 140 | ------------------------ 141 | 142 | Devido à lista ser uma estrutura mutável, é possível remover seus elementos utilizando o comando ``del``: 143 | 144 | .. doctest:: 145 | 146 | >>> lista_estranha 147 | ['duas palavras', 42, True, ['batman', 'robin'], -0.84, 'hipófise'] 148 | 149 | >>> del lista_estranha[2] 150 | >>> lista_estranha 151 | ['duas palavras', 42, ['batman', 'robin'], -0.84, 'hipófise'] 152 | 153 | >>> del lista_estranha[-1] # Remove o último elemento da lista 154 | >>> lista_estranha 155 | ['duas palavras', 42, ['batman', 'robin'], -0.84] 156 | 157 | Trabalhando com listas 158 | ---------------------- 159 | 160 | O operador ``+`` concatena listas: 161 | 162 | .. doctest:: 163 | 164 | >>> a = [1, 2, 3] 165 | >>> b = [4, 5, 6] 166 | >>> c = a + b 167 | >>> c 168 | [1, 2, 3, 4, 5, 6] 169 | 170 | O operador ``*`` repete a lista dado um número de vezes: 171 | 172 | .. doctest:: 173 | 174 | >>> [0] * 3 175 | [0, 0, 0] 176 | 177 | >>> [1, 2, 3] * 2 178 | [1, 2, 3, 1, 2, 3] 179 | 180 | O método ``append()`` adiciona um elemento ao final da lista: 181 | 182 | .. doctest:: 183 | 184 | >>> lista = ['a', 'b', 'c'] 185 | >>> lista 186 | ['a', 'b', 'c'] 187 | 188 | >>> lista.append('e') 189 | >>> lista 190 | ['a', 'b', 'c', 'e'] 191 | 192 | Temos também o ``insert()``, que insere um elemento na posição especificada 193 | e move os demais elementos para direita: 194 | 195 | .. doctest:: 196 | 197 | >>> lista.insert(3, 'd') 198 | >>> lista 199 | ['a', 'b', 'c', 'd', 'e'] 200 | 201 | .. warning:: 202 | 203 | Cuidado com ``lista.insert(-1, algo)``! Nesse caso, inserimos ``algo`` na 204 | posição ``-1`` e o elemento que estava previamente na posição ``-1`` é 205 | movido para a direita: 206 | 207 | .. doctest:: 208 | 209 | >>> lista.insert(-1, 'ç') 210 | >>> lista 211 | ['a', 'b', 'c', 'd', 'ç', 'e'] 212 | 213 | Use ``append()`` caso queira algo adicionado ao final da lista. 214 | 215 | ``extend()`` recebe uma lista como argumento e adiciona todos seus elementos a 216 | outra: 217 | 218 | .. doctest:: 219 | 220 | >>> lista1 = ['a', 'b', 'c'] 221 | >>> lista2 = ['d', 'e'] 222 | >>> lista1 223 | ['a', 'b', 'c'] 224 | 225 | >>> lista2 226 | ['d', 'e'] 227 | 228 | >>> lista1.extend(lista2) 229 | >>> lista1 230 | ['a', 'b', 'c', 'd', 'e'] 231 | 232 | ``lista2`` não é modificado: 233 | 234 | .. doctest:: 235 | 236 | >>> lista2 237 | ['d', 'e'] 238 | 239 | O método ``sort()`` ordena os elementos da lista em ordem ascendente: 240 | 241 | .. doctest:: 242 | 243 | >>> lista_desordenada = ['b', 'z', 'k', 'a', 'h'] 244 | >>> lista_desordenada 245 | ['b', 'z', 'k', 'a', 'h'] 246 | 247 | >>> lista_desordenada.sort() 248 | >>> lista_desordenada # Agora está ordenada! 249 | ['a', 'b', 'h', 'k', 'z'] 250 | 251 | Para fazer uma cópia de uma lista, devemos usar o método ``copy()``: 252 | 253 | .. doctest:: 254 | 255 | >>> lista1 = ['a', 'b', 'c'] 256 | >>> lista2 = lista1.copy() 257 | >>> lista1 258 | ['a', 'b', 'c'] 259 | >>> lista2 260 | ['a', 'b', 'c'] 261 | >>> lista2.append('d') 262 | >>> lista1 263 | ['a', 'b', 'c'] 264 | >>> lista2 265 | ['a', 'b', 'c', 'd'] 266 | 267 | Se não usarmos o ``copy()``, acontece algo bem estranho: 268 | 269 | .. doctest:: 270 | 271 | >>> lista1 = ['a', 'b', 'c'] 272 | >>> lista2 = lista1 273 | >>> lista1 274 | ['a', 'b', 'c'] 275 | >>> lista2 276 | ['a', 'b', 'c'] 277 | >>> lista2.append('d') 278 | >>> lista1 279 | ['a', 'b', 'c', 'd'] 280 | >>> lista2 281 | ['a', 'b', 'c', 'd'] 282 | 283 | Tudo o que for feito com ``lista2`` nesse exemplo também altera ``lista1`` e vice-versa. 284 | 285 | 286 | Exercícios 287 | ---------- 288 | 289 | .. include:: exercicios_listas.rst 290 | 291 | .. o range faz parte de listas neste contexto 292 | .. include:: range.rst 293 | 294 | 295 | Sumário 296 | -------- 297 | 298 | .. csv-table:: 299 | :header: "Operação", "Descrição" 300 | :widths: auto 301 | :delim: ; 302 | 303 | ``lista = ['maçã', 'banana', 'abacaxi']`` ; Cria uma nova lista com 3 itens 304 | ``lista = []`` ; Cria uma lista vazia 305 | ``lista = list()`` ; Outra opção para criar uma lista vazia 306 | ``lista.append(item)`` ; Adiciona um item no fim da lista 307 | ``lista.insert(2, 'caju')`` ; insere um elemento na posição especificada e move os demais elementos para direita 308 | ``lista[0]`` ; Acessa o primeiro item da lista (os índices começam em 0) 309 | ``lista[-1]`` ; Acessa o último item da lista 310 | ``lista[-2]`` ; Acessa o penúltimo item da lista 311 | ``lista[2:4]`` ; Retorna uma fatia da posição 2 até a 4 (não inclusa) 312 | ``'maça' in lista`` ; Verifica se o item ``maça`` existe na lista 313 | ``del lista[0]`` ; Remove o primeiro item da lista 314 | ``lista1 + lista2`` ; Concatena duas listas em um uma nova 315 | ``lista1.extend(lista2)`` ; Atualiza a lista1, adicionando todos os elementos da lista2 316 | ``[0] * 3 => [0, 0, 0]`` ; O operador ``*`` repete a lista dado um número de vezes 317 | ``list(range(10))`` ; Produz uma lista com um intervalo de números: ``[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]`` -------------------------------------------------------------------------------- /source/prefacio.rst: -------------------------------------------------------------------------------- 1 | .. only:: latex 2 | 3 | .. raw:: latex 4 | 5 | \chapter*{Prefácio} 6 | \addcontentsline{toc}{chapter}{\protect\numberline{}Prefácio} 7 | 8 | O objetivo deste curso é introduzir os conceitos básicos de programação para 9 | pessoas sem experiência em desenvolvimento ou iniciantes que não conheçam a 10 | linguagem Python. 11 | 12 | O recomendado é cada participante ter acesso a um computador durante o curso 13 | para fazer os exercícios. O único modo de aprender programação é programando. 14 | 15 | A duração estimada para este curso é de cerca de 7 horas, mas esse tempo 16 | pode variar dependendo do tamanho da turma e da disponibilidade de café. 17 | 18 | Sugerimos que o curso seja realizado: 19 | 20 | - em um dia inteiro: com pausas (~20 min) no meio da manhã e da tarde e um 21 | intervalo para o almoço; ou 22 | 23 | - em três dias seguidos: por cerca de duas ou duas horas e meia em cada dia. 24 | 25 | Este trabalho está licenciado sob a Licença 26 | Atribuição-NãoComercial-CompartilhaIgual 4.0 Internacional (BY-NC-SA 4.0 27 | internacional) Creative Commons. Para visualizar uma cópia desta licença, 28 | visite http://creativecommons.org/licenses/by-nc-sa/4.0/ 29 | -------------------------------------------------------------------------------- /source/range.rst: -------------------------------------------------------------------------------- 1 | Função ``range()`` 2 | ------------------ 3 | 4 | Aprendemos a adicionar itens a uma lista mas, e se fosse necessário produzir 5 | uma lista com os números de 1 até 200? 6 | 7 | .. doctest:: 8 | 9 | >>> lista_grande = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] # ??? 10 | >>> lista_grande 11 | [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] 12 | 13 | Em Python existe a função embutida ``range()``, com ela é possível produzir uma lista extensa de uma maneira bem simples: 14 | 15 | .. doctest:: 16 | 17 | >>> print(list(range(1, 200))) 18 | [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199] 19 | 20 | Além disso, o ``range()`` também oferece algumas coisas interessantes. Por 21 | exemplo, imprimir os números espaçados de 5 em 5, entre 0 e 30: 22 | 23 | .. doctest:: 24 | 25 | >>> print(list(range(0, 30, 5))) 26 | [0, 5, 10, 15, 20, 25] 27 | 28 | Mas, como na maior parte das vezes apenas queremos uma lista começando em 0 e 29 | indo até o número desejado, a função ``range()`` também funciona da seguinte 30 | maneira: 31 | 32 | .. doctest:: 33 | 34 | >>> print(list(range(10))) 35 | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 36 | 37 | .. note:: O intervalo do ``range()`` é aberto, ou seja, quando passamos o valor 10, ele vai até o 9 (n - 1). Caso deseje criar a lista até o 10 de fato, deve-se passar o valor 11. 38 | 39 | Mas por que precisamos transformar o ``range()`` em ``list``? O que acontece se não fizermos isso? 40 | 41 | .. doctest:: 42 | 43 | >>> print(range(200)) 44 | range(0, 200) 45 | 46 | Mas o que é que essa função retorna? 47 | 48 | .. doctest:: 49 | 50 | >>> type(range(200)) 51 | " 52 | 53 | AHA! A função ``range()`` retorna algo do tipo ``range``, por isso precisamos transformar em uma lista para vermos todos os números no ``print()``! -------------------------------------------------------------------------------- /source/repeticao.rst: -------------------------------------------------------------------------------- 1 | ======================= 2 | Estruturas de repetição 3 | ======================= 4 | 5 | As estruturas de repetição são utilizadas quando queremos que um bloco de código 6 | seja executado várias vezes. 7 | 8 | Em Python existem duas formas de criar uma estrutura de repetição: 9 | 10 | - O ``for`` é usado quando se quer iterar sobre um bloco de código um 11 | número determinado de vezes. 12 | 13 | - O ``while`` é usado quando queremos que o bloco de código seja repetido 14 | até que uma condição seja satisfeita. Ou seja, é necessário que uma 15 | expressão booliana dada seja verdadeira. Assim que ela se tornar falsa, 16 | o ``while`` para. 17 | 18 | .. note:: 19 | 20 | Na linguagem Python a indentação é obrigatória. assim como nas estruturas 21 | de controle, as estruturas de repetição também precisam. 22 | 23 | .. doctest:: 24 | 25 | >>> # Aqui repetimos o print 3 vezes 26 | >>> for n in range(0, 3): 27 | ... print(n) 28 | ... 29 | 0 30 | 1 31 | 2 32 | 33 | >>> # Aqui iniciamos o n em 0, e repetimos o print até que seu valor seja maior ou igual a 3 34 | >>> n = 0 35 | >>> while n < 3: 36 | ... print(n) 37 | ... n += 1 38 | ... 39 | 0 40 | 1 41 | 2 42 | 43 | O *loop* ``for`` em Python itera sobre os itens de um conjunto, sendo assim, o 44 | ``range(0, 3)`` precisa ser um conjunto de elementos. E na verdade ele é: 45 | 46 | .. doctest:: 47 | 48 | >>> list(range(0, 3)) 49 | [0, 1, 2] 50 | 51 | Para iterar sobre uma lista: 52 | 53 | .. doctest:: 54 | 55 | >>> lista = [1, 2, 3, 4, 10] 56 | >>> for numero in lista: 57 | ... print(numero ** 2) 58 | ... 59 | 1 60 | 4 61 | 9 62 | 16 63 | 100 64 | 65 | Isso se aplica para *strings* também: 66 | 67 | .. doctest:: 68 | 69 | >>> # Para cada letra na palavra, imprimir a letra 70 | >>> palavra = "casa" 71 | >>> for letra in palavra: 72 | ... print(letra) 73 | ... 74 | c 75 | a 76 | s 77 | a 78 | 79 | Em dicionários podemos fazer assim: 80 | 81 | .. doctest:: 82 | 83 | >>> gatinhos = {"Português": "gato", "Inglês": "cat", "Francês": "chat", "Finlandês": "Kissa"} 84 | >>> for chave, valor in gatinhos.items(): 85 | ... print(chave, "->", valor) 86 | ... 87 | Português -> gato 88 | Inglês -> cat 89 | Francês -> chat 90 | Finlandês -> Kissa 91 | 92 | Para auxiliar as estruturas de repetição, existem dois comandos: 93 | 94 | * ``break``: É usado para sair de um *loop*, não importando o estado em 95 | que se encontra. 96 | 97 | * ``continue``: Funciona de maneira parecida com a do ``break``, porém 98 | no lugar de encerrar o *loop*, ele faz com que todo o código que 99 | esteja abaixo (porém ainda dentro do *loop*) seja ignorado e avança 100 | para a próxima iteração. 101 | 102 | Veja a seguir um exemplo de um código que ilustra o uso desses comandos. Note que há uma *string* de documentação no começo que explica a funcionalidade. 103 | 104 | .. testsetup:: input_loop 105 | 106 | def gen(): 107 | yield 'oi' 108 | yield '?' 109 | yield 'sair' 110 | 111 | values = gen() 112 | 113 | def input(text): 114 | value = next(values) 115 | print(text + value) 116 | return value 117 | 118 | 119 | .. doctest:: input_loop 120 | 121 | """ 122 | Esse código deve rodar até que a palavra "sair" seja digitada. 123 | * Caso uma palavra com 2 ou menos caracteres seja digitada, um aviso 124 | deve ser exibido e o loop será executado do início (devido ao 125 | continue), pedindo uma nova palavra ao usuário. 126 | * Caso qualquer outra palavra diferente de "sair" seja digitada, um 127 | aviso deve ser exibido. 128 | * Por fim, caso a palavra seja "sair", uma mensagem deve ser exibida e o 129 | loop deve ser encerrado (break). 130 | """ 131 | 132 | >>> while True: 133 | ... string_digitada = input("Digite uma palavra: ") 134 | ... if string_digitada.lower() == "sair": 135 | ... print("Fim!") 136 | ... break 137 | ... if len(string_digitada) < 2: 138 | ... print("String muito pequena") 139 | ... continue 140 | ... print("Tente digitar \"sair\"") 141 | ... 142 | Digite uma palavra: oi 143 | Tente digitar "sair" 144 | Digite uma palavra: ? 145 | String muito pequena 146 | Digite uma palavra: sair 147 | Fim! 148 | 149 | 150 | ---------- 151 | Exercícios 152 | ---------- 153 | 154 | .. include:: exercicios_repeticao.rst 155 | -------------------------------------------------------------------------------- /source/sobre_grupy.rst: -------------------------------------------------------------------------------- 1 | Sobre o grupy-sanca 2 | =================== 3 | 4 | O *grupy-sanca* (Grupo de Usuários Python de São Carlos) é uma comunidade que 5 | reúne pessoas interessadas em desenvolvimento de *software* e na linguagem 6 | Python. Prezamos pela troca de conhecimento, respeito mútuo e diversidade 7 | (tanto de opinião quanto de tecnologias). 8 | 9 | Somos um grupo da cidade de São Carlos (SP) e região. Realizamos 10 | periodicamente diversos eventos. 11 | 12 | 13 | Atividades 14 | ---------- 15 | 16 | Cursos e oficinas de programação 17 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 18 | 19 | Oferecemos cursos básicos de Python e também sobre alguns assuntos específicos. Durante os cursos os membros do grupy se voluntariam para serem monitores e ajudam a solucionar eventuais dúvidas dos participantes. 20 | 21 | .. figure:: images/sobre/curso01.jpg 22 | :align: center 23 | :width: 70% 24 | 25 | Nosso primeiro curso de Python \\o/ 26 | 27 | Realizado em 25 de março de 2017, no ICMC - USP - São Carlos. 28 | Tivemos ~200 inscritos! 81 participantes! 4 ministrantes! 8 monitores!! 29 | 2 *coffee-breaks*! 4 garrafas térmicas: café e chá! 30 | 31 | .. figure:: images/sobre/curso02.jpg 32 | :align: center 33 | :width: 70% 34 | 35 | Curso de Python básico no IFSC! 36 | 37 | Realizado em 01 de Julho de 2017, no IFSC - USP - São Carlos. 38 | Tivemos ~100 inscritos! 38 participantes! 2 ministrantes! 3 monitores!! 39 | 2 *coffee-breaks*! 2 garrafas térmicas com apenas café :P 40 | 41 | 42 | Também aceitamos convites para ministrar nossos cursos em eventos, como semanas acadêmicas. 43 | 44 | 45 | .. figure:: images/sobre/curso03.jpg 46 | :align: center 47 | :width: 70% 48 | 49 | Curso de Python básico na UNESP de Rio Claro!! 50 | 51 | Fez parte da programação da SECCOMP 2017, em 23 de Outubro de 2017. 52 | 53 | .. figure:: images/sobre/curso04.jpg 54 | :align: center 55 | :width: 70% 56 | 57 | Curso de Python básico na USP de São Carlos!! 58 | 59 | Fez parte da programação da SEnC 2018, em 24 de Outubro de 2018. 60 | 61 | 62 | Pylestras 63 | ~~~~~~~~~ 64 | 65 | Evento com o objetivo de reunir a comunidade, compartilhar conhecimento e 66 | divulgar novas tecnologias. É tradicionalmente composto por palestras rápidas (~17 minutos), onde obrigatoriamente uma delas não é sobre Python. 67 | 68 | Qualquer pessoa interessada pode submeter uma palestra, independentemente do tema ser para iniciantes ou usuários avançados. Para deixar a escolha democrática, costumamos usar o `Speakerfight `_, onde a própria comunidade escolhe as palestras que acha mais interessantes. 69 | 70 | .. figure:: images/sobre/palestras01.jpg 71 | :align: center 72 | :width: 70% 73 | 74 | .. figure:: images/sobre/palestras02.jpg 75 | :align: center 76 | :width: 70% 77 | 78 | 79 | Coding Dojos 80 | ~~~~~~~~~~~~ 81 | 82 | É um espaço para que as pessoas possam aprender, treinar e aprimorar suas 83 | habilidades em programação. O *coding dojo* é um ótimo lugar para aprender 84 | coisas novas. 85 | 86 | Em um *coding dojo* são propostos vários desafios e os participantes 87 | selecionam quais querem resolver. Após escolherem o desafio, as pessoas leem 88 | o problema, entendem e discutem como resolvê-lo. Com esses pontos resolvidos, 89 | começa a programação da solução. O desenvolvimento é feito em apenas um 90 | computador por duas pessoas programando por vez (*pair programming*). Sendo que 91 | a cada intervalo de 5 minutos as pessoas à frente do computador dão lugar para 92 | outras. 93 | 94 | .. figure:: images/sobre/dojo02.jpg 95 | :align: center 96 | :width: 70% 97 | 98 | Para o dojo fluir bem, adota-se o TDD (*Test Driven Development*), pois assim 99 | as pessoas pensam melhor em como o código será utilizado antes de desenvolver. 100 | Também segue-se o desenvolvimento por *baby steps* em que tenta-se dividir o 101 | problema em partes menores para resolvê-lo. 102 | 103 | Ao término do dojo acontece uma retrospectiva em que as pessoas respondem 104 | três perguntas básicas: *o que foi aprendido?*; *o que pode ser melhorado?* 105 | e *o que deve continuar a ser feito?*. Isso serve para os participantes 106 | melhorarem nos dojos futuros. Por experiência do grupy-sanca, fazer isso 107 | realmente vale a pena :) 108 | 109 | .. figure:: images/sobre/dojo01.jpg 110 | :align: center 111 | :width: 70% 112 | 113 | Antes ou depois do coding dojo acontece um coffee break comunitário. Mas já 114 | aconteceu de ser durante também... 115 | 116 | Eventos 117 | ~~~~~~~ 118 | 119 | O grupy-sanca também organiza eventos singulares, únicos no universo! 120 | 121 | Um dos maiores eventos realizados pela comunidade foi o `Caipyra 2018 <2018.caipyra.python.org.br>`_, o único evento de Python com quentão e paçoquinha, que tem por objetivo ser uma conferência de Python voltada ao público do interior do estado de São Paulo. 122 | 123 | Após duas edições sediadas em Ribeirão Preto, o grupy-sanca trouxe o evento para São Carlos em 2018 (e já está organizando a edição de 2019). 124 | 125 | .. figure:: images/sobre/caipyras01.jpg 126 | :align: center 127 | :width: 70% 128 | 129 | Tivemos 237 participantes, 16 palestras e 3 tutoriais 130 | 131 | .. figure:: images/sobre/caipyras02.jpg 132 | :align: center 133 | :width: 70% 134 | 135 | Foram consumidos ~40 litros de quentão e 1625 paçoquinhas 136 | 137 | .. figure:: images/sobre/caipyras03.jpg 138 | :align: center 139 | :width: 70% 140 | 141 | Oferecemos um espaço infantil para os papais e mamães poderem participar do evento 142 | 143 | .. figure:: images/sobre/caipyras04.jpg 144 | :align: center 145 | :width: 70% 146 | 147 | Tudo isso feito com muito carinho pelos membros do grupy-sanca <3 148 | 149 | Sprints 150 | ~~~~~~~ 151 | 152 | Sprints são maratonas de programação. Um grupo de pessoas se junta no 153 | mesmo lugar para desenvolver algum projeto novo, resolver *bugs* 154 | de algum software, ou implementar alguma funcionalidade nova. 155 | 156 | Durante os sprints, usuários iniciantes podem aprender como contribuir com projetos open source, sendo um ambiente ideal para ter contato com pessoas mais experientes e aprender boas práticas. 157 | 158 | .. figure:: images/sobre/sprint01.jpg 159 | :align: center 160 | :width: 70% 161 | 162 | *Hacktoberfest* de 2017 :) 163 | 164 | Fizemos cerca de 50 *commits* esse dia \o/ 165 | 166 | .. figure:: images/sobre/sprint02.jpg 167 | :align: center 168 | :width: 70% 169 | 170 | 171 | Encontros casuais 172 | ~~~~~~~~~~~~~~~~~ 173 | 174 | Também conhecidos como PyBares :) 175 | 176 | A ideia é bater um papo sobre a vida, o universo e tudo mais e tomar uma 177 | cerveja (ou não). 178 | 179 | A comunidade Python vai muito além de escrever código Python, participar de 180 | oficinas/minicursos ou realizar encontros técnicos. Os encontros no bar tem 181 | como objetivo conectar pessoas e prover uma conversa descontraída entre os 182 | participantes. 183 | 184 | .. figure:: images/sobre/bar01.jpg 185 | :align: center 186 | :width: 70% 187 | 188 | E em algumas situações, combinamos de conversar apenas *in english*! 189 | 190 | .. figure:: images/sobre/bar02.jpg 191 | :align: center 192 | :width: 70% 193 | 194 | 195 | Histórico 196 | --------- 197 | 198 | O grupo foi fundado em 28/06/2016 e desde então já tivemos: 199 | 200 | - 40+ Coding Dojos 201 | 202 | - 41+ PyBares 203 | 204 | - 16+ Cursos e workshops 205 | 206 | - 7 PyLestras 207 | 208 | - 4 Eventos 209 | 210 | - 5 Sprints 211 | 212 | Além disso, chegamos nos 1368+ inscritos no Meetup! 213 | 214 | 215 | Para saber mais sobre os eventos organizados pelo grupy-sanca acesse: 216 | 217 | - `Site oficial `_ 218 | 219 | .. only:: latex 220 | 221 | www.grupysanca.com.br 222 | 223 | - `Facebook `_ 224 | 225 | .. only:: latex 226 | 227 | facebook.com/grupysanca 228 | 229 | - `Instagram `_ 230 | 231 | .. only:: latex 232 | 233 | instagram.com/grupysanca/ 234 | 235 | - `Telegram `_ 236 | 237 | .. only:: latex 238 | 239 | t.me/grupysanca 240 | 241 | - `Discord `_ 242 | 243 | .. only:: latex 244 | 245 | discord.gg/AgS2dBa 246 | 247 | - `Meetup `_ 248 | 249 | .. only:: latex 250 | 251 | meetup.com/grupy-sanca 252 | 253 | - `YouTube `_ 254 | 255 | .. only:: latex 256 | 257 | youtube.com/grupysanca 258 | 259 | - `GitHub `_ 260 | 261 | .. only:: latex 262 | 263 | github.com/grupy-sanca 264 | 265 | - `Linkedin `_ 266 | 267 | .. only:: latex 268 | 269 | linkedin.com/company/grupy-sanca 270 | 271 | .. spelling:word-list:: 272 | grupysanca 273 | br 274 | coding 275 | 276 | Ou entre em contato através do nosso email: contato `@` grupysanca `.` com `.` br 277 | -------------------------------------------------------------------------------- /source/strings.rst: -------------------------------------------------------------------------------- 1 | `Strings` (sequência de caracteres) 2 | =================================== 3 | 4 | *Strings* são tipos que armazenam uma *sequência de caracteres*: 5 | 6 | .. doctest:: 7 | 8 | >>> "Texto bonito" 9 | 'Texto bonito' 10 | >>> "Texto com acentos de cedilhas: hoje é dia de caça!" 11 | 'Texto com acentos de cedilhas: hoje é dia de caça!' 12 | 13 | As *strings* aceitam aspas simples também: 14 | 15 | .. doctest:: 16 | 17 | >>> nome = 'Silvio Santos' 18 | >>> nome 19 | 'Silvio Santos' 20 | 21 | .. note:: *Strings* aceitam os dois tipos de aspas, desde que seja 22 | consistente. Se começou com uma, termine com aquela! 23 | 24 | .. doctest:: 25 | 26 | >>> cor_da_caneta = "azul brilhante' 27 | File "", line 1 28 | cor_da_caneta = "azul brilhante' 29 | ^ 30 | SyntaxError: EOL while scanning string literal 31 | 32 | Também é possível fazer algumas operações com strings: 33 | 34 | .. doctest:: 35 | 36 | >>> nome * 3 37 | 'Silvio SantosSilvio SantosSilvio Santos' 38 | >>> nome * 3.14 39 | Traceback (most recent call last): 40 | ... 41 | TypeError: can't multiply sequence by non-int of type 'float' 42 | 43 | .. doctest:: 44 | 45 | >>> canto1 = 'vem aí, ' 46 | >>> canto2 = 'lá ' 47 | >>> nome + ' ' + canto1 + canto2 * 6 + '!!' 48 | 'Silvio Santos vem aí, lá lá lá lá lá lá !!' 49 | 50 | Para strings em várias linhas, utilize 3 aspas: 51 | 52 | .. doctest:: 53 | 54 | >>> string_grande = '''Aqui consigo inserir um textão com várias linhas, posso iniciar em uma... 55 | ... e posso continuar em outra 56 | ... e em outra 57 | ... e mais uma 58 | ... e acabou.''' 59 | >>> string_grande 60 | 'Aqui consigo inserir um textão com várias linhas, posso iniciar em uma...\ne posso continuar em outra\ne em outra\ne mais uma\ne acabou.' 61 | >>> print(string_grande) 62 | Aqui consigo inserir um textão com várias linhas, posso iniciar em uma... 63 | e posso continuar em outra 64 | e em outra 65 | e mais uma 66 | e acabou. 67 | 68 | Caso queira um texto que dentro tem aspas, como ``Me dá um copo d'água``, é 69 | necessário utilizar aspas duplas para formar a *string*: 70 | 71 | .. doctest:: 72 | 73 | >>> agua = "Me dá um copo d'água" 74 | >>> agua 75 | "Me dá um copo d'água" 76 | 77 | E também é possível utilizar aspas simples, duplas e triplas ao mesmo tempo! 78 | Olha só: 79 | 80 | .. doctest:: 81 | 82 | >>> todas_as_aspas = """Essa é uma string que tem: 83 | ... - aspas 'simples' 84 | ... - aspas "duplas" 85 | ... - aspas '''triplas''' 86 | ... Legal né?""" 87 | >>> todas_as_aspas 88 | 'Essa é uma string que tem:\n- aspas \'simples\'\n- aspas "duplas"\n- aspas \'\'\'triplas\'\'\'\nLegal né?' 89 | >>> print(todas_as_aspas) 90 | Essa é uma string que tem: 91 | - aspas 'simples' 92 | - aspas "duplas" 93 | - aspas '''triplas''' 94 | Legal né? 95 | 96 | 97 | Tamanho 98 | ------- 99 | 100 | A função embutida ``len()`` nos permite, entre outras coisas, saber o 101 | tamanho de uma *string*: 102 | 103 | .. doctest:: 104 | 105 | >>> len('Abracadabra') 106 | 11 107 | >>> palavras = 'Faz um pull request lá' 108 | >>> len(palavras) 109 | 22 110 | 111 | Assim, vemos que a palavra ``Abracadabra`` tem 11 letras. 112 | 113 | 114 | Índices 115 | ------- 116 | 117 | Como visto anteriormente, o método ``len()`` pode ser utilizado para obter o 118 | tamanho de estruturas, sejam elas *strings*, listas, etc. Esse tamanho 119 | representa a quantidade de elementos na estrutura. 120 | 121 | Para obter somente um caractere de dentro dessas estruturas, deve-se utilizar 122 | o acesso por índices, no qual o índice entre colchetes ``[]`` representa a 123 | posição do elemento que se deseja acessar. 124 | 125 | .. note:: Os índices começam em zero. 126 | 127 | .. figure:: images/indices.png 128 | :align: center 129 | :scale: 80% 130 | 131 | .. doctest:: 132 | 133 | >>> palavra = 'Python' 134 | >>> palavra[0] # primeira 135 | 'P' 136 | >>> palavra[5] # última 137 | 'n' 138 | 139 | Índices negativos correspondem à percorrer a estrutura (string, lista, 140 | ...) na ordem reversa: 141 | 142 | .. doctest:: 143 | 144 | >>> palavra[-1] # última também 145 | 'n' 146 | >>> palavra[-3] # terceira de tras pra frente 147 | 'h' 148 | 149 | .. _section_fatias_strings: 150 | 151 | Fatias 152 | ------ 153 | 154 | Se, ao invés de obter apenas um elemento de uma estrutura (*string*, lista, 155 | ...), deseja-se obter múltiplos elementos, deve-se utilizar *slicing* 156 | (fatiamento). No lugar de colocar o índice do elemento entre chaves, 157 | deve-se colocar o índice do primeiro elemento, dois pontos (``:``) e o 158 | próximo índice do último elemento desejado, tudo entre colchetes. Por 159 | exemplo: 160 | 161 | .. doctest:: 162 | 163 | >>> frase = "Aprender Python é muito divertido!" 164 | >>> frase[0] 165 | 'A' 166 | >>> frase[5] 167 | 'd' 168 | >>> frase[0:5] # do zero até o antes do 5 169 | 'Apren' 170 | >>> frase[:] # tudo! 171 | 'Aprender Python é muito divertido!' 172 | >>> frase 173 | 'Aprender Python é muito divertido!' 174 | >>> frase[6:] # Se omitido o segundo índice significa 'obter até o final' 175 | 'er Python é muito divertido!' 176 | >>> frase[:6] # se omitido o primeiro indice, significa 'obter desde o começo' 177 | 'Aprend' 178 | >>> frase[2:-3] # funciona com números negativos também 179 | 'render Python é muito diverti' 180 | >>> frase[0:-5] 181 | 'Aprender Python é muito diver' 182 | >>> frase[0:-6] 183 | 'Aprender Python é muito dive' 184 | >>> frase[0:-7] 185 | 'Aprender Python é muito div' 186 | >>> frase[2:-2] 187 | 'render Python é muito divertid' 188 | 189 | É possível controlar o *passo* que a fatia usa. Para isso, coloca-se mais 190 | um dois pontos (``:``) depois do segundo índice e o *tamanho do passo*: 191 | 192 | .. doctest:: 193 | 194 | >>> frase[::1] # do começo, até o fim, de 1 em 1. Ou seja, tudo do jeito que ja era, não faz diferença nenhuma. 195 | 'Aprender Python é muito divertido!' 196 | >>> frase[::2] # do começo, até o fim, de 2 em 2 197 | 'Arne yhnémiodvrio 198 | >>> frase[2:-2:2] # Do terceiro, até o ante penúltimo, de 2 em dois 199 | 'rne yhnémiodvri' 200 | 201 | Resumindo: para fazer uma fatia de nossa *string*, precisamos saber de onde 202 | começa, até onde vai e o tamanho do passo. 203 | 204 | .. code:: 205 | 206 | fatiável[começo : fim : passo] 207 | 208 | .. note:: 209 | 210 | As fatias incluem o índice do primeiro elemento e *não incluem* o elemento do índice final. Por isso que ``frase[0:-1]`` perde o último elemento. 211 | 212 | Caso o final da fatia seja antes do começo, obtemos um resultado vazio: 213 | 214 | .. doctest:: 215 | 216 | >>> frase[15:2] 217 | '' 218 | 219 | E se quisermos uma fatia fora da string? 220 | 221 | .. doctest:: 222 | 223 | >>> frase[123:345] 224 | '' 225 | 226 | Mas e se o final da fatia for mais para frente que o tamanho da *string*? Não 227 | tem problemas, o Python vai até o onde der: 228 | 229 | .. doctest:: 230 | 231 | >>> frase[8:123456789] 232 | ' Python é muito divertido!' 233 | >>> frase[8:] 234 | ' Python é muito divertido!' 235 | >>> frase[123456789] 236 | Traceback (most recent call last): 237 | File "", line 1, in 238 | IndexError: string index out of range 239 | 240 | Tamanhos negativos de passo também funcionam. Passos positivos significam *para 241 | frente* e passos negativos significam *para trás*: 242 | 243 | .. doctest:: 244 | 245 | >>> "Python"[::-1] 246 | 'nohtyP' 247 | 248 | Quando usamos passos negativos, a fatia começa no fim e termina no começo e 249 | é percorrida ao contrário. Ou seja, invertemos a ordem. Mas tome cuidado: 250 | 251 | .. doctest:: 252 | 253 | >>> "Python"[2:6] 254 | 'thon' 255 | >>> "Python"[2:6:-1] 256 | '' 257 | >>> "Python"[6:2] 258 | '' 259 | >>> "Python"[6:2:-1] 260 | 'noh' 261 | 262 | No caso de ``"Python"[6:2]``, o começo é depois do fim. Por isso a *string* 263 | fica vazia. 264 | 265 | No caso de ``"Python"[2:6:-1]``, o começo é o índice ``6``, o fim é o índice 266 | ``2``, percorrida ao contrário. Ou seja, temos uma *string* vazia ao 267 | contrário, que continua vazia. 268 | 269 | Quando fazemos ``"Python"[6:2:-1]``, o começo é o índice ``2``, o fim é o índice 270 | ``6``, percorrida ao contrário. Lembre que o índice final nunca é incluído. 271 | Ou seja, temos a *string* ``hon`` a ser invertida. O que resulta em ``noh``. 272 | 273 | .. dica:: 274 | 275 | Se você quiser fazer uma fatia invertida, ou seja, inverter um trecho de 276 | uma *string*, é muito mais fácil fazer primeiro a fatia e depois a 277 | inversão: 278 | 279 | .. doctest:: 280 | 281 | >>> texto = "No alto da montanha havia uma rosa" 282 | >>> texto[3:19] 283 | 'alto da montanha' 284 | >>> texto[3:19][::-1] 285 | 'ahnatnom ad otla' 286 | 287 | 288 | Formatação de strings 289 | --------------------- 290 | 291 | A formatação de string nos permite criar frases dinâmicas, utilizando 292 | valores de quaisquer variáveis desejadas. Por exemplo: 293 | 294 | .. testsetup:: string_format 295 | 296 | def input(text): 297 | value = "Silvio Santos" 298 | print(text + value) 299 | return value 300 | 301 | .. doctest:: string_format 302 | 303 | >>> nome = input('Digite seu nome ') 304 | Digite seu nome Silvio Santos 305 | >>> nome 306 | 'Silvio Santos' 307 | >>> frase = 'Olá, {}'.format(nome) 308 | >>> frase 309 | 'Olá, Silvio Santos' 310 | 311 | Vale lembrar que as chaves ``{}`` só são trocadas pelo valor após a chamada do 312 | método ``str.format()``: 313 | 314 | .. doctest:: 315 | 316 | >>> string_a_ser_formatada = '{} me formate!' 317 | >>> string_a_ser_formatada 318 | '{} me formate!' 319 | 320 | >>> string_a_ser_formatada.format("Não") # também podemos passar valores diretamente para formatação, apesar de ser desncessário 321 | 'Não me formate!' 322 | 323 | A string a ser formatada não é alterada nesse processo, já que não foi 324 | feita nenhuma atribuição: 325 | 326 | .. doctest:: 327 | 328 | >>> string_a_ser_formatada 329 | '{} me formate!' 330 | 331 | É possível formatar uma quantidade arbitrária de valores: 332 | 333 | .. doctest:: 334 | 335 | >>> '{} x {} = {}'.format(7, 6, 7 * 6) 336 | '7 x 6 = 42' 337 | 338 | .. doctest:: 339 | 340 | >>> palavra = 'Python' 341 | >>> numero = 10 342 | >>> booleano = False 343 | >>> '{} é {}. E as outras linguagens? {}'.format(palavra, numero, booleano) 344 | 'Python é 10. E as outras linguagens? False' 345 | 346 | 347 | Além disso, também é possível usar nomes para identificar quais valores serão 348 | substituídos: 349 | 350 | .. doctest:: 351 | 352 | >>> '{a}, {a}, {a}. {b}, {b}, {b}'.format(a='oi', b='tchau') 353 | 'oi, oi, oi. tchau, tchau, tchau' 354 | 355 | 356 | Alternativa ao `.format()` 357 | __________________________ 358 | 359 | Uma maneira mais recente de formatar strings foi introduzida a partir da versão 360 | 3.6 do Python: `PEP 498 -- Literal String Interpolation`, carinhosamente 361 | conhecida como `fstrings` e funciona da seguinte forma: 362 | 363 | .. doctest:: 364 | 365 | >>> nome = 'Silvio' 366 | >>> f'Olá, {name}.' 367 | 'Olá, Silvio.' 368 | 369 | 370 | É também possível fazer operações: 371 | 372 | .. doctest:: 373 | 374 | >>> f'4654 * 321 é {4654 * 321}' 375 | '4654 * 321 é 1493934' 376 | 377 | 378 | 379 | Separação de *Strings* 380 | ---------------------- 381 | 382 | Se tivermos a frase ``Sílvio Santos vem aí, oleoleolá!`` e quisermos separar 383 | cada palavra, como fazer? Pode-se usar o fatiamento: 384 | 385 | .. doctest:: 386 | 387 | >>> frase = "Sílvio Santos vem aí, oleoleolá!" 388 | >>> frase[:6] 389 | 'Sílvio' 390 | >>> frase[7:13] 391 | 'Santos' 392 | >>> frase[14:17] 393 | 'vem' 394 | >>> frase[18:21] 395 | 'aí,' 396 | >>> frase[22:] 397 | 'oleoleolá!' 398 | 399 | Mas também podemos usar a função ``split()``: 400 | 401 | .. doctest:: 402 | 403 | >>> frase.split() 404 | ['Sílvio', 'Santos', 'vem', 'aí,', 'oleoleolá!'] 405 | 406 | .. note:: 407 | 408 | É possível transformar uma string em número, dado que seja um número: 409 | 410 | .. doctest:: 411 | 412 | >>> numero = int("2") 413 | >>> numero 414 | 2 415 | 416 | .. note:: 417 | 418 | A volta também é possível: 419 | 420 | .. doctest:: 421 | 422 | >>> numero_string = str(1900) 423 | >>> numero_string 424 | '1900' 425 | >>> type(numero_string) 426 | 427 | 428 | 429 | Exercícios 430 | ---------- 431 | 432 | .. include:: exercicios_string.rst 433 | --------------------------------------------------------------------------------