Datawhale7月组队学习task1数据加载及探索性数据分析

Datawhale7月task1数据加载及探索性数据分析

​ 有幸了解到了Datawhale这样一个开源组织，欣然报名了2021年7月的组队学习的动手学数据分析系列课程

​ 本系列目标：完成kaggle上泰坦尼克的任务，实战数据分析全流程

​ use machine learning to create a model that predicts which passengers survived the Titanic shipwreck

一.数据载入及初步观察

1.载入数据

①导入numpy和pandas

import numpy as np
import pandas as pd

②导入数据集

os 模块提供了非常丰富的方法用来处理文件和目录

os.getcwd() 方法可用于返回当前工作目录,可为路径的载入提供便捷的参考

import os
os.getcwd()

运行结果

查看当前路径还可用魔法方法%pwd

​ 关于魔法方法，后文遇到的问题 3. 那里有总结

（1）绝对路径载入

​ 在文件右键属性那里复制过来的路径是C:\Users\86171\Desktop\最近的都在这\datawhale\hands-on-data-analysis-master\第一单元项目集合\test_1.csv

​ 然而直接用这个路径会报错

df = pd.read_csv('C:\Users\86171\Desktop\最近的都在这\datawhale\hands-on-data-analysis-master\第一单元项目集合\test_1.csv')

​

将\改为\\或/就了，即：

df =pd.read_csv('C:\\Users\\86171\\Desktop\\最近的都在这\\datawhale\\hands-on-data-analysis-master\\第一单元项目集合\\test_1.csv')
#或
df =pd.read_csv('C:/Users/86171/Desktop/最近的都在这/datawhale/hands-on-data-analysis-master/第一单元项目集合/test_1.csv')

（2）相对路径载入

#相对路径
df = pd.read_csv('test_1.csv')

​ df是DataFrame的缩写，这里表示读取进来的数据

df.head()
df.head(3)

​ head()根据位置返回对象的前n行。如果你的对象中包含正确的数据类型, 则对于快速测试很有用。此方法用于返回数据帧或序列的前n行(默认值为5)

pd.read_csv()和pd.read_table()

pd.read_csv()的结果在上面

pd.read_table()结果如下：

区别：

​ .tsv 与 .csv 唯一的不同之处在于,数据列之间的分隔符是制表符 (tab), 而不是逗号。 文件的扩展名通常是.tsv,但有时也用.csv 作为扩展名。从本质上来看,.tsv 文件与.csv 文件在 Python 中的作用是相同的

• TSV : Tab-separated values
• CSV : Comma-separated values

怎样使他们一样呢？指定分隔符，修改sep参数

对于pd.read_csv(),将sep参数改为'/t'

针对上面的报错提示，加上参数engine='python',即可

对于pd.read_table(),将sep参数改为',',同时engine='python'

​ sep=可以省略不写

③每1000行为一个数据模块，逐块读取

​ 在处理很大的文件时，或找出大文件中的参数集以便于后续处理时，你可能只想读取文件的一小部 分或逐块对文件进行迭代

​ 所以逐块读取方便读取其中的一部分数据或对文件进行逐块处理,还可以减少资源消耗，提高效率

​ 先来读取一下整个文件，

pd.options.display.max_rows =8
#设置显示最大行数，看起来紧凑一些
df

​ 若只想读取几行，可通过nrows参数调整

df = pd.read_csv('test_1.csv',nrows=5)
df

​ nrows是用于选择记录的前n个元素的参数

逐块读取

​ 设置行数chunksize,先以100行为一个数据块

​ read_csv所返回的这个TextParser对象使你可以根据chunksize对文件进行逐块迭代

chunker = pd.read_csv('test_1.csv',chunksize=1000)
chunker
for chunk in chunker:
    print(chunk.head())

​ 运行结果:

#或
for chunk in chunker:
	print(chunk)

​ 运行结果:

④把表头改为中文，索引改为乘客ID

方法一

代码

df = pd.read_csv("train.csv",names=['乘客ID','是否幸存','仓位等级','姓名','性别','年龄','兄弟姐妹个数','父母子女个数','船票信息','票价','客舱','登船港口'],index_col='乘客ID',header=0)
df.head()

​ 关于header=0的解释

运行结果

​ 注：上面用到的names、index_col、header等参数

