├── README.md
├── Segundo Capítulo
├── Segundo capítulo.ipynb
└── .ipynb_checkpoints
│ └── Segundo capítulo-checkpoint.ipynb
├── Terceiro Capítulo
├── Terceiro Capítulo.ipynb
└── .ipynb_checkpoints
│ └── Terceiro Capítulo-checkpoint.ipynb
└── Primeiro Capítulo
└── Primeiro capítulo .ipynb
/README.md:
--------------------------------------------------------------------------------
1 | # Apostila de Data Science
2 |
3 | Este repositório é fruto do programa de bolsa ensino o programa que é sustentado pelo IFSP (Instituto Federal de ciência ,tecnologia e educação - São Paulo) neste caso em especial o projeto vinculado ao programa pertence ao campus-Guarulhos e tem como titulo *"Popularização do data Science em pesquisas de engenharia utilizando python" .*
4 |
5 | O objetivo desse projeto é a criação de uma apostila voltada para engenheiros afim de refinar a capacidade de processamento e visualização obtidas em trabalhos acadêmicos, pesquisas de iniciação cientifica, projetos de extensão e todas as outras modalidades que necessitarem de interpretação de uma situação baseada em dados.
6 |
7 | ### Sumário
8 |
9 | - Capítulo - Operações Matemáticas e comandos da IDE
10 | - Capítulo - Trabalhando com variaveis
11 | - Capítulo - Tipos de variaveis
12 |
13 | Realizado por : Victor Furim Poldauf
14 |
15 | Orientado por : Prof. Dr. João Alvez Pacheco
--------------------------------------------------------------------------------
/Segundo Capítulo/Segundo capítulo.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Capítulo 2\n",
8 | "### Compreendendo variáveis e seus tipos.\n",
9 | "Observamos que todos os cálculos realizados no capitulo anterior foram exibidos em forma de output, e acabaram apenas existindo na sua célula de execução, mas se por algum motivo quisermos armazenar esse resultado para o uso posterior?\n",
10 | "\n",
11 | " Para que isso aconteça existe no python assim como em outras linguagens de programação o conceito de \"variável\" nada mais é do que um elemento que atribuímos um valor e alteramos esse mesmo valor conforma nossa necessidade, dessa característica vem seu nome."
12 | ]
13 | },
14 | {
15 | "cell_type": "code",
16 | "execution_count": 2,
17 | "metadata": {},
18 | "outputs": [],
19 | "source": [
20 | "# Para atribuir um valor a variável apenas selecionamos o carácter desejado \n",
21 | "# Digitamos o sinal de igual \" = \"\n",
22 | "# E o valor desejado a ser atribuído \n",
23 | "a = 1"
24 | ]
25 | },
26 | {
27 | "cell_type": "markdown",
28 | "metadata": {},
29 | "source": [
30 | " Como podemos observar o resultado de uma atribuição não é exibido no output dessa IDE , mas para que seja exibido se faz necessário apenas digitá-la novamente antes do final da célula, desse modo:"
31 | ]
32 | },
33 | {
34 | "cell_type": "code",
35 | "execution_count": 3,
36 | "metadata": {},
37 | "outputs": [
38 | {
39 | "data": {
40 | "text/plain": [
41 | "2"
42 | ]
43 | },
44 | "execution_count": 3,
45 | "metadata": {},
46 | "output_type": "execute_result"
47 | }
48 | ],
49 | "source": [
50 | "b = 2\n",
51 | "b"
52 | ]
53 | },
54 | {
55 | "cell_type": "markdown",
56 | "metadata": {},
57 | "source": [
58 | " Logo podemos ver seu output preenchido com o valor da variável, mas provando para os leitores que a variável não existe apenas na célula em quem foi criada vamos chamar a variável \" a \" criada a duas células acima e ver o comportamento."
59 | ]
60 | },
61 | {
62 | "cell_type": "code",
63 | "execution_count": 4,
64 | "metadata": {},
65 | "outputs": [
66 | {
67 | "data": {
68 | "text/plain": [
69 | "1"
70 | ]
71 | },
72 | "execution_count": 4,
73 | "metadata": {},
74 | "output_type": "execute_result"
75 | }
76 | ],
77 | "source": [
78 | "a"
79 | ]
80 | },
81 | {
82 | "cell_type": "markdown",
83 | "metadata": {},
84 | "source": [
85 | " A variável também pode ser declarada a partir de um resultado matemático , ou ainda mais a ser igualada a outra variável"
86 | ]
87 | },
88 | {
89 | "cell_type": "code",
90 | "execution_count": 5,
91 | "metadata": {},
92 | "outputs": [
93 | {
94 | "data": {
95 | "text/plain": [
96 | "9"
97 | ]
98 | },
99 | "execution_count": 5,
100 | "metadata": {},
101 | "output_type": "execute_result"
102 | }
103 | ],
104 | "source": [
105 | "# Variavel declarada a partir de expressão matemática\n",
106 | "c = 4 + 5\n",
107 | "c"
108 | ]
109 | },
110 | {
111 | "cell_type": "code",
112 | "execution_count": 6,
113 | "metadata": {},
114 | "outputs": [
115 | {
116 | "data": {
117 | "text/plain": [
118 | "-3"
119 | ]
120 | },
121 | "execution_count": 6,
122 | "metadata": {},
123 | "output_type": "execute_result"
124 | }
125 | ],
126 | "source": [
127 | "# Variavel declarada a partir de expressão matemática envolvendo outra variável\n",
128 | "d = a - 4\n",
129 | "d"
130 | ]
131 | },
132 | {
133 | "cell_type": "code",
134 | "execution_count": 7,
135 | "metadata": {},
136 | "outputs": [
137 | {
138 | "data": {
139 | "text/plain": [
140 | "1"
141 | ]
142 | },
143 | "execution_count": 7,
144 | "metadata": {},
145 | "output_type": "execute_result"
146 | }
147 | ],
148 | "source": [
149 | "# Variavel recebendo o valor integro de outra variável\n",
150 | "e = a\n",
151 | "e"
152 | ]
153 | },
154 | {
155 | "cell_type": "markdown",
156 | "metadata": {},
157 | "source": [
158 | "## Alterando valores de uma variável\n",
159 | "Agora vamos realizar a característica principal de uma variável que nada mais é que variar seu próprio valor vamos acompanhar logo abaixo:"
160 | ]
161 | },
162 | {
163 | "cell_type": "code",
164 | "execution_count": 8,
165 | "metadata": {},
166 | "outputs": [
167 | {
168 | "data": {
169 | "text/plain": [
170 | "2"
171 | ]
172 | },
173 | "execution_count": 8,
174 | "metadata": {},
175 | "output_type": "execute_result"
176 | }
177 | ],
178 | "source": [
179 | "k = 1 # Nesse exato momento valor k vale 1\n",
180 | "k = 2 # Nesse exato momento valor k vale 2\n",
181 | "k"
182 | ]
183 | },
184 | {
185 | "cell_type": "markdown",
186 | "metadata": {},
187 | "source": [
188 | "- Assim como em muitas outras linguagens de programação o pythom é estruturando e o código é executado linha a linha seguindo sua sequencia logica de construção ou seja o ultimo valor atribuído sera o valor final do output nesse caso.
"
189 | ]
190 | },
191 | {
192 | "cell_type": "code",
193 | "execution_count": 9,
194 | "metadata": {},
195 | "outputs": [
196 | {
197 | "data": {
198 | "text/plain": [
199 | "8"
200 | ]
201 | },
202 | "execution_count": 9,
203 | "metadata": {},
204 | "output_type": "execute_result"
205 | }
206 | ],
207 | "source": [
208 | "# Vamos utilizar a mesma variável k lembrando que seu valor é 2\n",
209 | "k = k + 6 # Neste caso iremos atribuir um novo valor a variável utilizando o valor passado dela ou seja o k novo é 2+6=8\n",
210 | "k\n",
211 | "\n"
212 | ]
213 | }
214 | ],
215 | "metadata": {
216 | "kernelspec": {
217 | "display_name": "Python 3",
218 | "language": "python",
219 | "name": "python3"
220 | },
221 | "language_info": {
222 | "codemirror_mode": {
223 | "name": "ipython",
224 | "version": 3
225 | },
226 | "file_extension": ".py",
227 | "mimetype": "text/x-python",
228 | "name": "python",
229 | "nbconvert_exporter": "python",
230 | "pygments_lexer": "ipython3",
231 | "version": "3.7.3"
232 | }
233 | },
234 | "nbformat": 4,
235 | "nbformat_minor": 2
236 | }
237 |
--------------------------------------------------------------------------------
/Segundo Capítulo/.ipynb_checkpoints/Segundo capítulo-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Capítulo 2\n",
8 | "### Compreendendo variáveis e seus tipos.\n",
9 | "Observamos que todos os cálculos realizados no capitulo anterior foram exibidos em forma de output, e acabaram apenas existindo na sua célula de execução, mas se por algum motivo quisermos armazenar esse resultado para o uso posterior?\n",
10 | "\n",
11 | " Para que isso aconteça existe no python assim como em outras linguagens de programação o conceito de \"variável\" nada mais é do que um elemento que atribuímos um valor e alteramos esse mesmo valor conforma nossa necessidade, dessa característica vem seu nome."
12 | ]
13 | },
14 | {
15 | "cell_type": "code",
16 | "execution_count": 2,
17 | "metadata": {},
18 | "outputs": [],
19 | "source": [
20 | "# Para atribuir um valor a variável apenas selecionamos o carácter desejado \n",
21 | "# Digitamos o sinal de igual \" = \"\n",
22 | "# E o valor desejado a ser atribuído \n",
23 | "a = 1"
24 | ]
25 | },
26 | {
27 | "cell_type": "markdown",
28 | "metadata": {},
29 | "source": [
30 | " Como podemos observar o resultado de uma atribuição não é exibido no output dessa IDE , mas para que seja exibido se faz necessário apenas digitá-la novamente antes do final da célula, desse modo:"
31 | ]
32 | },
33 | {
34 | "cell_type": "code",
35 | "execution_count": 3,
36 | "metadata": {},
37 | "outputs": [
38 | {
39 | "data": {
40 | "text/plain": [
41 | "2"
42 | ]
43 | },
44 | "execution_count": 3,
45 | "metadata": {},
46 | "output_type": "execute_result"
47 | }
48 | ],
49 | "source": [
50 | "b = 2\n",
51 | "b"
52 | ]
53 | },
54 | {
55 | "cell_type": "markdown",
56 | "metadata": {},
57 | "source": [
58 | " Logo podemos ver seu output preenchido com o valor da variável, mas provando para os leitores que a variável não existe apenas na célula em quem foi criada vamos chamar a variável \" a \" criada a duas células acima e ver o comportamento."
59 | ]
60 | },
61 | {
62 | "cell_type": "code",
63 | "execution_count": 4,
64 | "metadata": {},
65 | "outputs": [
66 | {
67 | "data": {
68 | "text/plain": [
69 | "1"
70 | ]
71 | },
72 | "execution_count": 4,
73 | "metadata": {},
74 | "output_type": "execute_result"
75 | }
76 | ],
77 | "source": [
78 | "a"
79 | ]
80 | },
81 | {
82 | "cell_type": "markdown",
83 | "metadata": {},
84 | "source": [
85 | " A variável também pode ser declarada a partir de um resultado matemático , ou ainda mais a ser igualada a outra variável"
86 | ]
87 | },
88 | {
89 | "cell_type": "code",
90 | "execution_count": 5,
91 | "metadata": {},
92 | "outputs": [
93 | {
94 | "data": {
95 | "text/plain": [
96 | "9"
97 | ]
98 | },
99 | "execution_count": 5,
100 | "metadata": {},
101 | "output_type": "execute_result"
102 | }
103 | ],
104 | "source": [
105 | "# Variavel declarada a partir de expressão matemática\n",
106 | "c = 4 + 5\n",
107 | "c"
108 | ]
109 | },
110 | {
111 | "cell_type": "code",
112 | "execution_count": 6,
113 | "metadata": {},
114 | "outputs": [
115 | {
116 | "data": {
117 | "text/plain": [
118 | "-3"
119 | ]
120 | },
121 | "execution_count": 6,
122 | "metadata": {},
123 | "output_type": "execute_result"
124 | }
125 | ],
126 | "source": [
127 | "# Variavel declarada a partir de expressão matemática envolvendo outra variável\n",
128 | "d = a - 4\n",
129 | "d"
130 | ]
131 | },
132 | {
133 | "cell_type": "code",
134 | "execution_count": 7,
135 | "metadata": {},
136 | "outputs": [
137 | {
138 | "data": {
139 | "text/plain": [
140 | "1"
141 | ]
142 | },
143 | "execution_count": 7,
144 | "metadata": {},
145 | "output_type": "execute_result"
146 | }
147 | ],
148 | "source": [
149 | "# Variavel recebendo o valor integro de outra variável\n",
150 | "e = a\n",
151 | "e"
152 | ]
153 | },
154 | {
155 | "cell_type": "markdown",
156 | "metadata": {},
157 | "source": [
158 | "## Alterando valores de uma variável\n",
159 | "Agora vamos realizar a característica principal de uma variável que nada mais é que variar seu próprio valor vamos acompanhar logo abaixo:"
160 | ]
161 | },
162 | {
163 | "cell_type": "code",
164 | "execution_count": 8,
165 | "metadata": {},
166 | "outputs": [
167 | {
168 | "data": {
169 | "text/plain": [
170 | "2"
171 | ]
172 | },
173 | "execution_count": 8,
174 | "metadata": {},
175 | "output_type": "execute_result"
176 | }
177 | ],
178 | "source": [
179 | "k = 1 # Nesse exato momento valor k vale 1\n",
180 | "k = 2 # Nesse exato momento valor k vale 2\n",
181 | "k"
182 | ]
183 | },
184 | {
185 | "cell_type": "markdown",
186 | "metadata": {},
187 | "source": [
188 | "- Assim como em muitas outras linguagens de programação o pythom é estruturando e o código é executado linha a linha seguindo sua sequencia logica de construção ou seja o ultimo valor atribuído sera o valor final do output nesse caso.
"
189 | ]
190 | },
191 | {
192 | "cell_type": "code",
193 | "execution_count": 9,
194 | "metadata": {},
195 | "outputs": [
196 | {
197 | "data": {
198 | "text/plain": [
199 | "8"
200 | ]
201 | },
202 | "execution_count": 9,
203 | "metadata": {},
204 | "output_type": "execute_result"
205 | }
206 | ],
207 | "source": [
208 | "# Vamos utilizar a mesma variável k lembrando que seu valor é 2\n",
209 | "k = k + 6 # Neste caso iremos atribuir um novo valor a variável utilizando o valor passado dela ou seja o k novo é 2+6=8\n",
210 | "k\n",
211 | "\n"
212 | ]
213 | }
214 | ],
215 | "metadata": {
216 | "kernelspec": {
217 | "display_name": "Python 3",
218 | "language": "python",
219 | "name": "python3"
220 | },
221 | "language_info": {
222 | "codemirror_mode": {
223 | "name": "ipython",
224 | "version": 3
225 | },
226 | "file_extension": ".py",
227 | "mimetype": "text/x-python",
228 | "name": "python",
229 | "nbconvert_exporter": "python",
230 | "pygments_lexer": "ipython3",
231 | "version": "3.7.3"
232 | }
233 | },
234 | "nbformat": 4,
235 | "nbformat_minor": 2
236 | }
237 |
--------------------------------------------------------------------------------
/Terceiro Capítulo/Terceiro Capítulo.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Terceiro Capítulo\n",
8 | "## Tipos de variáveis\n",
9 | "De acordo com o capitulo passado foi exibido o método de atribuição de valor a uma variável e alteração do mesmo, agora vamos descobrir quais são os tipos de variáveis.
\n",
10 | "Para identificar o tipo da variável existe um comando chamado Type, sua sintaxe é:
\n",
11 | "\" type(nomeDaVariavel) \""
12 | ]
13 | },
14 | {
15 | "cell_type": "code",
16 | "execution_count": 35,
17 | "metadata": {},
18 | "outputs": [
19 | {
20 | "data": {
21 | "text/plain": [
22 | "4"
23 | ]
24 | },
25 | "execution_count": 35,
26 | "metadata": {},
27 | "output_type": "execute_result"
28 | }
29 | ],
30 | "source": [
31 | "a = 4 #Quando atribuímos um valor numérico inteiro a uma variável seu tipo e classificado como \" int \" que vem da palavra inteiro\n",
32 | "a"
33 | ]
34 | },
35 | {
36 | "cell_type": "code",
37 | "execution_count": 36,
38 | "metadata": {},
39 | "outputs": [
40 | {
41 | "data": {
42 | "text/plain": [
43 | "3.6"
44 | ]
45 | },
46 | "execution_count": 36,
47 | "metadata": {},
48 | "output_type": "execute_result"
49 | }
50 | ],
51 | "source": [
52 | "numeroNãoInteiro = 3.6 #Quando atribuímos um valor numérico não inteiro a uma variável seu tipo e classificado como \" float \" \n",
53 | "numeroNãoInteiro #Sim uma variável pode ser escrita como um texto"
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "- Recordando do primeiro capítulo, notávamos que quando existia uma operação com divisões a nossa output aparecia com um zero depois da virgula mesmo não tendo algum algarismo significativo apos a virgula isso acontece porque o python afim de facilitar e poupa-nos de conversores já realiza automaticamente a conversão
"
61 | ]
62 | },
63 | {
64 | "cell_type": "code",
65 | "execution_count": 30,
66 | "metadata": {},
67 | "outputs": [
68 | {
69 | "data": {
70 | "text/plain": [
71 | "'Data Science'"
72 | ]
73 | },
74 | "execution_count": 30,
75 | "metadata": {},
76 | "output_type": "execute_result"
77 | }
78 | ],
79 | "source": [
80 | "c = \"Data Science\" #Podemos adicionar o valor de um texto a uma variável simplesmente igualando a variável a um texto entre aspas\n",
81 | "c #O nome que se da a uma variável com o valor de texto é \" String \""
82 | ]
83 | },
84 | {
85 | "cell_type": "markdown",
86 | "metadata": {},
87 | "source": [
88 | "### Assim como na matemática existem elementos que armazenam mais de um valor.\n",
89 | "\n",
90 | "Esses elementos no python são chamados de \" vetores \" e \" matrizes \" assim como na matemática ambos carregam a capacidade de armazenar infinitos valores, se seguida a sua sintaxi devidamente .
\n",
91 | "Além dessas duas formas de armazenamento de multi valores temos também os dicionários."
92 | ]
93 | },
94 | {
95 | "cell_type": "code",
96 | "execution_count": 37,
97 | "metadata": {},
98 | "outputs": [
99 | {
100 | "data": {
101 | "text/plain": [
102 | "[5, 9, 'IFSP', 4.9, 'O futuro são os dados']"
103 | ]
104 | },
105 | "execution_count": 37,
106 | "metadata": {},
107 | "output_type": "execute_result"
108 | }
109 | ],
110 | "source": [
111 | "# Listas ou vetores são os nomes dados a variavel a seguir.\n",
112 | "v = [5, 9 ,\"IFSP\",4.9,\"O futuro são os dados\" ] #Como podemos ver o vetor pode conter todo tipo de variável dentro de si.\n",
113 | "v"
114 | ]
115 | },
116 | {
117 | "cell_type": "code",
118 | "execution_count": 38,
119 | "metadata": {},
120 | "outputs": [
121 | {
122 | "data": {
123 | "text/plain": [
124 | "([1, 2, 3], [4, 5, 6], [7, 8, 9])"
125 | ]
126 | },
127 | "execution_count": 38,
128 | "metadata": {},
129 | "output_type": "execute_result"
130 | }
131 | ],
132 | "source": [
133 | "# Matrizes que nada mais são que um aglomerado de vetores popularmente chamado de tuple\n",
134 | "matriz = [1,2,3],[4,5,6],[7,8,9]\n",
135 | "matriz"
136 | ]
137 | },
138 | {
139 | "cell_type": "markdown",
140 | "metadata": {},
141 | "source": [
142 | "
- As tuplas tem uma singularidade que as definem , apos sua criação elas não podem sofrer alteração nos seus valores
"
143 | ]
144 | },
145 | {
146 | "cell_type": "code",
147 | "execution_count": 41,
148 | "metadata": {},
149 | "outputs": [
150 | {
151 | "data": {
152 | "text/plain": [
153 | "{'Numero de prédios': 6,\n",
154 | " 'Endereço': 'Av. Salgado Filho, 3501 - Centro, Guarulhos - SP, 07115-000',\n",
155 | " 'Licenciatura': 'Matemática',\n",
156 | " 'Tecnólogo': ['Automação industrial',\n",
157 | " 'Analise e desenvolvimento de sistemas'],\n",
158 | " 'Bacharel': 'Engenharia de controle e automação'}"
159 | ]
160 | },
161 | "execution_count": 41,
162 | "metadata": {},
163 | "output_type": "execute_result"
164 | }
165 | ],
166 | "source": [
167 | "# Dicionários ou popularmente conhecidos em outras linguagens \" objetos \"\n",
168 | "campusIFSP ={'Numero de prédios': 6 , 'Endereço' : 'Av. Salgado Filho, 3501 - Centro, Guarulhos - SP, 07115-000' , 'Licenciatura' : 'Matemática' , 'Tecnólogo' : ['Automação industrial','Analise e desenvolvimento de sistemas'] , 'Bacharel' : 'Engenharia de controle e automação'}\n",
169 | "campusIFSP"
170 | ]
171 | },
172 | {
173 | "cell_type": "code",
174 | "execution_count": 40,
175 | "metadata": {},
176 | "outputs": [
177 | {
178 | "data": {
179 | "text/plain": [
180 | "['Automação industrial', 'Analise e desenvolvimento de sistemas']"
181 | ]
182 | },
183 | "execution_count": 40,
184 | "metadata": {},
185 | "output_type": "execute_result"
186 | }
187 | ],
188 | "source": [
189 | "# A vantagem do dicionario é que eu apenas posso acessar a informação desejada dele de maneira explicita\n",
190 | "campusIFSP['Tecnólogo']"
191 | ]
192 | }
193 | ],
194 | "metadata": {
195 | "kernelspec": {
196 | "display_name": "Python 3",
197 | "language": "python",
198 | "name": "python3"
199 | },
200 | "language_info": {
201 | "codemirror_mode": {
202 | "name": "ipython",
203 | "version": 3
204 | },
205 | "file_extension": ".py",
206 | "mimetype": "text/x-python",
207 | "name": "python",
208 | "nbconvert_exporter": "python",
209 | "pygments_lexer": "ipython3",
210 | "version": "3.7.3"
211 | }
212 | },
213 | "nbformat": 4,
214 | "nbformat_minor": 2
215 | }
216 |
--------------------------------------------------------------------------------
/Terceiro Capítulo/.ipynb_checkpoints/Terceiro Capítulo-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Terceiro Capítulo\n",
8 | "## Tipos de variáveis\n",
9 | "De acordo com o capitulo passado foi exibido o método de atribuição de valor a uma variável e alteração do mesmo, agora vamos descobrir quais são os tipos de variáveis.
\n",
10 | "Para identificar o tipo da variável existe um comando chamado Type, sua sintaxe é:
\n",
11 | "\" type(nomeDaVariavel) \""
12 | ]
13 | },
14 | {
15 | "cell_type": "code",
16 | "execution_count": 35,
17 | "metadata": {},
18 | "outputs": [
19 | {
20 | "data": {
21 | "text/plain": [
22 | "4"
23 | ]
24 | },
25 | "execution_count": 35,
26 | "metadata": {},
27 | "output_type": "execute_result"
28 | }
29 | ],
30 | "source": [
31 | "a = 4 #Quando atribuímos um valor numérico inteiro a uma variável seu tipo e classificado como \" int \" que vem da palavra inteiro\n",
32 | "a"
33 | ]
34 | },
35 | {
36 | "cell_type": "code",
37 | "execution_count": 36,
38 | "metadata": {},
39 | "outputs": [
40 | {
41 | "data": {
42 | "text/plain": [
43 | "3.6"
44 | ]
45 | },
46 | "execution_count": 36,
47 | "metadata": {},
48 | "output_type": "execute_result"
49 | }
50 | ],
51 | "source": [
52 | "numeroNãoInteiro = 3.6 #Quando atribuímos um valor numérico não inteiro a uma variável seu tipo e classificado como \" float \" \n",
53 | "numeroNãoInteiro #Sim uma variável pode ser escrita como um texto"
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "- Recordando do primeiro capítulo, notávamos que quando existia uma operação com divisões a nossa output aparecia com um zero depois da virgula mesmo não tendo algum algarismo significativo apos a virgula isso acontece porque o python afim de facilitar e poupa-nos de conversores já realiza automaticamente a conversão
"
61 | ]
62 | },
63 | {
64 | "cell_type": "code",
65 | "execution_count": 30,
66 | "metadata": {},
67 | "outputs": [
68 | {
69 | "data": {
70 | "text/plain": [
71 | "'Data Science'"
72 | ]
73 | },
74 | "execution_count": 30,
75 | "metadata": {},
76 | "output_type": "execute_result"
77 | }
78 | ],
79 | "source": [
80 | "c = \"Data Science\" #Podemos adicionar o valor de um texto a uma variável simplesmente igualando a variável a um texto entre aspas\n",
81 | "c #O nome que se da a uma variável com o valor de texto é \" String \""
82 | ]
83 | },
84 | {
85 | "cell_type": "markdown",
86 | "metadata": {},
87 | "source": [
88 | "### Assim como na matemática existem elementos que armazenam mais de um valor.\n",
89 | "\n",
90 | "Esses elementos no python são chamados de \" vetores \" e \" matrizes \" assim como na matemática ambos carregam a capacidade de armazenar infinitos valores, se seguida a sua sintaxi devidamente .
\n",
91 | "Além dessas duas formas de armazenamento de multi valores temos também os dicionários."
92 | ]
93 | },
94 | {
95 | "cell_type": "code",
96 | "execution_count": 37,
97 | "metadata": {},
98 | "outputs": [
99 | {
100 | "data": {
101 | "text/plain": [
102 | "[5, 9, 'IFSP', 4.9, 'O futuro são os dados']"
103 | ]
104 | },
105 | "execution_count": 37,
106 | "metadata": {},
107 | "output_type": "execute_result"
108 | }
109 | ],
110 | "source": [
111 | "# Listas ou vetores são os nomes dados a variavel a seguir.\n",
112 | "v = [5, 9 ,\"IFSP\",4.9,\"O futuro são os dados\" ] #Como podemos ver o vetor pode conter todo tipo de variável dentro de si.\n",
113 | "v"
114 | ]
115 | },
116 | {
117 | "cell_type": "code",
118 | "execution_count": 38,
119 | "metadata": {},
120 | "outputs": [
121 | {
122 | "data": {
123 | "text/plain": [
124 | "([1, 2, 3], [4, 5, 6], [7, 8, 9])"
125 | ]
126 | },
127 | "execution_count": 38,
128 | "metadata": {},
129 | "output_type": "execute_result"
130 | }
131 | ],
132 | "source": [
133 | "# Matrizes que nada mais são que um aglomerado de vetores popularmente chamado de tuple\n",
134 | "matriz = [1,2,3],[4,5,6],[7,8,9]\n",
135 | "matriz"
136 | ]
137 | },
138 | {
139 | "cell_type": "markdown",
140 | "metadata": {},
141 | "source": [
142 | "
- As tuplas tem uma singularidade que as definem , apos sua criação elas não podem sofrer alteração nos seus valores
"
143 | ]
144 | },
145 | {
146 | "cell_type": "code",
147 | "execution_count": 41,
148 | "metadata": {},
149 | "outputs": [
150 | {
151 | "data": {
152 | "text/plain": [
153 | "{'Numero de prédios': 6,\n",
154 | " 'Endereço': 'Av. Salgado Filho, 3501 - Centro, Guarulhos - SP, 07115-000',\n",
155 | " 'Licenciatura': 'Matemática',\n",
156 | " 'Tecnólogo': ['Automação industrial',\n",
157 | " 'Analise e desenvolvimento de sistemas'],\n",
158 | " 'Bacharel': 'Engenharia de controle e automação'}"
159 | ]
160 | },
161 | "execution_count": 41,
162 | "metadata": {},
163 | "output_type": "execute_result"
164 | }
165 | ],
166 | "source": [
167 | "# Dicionários ou popularmente conhecidos em outras linguagens \" objetos \"\n",
168 | "campusIFSP ={'Numero de prédios': 6 , 'Endereço' : 'Av. Salgado Filho, 3501 - Centro, Guarulhos - SP, 07115-000' , 'Licenciatura' : 'Matemática' , 'Tecnólogo' : ['Automação industrial','Analise e desenvolvimento de sistemas'] , 'Bacharel' : 'Engenharia de controle e automação'}\n",
169 | "campusIFSP"
170 | ]
171 | },
172 | {
173 | "cell_type": "code",
174 | "execution_count": 40,
175 | "metadata": {},
176 | "outputs": [
177 | {
178 | "data": {
179 | "text/plain": [
180 | "['Automação industrial', 'Analise e desenvolvimento de sistemas']"
181 | ]
182 | },
183 | "execution_count": 40,
184 | "metadata": {},
185 | "output_type": "execute_result"
186 | }
187 | ],
188 | "source": [
189 | "# A vantagem do dicionario é que eu apenas posso acessar a informação desejada dele de maneira explicita\n",
190 | "campusIFSP['Tecnólogo']"
191 | ]
192 | }
193 | ],
194 | "metadata": {
195 | "kernelspec": {
196 | "display_name": "Python 3",
197 | "language": "python",
198 | "name": "python3"
199 | },
200 | "language_info": {
201 | "codemirror_mode": {
202 | "name": "ipython",
203 | "version": 3
204 | },
205 | "file_extension": ".py",
206 | "mimetype": "text/x-python",
207 | "name": "python",
208 | "nbconvert_exporter": "python",
209 | "pygments_lexer": "ipython3",
210 | "version": "3.7.3"
211 | }
212 | },
213 | "nbformat": 4,
214 | "nbformat_minor": 2
215 | }
216 |
--------------------------------------------------------------------------------
/Primeiro Capítulo/Primeiro capítulo .ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Capítulo 1\n",
8 | "### Comandos básicos e matemáticos\n",
9 | "O primeiro comando é o comentário , tem função de explicação alem de ser uma boa pratica para facilitar o entendimento do código afim de terceiros os quais não realizarão parte da confecção do código melhor interpretar a sua função."
10 | ]
11 | },
12 | {
13 | "cell_type": "code",
14 | "execution_count": 1,
15 | "metadata": {},
16 | "outputs": [],
17 | "source": [
18 | "#A estrutura de um comentário inicia com uma hashtag ou popularmente conhecida como \"jogo da velha\" ,logo apos um texto\n",
19 | "#Para executar a compilação da célula apertar ctrl+Enter, mas não se preocupe o comenta tio não influencia no código"
20 | ]
21 | },
22 | {
23 | "cell_type": "markdown",
24 | "metadata": {},
25 | "source": [
26 | "### Comando da soma \n",
27 | "O comando da soma é dado pelo açúcar sintático \" + \" entre dois argumentos a qual responde o resultado da operação"
28 | ]
29 | },
30 | {
31 | "cell_type": "code",
32 | "execution_count": 8,
33 | "metadata": {},
34 | "outputs": [
35 | {
36 | "data": {
37 | "text/plain": [
38 | "4"
39 | ]
40 | },
41 | "execution_count": 8,
42 | "metadata": {},
43 | "output_type": "execute_result"
44 | }
45 | ],
46 | "source": [
47 | "1 + 3"
48 | ]
49 | },
50 | {
51 | "cell_type": "markdown",
52 | "metadata": {},
53 | "source": [
54 | "Repare que a célula criou uma nova linha chamada de \"Out\" que traduzida para o português \"saída\" ou seja toda logica matemática é interpretada e realizada e por fim o resultado é dado na nova linha.\n",
55 | "\n",
56 | "### Comando de subtração\n",
57 | "O comando da subtração é dado pelo açúcar sintático \" - \" entre dois argumentos a qual responde o resultado da operação"
58 | ]
59 | },
60 | {
61 | "cell_type": "code",
62 | "execution_count": 7,
63 | "metadata": {},
64 | "outputs": [
65 | {
66 | "data": {
67 | "text/plain": [
68 | "2"
69 | ]
70 | },
71 | "execution_count": 7,
72 | "metadata": {},
73 | "output_type": "execute_result"
74 | }
75 | ],
76 | "source": [
77 | "5 - 3"
78 | ]
79 | },
80 | {
81 | "cell_type": "markdown",
82 | "metadata": {},
83 | "source": [
84 | "### Comando de multiplicação\n",
85 | "O comando da multiplicação é dado pelo açúcar sintático \" * \" entre dois argumentos a qual responde o resultado da operação"
86 | ]
87 | },
88 | {
89 | "cell_type": "code",
90 | "execution_count": 6,
91 | "metadata": {},
92 | "outputs": [
93 | {
94 | "data": {
95 | "text/plain": [
96 | "16"
97 | ]
98 | },
99 | "execution_count": 6,
100 | "metadata": {},
101 | "output_type": "execute_result"
102 | }
103 | ],
104 | "source": [
105 | "2 * 8"
106 | ]
107 | },
108 | {
109 | "cell_type": "markdown",
110 | "metadata": {},
111 | "source": [
112 | "### Comando de divisão\n",
113 | "O comando da divisão é dado pelo açúcar sintático \" / \" entre dois argumentos a qual responde o resultado da operação"
114 | ]
115 | },
116 | {
117 | "cell_type": "code",
118 | "execution_count": 9,
119 | "metadata": {},
120 | "outputs": [
121 | {
122 | "data": {
123 | "text/plain": [
124 | "5.0"
125 | ]
126 | },
127 | "execution_count": 9,
128 | "metadata": {},
129 | "output_type": "execute_result"
130 | }
131 | ],
132 | "source": [
133 | "15 / 3"
134 | ]
135 | },
136 | {
137 | "cell_type": "markdown",
138 | "metadata": {},
139 | "source": [
140 | "- Note que o resultado da divisão resulta em um numero, mas diferente das operações anteriores ele vem acompanhado de uma virgula, isso pode ser explicado pelo tipo de \"variável\" que sera o assunto tratado no próximo capitulo.li>
\n",
141 | "\n",
142 | "### Comando de exponenciação e radiciação\n",
143 | "O comando da exponenciação é dado pelo açúcar sintático \" ** \" entre dois argumentos a qual responde o resultado da operação"
144 | ]
145 | },
146 | {
147 | "cell_type": "code",
148 | "execution_count": 10,
149 | "metadata": {},
150 | "outputs": [
151 | {
152 | "data": {
153 | "text/plain": [
154 | "32"
155 | ]
156 | },
157 | "execution_count": 10,
158 | "metadata": {},
159 | "output_type": "execute_result"
160 | }
161 | ],
162 | "source": [
163 | "2 ** 5"
164 | ]
165 | },
166 | {
167 | "cell_type": "markdown",
168 | "metadata": {},
169 | "source": [
170 | "É importante lembrar que a radiciação pode ser obtida conforme a sintaxe matemática de frações localizadas no expoente lembrando de seguir o uso de parentes para organizar a expressão como por exemplo:\n"
171 | ]
172 | },
173 | {
174 | "cell_type": "code",
175 | "execution_count": 14,
176 | "metadata": {},
177 | "outputs": [
178 | {
179 | "data": {
180 | "text/plain": [
181 | "3.0"
182 | ]
183 | },
184 | "execution_count": 14,
185 | "metadata": {},
186 | "output_type": "execute_result"
187 | }
188 | ],
189 | "source": [
190 | "9 ** (1/2)"
191 | ]
192 | },
193 | {
194 | "cell_type": "markdown",
195 | "metadata": {},
196 | "source": [
197 | "- Veja que como existe a divisão no codigo acima acontece novamente a converção da variavel que sera explicada no proximo capitulo
\n",
198 | " Ou ainda podemos diretamente colocar o resultado da fração"
199 | ]
200 | },
201 | {
202 | "cell_type": "code",
203 | "execution_count": 12,
204 | "metadata": {},
205 | "outputs": [
206 | {
207 | "data": {
208 | "text/plain": [
209 | "3.0"
210 | ]
211 | },
212 | "execution_count": 12,
213 | "metadata": {},
214 | "output_type": "execute_result"
215 | }
216 | ],
217 | "source": [
218 | "9 ** 0.5"
219 | ]
220 | },
221 | {
222 | "cell_type": "markdown",
223 | "metadata": {},
224 | "source": [
225 | "### Comando para obter a parte inteira de uma divisão\n",
226 | "Digamos que seja necessario obter apenas o resultado inteiro que foi dividido o açúcar sintático é \" // \" entre dois argumentos , vejamos :"
227 | ]
228 | },
229 | {
230 | "cell_type": "code",
231 | "execution_count": 20,
232 | "metadata": {},
233 | "outputs": [
234 | {
235 | "data": {
236 | "text/plain": [
237 | "2"
238 | ]
239 | },
240 | "execution_count": 20,
241 | "metadata": {},
242 | "output_type": "execute_result"
243 | }
244 | ],
245 | "source": [
246 | "10 // 4"
247 | ]
248 | },
249 | {
250 | "cell_type": "markdown",
251 | "metadata": {},
252 | "source": [
253 | "### Comando para obter o modulo \n",
254 | "Digamos que seja necessario obter apenas o resto da divisão o o açúcar sintático é \" % \" entre dois argumentos , vejamos :"
255 | ]
256 | },
257 | {
258 | "cell_type": "code",
259 | "execution_count": 22,
260 | "metadata": {},
261 | "outputs": [
262 | {
263 | "data": {
264 | "text/plain": [
265 | "2"
266 | ]
267 | },
268 | "execution_count": 22,
269 | "metadata": {},
270 | "output_type": "execute_result"
271 | }
272 | ],
273 | "source": [
274 | "10 % 4"
275 | ]
276 | }
277 | ],
278 | "metadata": {
279 | "kernelspec": {
280 | "display_name": "Python 3",
281 | "language": "python",
282 | "name": "python3"
283 | },
284 | "language_info": {
285 | "codemirror_mode": {
286 | "name": "ipython",
287 | "version": 3
288 | },
289 | "file_extension": ".py",
290 | "mimetype": "text/x-python",
291 | "name": "python",
292 | "nbconvert_exporter": "python",
293 | "pygments_lexer": "ipython3",
294 | "version": "3.7.3"
295 | }
296 | },
297 | "nbformat": 4,
298 | "nbformat_minor": 2
299 | }
300 |
--------------------------------------------------------------------------------