ch07.ipynb

Kernel: Python 3

import numpy as np
import pandas as pd
PREVIOUS_MAX_ROWS = pd.options.display.max_rows
pd.options.display.max_rows = 25
pd.options.display.max_columns = 20
pd.options.display.max_colwidth = 82
np.random.seed(12345)
import matplotlib.pyplot as plt
plt.rc("figure", figsize=(10, 6))
np.set_printoptions(precision=4, suppress=True)

import numpy as np
import pandas as pd

float_data = pd.Series([1.2, -3.5, np.nan, 0])
float_data

float_data.isna()

string_data = pd.Series(["aardvark", np.nan, None, "avocado"])
string_data
string_data.isna()
float_data = pd.Series([1, 2, None], dtype='float64')
float_data
float_data.isna()

data = pd.Series([1, np.nan, 3.5, np.nan, 7])
data.dropna()

data[data.notna()]

data = pd.DataFrame([[1., 6.5, 3.], [1., np.nan, np.nan],
                     [np.nan, np.nan, np.nan], [np.nan, 6.5, 3.]])
data
data.dropna()

data.dropna(how="all")

data[4] = np.nan
data
data.dropna(axis="columns", how="all")

df = pd.DataFrame(np.random.standard_normal((7, 3)))
df.iloc[:4, 1] = np.nan
df.iloc[:2, 2] = np.nan
df
df.dropna()
df.dropna(thresh=2)

df.fillna(0)

df.fillna({1: 0.5, 2: 0})

df = pd.DataFrame(np.random.standard_normal((6, 3)))
df.iloc[2:, 1] = np.nan
df.iloc[4:, 2] = np.nan
df
df.fillna(method="ffill")
df.fillna(method="ffill", limit=2)

data = pd.Series([1., np.nan, 3.5, np.nan, 7])
data.fillna(data.mean())

data = pd.DataFrame({"k1": ["one", "two"] * 3 + ["two"],
                     "k2": [1, 1, 2, 3, 3, 4, 4]})
data

data.duplicated()

data.drop_duplicates()

data["v1"] = range(7)
data
data.drop_duplicates(subset=["k1"])

data.drop_duplicates(["k1", "k2"], keep="last")

data = pd.DataFrame({"food": ["bacon", "pulled pork", "bacon",
                              "pastrami", "corned beef", "bacon",
                              "pastrami", "honey ham", "nova lox"],
                     "ounces": [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
data

meat_to_animal = {
  "bacon": "pig",
  "pulled pork": "pig",
  "pastrami": "cow",
  "corned beef": "cow",
  "honey ham": "pig",
  "nova lox": "salmon"
}

data["animal"] = data["food"].map(meat_to_animal)
data

def get_animal(x):
    return meat_to_animal[x]
data["food"].map(get_animal)

data = pd.Series([1., -999., 2., -999., -1000., 3.])
data

data.replace(-999, np.nan)

data.replace([-999, -1000], np.nan)

data.replace([-999, -1000], [np.nan, 0])

data.replace({-999: np.nan, -1000: 0})

data = pd.DataFrame(np.arange(12).reshape((3, 4)),
                    index=["Ohio", "Colorado", "New York"],
                    columns=["one", "two", "three", "four"])

def transform(x):
    return x[:4].upper()

data.index.map(transform)

data.index = data.index.map(transform)
data

data.rename(index=str.title, columns=str.upper)

data.rename(index={"OHIO": "INDIANA"},
            columns={"three": "peekaboo"})

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]

bins = [18, 25, 35, 60, 100]
age_categories = pd.cut(ages, bins)
age_categories

age_categories.codes
age_categories.categories
age_categories.categories[0]
pd.value_counts(age_categories)

pd.cut(ages, bins, right=False)

group_names = ["Youth", "YoungAdult", "MiddleAged", "Senior"]
pd.cut(ages, bins, labels=group_names)

data = np.random.uniform(size=20)
pd.cut(data, 4, precision=2)

data = np.random.standard_normal(1000)
quartiles = pd.qcut(data, 4, precision=2)
quartiles
pd.value_counts(quartiles)

pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.]).value_counts()

data = pd.DataFrame(np.random.standard_normal((1000, 4)))
data.describe()

col = data[2]
col[col.abs() > 3]

data[(data.abs() > 3).any(axis="columns")]

data[data.abs() > 3] = np.sign(data) * 3
data.describe()

np.sign(data).head()

df = pd.DataFrame(np.arange(5 * 7).reshape((5, 7)))
df
sampler = np.random.permutation(5)
sampler

df.take(sampler)
df.iloc[sampler]

column_sampler = np.random.permutation(7)
column_sampler
df.take(column_sampler, axis="columns")

df.sample(n=3)

choices = pd.Series([5, 7, -1, 6, 4])
choices.sample(n=10, replace=True)

df = pd.DataFrame({"key": ["b", "b", "a", "c", "a", "b"],
                   "data1": range(6)})
df
pd.get_dummies(df["key"], dtype=float)

dummies = pd.get_dummies(df["key"], prefix="key", dtype=float)
df_with_dummy = df[["data1"]].join(dummies)
df_with_dummy

mnames = ["movie_id", "title", "genres"]
movies = pd.read_table("datasets/movielens/movies.dat", sep="::",
                       header=None, names=mnames, engine="python")
movies[:10]

dummies = movies["genres"].str.get_dummies("|")
dummies.iloc[:10, :6]

movies_windic = movies.join(dummies.add_prefix("Genre_"))
movies_windic.iloc[0]