CSDN里面还有一个很好的☝️ 解释

方法二

​ 设置列名

df=pd.read_csv("train.csv")
df.columns = ['乘客ID','是否幸存','仓位等级','姓名','性别','年龄','兄弟姐妹个数','父母子女个数','船票信息','票价','客舱','登船港口']#必须一一对应
df = df.set_index('乘客ID')  # 重新设 乘客ID 为索引，去掉默认会自动加上一列行号
df.head()

​ 关于set_index

方法三

df.rename(columns={'PassengerId':'乘客ID','Survived':'是否幸存', 'Pclass':'仓位等级', 'Name':'姓名','Sex':'性别','Age':'年龄','SibSp': '堂兄弟/妹个数','Parch':'父母与小孩个数', 'Ticket':' 船票信息','Fare':'票价' ,'Cabin': '客舱','Embarked':'登船港口' }, inplace = True)#可以修改部分列名或者全部
df = df.set_index('乘客ID')  # 重新设 乘客ID 为索引，去掉默认会自动加上一列行号
df.head()

​ 关于df.rename()

​ 方法二和方法三均学习自https://blog.csdn.net/miaochangq/article/details/108052553

2.初步观察

​ 导入数据后，你可能要对数据的整体结构和样例进行概览，比如说，数据大小、有多少列，各列都是什么格式的，是否包含null等

①查看数据基本信息

方法一

df.info()

方法二

​ 逐个打印Dataframe的基本属性

print(df.index)  # 索引

print(df.shape)  # 数据结构（几行几列）
print(df.size) #元素总个数
print(df.values) #元素值
print(df.ndim) #维度数

print(df.columns)  # 列名
# 查看列类型
cols = df.columns
for col in cols:
    print(col+' : '+ str(df[col].dtype))

运行结果

另：查看缺省值

print(df.apply(lambda x:np.sum(x.isnull())))
#或
df.isna().sum()

运行结果

②观察表格前10行的数据和后15行的数据

#前十行
df.head(10)
#或
df.iloc[:10,:]

运行结果

#后15行
df.tail(15)
#或
df.iloc[-15:,:]

运行结果

③判断数据是否为空，为空的地方返回True，其余地方返回False

df.isnull()

运行结果

3.保存数据

# 注意：不同的操作系统保存下来可能会有乱码。可以加入`encoding='GBK' 或者 ’encoding = ’utf-8‘‘`
df.to_csv("train_language_of_Chinese.csv",sep=',',encoding='utf-8')

二.pandas基础

​ 数据分析的第一步，加载数据已经学习完毕了。当数据展现在我们面前的时候，我们所要做的第一步就是认识他,下面要学习的就是了解字段含义以及初步观察数据

1.基本数据类型:DataFrame和Series

①Series

​ Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关 的数据标签（即索引）组成

仅由一组数据即可产生最简单的Series：

import pandas as pd
import numpy as np
obj = pd.Series([4,7,-5,3])
print(obj)

运行结果

​ Series的字符串表现形式为：索引在左边，值在右边

​ 可以通过Series 的values和index属性获取 其数组表示形式和索引对象：

print(obj.values)
print(obj.index)

运行结果

[ 4  7 -5  3]
RangeIndex(start=0, stop=4, step=1)

​ 自创索引：

obj=pd.Series([4,7,-5,3],index=['h','z','s,s','p'])
print(obj)

运行结果

h      4
z      7
s,s   -5
p      3
dtype: int64

​ 与普通NumPy数组相比，可以通过索引的方式选取Series中的单个或一组值：

obj=pd.Series([4,7,-5,3],index=['h','z','s,s','p'])
print(obj['h'])
obj['p']='a'
print(obj[['z','p','h']])#['Z','P','h']是索引列表

运行结果

4
z    7
p    a
h    4
dtype: object

​ 使用NumPy函数或类似NumPy的运算（如根据布尔型数组进行过滤、标量乘法、应用数学函数 等）都会保留索引值的链接

obj=pd.Series([4,7,-5,3],index=['h','z','s,s','p'])
print(obj[obj>0])
print(obj*2)
print(np.exp(obj))

h    4
z    7
p    3
dtype: int64
h       8
z      14
s,s   -10
p       6
dtype: int64
h        54.598150
z      1096.633158
s,s       0.006738
p        20.085537
dtype: float64

