Python 数据科学实用指南

!python -m pip install --upgrade pip    
!python -m pip install jupyter

  !jupyter notebook

   !pip install scipy
   !pip install numpy
   !pip install matplotlib
   !pip install pandas

# For displaying graphics in the code sequence, 
# and not in a separate window:
%matplotlib inline

# By using the randint function, which generates numbers
# whole in a random way:
from random import randint, seed

# An Enum is a data structure that consists of a 
# set of appointed elements. This type of variable can be
# have as value one of these elements.
from enum import Enum

# For displaying graphs:
import matplotlib.pyplot as plt

class Strategy(Enum) :
    CHANGE = 1
    KEEP = 2

# Uses the system clock to initialize the generator of 
# pseudo-random numbers.
seed() 

def Hall_game(strategy) :
    ''' Simulates part of the Monty Hall game. This function simulates the participant's choice of door, the elimination of a bad door by the presenter, and the final choice. It only returns the result of the game, because that we will only need the result to perform our calculations.
    
    Args:
        strategy (strategy) : The player's strategy
        
    Returns:
        bool: Has the player won?
 '''
    doors =[0, 1, 2]
    
    good_door = randint(0,2) 
    
    # Choice of player
    first_choice = randint(0,2) 
    
    # We have two doors left
    doors.remove(first_choice) 
    
    # The presenter eliminates a door
    if first_choice == good_door:
        doors.remove(doors[randint(0,1) ]) 
    else:
        doors =[good_door]
    
    second_choice = 0
    # The second choice depends on the strategy
    if strategy == Strategy.CHANGE:
        second_choice = doors[0]
    elif strategy == Strategy.KEEP:
        second_choice = first_choice
    else:
        raise ValueError("Strategy not recognized!") 
    
    return second_choice == good_door

strategy = Strategy.CHANGE
Hall_game(strategy) 

True

def Play(strategy, nb_turns) :
    '''Simulates a sequence of game turns. This function returns the results of several games of the Monty Hall game in the form of a list of winnings by the player.
    
    Args:
        strategy (strategy) : The player's strategy
        nb_turns (int) : Number of revolutions
        
    Returns:
        list: List of players' winnings for each game
    '''

    return [1 if Hall_game(strategy) else 0 for i in range(nb_turns) ]

print("By changing doors, the player has won {} on 10,000 games."
      .format(sum(Play(Strategy.CHANGE, 10000) )) )
      
print("By keeping his initial choice, the player has won {} out of 10,000 games."
      .format(sum(Play(Strategy.KEEP, 10000) )) )

By changing doors, the player has won 6737 on 10,000 games.
By keeping his initial choice, the player has won 3441 out of 10,000 games.

import numpy as np

# Array of integers:
np.array([1, 2, 3]) 

array([1, 2, 3])

np.array([3.1, 4, 5, 6]) 

array([3.1, 4. , 5. , 6. ])

np.array([1, 2, 3], dtype='float32') 

array([1., 2., 3.], dtype=float32)

# An array of length 10, filled with integers that are worth 0
np.zeros(10, dtype=int) 

# A 3x5 size array filled with floating point numbers of value 1
np.ones((3, 5) , dtype=float) 

# A 3x5 table filled with 3.14
np.full((3, 5) , 3.14) 

# A table filled with a linear sequence
# starting from 0 and ending from 20, with a step of 2
np.arange(0, 20, 2) 

# A table of 5 values, uniformly spaced between 0 and 1
np.linspace(0, 1, 5) 

# This one you already know! Try also "randint" and "normal"
#np.random((3, 3) )

# The identity matrix size 3x3 
np.eye(3) 

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

np.random.seed(0) 
x1 = np.random.randint(10, size=6) # Dimension table 1
print("dimensions number of x1:", x1.ndim) 
print("shape of x1:", x1.shape) 
print("size of x1:", x1.size) 
print("type of x1:", x1.dtype) 

dimensions number of x1: 1
shape of x1: (6,)
size of x1: 6
type of x1: int64

print(x1) 

# To get access to the first element
print(x1[0]) 

# to get access to the last element
print(x1[-1]) 

x2 = np.random.randint(10, size=(3, 4) ) # Dimension table of 2
print(x2[0,1]) 

# We can also set different values
x1[1] = "1000"
print(x1) 

x1[1] = 3.14
print(x1) 

