├── .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 |
--------------------------------------------------------------------------------