​ 可以将Series看成是一个定长的有序字典，因为它是索引值到数据值的一个映射。它可以用在许 多原本需要字典参数的函数中：

print('h' in obj)
print('q'in obj)

运行结果

True
False

​ 如果数据被存放在一个Python字典中，也可以直接通过这个字典来创建Series：

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj = pd.Series(sdata)
print(obj)

运行结果

Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64

如果只传入一个字典，则结果Series中的索引就是原字典的键（有序排列）。可以传入排好序的 字典的键以改变顺序：

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}

states =['California','Ohio','Oregon','Texas']
obj=pd.Series(sdata,index=states)
print(obj)

运行结果

California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float64

​ 在这个例子中，sdata中跟states索引相匹配的那3个值会被找出来并放到相应的位置上，但由 于"California"所对应的sdata值找不到，所以其结果就为NaN（即“非数字”（not a number），在 pandas中，它用于表示缺失或NA值）。因为‘Utah’不在states中，它被从结果中除去。 缺失（missing）或NA表示缺失数据。

​ pandas的isnull和notnull函数可用于检测缺失数 据：

print(pd.isnull(obj))
print(pd.notnull(obj))

运行结果

California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool
California 	  False
Ohio 		   True
Oregon 		   True
Texas 		   True
dtype: bool

​ Series也有类似的实例方法：

print(obj.isnull())
print(obj.notnull())

运行结果

California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool
California    False
Ohio           True
Oregon         True
Texas          True
dtype: bool

对于许多应用而言，Series最重要的一个功能是，它会根据运算的索引标签自动对齐数据

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
states =['California','Ohio','Oregon','Texas']
obj1=pd.Series(sdata)
obj2=pd.Series(sdata,states)
print(obj1+obj2)

运行结果

California         NaN
Ohio           70000.0
Oregon         32000.0
Texas         142000.0
Utah               NaN
dtype: float64

​ Series对象本身及其索引都有一个name属性，该属性跟pandas其他的关键功能关系非常密切：

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
states =['California','Ohio','Oregon','Texas']
obj=pd.Series(sdata,states)
obj.name='population'
obj.index.name='state'
print(obj)

运行结果

state
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
Name: population, dtype: float64

​ Series的索引可以通过赋值的方式就地修改：

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
states =['California','Ohio','Oregon','Texas']
obj=pd.Series(sdata,states)
print(obj)
obj.index= ['Bob', 'Steve', 'Jeff', 'Ryan']
print(obj)

运行结果

California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float64
Bob          NaN
Steve    35000.0
Jeff     16000.0
Ryan     71000.0
dtype: float64

②DataFrame

​ DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字 符串、布尔值等）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。DataFrame中的数据是以一个或多个二维块存放的（而不是列表、字典或别的一维 数据结构）

​ 下面的解释都写在代码的注释里面

#建DataFrame的办法有很多，最常用的一种是直接传入一个由等长列表或NumPy数组组成的字典：
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2001, 2002, 2003],
'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)
print(frame)
#结果DataFrame会自动加上索引（跟Series一样），且全部列会被有序排列：
#对于特别大的DataFrame，head方法会选取前五行：
print(frame.head())

运行结果

    state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9
5  Nevada  2003  3.2
    state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9

#如果指定了列序列，则DataFrame的列就会按照指定顺序进行排列：
print(pd.DataFrame(data,columns=['year','state','pop']).head(3))
#如果传入的列在数据中找不到，就会在结果中产生缺失值：
frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
 index=['one', 'two', 'three', 'four', 'five', 'six'])
print(frame2)
#通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series：
print(frame2['state'])
#注意，返回的Series拥有原DataFrame相同的索引，且其name属性也已经被相应地设置好了,行也可以通过位置或名称的方式进行获取，比如用loc属性
print(frame2.loc['state'])

运行结果

   year state  pop
0  2000  Ohio  1.5
1  2001  Ohio  1.7
2  2002  Ohio  3.6
       year   state  pop debt
one    2000    Ohio  1.5  NaN
two    2001    Ohio  1.7  NaN
three  2002    Ohio  3.6  NaN
four   2001  Nevada  2.4  NaN
five   2002  Nevada  2.9  NaN
six    2003  Nevada  3.2  NaN
one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
six      Nevada
Name: state, dtype: object
one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
six      Nevada
Name: state, dtype: object