[5 0 3 3 7 9]
5
9
5
[   5 1000    3    3    7    9]
[5 3 3 3 7 9]

print(x1[:5]) # The first five elements

print(x1[5:]) # Elements starting at index 5

print(x1[::2]) # One of two elements

[5 3 3 3 7]
[9]
[5 3 7]

x = np.array([1, 2, 3]) 
y = np.array([3, 2, 1]) 
np.concatenate([x, y]) 

array([1, 2, 3, 3, 2, 1])

def reverse_calculation(values) :
    output = np.empty(len(values) )
    for i in range(len(values) ):
        output[i] = 1.0 / values[i]
    return output
        
values = np.random.randint(1, 10, size=5) 
print(reverse_calculation(values) )

wide_array = np.random.randint(1, 100, size=1000000) 

[0.11111111 0.5        0.16666667 0.11111111 0.2       ]

# First of all, there are simple mathematical operations
x = np.arange(4) 
print("x =", x) 
print("x + 5 =", x + 5) 
print("x - 5 =", x - 5) 
print("x * 2 =", x * 2) 
print("x / 2 =", x / 2) 
print("x // 2 =", x // 2) 

x = [0 1 2 3]
x + 5 = [5 6 7 8]
x - 5 = [-5 -4 -3 -2]
x * 2 = [0 2 4 6]
x / 2 = [0.  0.5 1.  1.5]
x // 2 = [0 0 1 1]

x = [-6, -3, 2, 5]
print("Absolute value:", np.abs(x) )
print("Exponential:", np.exp(x) )
print("Logarithm:", np.log(np.abs(x) )) 

Absolute value: [6 3 2 5]
Exponential: [2.47875218e-03 4.97870684e-02 7.38905610e+00 1.48413159e+02]
Logarithm: [1.79175947 1.09861229 0.69314718 1.60943791]

x = np.random.rand(4,4) 
x > 0.7

array([[ True,  True, False,  True],
       [ True, False, False, False],
       [False, False, False, False],
       [False,  True, False, False]])

L = np.random.random(10) 
np.sum(L) 

4.698357490059848

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid') 
import numpy as np

fig = plt.figure() 
ax = plt.axes() 
x = np.linspace(0, 10, 1000) 
ax.plot(x, np.sin(x) );

x = np.linspace(0, 30, 80) 
dy = 0.3
y = np.sin(x) + dy * np.random.randn(80) 

plt.errorbar(x, y, yerr=dy, fmt='.k') ;

import numpy as np
panda_numpy = np.array([200,50,100,80]) 
panda_numpy

array([200,  50, 100,  80])

family = [
    np.array([100, 5, 20, 80]) , # mom 
    np.array([50, 2.5, 10, 40]) , # baby 
    np.array([110, 6, 22, 80]) , # daddy 
]

import pandas as pd
family_df = pd.DataFrame(family) 
family_df

family_df = pd.DataFrame(family,
                                index = ['mom','baby','dad'],
                                columns = ['legs','hair','hands','belly']) 
family_df

.dataframe tbody tr th {
    vertical-align: top;
}

.dataframe thead th {
    text-align: right;
}

family_df.belly
family_df["belly"]

mom     80.0
baby    40.0
dad     80.0
Name: belly, dtype: float64

for ind, content in family_df.iterrows() :
    print("Family:  %s :" % ind) 
    print(content) 

Family:  mom :
legs     100.0
hair       5.0
hands     20.0
belly     80.0
Name: mom, dtype: float64
Family:  baby :
legs     50.0
hair      2.5
hands    10.0
belly    40.0
Name: baby, dtype: float64
Family:  dad :
legs     110.0
hair       6.0
hands     22.0
belly     80.0
Name: dad, dtype: float64

# Create a CSV file called dataset

%%writefile dataset.csv

John,Doe,120 jefferson st.,Riverside, NJ, 08075
Jack,McGinnis,220 hobo Av.,Phila, PA,09119
"John ""Da Man""",Repici,120 Jefferson St.,Riverside, NJ,08075
Stephen,Tyler,"7452 Terrace ""At the Plaza"" road",SomeTown,SD, 91234
,Blankman,,SomeTown, SD, 00298
"Joan ""the bone"", Anne",Jet,"9th, at Terrace plc",Desert City,CO,00123

Overwriting dataset.csv

data = pd.read_csv("dataset.csv", sep=";") 

data