Go to canvas and download titanic.csv
Notebook
使用命令行运行 Jupyter Notebook 的具体流程如下：
- 思考🤔：你想在哪里运行你的项目 or 你想把代码存储在哪里？「确定路径」
- 启动 CMD：在文件夹上面的路径中，直接输入 cmd 回车「Enter」目标🎯：为了更快速的到达目标路径。（还有多种方法，以后再讲）
- 确保安装了 Jupyter Notebook：
jupyter notebook
- 安装 Jupyter：
pip install jupyter notebook
题目
Go to canvas and download titanic.csv
Data Dictionary
| Variable | Definition | Values |
|---|---|---|
| survival | Survival | 0 = No, 1 = Yes |
| pclass | Ticket class | 1 = 1st, 2 = 2nd, 3 = 3rd |
| sex | Sex | |
| Age | Age in years | |
| sibsp | # of siblings / spouses aboard the Titanic | |
| parch | # of parents / children aboard the Titanic | |
| ticket | Ticket number | |
| fare | Passenger fare | |
| cabin | Cabin number | |
| embarked | Port of Embarkation | C = Cherbourg, Q = Queenstown, S = Southampton |
Useful Pandas functions
.value_counts() | .nlargest()/nsmallest() |
|---|---|
.size() | .rename() |
loc[]/iloc[] | .qcut() |
.at[]/iat[] | .to_excel() |
.groupby() | .astype(str) |
.agg() | .nlargest()/nsmallest() |
.drop() | np.where() |
.isnull() | .to_numeric() |
.apply() |
Tasks (be careful about overwriting the dataframe! You may need to create a copy) *More advanced
Convert PassengerId to a category
Create a feature called “Family_size” that is the sum of siblings and parents/children
Subsetting rows
a. Find rows where Age > 10 and display the values for columns “Survived” and “Pclass”
b. *Find the people with the 10 smallest Ages and compute the mean and standard deviation of their ages
Sorting & counting values
a. Who paid the highest fair?
b. Which man who survived paid the highest fare?
c. What are the top 5 oldest people in class 3?
d. What was the percentage of men and women that died by point of embarcation?
Cleaning data
a. *Impute the cabin of (the oldest) Mr. Hickman as “B99” (hint: Google “accessor function str pandas”)
Transforming data
a) Create a new column “is_missing_age” if the row contains any missing values for Age. It should have 1 if missing any values, and 0 otherwise
b) *Create a new column called “long_name” with .apply() that counts the letters in the name and if there are more than 20 returns “long name”
c) Drop new the newly created column
Grouping data
d) What was the average fare by class?
e) Who paid more on average for tickets? Men or women?
f) *Bonus: Can you create a print(f'') that displays the results rounded to the nearest 2 digits?
g) What is the total number of siblings for men? for women?
Summarizing grouped data
h) Use the .agg() function to find the mean and standard deviation of Ages for men and women who survived/did not survive
Export a version with only complete cases (no missing values) with the name ‘complete_titanic.csv’ without index numbers. How many rows remain?
i) How would you export it as an Excel file with the sheet name “passenger_list”?
前往 canvas 并下载 titanic.csv
数据字典
| 变量 | 定义 | 值 |
|---|---|---|
| survival | 是否幸存 | 0 = 否, 1 = 是 |
| pclass | 船票类别 | 1 = 一等, 2 = 二等, 3 = 三等 |
| sex | 性别 | |
| Age | 年龄 | |
| sibsp | 在泰坦尼克号上的兄弟姐妹/配偶数量 | |
| parch | 在泰坦尼克号上的父母/子女数量 | |
| ticket | 船票号码 | |
| fare | 乘客票价 | |
| cabin | 舱位号码 | |
| embarked | 登船港口 | C = 瑟堡, Q = 皇后镇, S = 南安普敦 |
实用的 Pandas 函数
.value_counts() | .nlargest()/nsmallest() |
|---|---|
.size() | .rename() |
loc[]/iloc[] | .qcut() |
.at[]/iat[] | .to_excel() |
.groupby() | .astype(str) |
.agg() | .nlargest()/nsmallest() |
.drop() | np.where() |
.isnull() | .to_numeric() |
.apply() |
任务 (注意不要覆盖原始的 dataframe！你可能需要创建一个副本) *较为进阶
将 PassengerId 转换为类别
创建一个名为“Family_size”的特征，该特征是兄弟姐妹和父母/子女的总和
子集筛选
a. 找到年龄 > 10 的行，并显示“Survived”和“Pclass”列的值
b. *找到年龄最小的10个人并计算他们年龄的均值和标准差
排序和计数值
a. 谁支付了最高的票价？
b. 哪位幸存的男性支付了最高的票价？
c. 三等舱中最老的5个人是谁？
d. 在哪个登船港口，男性和女性的死亡比例是多少？
数据清洗
a. *将(年纪最大的) Mr. Hickman 的舱位补充为“B99”(提示：搜索“accessor function str pandas”)
数据转换
a) 如果行中年龄有任何缺失值，创建一个新列“is_missing_age”。如果缺失任何值则为1，否则为0
b) *使用 .apply() 创建一个新列“long_name”，计算名字中的字母数量，如果超过20个则返回“long name”
c) 删除新创建的列
数据分组
d) 按舱位类别的平均票价是多少？
e) 谁的票价平均更高？男性还是女性？
f) *附加：你能创建一个 print(f'') 来显示结果，并四舍五入到最接近的2位小数吗？
g) 男性的兄弟姐妹总数是多少？女性呢？
汇总分组数据
h) 使用 .agg() 函数找到幸存/未幸存的男性和女性的年龄均值和标准差
导出一个只有完整案例(无缺失值)的版本，命名为‘complete_titanic.csv’，不带索引号。还剩多少行？
i) 如何将其导出为名为“passenger_list”的Excel文件工作表？
Solution
1. 将 PassengerId 转为 category 类型
# 使用 astype 方法将 PassengerId 列的数据类型转换为'category'
titanic['PassengerId'] = titanic['PassengerId'].astype('category')
在 pandas 中，category 是一种特殊的数据类型，它用于表示具有固定数量不同值的数据列。这种数据类型特别适用于具有许多重复值的列，因为它可以大大减少内存的使用。它可以被视为在 pandas 中的枚举或因子类型。
例如，假设你有一个包含数百万行的数据集，其中一个列是国家名。尽管你有数百万行数据，但国家的实际数量可能只有几十个。这种情况下，使用 category 类型会比使用传统的字符串类型更加内存高效。
但在这个特定的上下文中，将 PassengerId 转换为 category 可能并不是一个理想的选择，因为 PassengerId 通常应该是一个唯一的标识符，每个值都是独特的，所以转换它为 category 类型可能并不会带来太多好处，可能还会增加计算的复杂性。这是一个错误，应该被更正。
我将为你提供一个简化的示例以说明 category 数据类型的效益。
示例
假设你有一个包含很多员工信息的数据集。
其中一列是员工的部门，尽管数据集中可能有数千或数万个员工，但部门的数量相对较少，例如：["HR", "Finance", "Engineering", "Sales"]。
如果你使用常规的字符串类型存储每个员工的部门信息，那么每个字符串都会在内存中占用一定的空间。但如果使用 category 数据类型，pandas 只会存储每个唯一的部门名称一次，并为数据集中的每个员工使用一个小的整数代码来引用这些名称，从而节省内存。
代码示例
我们首先创建一个简单的数据集，然后比较两种不同数据类型的内存使用情况。
import pandas as pd
# 创建一个简化的数据集
data = {'EmployeeID': range(1, 10001),
'Department': ['HR', 'Finance', 'Engineering', 'Sales'] * 2500}
df = pd.DataFrame(data)
# 默认情况下，'Department'列的数据类型是object，即字符串
print(df.info())
# 转换'Department'列为category类型
df['Department'] = df['Department'].astype('category')
# 查看转换后的内存使用情况
print(df.info())
输出如下：
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10000 entries, 0 to 9999
Data columns (total 2 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 EmployeeID 10000 non-null int64
1 Department 10000 non-null object
dtypes: int64(1), object(1)
memory usage: 156.4+ KB
None
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10000 entries, 0 to 9999
Data columns (total 2 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 EmployeeID 10000 non-null int64
1 Department 10000 non-null category
dtypes: category(1), int64(1)
memory usage: 88.0 KB
None
我们会注意到，将 Department 列转换为 category 数据类型后，内存使用量大大减少了。这只是一个简化的示例，但它说明了为什么在某些情况下使用 category 数据类型是有益的。
是不是底层使用类似数字映射，这样达到节省空间的目的？我如何可以直观的查看这样的映射？
是的，完全正确。category 数据类型在底层使用整数编码来表示每一个唯一的值或类别。每一个唯一的类别值都会与一个整数相关联，而在 DataFrame 或 Series 中实际存储的是这些整数，而不是重复的字符串值。这就是为什么它可以节省大量内存的原因。
要直观地查看这种映射，您可以使用 cat accessor，特别是 categories 和 codes 属性：
示例：
import pandas as pd
# 创建一个简单的数据集
data = {'Department': ['HR', 'Finance', 'Engineering', 'Sales'] * 5}
df = pd.DataFrame(data)
# 将'Department'列转换为category数据类型
df['Department'] = df['Department'].astype('category')
# 查看类别
print("Categories:", df['Department'].cat.categories)
# 输出：Index(['Engineering', 'Finance', 'HR', 'Sales'], dtype='object')
# 查看整数编码
print("Codes:", df['Department'].cat.codes)
# 输出：
0 2
1 1
2 0
3 3
4 2
..
9995 3
9996 2
9997 1
9998 0
9999 3
Length: 10000, dtype: int8
在上述代码中：
df['Department'].cat.categories返回一个 Index 对象，包含列中所有唯一的类别值。df['Department'].cat.codes返回一个包含整数编码的 Series。这些整数编码对应于上述的类别值。
运行上述代码，我们可以直观地看到字符串类别如何映射到整数编码。
2. 创建一个名为“Family_size”的特征，该特征是 siblings 和 parents/children 的总和
# 通过加法直接创建新列'Family_size'
titanic['Family_size'] = titanic['SibSp'] + titanic['Parch']
这个代码：titanic['Family_size'] = titanic['SibSp'] + titanic['Parch'] 这个计算原理是什么？
这段代码的逻辑是基于数据字典中给出的定义来创建一个新的特征或列。在数据字典中：
SibSp表示乘客在泰坦尼克号上的兄弟姐妹和配偶的数量。Parch表示乘客在泰坦尼克号上的父母和孩子的数量。
根据上述定义，一个人在船上的家庭大小可以通过将这两个值相加来计算，因为这两个值加在一起就代表了这个人的家庭成员总数。
因此，这段代码的目的是计算每个乘客的家庭总人数，并将这个值保存在一个新的列 Family_size 中。
例如，如果一个乘客有 1 个兄弟姐妹和 2 个孩子在船上，那么他的 SibSp 值为1，Parch 值为2。因此，Family_size 值为3，表示这个乘客的家庭总共有3个成员（除了他自己）在船上。
让我们用一个小示例来解释上述代码的计算原理。
首先，我们创建一个简单的 DataFrame 来模拟 Titanic 数据的一个小部分：
import pandas as pd
# 创建一个小的 DataFrame 来模拟 Titanic 数据集的一部分。
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'SibSp': [2, 0, 1, 3], # 兄弟姐妹和配偶的数量
'Parch': [1, 0, 2, 0] # 父母和孩子的数量
}
df = pd.DataFrame(data)
print("Original DataFrame:")
print(df)
输出：
Original DataFrame:
Name SibSp Parch
0 Alice 2 1
1 Bob 0 0
2 Charlie 1 2
3 David 3 0
现在，我们使用上述代码来计算 Family_size。
使用 SibSp 和 Parch 的值来计算每个人的 Family_size：
# 根据 SibSp 和 Parch 的值计算 Family_size
df['Family_size'] = df['SibSp'] + df['Parch']
print("\nDataFrame after adding Family_size:")
print(df)
输出：
DataFrame after adding Family_size:
Name SibSp Parch Family_size
0 Alice 2 1 3
1 Bob 0 0 0
2 Charlie 1 2 3
3 David 3 0 3
如上所示，Family_size 列已被成功添加到 DataFrame 中，并且其值是 SibSp 和 Parch 两列值的和。例如，对于"Alice"，她有 2 个兄弟姐妹/配偶和 1 个父母/孩子在船上，所以她的 Family_size 是 3。
3. 子集筛选
a. 找到年龄大于 10 的行，并显示 “Survived” 和 “Pclass” 的值。
subset_a = titanic[titanic['Age'] > 10][['Survived', 'Pclass']]
代码 subset_a = titanic[titanic['Age'] > 10][['Survived', 'Pclass']] 是在使用 Pandas 的 DataFrame 进行行和列的筛选。我们来详细拆解这段代码。
titanic['Age'] > 10: 这部分返回一个布尔型的 Series（也可以看作是一个布尔型的列），其中每个元素表示对应行的 'Age' 值是否大于 10。结果会是一个由 True 和 False 组成的序列。titanic[titanic['Age'] > 10]: 这部分利用上面生成的布尔型 Series 来筛选出 DataFrame 中 'Age' 大于 10 的所有行。这种筛选方法在 Pandas 中称为布尔索引(Boolean indexing)。[['Survived', 'Pclass']]: 这部分用于筛选特定的列。当你使用一个列名列表来索引 DataFrame 时，它会返回一个新的 DataFrame，包含你指定的列。
所以，subset_a = titanic[titanic['Age'] > 10][['Survived', 'Pclass']] 整体的意思是：从 titanic 数据集中筛选出 'Age' 大于 10 的行，并仅保留 'Survived' 和 'Pclass' 这两列。
我们使用一个简单的 DataFrame 作为例子来逐步解释这个操作。
假设我们有以下的小型 DataFrame：
import pandas as pd
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [5, 15, 12, 8],
'Survived': [1, 0, 1, 1],
'Pclass': [3, 2, 1, 3]
}
df = pd.DataFrame(data)
print(df)
这将显示：
Name Age Survived Pclass
0 Alice 5 1 3
1 Bob 15 0 2
2 Charlie 12 1 1
3 David 8 1 3
df['Age'] > 10:
这一步会为数据集中的每一行检查 “Age” 是否大于 10，并返回一个布尔值序列：
0 False
1 True
2 True
3 False
Name: Age, dtype: bool
df[df['Age'] > 10]:
现在，我们使用上面的布尔值序列来筛选出 DataFrame 中满足条件（'Age'大于 10）的行。这会返回一个新的 DataFrame：
Name Age Survived Pclass
1 Bob 15 0 2
2 Charlie 12 1 1
df[df['Age'] > 10][['Survived', 'Pclass']]:
在已筛选的 DataFrame 中，我们进一步选择 'Survived' 和 'Pclass' 这两列：
Survived Pclass
1 0 2
2 1 1
现在，你应该可以看到，我们已经成功地从原始数据集中筛选出了 'Age' 大于 10 的行，并仅保留了 'Survived' 和 'Pclass' 这两列。
b. 找到年龄最小的 10 个人，并计算他们的年龄的平均值和标准差。
subset_b = titanic.nsmallest(10, 'Age')['Age']
mean_age = subset_b.mean()
std_age = subset_b.std()
这段代码的目标是找到数据集中年龄最小的 10 个人，并计算他们年龄的平均值和标准差。
subset_b = titanic.nsmallest(10, 'Age')['Age']titanic.nsmallest(10, 'Age'): 这个方法从 “titanic” 数据框中选择了年龄最小的 10 个人。nsmallest方法对数据框中的指定列（在这里是'Age'列）进行排序，并返回前n个最小值对应的行。在这个例子中，我们想要前 10 个最小的年龄。['Age']: 这部分代码是对上面返回的 10 行数据进行列子集选择，仅选择'Age'列。结果是一个包含 10 个最小年龄的 Pandas 序列。
mean_age = subset_b.mean()subset_b.mean(): 这个方法计算 Pandas 序列subset_b的平均值。由于subset_b包含了年龄最小的 10 个人的年龄，因此这个方法会返回这 10 个年龄的平均值。
std_age = subset_b.std()subset_b.std(): 这个方法计算 Pandas 序列subset_b的标准差。同样地，因为subset_b包含了年龄最小的 10 个人的年龄，所以这个方法会返回这 10 个年龄的标准差。
综上所述，这段代码首先找到了年龄最小的 10 个人，然后计算了他们的年龄的平均值和标准差。
假设我们的 'titanic' 数据集如下：
| PassengerId | Age |
|---|---|
| 1 | 2 |
| 2 | 4 |
| 3 | 3 |
| 4 | 6 |
| 5 | 5 |
| 6 | 1 |
| 7 | 7 |
| 8 | 8 |
| 9 | 9 |
| 10 | 10 |
| 11 | 11 |
1. subset_b = titanic.nsmallest(10, 'Age')['Age']
首先，titanic.nsmallest(10, 'Age') 会对年龄进行排序并选取年龄最小的 10 个乘客：
| PassengerId | Age |
|---|---|
| 6 | 1 |
| 1 | 2 |
| 3 | 3 |
| 2 | 4 |
| 5 | 5 |
| 4 | 6 |
| 7 | 7 |
| 8 | 8 |
| 9 | 9 |
| 10 | 10 |
再然后，['Age'] 将只选择 'Age' 列的值，因此 subset_b 将是：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
2. mean_age = subset_b.mean()
现在，我们来计算这 10 个年龄的平均值：
(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10) / 10 = 5.5
因此，mean_age为 5.5。
3. std_age = subset_b.std()
接下来，我们来计算这 10 个年龄的标准差。虽然具体计算过程可能会涉及较为复杂的数学，但简化后，给定这 10 个数，我们可以找到它们的标准差。在这个例子中，这 10 个数的标准差大约为 3.03。
所以，std_age 为3.03。
让我们用Python代码来模拟一个简化的数据集并执行上述步骤：
- 创建一个简化的数据集：
import pandas as pd
# 创建一个简化的数据集
data = {
'PassengerId': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
'Age': [2, 4, 3, 6, 5, 1, 7, 8, 9, 10, 11]
}
titanic_sample = pd.DataFrame(data)
print(titanic_sample)
- 执行代码：找到年龄最小的 10 个乘客，并获取他们的年龄的平均值和标准差：
# 找到年龄最小的10个乘客
subset_b = titanic_sample.nsmallest(10, 'Age')['Age']
print("\n10 smallest ages:\n", subset_b)
# 计算这10个年龄的平均值
mean_age = subset_b.mean()
print("\nMean age:", mean_age)
# 计算这10个年龄的标准差
std_age = subset_b.std()
print("\nStandard deviation of age:", std_age)
当你运行上述代码时，你会首先看到简化的数据集。接下来，代码将显示年龄最小的10个乘客的年龄列表，然后是这10个年龄的平均值和标准差。
4. 排序和计数值
a. 谁支付了最高的票价？
highest_fare_person = titanic[titanic['Fare'] == titanic['Fare'].max()]['Name']
这行代码的目的是找到支付了最高票价的乘客的名字。其实现原理是通过将数据框与其自身的某一列的最大值进行比较，然后利用这种比较来筛选出数据框中的特定行。以下是这行代码的逐步解释：
titanic['Fare'].max()：这将从titanic数据框的 'Fare' 列中获取最大值，即最高的票价。titanic['Fare'] == titanic['Fare'].max()：这会为titanic数据框中的每一行生成一个布尔值（True 或 False），取决于该行的 'Fare' 值是否等于最高票价。如果是，返回 True，否则返回 False。titanic[titanic['Fare'] == titanic['Fare'].max()]：这将筛选出所有票价等于最高票价的行。这是通过将上述布尔系列作为索引传递给数据框来实现的，这样只有那些其对应布尔值为 True 的行才会被选中。titanic[titanic['Fare'] == titanic['Fare'].max()]['Name']：最后，这将从筛选出的行中提取 'Name' 列，从而得到支付了最高票价的乘客的名字。
综上所述，这行代码将返回一个系列，其中包含了所有支付了最高票价的乘客的名字。如果只有一名乘客支付了最高票价，那么系列中将只有一个名字；如果有多名乘客支付了相同的最高票价，那么系列中将包含所有这些乘客的名字。
以下是一个简化的Python例子，旨在帮助我们理解上述代码的工作原理：
假设我们有一个数据框，记录了4名乘客的名字和票价：
import pandas as pd
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Fare': [10, 20, 20, 15]
}
df = pd.DataFrame(data)
这个数据框的内容如下：
Name Fare
0 Alice 10
1 Bob 20
2 Charlie 20
3 David 15
我们可以使用以下代码找到支付最高票价的乘客的名字：
highest_fare_person = df[df['Fare'] == df['Fare'].max()]['Name']
print(highest_fare_person)
输出：
1 Bob
2 Charlie
Name: Name, dtype: object
Bob 和 Charlie 都支付了最高的票价（20），所以他们的名字都出现在输出结果中。
这个简化的例子和先前的代码的工作原理相同：首先找到最高的票价，然后筛选出支付这个票价的乘客，最后提取他们的名字。
假设您有以下的一个数据框，记录了 5 名学生的名字和他们的数学和英语成绩：
import pandas as pd
data = {
'Name': ['Anna', 'Ben', 'Cindy', 'Daniel', 'Ella'],
'Math': [85, 90, 78, 88, 76],
'English': [80, 89, 91, 85, 87]
}
df = pd.DataFrame(data)
这个数据框的内容如下：
Name Math English
0 Anna 85 80
1 Ben 90 89
2 Cindy 78 91
3 Daniel 88 85
4 Ella 76 87
基于上述数据，请完成以下任务：
- 找出数学成绩最高的学生的名字。
- 找出英语成绩超过88分的所有学生的名字。
- 计算每名学生的平均分，并找出平均分最高的学生的名字。
- 创建一个新列
Passed_Math，如果学生的数学成绩 >=85 ，则该列值为 'Yes'，否则为 'No'。 - 找出数学和英语都不及格（假设及格线为 80 分）的学生名字。
首先，先定义数据框：
import pandas as pd
data = {
'Name': ['Anna', 'Ben', 'Cindy', 'Daniel', 'Ella'],
'Math': [85, 90, 78, 88, 76],
'English': [80, 89, 91, 85, 87]
}
df = pd.DataFrame(data)
- 找出数学成绩最高的学生的名字。
top_math_student = df[df['Math'] == df['Math'].max()]['Name']
print(top_math_student)
输出：
1 Ben
Name: Name, dtype: object
- 找出英语成绩超过88分的所有学生的名字。
english_above_88 = df[df['English'] > 88]['Name']
print(english_above_88)
输出：
1 Ben
2 Cindy
Name: Name, dtype: object
- 计算每名学生的平均分，并找出平均分最高的学生的名字。
df['Average'] = (df['Math'] + df['English']) / 2
top_avg_student = df[df['Average'] == df['Average'].max()]['Name']
print(top_avg_student)
输出：
1 Ben
Name: Name, dtype: object
- 创建一个新列Passed_Math，如果学生的数学成绩>=85，则该列值为'Yes'，否则为'No'。
df['Passed_Math'] = df['Math'].apply(lambda x: 'Yes' if x >= 85 else 'No')
print(df[['Name', 'Passed_Math']])
输出：
Name Passed_Math
0 Anna Yes
1 Ben Yes
2 Cindy No
3 Daniel Yes
4 Ella No
- 找出数学和英语都不及格（假设及格线为80分）的学生名字。
failing_students = df[(df['Math'] < 80) & (df['English'] < 80)]['Name']
print(failing_students)
输出：
Empty DataFrame
根据提供的数据，没有学生的数学和英语成绩都低于 80 分。
b. 哪个幸存下来的男性支付了最高的票价？
highest_fare_survived_man = titanic[(titanic['Sex'] == 'male') & (titanic['Survived'] == 1)].nlargest(1, 'Fare')['Name']
c. 三等舱里最老的5个人是谁？
oldest_in_class_3 = titanic[titanic['Pclass'] == 3].nlargest(5, 'Age')['Name']
d. 按登船点计算死亡的男性和女性的百分比。
embarked_death_ratio = titanic[titanic['Survived'] == 0].groupby(['Embarked', 'Sex']).size() / titanic.groupby(['Embarked', 'Sex']).size()
- 数据清理
a. 将最老的Mr. Hickman的舱位填充为“B99”。
hickman_index = titanic[titanic['Name'].str.contains('Hickman') & (titanic['Age'] == titanic['Age'].max())].index
titanic.at[hickman_index, 'Cabin'] = 'B99'
- 数据转换
a. 如果行中的Age列有缺失值，则创建一个新列“is_missing_age”。
titanic['is_missing_age'] = np.where(titanic['Age'].isnull(), 1, 0)
b. 使用.apply()创建一个名为“long_name”的新列，该列计算名字中的字母数量，并在超过20时返回“long name”。
titanic['long_name'] = titanic['Name'].apply(lambda x: "long name" if len(x) > 20 else "")
c. 删除新创建的列。
titanic.drop('long_name', axis=1, inplace=True)
- 数据分组
d. 按舱位等级计算平均票价。
avg_fare_by_class = titanic.groupby('Pclass')['Fare'].mean()
e. 平均来说，男性还是女性支付了更多的票价？
avg_fare_by_sex = titanic.groupby('Sex')['Fare'].mean()
f. 创建一个打印输出，显示结果保留到最接近的2位数字。
print(f'Men: {avg_fare_by_sex["male"]:.2f}, Women: {avg_fare_by_sex["female"]:.2f}')
g. 男性的总兄弟姐妹数是多少？女性呢？
total_siblings_by_sex = titanic.groupby('Sex')['SibSp'].sum()
- 总结分组数据
h. 使用.agg()函数查找幸存/未幸存的男性和女性的年龄的平均值和标准差。
agg_data = titanic.groupby(['Sex', 'Survived'])['Age'].agg(['mean', 'std'])
- 导出一个只包含完整案例的版本（没有缺失值），命名为'complete_titanic.csv'，不带索引号。还剩多少行？
complete_cases = titanic.dropna()
complete_cases.to_csv('complete_titanic.csv', index=False)
rows_remaining = complete_cases.shape[0]
i. 如果要将其导出为Excel文件，并命名工作表为“passenger_list”，应如何操作？
complete_cases.to_excel('complete_titanic.xlsx', sheet_name='passenger_list', index=False)
此实现应该是正确的，但是实际使用时，您可能需要根据您具体的数据和需求进行适当的调整。
import pandas as pd
import numpy as np
# 读取数据
titanic = pd.read_csv('titanic.csv')
# 1. 将PassengerId转为category类型
titanic['PassengerId'] = titanic['PassengerId'].astype('category')
# 2. 创建Family_size特征
titanic['Family_size'] = titanic['SibSp'] + titanic['Parch']
# 3a. 年龄大于10的行的Survived和Pclass
subset_a = titanic.loc[titanic['Age'] > 10, ['Survived', 'Pclass']]
# 3b. 年龄最小的10个人的年龄的均值和标准差
subset_b = titanic.nsmallest(10, 'Age')['Age']
mean_age, std_age = subset_b.mean(), subset_b.std()
# 4a. 付最高票价的人
highest_fare_person = titanic.loc[titanic['Fare'].idxmax(), 'Name']
# 4b. 幸存的男性中付最高票价的人
survived_men = titanic[(titanic['Sex'] == 'male') & (titanic['Survived'] == 1)]
highest_fare_survived_man = survived_men.loc[survived_men['Fare'].idxmax(), 'Name']
# 4c. 三等舱中年纪最大的5个人
oldest_in_class_3 = titanic[titanic['Pclass'] == 3].nlargest(5, 'Age')['Name'].tolist()
# 5a. 更改Mr. Hickman的舱位
titanic.loc[titanic['Name'].str.contains('Hickman') & titanic['Age'].idxmax(), 'Cabin'] = 'B99'
# 6a. 标记缺失年龄
titanic['is_missing_age'] = titanic['Age'].isnull().astype(int)
# 6b. 标记名字长度大于20的乘客
titanic['long_name'] = titanic['Name'].apply(lambda x: "long name" if len(x) > 20 else "")
# 7d. 按舱位等级计算票价均值
avg_fare_by_class = titanic.groupby('Pclass')['Fare'].mean().to_dict()
# 9. 保存没有缺失值的数据
titanic.dropna().to_csv('complete_titanic.csv', index=False)
公众号：AI悦创【二维码】
AI悦创·编程一对一
AI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh
C++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh
方法一：QQ
方法二：微信：Jiabcdefh
0
0
0
0
0
0