np.random.seed(12345) # to make the example repeatable
values = np.random.uniform(size=10)
values
bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
pd.get_dummies(pd.cut(values, bins))

s = pd.Series([1, 2, 3, None])
s
s.dtype

s = pd.Series([1, 2, 3, None], dtype=pd.Int64Dtype())
s
s.isna()
s.dtype

s[3]
s[3] is pd.NA

s = pd.Series([1, 2, 3, None], dtype="Int64")

s = pd.Series(['one', 'two', None, 'three'], dtype=pd.StringDtype())
s

df = pd.DataFrame({"A": [1, 2, None, 4],
                   "B": ["one", "two", "three", None],
                   "C": [False, None, False, True]})
df
df["A"] = df["A"].astype("Int64")
df["B"] = df["B"].astype("string")
df["C"] = df["C"].astype("boolean")
df

val = "a,b,  guido"
val.split(",")

pieces = [x.strip() for x in val.split(",")]
pieces

first, second, third = pieces
first + "::" + second + "::" + third

"::".join(pieces)

"guido" in val
val.index(",")
val.find(":")

val.index(":")

val.count(",")

val.replace(",", "::")
val.replace(",", "")

import re
text = "foo    bar\t baz  \tqux"
re.split(r"\s+", text)

regex = re.compile(r"\s+")
regex.split(text)

regex.findall(text)

text = """Dave [email protected]
Steve [email protected]
Rob [email protected]
Ryan [email protected]"""
pattern = r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}"

# re.IGNORECASE makes the regex case insensitive
regex = re.compile(pattern, flags=re.IGNORECASE)

regex.findall(text)

m = regex.search(text)
m
text[m.start():m.end()]

print(regex.match(text))

print(regex.sub("REDACTED", text))

pattern = r"([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})"
regex = re.compile(pattern, flags=re.IGNORECASE)

m = regex.match("[email protected]")
m.groups()

regex.findall(text)

print(regex.sub(r"Username: \1, Domain: \2, Suffix: \3", text))

data = {"Dave": "[email protected]", "Steve": "[email protected]",
        "Rob": "[email protected]", "Wes": np.nan}
data = pd.Series(data)
data
data.isna()

data.str.contains("gmail")

data_as_string_ext = data.astype('string')
data_as_string_ext
data_as_string_ext.str.contains("gmail")

pattern = r"([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})"
data.str.findall(pattern, flags=re.IGNORECASE)

matches = data.str.findall(pattern, flags=re.IGNORECASE).str[0]
matches
matches.str.get(1)

data.str[:5]

data.str.extract(pattern, flags=re.IGNORECASE)

values = pd.Series(['apple', 'orange', 'apple',
                    'apple'] * 2)
values
pd.unique(values)
pd.value_counts(values)

values = pd.Series([0, 1, 0, 0] * 2)
dim = pd.Series(['apple', 'orange'])
values
dim

dim.take(values)

fruits = ['apple', 'orange', 'apple', 'apple'] * 2
N = len(fruits)
rng = np.random.default_rng(seed=12345)
df = pd.DataFrame({'fruit': fruits,
                   'basket_id': np.arange(N),
                   'count': rng.integers(3, 15, size=N),
                   'weight': rng.uniform(0, 4, size=N)},
                  columns=['basket_id', 'fruit', 'count', 'weight'])
df

fruit_cat = df['fruit'].astype('category')
fruit_cat

c = fruit_cat.array
type(c)

c.categories
c.codes

dict(enumerate(c.categories))

df['fruit'] = df['fruit'].astype('category')
df["fruit"]

my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
my_categories

categories = ['foo', 'bar', 'baz']
codes = [0, 1, 2, 0, 0, 1]
my_cats_2 = pd.Categorical.from_codes(codes, categories)
my_cats_2

ordered_cat = pd.Categorical.from_codes(codes, categories,
                                        ordered=True)
ordered_cat

my_cats_2.as_ordered()

rng = np.random.default_rng(seed=12345)
draws = rng.standard_normal(1000)
draws[:5]

bins = pd.qcut(draws, 4)
bins

bins = pd.qcut(draws, 4, labels=['Q1', 'Q2', 'Q3', 'Q4'])
bins
bins.codes[:10]

bins = pd.Series(bins, name='quartile')
results = (pd.Series(draws)
           .groupby(bins)
           .agg(['count', 'min', 'max'])
           .reset_index())
results

results['quartile']

N = 10_000_000
labels = pd.Series(['foo', 'bar', 'baz', 'qux'] * (N // 4))

categories = labels.astype('category')

labels.memory_usage(deep=True)
categories.memory_usage(deep=True)

%time _ = labels.astype('category')

%timeit labels.value_counts()
%timeit categories.value_counts()

s = pd.Series(['a', 'b', 'c', 'd'] * 2)
cat_s = s.astype('category')
cat_s

cat_s.cat.codes
cat_s.cat.categories

actual_categories = ['a', 'b', 'c', 'd', 'e']
cat_s2 = cat_s.cat.set_categories(actual_categories)
cat_s2

cat_s.value_counts()
cat_s2.value_counts()

cat_s3 = cat_s[cat_s.isin(['a', 'b'])]
cat_s3
cat_s3.cat.remove_unused_categories()

cat_s = pd.Series(['a', 'b', 'c', 'd'] * 2, dtype='category')

pd.get_dummies(cat_s, dtype=float)

pd.options.display.max_rows = PREVIOUS_MAX_ROWS