<jupyter_start><jupyter_text>![alt text](https://encrypted-tbn0.gstatic.com/images?q=tbn%3AANd9GcTK4gQ9nhwHHaSXMHpeggWg7twwMCgb877smkRmtkmDeDoGF9Z6&usqp=CAU) Dicas e Truques de Ciência de Dados  Baby Steps em Ciência de Dados   **Python Crash Course**
![alt text](https://www.python.org/static/img/python-logo@2x.png)

 Strings<jupyter_code>data = 'Cientista de Dados'

print(data)
print(len(data))
data[10:]<jupyter_output><empty_output><jupyter_text>Números<jupyter_code># Numbers
value = 123
value
type(value)
print(value)<jupyter_output><empty_output><jupyter_text>Boleanos<jupyter_code># Boolean
a = True
b = False

print(a,b)
# Multiple Assignment
a, b, c = 1, 2, 3
print(a, b,c)


# No value
a = None
print(a)<jupyter_output>None<jupyter_text>Flow Control
If-Then-Else Condition Example<jupyter_code>idade = 21
if idade >= 18:
    print('maior de idade')
else:
    print('menor de idade')
idade = 39

if idade < 12:
    print('crianca')
elif idade < 18:
    print('adolescente')

elif idade < 39:
    print('maduro')

elif idade < 60:
    print('adulto')
else:
    print('idoso')<jupyter_output>adulto<jupyter_text>For-Loop Example<jupyter_code># For-Loop
for i in range(10):
	print(i)<jupyter_output><empty_output><jupyter_text>While-Loop Example<jupyter_code># While-Loop
e = 5
while e <= 100:
	print(e)
	e += 10<jupyter_output><empty_output><jupyter_text>Estrutura de Dados Tupla<jupyter_code>tupla =  (1, 2, 3)
print(tupla)
type(tupla)<jupyter_output><empty_output><jupyter_text>Lista<jupyter_code>mylist = [1, 2, 3]

print("O índice ZERO é o número: %d" % mylist[0])
type(mylist)
mylist[0]
mylist.append(4)
print("List Length: %d" % len(mylist))
for value in mylist:
	print(value)<jupyter_output><empty_output><jupyter_text>Dicionário<jupyter_code>mydict = {'a': 1, 'b': 2, 'c': 3}
print("O valor da chave 'a' é igual: %d" % mydict['a'])

mydict['a'] = 11
mydict['a'] = 11
print("A value: %d" % mydict['a'])
print("Keys: %s" % mydict.keys())
print("Values: %s" % mydict.values())

for key in mydict.keys():
	print(mydict[key])<jupyter_output>11
2
3<jupyter_text>Functions<jupyter_code># Sum function
def mysum(x, y):
	return x + y
 

def myfun (x,y):
  return x+y 
print(myfun)
# Test sum function
myfun(1,3)
# Sum function
def myexp(x, y):
	return x**y
 
myexp(3,3)<jupyter_output><empty_output><jupyter_text>**NumPy Crash Course**
![alt text](https://miro.medium.com/max/765/0*p0FtnloWd4ogMvTQ.png)

 Create Array (matriz)
matrizes são tensores com 2 dimensões (**tensores de rank 2**).<jupyter_code># define an array
import numpy
mylist = [1, 2, 3]
myarray = numpy.array(mylist)
print(myarray)
print(myarray.shape)<jupyter_output>[1 2 3]
(3,)<jupyter_text>Acessando os dados do Array (matriz)<jupyter_code># access values
import numpy
mylist = [[1, 2, 3], [3, 4, 5]]
myarray = numpy.array(mylist)
print(myarray)
print(myarray.shape)

print("Primeira linha: %s" % myarray[0])

print("última linha: %s" % myarray[-1])

print("Qual elemento está na Posição dessa consulta? A Resposta é %s" % myarray[0, 2])

print("Quais elementos estão na coluna dessa consulta? A Resposta é %s" % myarray[:, 2])<jupyter_output>Quais elementos estão na coluna dessa consulta? A Resposta é [3 5]<jupyter_text>Arithmetic<jupyter_code># arithmetic
import numpy
myarray1 = numpy.array([2, 2, 2])
myarray2 = numpy.array([3, 3, 3])
print("Soma: %s" % (myarray1 + myarray2))
print("Multiplicação: %s" % (myarray1 * myarray2))<jupyter_output>Soma: [5 5 5]
Multiplicação: [6 6 6]<jupyter_text>O vetor n-dimensional (tensor)

O NumPy é uma biblioteca para a linguagem Python com funções para se trabalhar com **computação numérica**. Seu **principal objeto é o vetor n-dimensional, ou ndarray**. Um vetor n-dimensional também é conhecido pelo nome **tensor**.

 A principal característica do ndarray é que ele deve ser homogêneo, ou seja, diferentemente do objeto lista, todos os seus elementos devem ser do mesmo tipo.<jupyter_code>#cria um vetor
import numpy as np
v = np.array([1,2,3,4])
print(v)
print(v.dtype)
v = np.array([1,2,3,4], dtype='float64')
print(v.dtype)<jupyter_output>float64<jupyter_text>Os tensores NumPy também possuem um atributo chamado shape. Esse atributo indica a forma do tensor, por exemplo:<jupyter_code>print(v.shape)<jupyter_output>(4,)<jupyter_text>Neste caso, o tensor v possui 1 dimensão (ou eixo) com 4 elementos. Um tensor unidimensional corresponde a um vetor.  Podemos também criar um tensor bidimensional (uma matriz) usando o atributo shape:<jupyter_code># Alterando a dimensão do tensor
v = np.array([1,2,3,4])
v.shape = (2,2)
print(v)<jupyter_output>[[1 2]
 [3 4]]<jupyter_text>Reshape

Outra forma útil de mudar o shape de um tensor é simplesmente utilizando a função reshape:<jupyter_code>v = np.array([1,2,3,4]).reshape(2,2)
print(v)<jupyter_output>[[1 2]
 [3 4]]<jupyter_text>**ndim** (eixos ou dimensões do tensor) e **size** (total de elementos/registros)
O número de eixos (ou dimensões) de um tensor é dado pelo atributo ndim, enquanto o número total de elementos é dado por size:<jupyter_code>v = np.array(range(9)).reshape(1,3,3)
v

print('Shape = ', v.shape)
print('Número de dimensões = ', v.ndim)
print('Número de elementos = ', v.size)
print('\n\n Veja abaixo o Tensor v  \n\n', v)<jupyter_output>Shape =  (1, 3, 3)
Número de dimensões =  3
Número de elementos =  9


 Veja abaixo o Tensor v  

 [[[0 1 2]
  [3 4 5]
  [6 7 8]]]<jupyter_text>**Matplotlib Crash Course**
![alt text](https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRhMLqZjlbD_mb9HsaF8t1I2s9VI-8ZD60s1g&usqp=CAU) Line Plot<jupyter_code># basic line plot
import matplotlib.pyplot as plt
import numpy

myarray = numpy.array([1, 2, 3])
plt.plot(myarray)
plt.xlabel('Data')
plt.ylabel('Faturamento')
plt.show()<jupyter_output><empty_output><jupyter_text>Scatter Plot<jupyter_code># basic scatter plot
import matplotlib.pyplot as plt
import numpy
vendas = numpy.array([1, 2, 3, 4, 8, 16 ])
faturamento = numpy.array([2, 4, 6, 8, 10, 12])
plt.scatter(vendas,faturamento)
plt.xlabel('vendas')
plt.ylabel('faturamento')
plt.show()
fig, ax = plt.subplots()

size = 0.3
vals = np.array([[60., 32.], [37., 40.], [29., 10.]])

cmap = plt.get_cmap("tab20c")
outer_colors = cmap(np.arange(3)*4)
inner_colors = cmap([1, 2, 5, 6, 9, 10])

ax.pie(vals.sum(axis=1), radius=1, colors=outer_colors,
       wedgeprops=dict(width=size, edgecolor='w'))

ax.pie(vals.flatten(), radius=1-size, colors=inner_colors,
       wedgeprops=dict(width=size, edgecolor='w'))

ax.set(aspect="equal", title='Pie plot with `ax.pie`')
plt.show()
import matplotlib.pyplot as plt
from matplotlib.patches import ConnectionPatch
import numpy as np

# make figure and assign axis objects
fig = plt.figure(figsize=(9, 5))
ax1 = fig.add_subplot(121)
ax2 = fig.add_subplot(122)
fig.subplots_adjust(wspace=0)

# pie chart parameters
ratios = [.27, .56, .17]
labels = ['Alta Renda', 'Baixa renda', 'Classe Média']
explode = [0.1, 0, 0]
# rotate so that first wedge is split by the x-axis
angle = -180 * ratios[0]
ax1.pie(ratios, autopct='%1.1f%%', startangle=angle,
        labels=labels, explode=explode)

# bar chart parameters

xpos = 0
bottom = 0
ratios = [.33, .54, .07, .06]
width = .2
colors = [[.1, .3, .5], [.1, .3, .3], [.1, .3, .7], [.1, .3, .9]]

for j in range(len(ratios)):
    height = ratios[j]
    ax2.bar(xpos, height, width, bottom=bottom, color=colors[j])
    ypos = bottom + ax2.patches[j].get_height() / 2
    bottom += height
    ax2.text(xpos, ypos, "%d%%" % (ax2.patches[j].get_height() * 100),
             ha='center')

ax2.set_title('Faixa Etária - Alta Renda')
ax2.legend(('50-65', 'acima 65', '35-49', 'abaixo 35'))
ax2.axis('off')
ax2.set_xlim(- 2.5 * width, 2.5 * width)

# use ConnectionPatch to draw lines between the two plots
# get the wedge data
theta1, theta2 = ax1.patches[0].theta1, ax1.patches[0].theta2
center, r = ax1.patches[0].center, ax1.patches[0].r
bar_height = sum([item.get_height() for item in ax2.patches])

# draw top connecting line
x = r * np.cos(np.pi / 180 * theta2) + center[0]
y = r * np.sin(np.pi / 180 * theta2) + center[1]
con = ConnectionPatch(xyA=(-width / 2, bar_height), coordsA=ax2.transData,
                      xyB=(x, y), coordsB=ax1.transData)
con.set_color([0, 0, 0])
con.set_linewidth(4)
ax2.add_artist(con)

# draw bottom connecting line
x = r * np.cos(np.pi / 180 * theta1) + center[0]
y = r * np.sin(np.pi / 180 * theta1) + center[1]
con = ConnectionPatch(xyA=(-width / 2, 0), coordsA=ax2.transData,
                      xyB=(x, y), coordsB=ax1.transData)
con.set_color([0, 0, 0])
ax2.add_artist(con)
con.set_linewidth(4)

plt.show()
import matplotlib.pyplot as plt
import numpy as np


plt.style.use('fivethirtyeight')

x = np.linspace(0, 10)

# Fixing random state for reproducibility
np.random.seed(7)

fig, ax = plt.subplots()

ax.plot(x, np.sin(x) + x + np.random.randn(50))
ax.plot(x, np.sin(x) + 0.5 * x + np.random.randn(50))
ax.plot(x, np.sin(x) + 2 * x + np.random.randn(50))
ax.plot(x, np.sin(x) - 0.5 * x + np.random.randn(50))
ax.plot(x, np.sin(x) - 2 * x + np.random.randn(50))
ax.plot(x, np.sin(x) + np.random.randn(50))
ax.set_title("'fivethirtyeight' é o Estilo do Gráfico")

plt.show()<jupyter_output><empty_output><jupyter_text>**Eletroencefalograma**

é um exame que avalia a atividade elétrica espontânea do cérebro. Para tanto, o teste, também conhecido pela abreviação EEG, amplifica os impulsos elétricos cerebrais e os registra, a fim de detectar anormalidades neurológicas.<jupyter_code>import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cbook as cbook
import matplotlib.cm as cm

from matplotlib.collections import LineCollection
from matplotlib.ticker import MultipleLocator

fig = plt.figure("MRI_with_EEG")

# Load the MRI data (256x256 16 bit integers)
with cbook.get_sample_data('s1045.ima.gz') as dfile:
    im = np.frombuffer(dfile.read(), np.uint16).reshape((256, 256))

# Plot the MRI image
ax0 = fig.add_subplot(2, 2, 1)
ax0.imshow(im, cmap=cm.gray)
ax0.axis('off')

# Plot the histogram of MRI intensity
ax1 = fig.add_subplot(2, 2, 2)
im = np.ravel(im)
im = im[np.nonzero(im)]  # Ignore the background
im = im / (2**16 - 1)  # Normalize
ax1.hist(im, bins=100)
ax1.xaxis.set_major_locator(MultipleLocator(0.4))
ax1.minorticks_on()
ax1.set_yticks([])
ax1.set_xlabel('Intensity (a.u.)')
ax1.set_ylabel('MRI density')

# Load the EEG data
n_samples, n_rows = 800, 4
with cbook.get_sample_data('eeg.dat') as eegfile:
    data = np.fromfile(eegfile, dtype=float).reshape((n_samples, n_rows))
t = 10 * np.arange(n_samples) / n_samples

# Plot the EEG
ticklocs = []
ax2 = fig.add_subplot(2, 1, 2)
ax2.set_xlim(0, 10)
ax2.set_xticks(np.arange(10))
dmin = data.min()
dmax = data.max()
dr = (dmax - dmin) * 0.7  # Crowd them a bit.
y0 = dmin
y1 = (n_rows - 1) * dr + dmax
ax2.set_ylim(y0, y1)

segs = []
for i in range(n_rows):
    segs.append(np.column_stack((t, data[:, i])))
    ticklocs.append(i * dr)

offsets = np.zeros((n_rows, 2), dtype=float)
offsets[:, 1] = ticklocs

lines = LineCollection(segs, offsets=offsets, transOffset=None)
ax2.add_collection(lines)

# Set the yticks to use axes coordinates on the y axis
ax2.set_yticks(ticklocs)
ax2.set_yticklabels(['PG3', 'PG5', 'PG7', 'PG9'])

ax2.set_xlabel('Time (s)')


plt.tight_layout()
plt.show()
from mpl_toolkits.mplot3d import axes3d
import matplotlib.pyplot as plt
from matplotlib import cm

fig = plt.figure()
ax = fig.gca(projection='3d')
X, Y, Z = axes3d.get_test_data(0.05)

# Plot the 3D surface
ax.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3)

# Plot projections of the contours for each dimension.  By choosing offsets
# that match the appropriate axes limits, the projected contours will sit on
# the 'walls' of the graph
cset = ax.contourf(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm)
cset = ax.contourf(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm)
cset = ax.contourf(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm)

ax.set_xlim(-40, 40)
ax.set_ylim(-40, 40)
ax.set_zlim(-100, 100)

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

plt.show()<jupyter_output><empty_output><jupyter_text>**Pandas Crash Course**
![alt text](https://s3.amazonaws.com/lintel-blogs-static-files/wp-content/uploads/2019/07/14165137/pandas.jpg) **Series**: Uma série é um array unidimensional onde as linhas e colunas podem ser rotuladas.<jupyter_code># series
import numpy as np
import pandas as pd
myarray = np.array([1, 2, 3])
rownames = ['Kiwi', 'Marlos', 'Bruno']
myseries = pd.Series(myarray, index=rownames)
print(myseries)
print(myseries['Marlos'])<jupyter_output><empty_output><jupyter_text>**Dataframe**<jupyter_code># dataframe
import numpy as np
import pandas as pd

myarray = np.array([[10, 9, 7], [5, 5, 8], [1,1,1]])
rownames = ['Marlos', 'Kiwi','Oliveira']
colnames = ['Geografia', 'Matemática', 'Biologia']
mydataframe = pd.DataFrame(myarray, index=rownames, columns=colnames)
print(mydataframe)
#Quantidade de linhas
mydataframe.value_counts().sum()
mydataframe.Biologia.mean()

mydataframe.Biologia.median()
df = pd.read_csv('/content/bank-full.csv',delimiter=';' )
df
df.head()
df.describe()
df.balance.sum()
df.y.value_counts()<jupyter_output><empty_output><jupyter_text>**Resumão**
![alt text](https://static.imagensparawhats.com.br/content/assetz/uploads/2018/08/imagens-para-whats-praia-e-mar-gifs.gif) Você acaba de colocar o pé nesse MAR que é o **Python**. 

Você descobriu a sintaxe básica e o uso do Python e 3 bibliotecas Python principais usadas para inicira os trabalhos de aprendizado de máquina:

* **NumPy**
* **Matplotlib**
* **Pandas** 

Agora você conhece sintaxe e informações de uso suficientes para ler e entender o código Python para aprendizado de máquina e para começar a criar seus próprios scripts.

Simbóra!

  Fim  Valeu!  Links - Ciência dos Dados https://linktr.ee/cienciadosdados  YouTube - Mais Aulas como essa no YouTube https://www.youtube.com/watch?v=IaIc5oHd3II&t=1569s<jupyter_code>from IPython.core.display import HTML
HTML('<iframe width="380" height="200" src="https://www.youtube.com/embed/W9iktBS67Iw" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1488497038159526, 'fraction_numerical': 0.03698856591817055, 'mean_word_length': 4.582083813917724, 'pattern_counts': {'":': 0, '<': 93, '<?xml version=': 0, '>': 89, 'https://': 9, 'lorem ipsum': 0, 'www.': 3, 'xml': 0}, 'pii_count': 1, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '24', 'dir': 'jupyter-structured-clean-dedup', 'id': '668228', 'license': 'MIT', 'n_tokens_mistral': 6352, 'n_tokens_neox': 6009, 'n_words': 1404, 'path': 'Crash_Course_Python_Parte_2.ipynb', 'repo_name': 'Adrianacms/Hello-Word', 'size': '14518'}