#列可以通过赋值的方式进行修改。例如，我们可以给那个空的"debt"列赋上一个标量值或一组值：
frame2['debt']=10.1
print(frame2)
frame2['debt']=np.arange(6.)
print(frame2)

运行结果

       year   state  pop  debt
one    2000    Ohio  1.5  10.1
two    2001    Ohio  1.7  10.1
three  2002    Ohio  3.6  10.1
four   2001  Nevada  2.4  10.1
five   2002  Nevada  2.9  10.1
six    2003  Nevada  3.2  10.1
       year   state  pop  debt
one    2000    Ohio  1.5   0.0
two    2001    Ohio  1.7   1.0
three  2002    Ohio  3.6   2.0
four   2001  Nevada  2.4   3.0
five   2002  Nevada  2.9   4.0
six    2003  Nevada  3.2   5.0

#将列表或数组赋值给某个列时，其长度必须跟DataFrame的长度相匹配。如果赋值的是一个Series，就会精确匹配DataFrame的索引，所有的空位都将被填上缺失值：

val = pd.Series([-1.2,-1,-1.3],index=['four','two','five'])
frame2['debt']=val
print(frame2)
frame2['eastern']=frame2.state=='Ohio'
print(frame2)
del frame2['eastern']
print(frame2.columns)

运行结果

       year   state  pop  debt
one    2000    Ohio  1.5  10.1
two    2001    Ohio  1.7  10.1
three  2002    Ohio  3.6  10.1
four   2001  Nevada  2.4  10.1
five   2002  Nevada  2.9  10.1
six    2003  Nevada  3.2  10.1
       year   state  pop  debt
one    2000    Ohio  1.5   0.0
two    2001    Ohio  1.7   1.0
three  2002    Ohio  3.6   2.0
four   2001  Nevada  2.4   3.0
five   2002  Nevada  2.9   4.0
six    2003  Nevada  3.2   5.0
       year   state  pop  debt
one    2000    Ohio  1.5   NaN
two    2001    Ohio  1.7  -1.0
three  2002    Ohio  3.6   NaN
four   2001  Nevada  2.4  -1.2
five   2002  Nevada  2.9  -1.3
six    2003  Nevada  3.2   NaN

#为不存在的列赋值会创建出一个新列。关键字del用于删除列。作为del的例子，先添加一个新的布尔值的列，state是否为'Ohio'：
frame2['eastern']=frame2.state=='Ohio'
#不能用frame2.eastern创建新的列。
print(frame2)
#del方法可以用来删除这列
del frame2['eastern']
print(frame2.columns)

运行结果

   year   state  pop  debt  eastern
one    2000    Ohio  1.5   NaN     True
two    2001    Ohio  1.7  -1.0     True
three  2002    Ohio  3.6   NaN     True
four   2001  Nevada  2.4  -1.2    False
five   2002  Nevada  2.9  -1.3    False
six    2003  Nevada  3.2   NaN    False
Index(['year', 'state', 'pop', 'debt'], dtype='object')

#另一种常见的数据形式是嵌套字典：
pop = {'Nevada': {2001: 2.4, 2002: 2.9},
....: 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame3 =pd.DataFrame(pop)
print(frame3)

运行结果

      Nevada  Ohio
2001     2.4   1.7
2002     2.9   3.6
2000     NaN   1.5

#  也可以使用类似NumPy数组的方法，对DataFrame进行转置（交换行和列）：
print(frame3.T)
#
frame4=pd.DataFrame(pop, index=[2001, 2002, 2003])
print(frame4)

运行结果

     2001  2002  2000
Nevada   2.4   2.9   NaN
Ohio     1.7   3.6   1.5
      Nevada  Ohio
2001     2.4   1.7
2002     2.9   3.6
2003     NaN   NaN

#由Series组成的字典差不多也是一样的用法：
pdata = {'Ohio': frame3['Ohio'][:-1],
....: 'Nevada': frame3['Nevada'][:2]}
pd.DataFrame(pdata)

运行结果

Ohio	Nevada
2001	1.7	2.4
2002	3.6	2.9

2.知道你的数据叫什么

①导入"train.csv"文件

df = pd.read_csv("train.csv")
df

②查看DataFrame数据的每列的名称

print(df.columns)

运行结果

Index(['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp',
       'Parch', 'Ticket', 'Fare', 'Cabin', 'Embarked'],
      dtype='object')

③查看"Cabin"这列的所有值[多种方法]

方法

print(df['Cabin'])
df.Cabin

print(df.loc[:,'Cabin'])
print(df.iloc[:,10])

​ 对于DataFrame的行的标签索引，引入了特殊的标签运算符loc和iloc。它们可以让你用类似 NumPy的标记，使用轴标签（loc）或整数索引（iloc），从DataFrame选择行和列的子集

​ 这两个索引函数也适用于一个标签或多个标签的切片：

​ pandas版本0.20.0及其以后版本中，ix已经不被推荐使用

故不推荐使用df.ix[:,“Cabin”]

运行结果

0       NaN
1       C85
2       NaN
3      C123
4       NaN
       ... 
886     NaN
887     B42
888     NaN
889    C148
890     NaN
Name: Cabin, Length: 891, dtype: object

④加载文件"test_1.csv"，然后对比"train.csv"，看看有哪些多出的列，然后将多出的列删除

方法一

df2=pd.read_csv("test_1.csv")
del df2['a']
df2

方法二

df2=pd.read_csv("test_1.csv")
df2.drop(['a'],axis=1)
df2

​

⑤ 将[‘PassengerId’,‘Name’,‘Age’,‘Ticket’]这几个列元素隐藏，只观察其他几个列元素

df.drop(['PassengerId','Name','Age','Ticket'],axis=1)
#如果想要完全的删除你的数据结构，使用inplace=True，因为使用inplace就将原数据覆盖了，所以这里没有用

3.筛选条件

​ 表格数据中，最重要的一个功能就是要具有可筛选的能力，选出我所需要的信息，丢弃无用的信息

①以"Age"为筛选条件，显示年龄在10岁以下的乘客信息

df[df['Age']<10]

②以"Age"为条件，将年龄在10岁以上和50岁以下的乘客信息显示出来，并将这个数据命名为midage

midage=df[(df['Age']>10)&(df['Age']<50)]
midage

③将midage的数据中第100行的"Pclass"和"Sex"的数据显示出来

midage.reset_index(drop = True)#重新设置索引因为切片可能会造成索引缺失
midage.loc[100,['Pclass','Sex']]
midage.loc[[100],['Pclass','Sex']]#会以表格形式显现

④使用loc方法将midage的数据中第100，105，108行的"Pclass"，"Name"和"Sex"的数据显示出来

midage.loc[[100,105,108],['Pclass','Name','Sex']]

⑤使用iloc方法将midage的数据中第100，105，108行的"Pclass"，"Name"和"Sex"的数据显示出来

midage.iloc[[100,105,108],[2,3,4]]

三.探索性数据分析

​ 了解你的数据吗？

1.利用Pandas对示例数据进行排序，要求升序

frame = pd.DataFrame(np.arange(16).reshape((8,2)),index=['s','S','t','T','1',',','1','!'],columns=['q','w'])
frame.sort_index(axis=0)

运行结果

frame.sort_index(axis=1)

运行结果

​ 大多数时候我们都是想根据列的值来排序,所以将构建的DataFrame中的数据根据某一列，升序排列

#如：按q那一列
frame.sort_values(by='q',ascending=True)

让行索引升序排序

frame.sort_index()#默认是升序

让列索引升序排序

frame.sort_index(axis=1)

列索引降序排序

frame.sort_index(axis=1,ascending=False)

让任选两列数据同时降序排序

frame.sort_values(by=['q','w'])

​ 对索引排序用sort_index

​ Serious对象就直接sort_index

DataFrame对象对列要加上axis=1

​ 对一个或多个列中的值进行排序：将一个或多个列的名字 传递给sort_values的by选项即可达到该目的

2.对泰坦尼克号数据（trian.csv）按票价和年龄两列进行综合排序（降序排列）

​ 从这个数据中你可以分析出什么？

df=pd.read_csv("train_chinese.csv")
df.head(20)
df.sort_values(by=['票价','年龄'],ascending=False).head(20)

​

​ 排序后，如果我们仅仅关注年龄和票价两列。根据常识我知道发现票价越高的应该客舱越好，所以我们会明显看出，票价前20的乘客中存活的有14人，这是相当高的一个比例，那么我们后面是不是可以进一步分析一下票价和存活之间的关系，年龄和存活之间的关系呢？当你开始发现数据之间的关系了，数据分析就开始了

df.sort_values(by='年龄',ascending=True).head(20)
df.sort_values(by='年龄',ascending=False).head(20)

​ 观察可以初步判断：年龄越小存活率越高，年龄越大存活率越低

3.利用Pandas进行算术计算，计算两个DataFrame数据相加结果

frame1_a = pd.DataFrame(np.arange(9.).reshape(3, 3),
                     columns=['a', 'b', 'c'],
                     index=['one', 'two', 'three'])
frame1_b = pd.DataFrame(np.arange(12.).reshape(4, 3),
                     columns=['a', 'e', 'c'],
                     index=['first', 'one', 'two', 'second'])
frame1_a + frame1_b

​ 两个DataFrame相加后，会返回一个新的DataFrame，对应的行和列的值会相加，没有对应的会变成空值NaN

4.通过泰坦尼克号数据如何计算出在船上最大的家族有多少人

max(df['兄弟姐妹个数']+df['父母子女个数'])

5.学会使用Pandas describe()函数查看数据基本统计信息

frame2 = pd.DataFrame([[1.4, np.nan], 
                       [7.1, -4.5],
                       [np.nan, np.nan], 
                       [0.75, -1.3]
                      ], index=['a', 'b', 'c', 'd'], columns=['one', 'two'])
frame2.describe()

运行结果

6.分别看看泰坦尼克号数据集中 票价、父母子女 这列数据的基本统计数据，你能发现什么？

df['票价'].describe()
df['父母子女个数'].describe()

四.遇到的问题

1.注册Kaggle账号

​ 用邮箱注册会出现无法人机验证的问题，而网上应该也有对策

​ 但因为我是懒，所以直接用Google账号注册啦

2.下载数据集

CSV文件

逗号分隔值（Comma-Separated Values，CSV，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）

3.jupyter中切换工作目录

一开始搜os.getcwd()时，搜到一个这个玩意

然后我就试了一下，结果：

然后，看既然找不到magic，把magic去掉，就%cd

又乱搜一砌，搜到这个

试来试去，各种报错

​ 令我很迷的是上面这张图中的命令cd C:\\Users\\86171\\Desktop\\最近的都在这\\datawhale\\hands-on-data-analysis-master\\第一单元项目集合,我在这个代码单元的上方和下方中插入的新的代码单元中运行这个命令，都没有报错

❓❓❓
先不管了

终于，后来搜到了这好像是Jupyter Notebook的魔法命令之一，这又有一个jupyter常用魔法命令的总结

输入%lsmagic命令

能得到可用魔法命令

Available line magics:
%alias  %alias_magic  %autoawait  %autocall  %automagic  %autosave  %bookmark  %cd  %clear  %cls  %colors  %conda  %config  %connect_info  %copy  %ddir  %debug  %dhist  %dirs  %doctest_mode  %echo  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %macro  %magic  %matplotlib  %mkdir  %more  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %pip  %popd  %pprint  %precision  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %ren  %rep  %rerun  %reset  %reset_selective  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode

Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%cmd  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

然后才用%cd把路径切回去了

> > 这个地方折腾了老久…

4.逐块读取数据那里

​ 我先以每100行为数据块，逐块读取，然后我按照《利用Python进行数据分析》这本书上的代码敲了一下，得到了一个弃用警告

​ 在各大搜索引擎里面苦苦寻觅​这个问题，看到官方文档的弃用说明

​ 在Stackoverflow上搜到一个，仍然无济于事…

​ 然后又搜到了这个，暂时先放弃了

Stackoverflow和官方文档上的英文看的头疼，真是是

想想可能版本不同了吧

还有书上的例子，和这个不搭呀…

耗费了太多时间，先放了…

然后还是去看了别人写完成datawhale的这个任务的博客，恍然大悟…

5.排序

​ 这个地方，第一个是降序升序排列，前20个是年龄最小的，

我一开始看年龄最大的想用.tail(20),发现全是缺省值NaN,意识到排序会把缺省值放最后，所以换成了降序，然后用.head(20)

6.为什么我这么菜

​ 呜呜呜，感觉自己好菜啊