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 dave@google.com
Steve steve@gmail.com
Rob rob@gmail.com
Ryan ryan@yahoo.com"""
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("wesm@bright.net")
m.groups()
regex.findall(text)
print(regex.sub(r"Username: \1, Domain: \2, Suffix: \3", text))
data = {"Dave": "dave@google.com", "Steve": "steve@gmail.com",
"Rob": "rob@gmail.com", "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