萌新向Python数据分析及数据挖掘 第二章 pandas 第一节 pandas使用基础Q&A 16-30
16. How do I handle missing values in pandas? (video)
In [121]:
url3 = "https://raw.githubusercontent.com/justmarkham/pandas-videos/master/data/ufo.csv"#定义列名
ufo = pd.read_csv(url3)#用read_csv打开csv文件
ufo.tail()
Out[121]:
“NaN”是什么意思？
“NaN”不是字符串，而是一个特殊值：numpy.nan。 它代表“非数字”并表示缺失值。 read_csv在读取文件时检测缺失值（默认情况下），并用此特殊值替换它们。
Documentation for read_csv
In [122]:
# ''isnull'返回一个布尔DataFrame（如果缺少则为True，如果没有缺失则为False）
ufo.isnull().tail()
Out[122]:
In [123]:
# 'nonnull'返回'isnull'的反面（如果不丢失，则返回true，如果丢失则返回False）
ufo.notnull().tail()
Out[123]:
In [124]:
# 计算每个Series中缺失值的数量
ufo.isnull().sum()
Out[124]:
此计算有效，因为：
1.默认情况下，DataFrame的sum **方法在axis = 0 上运行（因此产生列总和）。 2.为了添加布尔值，pandas将“True”转换为 1 ，将“False”转换为 0 **。
In [125]:
# 使用'isnull'Series方法过滤DataFrame行
ufo[ufo.City.isnull()].head()
Out[125]:
How to handle missing values depends on the dataset as well as the nature of your analysis. Here are some options:
In [126]:
# 检查行数和列数
ufo.shape
Out[126]:
In [127]:
# 如果连续缺少“任何”值，则删除该行
ufo.dropna(how='any').shape
Out[127]:
Documentation for dropna
In [128]:
# 默认情况下，'dropna'的inplace'参数为False，因此只暂时删除行
ufo.shape
Out[128]:
In [129]:
# 如果一行中缺少'all'值，则删除该行（在这种情况下不丢弃）
ufo.dropna(how='all').shape
Out[129]:
In [130]:
# 给 any 一个范围
ufo.dropna(subset=['City', 'Shape Reported'], how='any').shape
Out[130]:
In [131]:
# 给all 一个范围
ufo.dropna(subset=['City', 'Shape Reported'], how='all').shape
Out[131]:
In [132]:
# 默认情况下，value_counts'不包含缺失值
ufo['Shape Reported'].value_counts().head()
Out[132]:
In [133]:
# 明确包含缺失值
ufo['Shape Reported'].value_counts(dropna=False).head()
Out[133]:
Documentation for value_counts
In [134]:
# 使用指定值填充缺失值
ufo['Shape Reported'].fillna(value='VARIOUS', inplace=True)
Documentation for fillna
In [135]:
# 确认填写了缺失值
ufo['Shape Reported'].value_counts().head()
Out[135]:
17. What do I need to know about the pandas index? (Part 1) (video)
In [137]:
drinks = pd.read_csv(url7)
drinks.head()
Out[137]:
In [138]:
# 每个DataFrame都有一个索引（有时称为“行标签”）
drinks.index
Out[138]:
In [139]:
# 列名也存储在特殊的“索引”对象中
drinks.columns
Out[139]:
In [140]:
# 索引和列名都不包含在形状中
drinks.shape
Out[140]:
In [141]:
# 如果不定义索引和列名，则默认为整数
pd.read_table('http://bit.ly/movieusers', header=None, sep='|').head()
Out[141]:
索引用于什么？
识别 选择 对齐
In [142]:
# i识别：过滤DataFrame时，每行保留索引
drinks[drinks.continent=='South America']
Out[142]:
In [143]:
# 选择：使用索引选择DataFrame的一部分
drinks.loc[23, 'beer_servings']
Out[143]:
Documentation for loc
In [144]:
# 将现有列设置为索引
drinks.set_index('country', inplace=True)
drinks.head()
Out[144]:
Documentation for set_index
In [145]:
# 'country'现在是索引
drinks.index
Out[145]:
In [146]:
# 'country'不再是列名
drinks.columns
Out[146]:
In [147]:
# 'country'数据不再是DataFrame内容的一部分
drinks.shape
Out[147]:
In [148]:
# 国家名字现在可用于选择
drinks.loc['Brazil', 'beer_servings']
Out[148]:
In [149]:
# 索引名称是可选的
drinks.index.name = None
drinks.head()
Out[149]:
In [150]:
# 恢复索引名称，并将索引移回列
drinks.index.name = 'country'
drinks.reset_index(inplace=True)
drinks.head()
Out[150]:
Documentation for reset_index
In [151]:
# 许多DataFrame方法输出一个DataFrame
drinks.describe()
Out[151]:
In [152]:
# 您可以使用其索引和列与任何DataFrame进行交互
drinks.describe().loc['25%', 'beer_servings']
Out[152]:
18. What do I need to know about the pandas index? (Part 2) (video)
In [153]:
drinks = pd.read_csv(url7)
drinks.head()
Out[153]:
In [154]:
# 每个DataFrame都有一个索引
drinks.index
Out[154]:
In [155]:
# 每个Series还有一个索引（从DataFrame继承）
drinks.continent.head()
Out[155]:
In [156]:
# 将'country'设置为索引
drinks.set_index('country', inplace=True)
Documentation for set_index
In [157]:
# Series 索引在左侧，值在右侧
drinks.continent.head()
Out[157]:
In [158]:
# 系Series的另一个例子（来自'value_counts'方法的输出）
drinks.continent.value_counts()
Out[158]:
Documentation for value_counts
In [159]:
# Series 访问索引
drinks.continent.value_counts().index
Out[159]:
In [160]:
# 访问Series 的值
drinks.continent.value_counts().values
Out[160]:
In [161]:
#可以通过索引选择系列中的元素（使用括号表示法）
drinks.continent.value_counts()['Africa']
Out[161]:
In [162]:
# 任何Series都可以按其值排序
drinks.continent.value_counts().sort_values()
Out[162]:
In [163]:
# a任何Series都可以按其索引排序
drinks.continent.value_counts().sort_index()
Out[163]:
Documentation for sort_values and sort_index
索引用于什么？
识别 选择 对齐
In [164]:
# beer_servings'包含每人平均每年的啤酒摄取量
drinks.beer_servings.head()
Out[164]:
In [165]:
# 创建一个包含两个国家人口的Series
people = pd.Series([3000000, 85000], index=['Albania', 'Andorra'], name='population')
people
Out[165]:
Documentation for Series
In [166]:
# 计算每个国家的年度啤酒总量
(drinks.beer_servings * people).head()
Out[166]:
两个Series按其指数对齐。 如果任一Series中缺少值，则结果标记为NaN。 对齐使我们能够轻松处理不完整的数据。
In [167]:
# concatenate the 'drinks' DataFrame with the 'population' Series (aligns by the index)
pd.concat([drinks, people], axis=1).head()
Out[167]:
19. How do I select multiple rows and columns from a pandas DataFrame? (video)
In [168]:
ufo = pd.read_csv(url3)
ufo.head(3)
Out[168]:
The loc y loc方法用于按标签选择行和列。你可以传递它：
单个标签 标签列表 标签切片 布尔Series 冒号（表示“所有标签”）
In [169]:
# 第0行，所有列
ufo.loc[0, :]
Out[169]:
In [170]:
# 头三行，所有列
ufo.loc[[0, 1, 2], :]
Out[170]:
In [171]:
# 0：2行 包括2, all columns
ufo.loc[0:2, :]
Out[171]:
In [172]:
# t这意味着“所有列”，但明确声明“所有列”更好
ufo.loc[0:2]
Out[172]:
In [173]:
# 行0到行2（包含行2），列'城市'
ufo.loc[0:2, 'City']
Out[173]:
In [174]:
# 行0到行2（包含行2）, 列 'City' and 'State'
ufo.loc[0:2, ['City', 'State']]
Out[174]:
In [175]:
# 使用双括号完成相同的事情 - 但使用'loc'是首选，因为它更明确
ufo[['City', 'State']].head(3)
Out[175]:
In [176]:
# 行0到行2（包含行2）, 列 'City' 到 'State')
ufo.loc[0:2, 'City':'State']
Out[176]:
In [177]:
# 使用'head'和'drop'完成同样的事情
ufo.head(3).drop('Time', axis=1)
Out[177]:
In [178]:
# 'City'为'Oakland'的行，'State'列
ufo.loc[ufo.City=='Oakland', 'State']
Out[178]:
In [179]:
# 使用“链式索引”完成同样的事情 - 但使用'loc'是首选，因为链式索引可能会导致问题
ufo[ufo.City=='Oakland'].State
Out[179]:
The iloc iloc'方法用于通过整数位置选择行和列。你可以传递它：
- 单个整数位置
- 整数位置列表
- 整数位置切片
- 冒号（表示“所有整数位置”）
In [180]:
# 位置0和1中的行，位置0和3中的列
ufo.iloc[[0, 1], [0, 3]]
Out[180]:
In [181]:
# 位置0到2中的行（不包括），位置0到4中的列（不包括）
ufo.iloc[0:2, 0:4]
Out[181]:
In [182]:
# 所有列中位置0到2（不包括）的行
ufo.iloc[0:2, :]
Out[182]:
In [183]:
# 完成同样的事情 - 但使用'iloc'是首选，因为它更明确
ufo[0:2]
Out[183]:
The ix ix方法用于通过标签或整数位置选择行和列，并且只应在需要在同一调用中混合基于标签和基于整数的选择时使用。
In [184]:
# read a dataset of alcohol consumption into a DataFrame and set 'country' as the index
drinks = pd.read_csv(url7, index_col='country')
drinks.head()
Out[184]:
In [185]:
# 标有'Albania'的行，位于0的列
drinks.ix['Albania', 0]
Out[185]:
In [186]:
# row in position 1, column with label 'beer_servings'
drinks.ix[1, 'beer_servings']
Out[186]:
使用带有ix的数字的规则：
- 如果索引是字符串，则数字被视为整数位置，因此切片在右侧是不包含。
- 如果索引是整数，则数字被视为标签，因此切片是包含。
In [187]:
# 行'阿尔巴尼亚'到'安道尔'（包括），0到2位的列（包含）
drinks.ix['Albania':'Andorra', 0:2]
Out[187]:
In [188]:
# 行0到2（含），0到2位的列（不包括）
ufo.ix[0:2, 0:2]
Out[188]:
20. When should I use the "inplace" parameter in pandas? (video)
In [189]:
# read a dataset of UFO reports into a DataFrame
ufo = pd.read_csv(url3)
ufo.head()
Out[189]:
In [190]:
ufo.shape
Out[190]:
In [191]:
# 删除“城市”列（因为inplace = False，不会影响DataFrame）
ufo.drop('City', axis=1).head()
Out[191]:
In [192]:
# 确认实际上没有删除“城市”列
ufo.head()
Out[192]:
In [193]:
# 删除“城市”列（因为inplace = True，确实会影响DataFrame）
ufo.drop('City', axis=1, inplace=True)
In [194]:
# 确认实际删除了“城市”列
ufo.head()
Out[194]:
In [195]:
# 如果该行中缺少任何值，则删除一行（因为inplace = False，不会影响DataFrame）
ufo.dropna(how='any').shape
Out[195]:
In [196]:
# 确认没有实际删除任何行
ufo.shape
Out[196]:
In [197]:
# 使用赋值语句而不是'inplace'参数
ufo = ufo.set_index('Time')
ufo.tail()
Out[197]:
In [198]:
# 使用“向后填充”策略填充缺失值（因为inplace = False不影响DataFrame)
ufo.fillna(method='bfill').tail()
Out[198]:
In [199]:
# 使用“前向填充”策略进行操作（因为inplace = False，不会影响DataFrame）
ufo.fillna(method='ffill').tail()
Out[199]:
21. How do I make my pandas DataFrame smaller and faster? (video)
In [200]:
drinks = pd.read_csv(url7)
drinks.head()
Out[200]:
In [201]:
# 确切的内存使用是未知的，因为对象列是别处的引用
drinks.info()
In [202]:
#强制pandas计算真正的内存使用量
drinks.info(memory_usage='deep')
In [203]:
# 计算每个系列的内存使用量（以字节为单位）
drinks.memory_usage(deep=True)
Out[203]:
Documentation for info and memory_usage
In [204]:
# 使用'category'数据类型（pandas 0.15）将'continent'字符串存储为整数
drinks['continent'] = drinks.continent.astype('category')
drinks.dtypes
Out[204]:
In [205]:
# 'continent'系列似乎没有变化
drinks.continent.head()
Out[205]:
In [206]:
# strings are now encoded (0 means 'Africa', 1 means 'Asia', 2 means 'Europe', etc.)
drinks.continent.cat.codes.head()
Out[206]:
In [207]:
# 现在对编码进行编码（0表示'非洲'，1表示'亚洲'，2表示'欧洲'等）
drinks.memory_usage(deep=True)
Out[207]:
In [208]:
# country' Series中重复这个过程'
drinks['country'] = drinks.country.astype('category')
drinks.memory_usage(deep=True)
Out[208]:
In [209]:
# 因为我们创建了193个类别，因此内存使用增加
drinks.country.cat.categories
Out[209]:
类别数据类型只应与具有少量可能值的字符串Series一起使用。
In [210]:
# 从字典中创建一个小型DataFrame
df = pd.DataFrame({'ID':[100, 101, 102, 103], 'quality':['good', 'very good', 'good', 'excellent']})
df
Out[210]:
In [211]:
# 按“质量”系列排序DataFrame（按字母顺序排列）
df.sort_values('quality')
Out[211]:
In [212]:
# 定义类别的逻辑顺序
df['quality'] = df.quality.astype('category', categories=['good', 'very good', 'excellent'], ordered=True)
df.quality
Out[212]:
In [213]:
# 按“质量”系列（逻辑顺序）输出DataFrame)
df.sort_values('quality')
Out[213]:
In [214]:
# 比较运算符使用有序类别
df.loc[df.quality > 'good', :]
Out[214]:
22. How do I use pandas with scikit-learn to create Kaggle submissions? (video)
In [215]:
# 从Kaggle的泰坦尼克号竞赛中将训练数据集读入DataFrame
url5 = 'https://raw.githubusercontent.com/justmarkham/pandas-videos/master/data/titanic_train.csv'
train = pd.read_csv(url5)
train.head()
Out[215]:
Goal: Predict passenger survival aboard the Titanic based on passenger attributes
In [216]:
#根据乘客属性预测泰坦尼克号上的乘客生存率
In [217]:
# 通过选择两个DataFrame列来创建特征矩阵“X”
feature_cols = ['Pclass', 'Parch']
X = train.loc[:, feature_cols]
X.shape
Out[217]:
In [218]:
# 通过选择一个系列来创建一个响应向量'y'
y = train.Survived
y.shape
Out[218]:
Note: There is no need to convert these pandas objects to NumPy arrays. scikit-learn will understand these objects as long as they are entirely numeric and the proper shapes.
In [219]:
#无需将这些pandas对象转换为NumPy数组。 scikit-learn将理解这些对象，只要它们完全是数字和正确的形状
In [220]:
# 将分类模型拟合到训练数据中
from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()
logreg.fit(X, y)
Out[220]:
Video series: Introduction to machine learning with scikit-learn
In [221]:
# 从Kaggle的泰坦尼克号竞赛中读取测试数据集到DataFrame
url6 ="https://raw.githubusercontent.com/justmarkham/pandas-videos/master/data/titanic_test.csv"
test = pd.read_csv(url6)
test.head()
Out[221]:
In [222]:
# 根据与训练数据匹配的测试数据创建特征矩阵
X_new = test.loc[:, feature_cols]
X_new.shape
Out[222]:
In [223]:
# 使用拟合模型对测试集进行预测
new_pred_class = logreg.predict(X_new)
In [224]:
# 输出结果
pd.DataFrame({'PassengerId':test.PassengerId, 'Survived':new_pred_class}).head()
Out[224]:
Documentation for the DataFrame constructor
In [225]:
# 通过将PassengerID设置为索引来确保PassengerID是第一列
pd.DataFrame({'PassengerId':test.PassengerId, 'Survived':new_pred_class}).set_index('PassengerId').head()
Out[225]:
In [226]:
# 将DataFrame写入可以提交给Kaggle的CSV文件
pd.DataFrame({'PassengerId':test.PassengerId, 'Survived':new_pred_class}).set_index('PassengerId').to_csv('sub.csv')
Documentation for to_csv
In [227]:
# save a DataFrame to disk ("pickle it")
train.to_pickle('train.pkl')
In [228]:
# read a pickled object from disk ("unpickle it")
pd.read_pickle('train.pkl').head()
Out[228]:
Documentation for to_pickle and read_pickle
23. More of your pandas questions answered! (video)
Question: Could you explain how to read the pandas documentation?
Question: What is the difference between ufo.isnull() and pd.isnull(ufo)?
In [229]:
ufo = pd.read_csv(url3)
ufo.head()
Out[229]:
In [230]:
# ＃使用'isnull'作为顶层函数
pd.isnull(ufo).head()
Out[230]:
In [231]:
# 等效：使用'isnull'作为DataFrame方法
ufo.isnull().head()
Out[231]:
Documentation for isnull
Question: Why are DataFrame slices inclusive when using .loc, but exclusive when using .iloc?
In [232]:
# 基于标签的切片包括开始和结束
ufo.loc[0:4, :]
Out[232]:
In [233]:
# 基于位置的切片包括开始和不包括结束
ufo.iloc[0:4, :]
Out[233]:
In [234]:
# iloc'只是遵循NumPy的切片惯例......
ufo.values[0:4, :]
Out[234]:
In [235]:
# ..而NumPy只是遵循Python的切片约定
'python'[0:4]
Out[235]:
In [236]:
# oc'包含停止标签，因为您不一定知道它后面会是什么标签
ufo.loc[0:4, 'City':'State']
Out[236]:
Question: How do I randomly sample rows from a DataFrame?
In [237]:
# 随机取三行
ufo.sample(n=3)
Out[237]:
Documentation for sample
In [238]:
# 使用'random_state'参数进行使结果可以再现
ufo.sample(n=3, random_state=42)
Out[238]:
In [239]:
# 按比例采样
train = ufo.sample(frac=0.75, random_state=99)
In [240]:
# 剩下数据存到另一个DataFrame
test = ufo.loc[~ufo.index.isin(train.index), :]
Documentation for isin
24. How do I create dummy variables in pandas? (video)
In [241]:
train = pd.read_csv(url5)
train.head()
Out[241]:
In [242]:
# 使用'map'方法创建'Sex_male'虚拟变量
train['Sex_male'] = train.Sex.map({'female':0, 'male':1})
train.head()
Out[242]:
Documentation for map
In [243]:
# 替代方法：使用'get_dummies'为每个可能的值创建一列
pd.get_dummies(train.Sex).head()
Out[243]:
Generally speaking:
- If you have "K" possible values for a categorical feature, you only need "K-1" dummy variablesto capture all of the information about that feature.
- One convention is to drop the first dummy variable, which defines that level as the "baseline".
In [244]:
"""一般来说：
如果分类特征具有“K”个可能值，则只需要“K-1”虚拟变量来捕获有关该特征的所有信息。
一种惯用方法是删除第一个虚拟变量，该变量将该级别定义为“基线”。"""
Out[244]:
In [245]:
# 使用'iloc'方法删除第一个虚拟变量（'female'）
pd.get_dummies(train.Sex).iloc[:, 1:].head()
Out[245]:
In [246]:
# 添加前缀以标识虚拟变量的来源
pd.get_dummies(train.Sex, prefix='Sex').iloc[:, 1:].head()
Out[246]:
In [247]:
# 使用 'get_dummies' 处理具有3个可能值
pd.get_dummies(train.Embarked, prefix='Embarked').head(10)
Out[247]:
In [248]:
# 删除第一个虚拟变量（'C'）
pd.get_dummies(train.Embarked, prefix='Embarked').iloc[:, 1:].head(10)
Out[248]:
How to translate these values back to the original 'Embarked' value:
- 0, 0 means C
- 1, 0 means Q
- 0, 1 means S
In [249]:
# 保存虚拟变量的DataFrame并将它们连接到原始DataFram
embarked_dummies = pd.get_dummies(train.Embarked, prefix='Embarked').iloc[:, 1:]
train = pd.concat([train, embarked_dummies], axis=1)
train.head()
Out[249]:
Documentation for concat
In [250]:
# 重新读取DataFrame
train = pd.read_csv(url5)
train.head()
Out[250]:
In [251]:
# 将DataFrame传递给'get_dummies'并指定哪些列为dummy（它删除了原始列）
pd.get_dummies(train, columns=['Sex', 'Embarked']).head()
Out[251]:
In [252]:
# 使用'drop_first'参数（pandas 0.18）删除每个特征的第一个虚拟变量
pd.get_dummies(train, columns=['Sex', 'Embarked'], drop_first=True).head()
Out[252]:
Documentation for get_dummies
25. How do I work with dates and times in pandas? (video)
In [253]:
ufo = pd.read_csv(url3)
ufo.head()
Out[253]:
In [254]:
# 'Time'当前存储为字符串
ufo.dtypes
Out[254]:
In [255]:
# 可以使用字符串切片访问小时，但这种方法很容易出问题
ufo.Time.str.slice(-5, -3).astype(int).head()
Out[255]:
In [256]:
# 将“时间”转换为日期时间格式
ufo['Time'] = pd.to_datetime(ufo.Time)
ufo.head()
Out[256]:
In [257]:
ufo.dtypes
Out[257]:
Documentation for to_datetime
In [258]:
#使用Series方法
ufo.Time.dt.hour.head()
Out[258]:
In [259]:
ufo.Time.dt.weekday_name.head()
Out[259]:
In [260]:
ufo.Time.dt.dayofyear.head()
Out[260]:
API reference for datetime properties and methods
In [261]:
# convert a single string to datetime format (outputs a timestamp object)
ts = pd.to_datetime('1/1/1999')
ts
Out[261]:
In [262]:
# 将datetime系列与时间戳进行比较
ufo.loc[ufo.Time >= ts, :].head()
Out[262]:
In [263]:
# 使用时间戳执行数学运算（输出timedelta对象）
ufo.Time.max() - ufo.Time.min()
Out[263]:
In [264]:
# timedelta对象还具有您可以访问的属性
(ufo.Time.max() - ufo.Time.min()).days
Out[264]:
In [265]:
# 允许绘图出现在笔记本jupyter notebook中
%matplotlib inline
In [266]:
# 计算每年不明飞行物报告的数量
ufo['Year'] = ufo.Time.dt.year
ufo.Year.value_counts().sort_index().head()
Out[266]:
In [267]:
# 绘制每年不明飞行物报告的数量（默认折线图）
ufo.Year.value_counts().sort_index().plot()
Out[267]:
26. How do I find and remove duplicate rows in pandas? (video)
In [268]:
user_cols = ['user_id', 'age', 'gender', 'occupation', 'zip_code']
users = pd.read_table(url2, sep='|', header=None, names=user_cols, index_col='user_id')
users.head()
Out[268]:
In [269]:
users.shape
Out[269]:
In [270]:
# 检测重复的邮政编码：如果项目与之前的项目相同，则为真
users.zip_code.duplicated().tail()
Out[270]:
In [271]:
# 计算重复项（True变为1，False变为0）
users.zip_code.duplicated().sum()
Out[271]:
In [272]:
# 检测重复的DataFrame行：如果整行与前一行相同，则为True
users.duplicated().tail()
Out[272]:
In [273]:
# 数重复的行
users.duplicated().sum()
Out[273]:
Logic for duplicated:
keep='first'(default): Mark duplicates as True except for the first occurrence.keep='last': Mark duplicates as True except for the last occurrence.keep=False: Mark all duplicates as True.
In [274]:
"""duplicated的逻辑：
keep ='first'（默认值）：将重复项标记为True，但第一次出现除外。
keep ='last'：将重复项标记为True，但最后一次出现除外。
keep = False：将所有重复项标记为True。"""
Out[274]:
In [275]:
# 检查重复行，忽略最第一次出现的
users.loc[users.duplicated(keep='first'), :]
Out[275]:
In [276]:
# 检查重复行，忽略最后一个出现的
users.loc[users.duplicated(keep='last'), :]
Out[276]:
In [277]:
# 检查重复行，保留所有重复数据
users.loc[users.duplicated(keep=False), :]
Out[277]:
In [278]:
# 删除重复的行（默认情况下为inplace = False）
users.drop_duplicates(keep='first').shape
Out[278]:
In [279]:
users.drop_duplicates(keep='last').shape
Out[279]:
In [280]:
users.drop_duplicates(keep=False).shape
Out[280]:
Documentation for drop_duplicates
In [281]:
# 在识别重复项时，只考虑列的子集
users.duplicated(subset=['age', 'zip_code']).sum()
Out[281]:
In [282]:
users.drop_duplicates(subset=['age', 'zip_code']).shape
Out[282]:
27. How do I avoid a SettingWithCopyWarning in pandas? (video)
In [283]:
movies = pd.read_csv(url4)
movies.head()
Out[283]:
In [284]:
# 数'content_rating'系列中的缺失值
movies.content_rating.isnull().sum()
Out[284]:
In [285]:
# 检查包含缺少值的DataFrame行
movies[movies.content_rating.isnull()]
Out[285]:
In [286]:
# 检查'content_rating'系列中的唯一值
movies.content_rating.value_counts()
Out[286]:
Goal: Mark the 'NOT RATED' values as missing values, represented by 'NaN'.
In [287]:
#目标：将“未评级”值标记为缺失值，由“NaN”表示。
In [288]:
# 首先，找到相关的行
movies[movies.content_rating=='NOT RATED'].head()
Out[288]:
In [289]:
# 然后，从这些行中选择'content_rating'系列
movies[movies.content_rating=='NOT RATED'].content_rating.head()
Out[289]:
In [290]:
# 最后，用'NaN'（从NumPy导入）替换'NOT RATED'值
import numpy as np
movies[movies.content_rating=='NOT RATED'].content_rating = np.nan
Problem: That statement involves two operations, a __getitem__ and a __setitem__. pandas can't guarantee whether the __getitem__ operation returns a view or a copy of the data.
- If
__getitem__returns a view of the data,__setitem__will affect the 'movies' DataFrame. - But if
__getitem__returns a copy of the data,__setitem__will not affect the 'movies' DataFrame.
In [291]:
"""问题：该语句涉及两个操作，__ getitem__和__setitem__。 pandas无法保证__getitem__操作是返回视图还是数据副本。
如果__getitem__返回数据视图，__ setitem__将影响'movies'DataFrame。
但是如果__getitem__返回数据的副本，__ setitem__将不会影响'movies'DataFrame。"""
Out[291]:
In [292]:
# 'content_rating'系列没有改变
movies.content_rating.isnull().sum()
Out[292]:
Solution: Use the loc method, which replaces the 'NOT RATED' values in a single __setitem__operation.
In [293]:
"""解决方案：使用loc方法，该方法用单个__setitem__操作中替换“NOT RATED”值。"""
Out[293]:
In [294]:
# 用'NaN'替换'NOT RATED'值（不会导致SettingWithCopyWarning）
movies.loc[movies.content_rating=='NOT RATED', 'content_rating'] = np.nan
In [295]:
# 这一次，'content_rating'Sreies发生了变化
movies.content_rating.isnull().sum()
Out[295]:
Summary: Use the loc method any time you are selecting rows and columns in the same statement.
More information: Modern Pandas (Part 1)
In [296]:
# 创建一个仅包含高'star_rating'影片的DataFrame
top_movies = movies.loc[movies.star_rating >= 9, :]
top_movies
Out[296]:
Goal: Fix the 'duration' for 'The Shawshank Redemption'.
In [297]:
'目标：修复“The Shawshank Redemption”的“持续时间”。'
Out[297]:
In [298]:
# 用正确的持续时间覆盖相关的单元格
top_movies.loc[0, 'duration'] = 150
Problem: pandas isn't sure whether 'top_movies' is a view or a copy of 'movies'.
In [299]:
"问题：pandas不确定'top_movies'是视图还是'电影'的副本。"
Out[299]:
In [300]:
# 结果还是修改了
top_movies
Out[300]:
In [301]:
# 'movies' 电影的DataFrame没有改变
movies.head(1)
Out[301]:
Solution: Any time you are attempting to create a DataFrame copy, use the copy method.
In [302]:
"解决方案：每次尝试创建DataFrame副本时，请使用copy方法。"
Out[302]:
In [303]:
# 明确创建'电影'的副本
top_movies = movies.loc[movies.star_rating >= 9, :].copy()
In [304]:
# andas现在知道你正在更新副本而不是视图（不会导致SettingWithCopyWarning
top_movies.loc[0, 'duration'] = 150
In [305]:
# 'top_movies'DataFrame已更新
top_movies
Out[305]:
Documentation on indexing and selection: Returning a view versus a copy
Stack Overflow: What is the point of views in pandas if it is undefined whether an indexing operation returns a view or a copy?
28. How do I change display options in pandas? (video)
In [306]:
drinks = pd.read_csv(url7)
In [307]:
# 打印时仅显示60行
drinks
Out[307]:
In [308]:
# 检查'max_rows'选项的当前设置
pd.get_option('display.max_rows')
Out[308]:
Documentation for get_option
In [309]:
# 覆盖当前设置，以便显示所有行
pd.set_option('display.max_rows', None)
drinks
Out[309]:
In [310]:
# 将'max_rows'选项重置为默认值
pd.reset_option('display.max_rows')
Documentation for set_option and reset_option
In [311]:
# 'max_columns'选项类似于'max_rows'
pd.get_option('display.max_columns')
Out[311]:
In [312]:
train = pd.read_csv(url5)
train.head()
Out[312]:
In [313]:
# 由于“max_colwidth”选项，省略号显示在第1行的“名称”单元格中
pd.get_option('display.max_colwidth')
Out[313]:
In [314]:
# 覆盖当前设置，以便显示更多字符
pd.set_option('display.max_colwidth', 1000)
train.head()
Out[314]:
In [315]:
# 覆盖''precision' '设置以显示'票价'小数点后的2位数
pd.set_option('display.precision', 2)
train.head()
Out[315]:
In [316]:
# 在饮料DataFrame中添加两个无意义的列
drinks['x'] = drinks.wine_servings * 1000
drinks['y'] = drinks.total_litres_of_pure_alcohol * 1000
drinks.head()
Out[316]:
In [317]:
# 使用Python格式字符串将逗号指定为千位分隔符
pd.set_option('display.float_format', '{:,}'.format)
drinks.head()
Out[317]:
In [318]:
# y'受影响（但不是'x'）因为'float_format'选项只影响浮点数（不是整数）
drinks.dtypes
Out[318]:
In [319]:
# 查看选项说明（包括默认值和当前值）
pd.describe_option()
In [320]:
# 按名称搜索特定选项
pd.describe_option('rows')
Documentation for describe_option
In [321]:
# 将所有选项重置为其默认值
pd.reset_option('all')
29. How do I create a pandas DataFrame from another object? (video)
In [322]:
# 从字典创建一个DataFrame（键成为列名，值成为数据）
pd.DataFrame({'id':[100, 101, 102], 'color':['red', 'blue', 'red']})
Out[322]:
In [323]:
# 指定列的顺序并定义索引
df = pd.DataFrame({'id':[100, 101, 102], 'color':['red', 'blue', 'red']}, columns=['id', 'color'], index=['a', 'b', 'c'])
df
Out[323]:
Documentation for DataFrame
In [324]:
# 从列表中的列表结构创建一个DataFrame（每个内部列表成为一行）
pd.DataFrame([[100, 'red'], [101, 'blue'], [102, 'red']], columns=['id', 'color'])
Out[324]:
In [325]:
# 创建一个NumPy数组（形状为4乘2）并用0到1之间的随机数填充它
import numpy as np
arr = np.random.rand(4, 2)
arr
Out[325]:
In [326]:
# 从NumPy数组创建一个DataFrame
pd.DataFrame(arr, columns=['one', 'two'])
Out[326]:
In [327]:
# 创建学生ID（100到109）和测试分数（60到10之间的随机整数）的DataFrame
pd.DataFrame({'student':np.arange(100, 110, 1), 'test':np.random.randint(60, 101, 10)})
Out[327]:
In [328]:
# set_index'可以与DataFrame构造函数链接以选择索引
pd.DataFrame({'student':np.arange(100, 110, 1), 'test':np.random.randint(60, 101, 10)}).set_index('student')
Out[328]:
Documentation for set_index
In [329]:
# 使用Series构造函数创建一个新Series
s = pd.Series(['round', 'square'], index=['c', 'b'], name='shape')
s
Out[329]:
Documentation for Series
In [330]:
# 连接DataFrame和Series（使用axis = 1来连接列）
pd.concat([df, s], axis=1)
Out[330]:
Notes:
- The Series name became the column name in the DataFrame.
- The Series data was aligned to the DataFrame by its index.
- The 'shape' for row 'a' was marked as a missing value (NaN) because that index was not present in the Series.
Documentation for concat
In [331]:
"""笔记：
系列名称成为DataFrame中的列名称。
Series数据通过其索引与DataFrame对齐。
行'a'的'形状'被标记为缺失值（NaN），因为该索引在系列中不存在。"""
Out[331]:
30. How do I apply a function to a pandas Series or DataFrame? (video)
In [332]:
# read the training dataset from Kaggle's Titanic competition into a DataFrame
train = pd.read_csv(url5)
train.head()
Out[332]:
Goal: Map the existing values of a Series to a different set of values
Method: map (Series method)
In [333]:
"""目标：将Series的现有值映射到不同的值集
方法：map（Series方法）"""
Out[333]:
In [334]:
# map 'female' to 0 and 'male' to 1
train['Sex_num'] = train.Sex.map({'female':0, 'male':1})
train.loc[0:4, ['Sex', 'Sex_num']]
Out[334]:
Goal: Apply a function to each element in a Series
Method: apply (Series method)
Note: map can be substituted for apply in many cases, but apply is more flexible and thus is recommended
In [335]:
"""目标：将函数应用于系列中的每个元素
方法：apply（Series方法）
注意：在许多情况下，map可以替换为apply，但是apply更灵活，因此建议使用"""
Out[335]:
In [336]:
# 计算“姓名”系列中每个字符串的长度
train['Name_length'] = train.Name.apply(len)
train.loc[0:4, ['Name', 'Name_length']]
Out[336]:
In [337]:
# 将“票价”系列中的每个元素四舍五入到下一个整数
import numpy as np
train['Fare_ceil'] = train.Fare.apply(np.ceil)
train.loc[0:4, ['Fare', 'Fare_ceil']]
Out[337]:
In [338]:
# 我们想要提取每个人的姓氏
train.Name.head()
Out[338]:
In [339]:
# 使用字符串方法以逗号分隔“名称”系列（返回一Series列表）
train.Name.str.split(',').head()
Out[339]:
In [340]:
# 定义一个函数，该函数根据位置从列表中返回一个元素
def get_element(my_list, position):
return my_list[position]
In [341]:
# 应用'get_element'函数并将'position'作为关键字参数传递
train.Name.str.split(',').apply(get_element, position=0).head()
Out[341]:
In [342]:
# 或者，使用lambda函数
train.Name.str.split(',').apply(lambda x: x[0]).head()
Out[342]:
Goal: Apply a function along either axis of a DataFrame
Method: apply (DataFrame method)
In [343]:
"""目标：沿DataFrame的任一轴应用函数
方法：apply（DataFrame方法）"""
Out[343]:
In [344]:
drinks = pd.read_csv(url7)
drinks.head()
Out[344]:
In [345]:
# 选择要使用的DataFrame的子集
drinks.loc[:, 'beer_servings':'wine_servings'].head()
Out[345]:
In [346]:
# 沿axix 0应用'max'函数来计算每列中的最大值
drinks.loc[:, 'beer_servings':'wine_servings'].apply(max, axis=0)
Out[346]:
In [347]:
# 沿axis 1应用'max'函数来计算每行的最大值
drinks.loc[:, 'beer_servings':'wine_servings'].apply(max, axis=1).head()
Out[347]:
In [348]:
# 使用'np.argmax'计算哪一列具有每行的最大值
drinks.loc[:, 'beer_servings':'wine_servings'].apply(np.argmax, axis=1).head()
Out[348]:
Goal: Apply a function to every element in a DataFrame
Method: applymap (DataFrame method)
In [349]:
# 将每个DataFrame元素转换为float
drinks.loc[:, 'beer_servings':'wine_servings'].applymap(float).head()
Out[349]:
In [350]:
#覆盖现有的DataFrame列
drinks.loc[:, 'beer_servings':'wine_servings'] = drinks.loc[:, 'beer_servings':'wine_servings'].applymap(float)
drinks.head()
Out[350]:
