统计软件与数据分析--Lesson3

---

dataframe数据常用知识点

DataFrame是Python中pandas库中一个非常重要的数据结构，它类似于电子表格或SQL表格，可以存储和操作带标签的二维数据。DataFrame的重要知识点如下：

• 1.创建DataFrame：可以通过读取外部文件、手动创建或从其他数据结构中创建DataFrame。常用的函数包括pandas.DataFrame()、pandas.read_csv()、pandas.read_excel()等。

• 2.DataFrame数据存取：可以通过不同的函数保存到txt、csv、excel等文件中，同样也可以利用不同的函数从不同的文件中读取数据。常用的函数包括.to_csv()、.to_excel()等。

• 3.数据查看和选择：可以使用.head()和.tail()方法查看前几行和后几行数据，使用.iloc[]和.loc[]方法选择数据。

• 4.数据查询：常见的 DataFrame 查询操作包括条件查询、模糊查询和多条件查询等。

• 5.数据清洗：包括数据的缺失值处理、重复值处理、数据类型转换等。常用的函数包括dropna()、fillna()、drop_duplicates()、astype()等。

• 6.数据运算：可以进行多种数据运算，包括列之间的运算、行之间的运算、元素级运算等。常用的运算包括加减乘除、apply()、groupby()、merge()等。

• 7.时间序列操作：pandas提供了多种时间序列处理和分析的工具，包括resample()、rolling()等。这些工具可以用于处理时间序列数据，如时间序列数据的重采样、平滑处理等。

• 8.数据可视化：可以使用pandas自带的可视化工具进行数据可视化。常用的函数包括plot()、hist()、boxplot()等。此外，还有其他专业的可视化库（如matplotlib和seaborn）。

总之，DataFrame是Python中非常重要的数据结构之一，可以用于处理和分析各种类型的数据，掌握这些知识点可以更好地使用DataFrame进行数据处理和分析。

---

1.创建dataframe

三种常用的创建DataFrame的方式，分别是使用字典、列表和numpy数组：

1.1使用字典创建DataFrame：

import pandas as pd

#创建字典
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, 14, 19, 22], 
        'gender': ['M', 'M', 'M', 'F']}

#将字典转换成DataFrame
df = pd.DataFrame(data)

#打印DataFrame
print(df)

1.2使用列表创建DataFrame：

import pandas as pd

#创建列表
data = [['Tom', 28, 'M'], ['Jack', 14, 'M'], ['Steve', 19, 'M'], ['Lucky', 22, 'F']]

#将列表转换成DataFrame
df = pd.DataFrame(data, columns=['name', 'age', 'gender'])

#打印DataFrame
print(df)

1.3使用numpy数组创建DataFrame：

import pandas as pd
import numpy as np

#创建numpy数组
data = np.array([['Tom', 28, 'M'], ['Jack', 14, 'M'], ['Steve', 19, 'M'], ['Lucky', 22, 'F']])

#将numpy数组转换成DataFrame
df = pd.DataFrame(data, columns=['name', 'age', 'gender'])

#打印DataFrame
print(df)

实际应用中，还可以通过读取外部文件、从数据库中读取数据等方式创建DataFrame：

上次学习了python数据的存取，我们先将上面的dataframe数据分别存到txt、csv、excel文件中：

import pandas as pd

df.to_csv('./data/data_df.txt', index=False, sep='\t')#保存到txt
df.to_csv('./data/data_df.csv', index=False, sep='\t')#保存到csv

#保存到excel
writer = pd.ExcelWriter('./data/data_df.xlsx')
df.to_excel(writer, index=False, sheet_name='Sheet1')
writer.save()

再分别从不同的外部文件中读取数据：

1.4从TXT文件中创建DataFrame：

import pandas as pd

从CSV文件中读取数据
df = pd.read_csv('./data/data_df.txt')

# 打印DataFrame
print(df)

1.5从CSV文件中创建DataFrame：

import pandas as pd

从CSV文件中读取数据
df = pd.read_csv('./data/data_df.csv')

# 打印DataFrame
print(df)

1.6从Excel文件中创建DataFrame：

import pandas as pd

#从Excel文件中读取数据
df = pd.read_excel('./data/data_df.xlsx')

#打印DataFrame
print(df)

此外还可以从MySQL数据库中创建DataFrame：

import pandas as pd
import mysql.connector

#连接MySQL数据库
cnx = mysql.connector.connect(user='root', password='password', host='127.0.0.1', database='test')

#从数据库中读取数据
df = pd.read_sql('SELECT * FROM data', con=cnx)

#关闭数据库连接
cnx.close()

#打印DataFrame
print(df)

上面这些是在实际应用中如何直接创建或通过读取外部文件、从数据库中读取数据等方式创建DataFrame。需要注意的是，不同的数据格式和数据源需要使用不同的读取函数，例如读取JSON文件需要使用pd.read_json()函数，读取SQLite数据库需要使用pd.read_sqlite()函数等等。同时，对于一些大型数据集，可以使用分块读取的方式进行处理，以避免内存不足的问题。

2.dataframe数据保存

见 统计软件与数据分析—Lesson2 之 3.1.4保存Dataframe

3.dataframe数据查看和选择

创建一个dataframe，后续操作均基于这个df进行：

#创建DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, 14, 19, 22], 
        'gender': ['M', 'M', 'M', 'F']}
df = pd.DataFrame(data)

3.1查看前/后n行：

• 查看DataFrame的前n行:df.head(n)

#查看前2行数据
print(df.head(2))

• 查看DataFrame的后n行:df.tail(n)

#查看后2行数据
print(df.tail(2))

3.2选择DataFrame中的某列/某行：

• 选择DataFrame中的某列:df[‘列名’]

#选择name列
name = df['name']

#打印name列
print(name)

• 选择DataFrame中的某行： df.loc[n]

#选择第2行
row = df.iloc[1]

# 打印第2行
print(row)

3.3选择DataFrame中的多列/多行：

• 选择DataFrame中的多列:df[[‘列名1’, ‘列名2’]]

# 选择name和age列
cols = df[['name', 'age']]

# 打印name和age列
print(cols)

• 选择DataFrame中的多行：df.loc[a:b]

# 选择第2-3行
rows = df.iloc[1:2]

# 打印第2-3行
print(rows)

3.4选择DataFrame中的特定行和列：

df.at[行数, ‘列名’]

#选择第2行和name列
cell = df.at[1, 'name']

#打印第2行和name列的值
print(cell)

4.dataframe数据查询

常见的 DataFrame 查询操作包括条件查询、模糊查询和多条件查询等，下面给出一些示例：

4.1条件查询

假设有一个 DataFrame df，其中有 name、age、gender 等列，可以使用如下方式进行条件查询：

#查询 age 大于等于20 岁的行
df[df['age'] >= 20]

#查询 name 是 'Tom' 的行
df[df['name'] == 'Tom']

4.2模糊查询

模糊查询一般使用 str.contains() 方法，可以匹配包含某个字符串的行。

#查询 name 中包含 'Tom' 的行
df[df['name'].str.contains('Tom')]

#查询 name 中以 'T' 开头的行
df[df['name'].str.startswith('T')]

4.3多条件查询

可以通过 & 和 | 连接多个条件进行查询。

#查询 age 大于等于 20 岁且 gender 是女性的行
df[(df['age'] >= 20) & (df['gender'] == 'F')]

#查询 age 小于 20 岁或者 gender 是男性的行
df[(df['age'] < 20) | (df['gender'] == 'M')]

5.dataframe数据清洗

数据清洗是数据分析的重要步骤之一，可以帮助我们提高数据质量和准确性。在Python中，pandas库提供了丰富的函数和方法，可以方便地进行数据清洗和处理。以下是几个常用的数据清洗示例：

5.1删除缺失值

• (1)删除含有缺失值的行:df.dropna()默认为行

import pandas as pd

#创建含有缺失值的DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, None, 19, 22], 
        'gender': ['M', 'M', None, 'F']}
df = pd.DataFrame(data)

#查看含有缺失值的行
null_rows = df[df.isnull().any(axis=1)]
print('含有缺失值的行为：'，null_rows)

#删除含有缺失值的行
df = df.dropna()

#查看删除后的DataFrame数据
print('删除缺失数行后的DataFrame数据为：')
print(df)

• (2)删除含有缺失值的列:df.dropna(axis=1)

#查看含有缺失值的列
print('含有缺失值的列为：')
print(df.isnull().any())

#删除含有缺失值的列
df = df.dropna(axis=1)

#查看删除后的DataFrame数据
print('删除缺失数列后的DataFrame数据为：')
print(df)

• (3)删除DataFrame中缺失值达到一定比例的列：

import pandas as pd

#创建一个示例数据框
df = pd.DataFrame({
    'A': [1, 2, 3, 4, 5],
    'B': [5, 4, 3, 2, 1],
    'C': [1, 2, 3, None, None],
    'D': [None, None, None, None, None],
    'E': [None, 1, 2, 3, 4]
})

#计算每一列中缺失值的比例
na_ratio = df.isna().sum() / len(df)

#选出缺失值比例小于0.3的列
cols_to_keep = na_ratio[na_ratio < 0.3].index

#删除缺失值比例大于等于0.3的列
df_clean = df[cols_to_keep].dropna(axis=1)

print(df_clean)

5.2填充缺失值

• (1)使用常数填充缺失值:df.fillna(value=xx, inplace=True)

可以使用fillna()函数的value参数来填充缺失值。

import pandas as pd
import numpy as np

df = pd.DataFrame({'A': [1, 2, np.nan, 4], 'B': [5, np.nan, np.nan, 8]})
print(df)

#使用常数填充缺失值
df.fillna(value=0, inplace=True)
print(df)

• (2)使用均值填充缺失值:df.fillna(value=df.mean(), inplace=True)

可以使用fillna()函数的mean()方法来填充缺失值，将缺失值替换成对应列的均值。

import pandas as pd
import numpy as np

df = pd.DataFrame({'A': [1, 2, np.nan, 4], 'B': [5, np.nan, np.nan, 8]})
print(df)

#使用均值填充缺失值
df.fillna(value=df.mean(), inplace=True)
print(df)

• (3)使用前一个/后一个非缺失值填充缺失值:df.fillna(method=‘ffill’/‘bfill’, inplace=True)

可以使用fillna()函数的method参数来指定填充方法，method='ffill’表示使用前一个非缺失值填充缺失值。

import pandas as pd
import numpy as np

df = pd.DataFrame({'A': [1, 2, np.nan, 4], 'B': [5, np.nan, np.nan, 8]})
print(df)

#使用前一个非缺失值填充缺失值
df.fillna(method='ffill', inplace=True)
##使用后一个非缺失值填充缺失值
#df.fillna(method='bfill', inplace=True)
print(df)

5.3数据替换:

df[‘列名’].replace(‘旧值’, ‘新值’)

import pandas as pd

#创建DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, 14, 19, 22], 
        'gender': ['M', 'M', 'M', 'F']}    
df = pd.DataFrame(data)

#将'F'替换为'Female'
df['gender'] = df['gender'].replace('F', 'Female')

#打印清洗后的DataFrame
print(df)

5.4去除重复数据:

df.drop_duplicates()

import pandas as pd

# 创建含有重复数据的DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky', 'Tom'], 
        'age': [28, 14, 19, 22,28], 
        'gender': ['M', 'M', 'M', 'F','M']}       
df = pd.DataFrame(data)

# 去除重复数据
df = df.drop_duplicates()

# 打印清洗后的DataFrame
print(df)

5.5更改数据类型:

df[‘列名’].astype(类型)

import pandas as pd

# 创建DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, 14, 19, 22], 
        'gender': ['M', 'M', 'M', 'F']}    
df = pd.DataFrame(data)

# 将'age'列的数据类型更改为int
df['age'] = df['age'].astype(int)

# 打印清洗后的DataFrame
print(df)

6.dataframe数据运算

pandas中DataFrame数据运算主要包括以下几类：

6.1算术运算

加、减、乘、除等运算符号用于数据框之间的运算。

import pandas as pd

df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'A': [10, 20, 30], 'B': [40, 50, 60]})

#加法运算
df_add = df1 + df2
print(df_add)

#减法运算
df_sub = df1 - df2
print(df_sub)

#乘法运算
df_mul = df1 * df2
print(df_mul)

#除法运算
df_div = df1 / df2
print(df_div)

6.2统计运算

可以对数据框中的数据进行统计分析，例如求和、均值、方差、标准差等。

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

#求和
df_sum = df.sum()
print(df_sum)

#均值
df_mean = df.mean()
print(df_mean)

#方差
df_var = df.var()
print(df_var)

#标准差
df_std = df.std()
print(df_std)

6.3行列运算

• (1)可以对数据框的所有行列进行运算。

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

#对列求和
df_sum_columns = df.sum(axis=0)
print(df_sum_columns)

#对行求和
df_sum_rows = df.sum(axis=1)
print(df_sum_rows)

• (2)指定列之间的运算

DataFrame中可以对不同列进行加减乘除等运算，结果将保存为一个新的列。

import pandas as pd

#创建DataFrame
data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)

#对A列和B列进行加法运算
df['C'] = df['A'] + df['B']

#对A列和B列进行乘法运算
df['D'] = df['A'] * df['B']

#打印结果
print(df)

• (3)指定行之间的运算

可以使用apply()方法对DataFrame中的每一行进行运算，结果将保存为一个新的列。

import pandas as pd

#创建DataFrame
data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)

#对每一行进行加法运算
df['C'] = df.apply(lambda row: row['A'] + row['B'], axis=1)

#对每一行进行乘法运算
df['D'] = df.apply(lambda row: row['A'] * row['B'], axis=1)

#打印结果
print(df)

• (4)元素级运算

DataFrame中的元素级运算可以使用类似NumPy中的函数进行运算，例如numpy.sin()等。

import pandas as pd
import numpy as np

#创建DataFrame
data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)

#对A列进行元素级sin函数运算
df['C'] = np.sin(df['A'])

#对B列进行元素级cos函数运算
df['D'] = np.cos(df['B'])

#打印结果
print(df)

6.4聚合运算

可以对数据框进行分组聚合计算。

• (1)groupby运算

groupby可以将DataFrame中的数据按照指定的列进行分组，然后对分组后的数据进行聚合运算。

import pandas as pd

#创建DataFrame
data = {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], 'C': [1, 2, 3, 4, 5, 6, 7, 8], 'D': [9, 10, 11, 12, 13, 14, 15, 16]}
df = pd.DataFrame(data)

#对A列进行groupby运算，并对C列和D列进行聚合运算（求平均值）
grouped = df.groupby(['A']).agg({'C': 'mean', 'D': 'mean'})

#打印结果
print(grouped)

• (2)merge运算

merge运算可以将两个DataFrame按照指定的列进行合并，类似于SQL中的JOIN操作。

import pandas as pd

#创建DataFrame
df1 = pd.DataFrame({'key': ['foo', 'bar', 'baz', 'qux'], 'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['foo', 'bar', 'baz', 'qux'], 'value': [5, 6, 7, 8]})

#合并DataFrame
merged = pd.merge(df1, df2, on='key')

#打印结果
print(merged)

6.5merge运算扩展

在pandas中，可以使用merge()函数实现DataFrame的合并。下面给出几个示例：

• (1)纵向合并两个DataFrame：pd.concat([df1, df2])

import pandas as pd

#创建两个DataFrame
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                    'B': ['B4', 'B5', 'B6', 'B7'],
                    'C': ['C4', 'C5', 'C6', 'C7'],
                    'D': ['D4', 'D5', 'D6', 'D7']})

#纵向合并两个DataFrame
df = pd.concat([df1, df2])

• (2)横向合并两个DataFrame:pd.merge(df1, df2, on=‘key’)

import pandas as pd

#创建两个DataFrame
df1 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})

df2 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})

#横向合并两个DataFrame
df = pd.merge(df1, df2, on='key')

• (3)使用多个键合并DataFrame:pd.merge(df1, df2, on=[‘key1’, ‘key2’])

import pandas as pd

#创建两个DataFrame
df1 = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                    'key2': ['K0', 'K1', 'K0', 'K1'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})

df2 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                    'key2': ['K0', 'K0', 'K0', 'K0'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})

#使用多个键合并DataFrame
df = pd.merge(df1, df2, on=['key1', 'key2'])

pandas中的merge()函数还支持多种合并方式（如左连接、右连接、内连接、外连接等）。下面是每种连接方式的示例：

• (4)左连接(left join):pd.merge(df1, df2, on=‘key’, how=‘left’)

左连接返回左侧数据集中所有的行，同时返回与右侧数据集中匹配的行。如果在右侧数据集中没有匹配的行，则返回空值。

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                   'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                   'value': [5, 6, 7, 8]})

left_join = pd.merge(df1, df2, on='key', how='left')
print(left_join)

• (5)右连接(right join): pd.merge(df1, df2, on=‘key’, how=‘right’)

右连接返回右侧数据集中所有的行，同时返回与左侧数据集中匹配的行。如果在左侧数据集中没有匹配的行，则返回空值。

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                   'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                   'value': [5, 6, 7, 8]})

right_join = pd.merge(df1, df2, on='key', how='right')
print(right_join)

• (6)内连接(inner join):pd.merge(df1, df2, on=‘key’, how=‘inner’)

内连接返回左侧和右侧数据集中都存在的行。

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                   'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                   'value': [5, 6, 7, 8]})

inner_join = pd.merge(df1, df2, on='key', how='inner')
print(inner_join)

• (7)外连接(outer join):pd.merge(df1, df2, on=‘key’, how=‘outer’)

外连接返回左侧和右侧数据集中所有的行，如果某一侧数据集中没有匹配的行，则返回空值。

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                   'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                   'value': [5, 6, 7,8]})

outer_join = pd.merge(df1, df2, on='key', how='outer')
print(outer_join)

6.6其他运算

包括透视表运算、窗口函数运算等。

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})

#透视表运算
df_pivot = pd.pivot_table(df, values=['B', 'C'], index='A', aggfunc='sum')
print(df_pivot)

#窗口函数运算
df_roll_mean = df.rolling(window=2).sum()
print(df_roll_mean)

7.dataframe 时间序列基本操作

DataFrame在时间序列分析中是非常重要的工具，可以轻松处理时间序列数据，如按时间排序、统计时间范围内的数据、时间偏移等等。以下是一些时间序列分析的示例：

7.1生成时间序列数据

import pandas as pd
import numpy as np

rng = pd.date_range('1/1/2020', periods=10, freq='D')
# rng = pd.date_range(start='2022-01-01', end='2022-12-31', freq='D')
df = pd.DataFrame({'date': rng, 'value': np.random.randn(10)})

这里生成了一个包含10天数据的DataFrame，其中date列为时间序列，value列为随机数列。

7.2按时间排序

#按照date列升序排列
df_ascend = df.sort_values('date')

#按照date列降序排列
df_descend = df.sort_values('date', ascending=False)

#打印排序结果
print("df_ascend:")
print(df_ascend)
print("df_descend:")
print(df_descend)

7.3统计时间范围内的数据

df.loc[(df['date'] >= '2020-01-03') & (df['date'] <= '2020-01-07')]

这里选取了2020年1月3日至7日之间的数据。

7.4时间偏移

df['shifted'] = df['value'].shift(1)

这里将value列向下平移了一个单位，生成了一个新的列shifted。

7.5时间重采样

df.set_index('date').resample('W').mean()

这里按照每周对数据进行重采样，并计算每周的平均值。

7.6移动窗口函数

df['rolling_mean'] = df['value'].rolling(window=3).mean()

这里计算了value列的移动平均值，窗口大小为3。

7.7时间差

df['diff'] = df['date'].diff()

#计算两个日期之间的天数
#df['diff'] = (df['date2'] - df['date1']).dt.days

这里计算了每一天和前一天之间的时间差。

7.8时间索引

df = df.set_index('date')

这里将date列设置为索引。

7.9时间戳转换

df.index = pd.to_datetime(df.index)

这里将索引从字符串转换为时间戳。

7.10按照时间周期进行统计

df.groupby(pd.Grouper(freq='M')).sum()

这里按照每个月进行数据统计。

7.11提取年、月、日等信息

df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day

7.12按照日期数据进行分组

df.groupby('year').mean()

7.13时区转换

df = df.tz_localize('UTC').tz_convert('US/Pacific')

这里将时区从UTC转换为美国太平洋时区。

7.14绘制时间序列图

df.plot(x='date', y='value')

以上是一些时间序列分析的示例，pandas在时间序列分析中提供了丰富的功能，可以满足不同的需求。

8.dataframe数据可视化

8.1使用pandas自带的可视化工具

在Python中，pandas自带了一些可视化工具，可以方便地对DataFrame数据进行可视化。下面给出几个使用pandas自带可视化工具绘制图表的示例：

• 1.绘制折线图

import pandas as pd

#创建数据集
data = {'year': [2010, 2011, 2012, 2013, 2014, 2015],
        'sales': [5, 7, 3, 4, 6, 8]}
df = pd.DataFrame(data)

#绘制折线图
df.plot(x='year', y='sales')

• 2.绘制柱状图

import pandas as pd

#创建数据集
data = {'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen'],
        'population': [2154, 2424, 1404, 1211]}
df = pd.DataFrame(data)

# 绘制柱状图
df.plot(kind='bar', x='city', y='population')

• 3.绘制散点图

import pandas as pd

#创建数据集
data = {'height': [165, 170, 175, 180, 185],
        'weight': [55, 60, 65, 70, 75]}
df = pd.DataFrame(data)

#绘制散点图
df.plot(kind='scatter', x='height', y='weight')

• 4.绘制箱线图

import pandas as pd

#创建数据集
data = {'gender': ['Male', 'Male', 'Female', 'Female'],
        'height': [180, 175, 165, 170]}
df = pd.DataFrame(data)

#绘制箱线图
df.boxplot(by='gender', column='height')

pandas自带的可视化工具可以方便地对DataFrame数据进行可视化，但其可视化效果可能不如其他专业的可视化库（如matplotlib和seaborn）。因此，在实际使用中，我们需要根据具体情况选择合适的可视化工具。

8.2使用matplotlib库

import pandas as pd
import matplotlib.pyplot as plt

#创建DataFrame数据
data = {'name': ['Tom', 'Jerry', 'Mike', 'Lucy'],
        'score': [80, 75, 90, 85],
        'age': [20, 21, 22, 20]}
df = pd.DataFrame(data)

#绘制柱状图
plt.bar(df['name'], df['score'])
plt.xlabel('Name')
plt.ylabel('Score')
plt.title('Student Scores')
plt.show()

#绘制散点图
plt.scatter(df['age'], df['score'])
plt.xlabel('Age')
plt.ylabel('Score')
plt.title('Student Scores')
plt.show()

#绘制折线图
plt.plot(df['name'], df['score'], marker='o')
plt.xlabel('Name')
plt.ylabel('Score')
plt.title('Student Scores')
plt.show()

8.3使用seaborn库

• 1.使用seaborn库绘制柱状图

import pandas as pd
import seaborn as sns

#创建数据集
data = {'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen'],
        'population': [2154, 2424, 1404, 1211]}
df = pd.DataFrame(data)

#绘制柱状图
sns.barplot(x='city', y='population', data=df)
plt.title('Population Data')
plt.show()

• 2.使用seaborn库绘制散点图

import pandas as pd
import seaborn as sns

#创建数据集
data = {'height': [165, 170, 175, 180, 185],
        'weight': [55, 60, 65, 70, 75]}
df = pd.DataFrame(data)

#绘制散点图
sns.scatterplot(x='height', y='weight', data=df)
plt.title('Height and Weight Data')
plt.show()

• 3.使用seaborn库绘制箱线图

import pandas as pd
import seaborn as sns

#创建数据集
data = {'gender': ['Male', 'Male', 'Female', 'Female'],
        'height': [180, 175, 165, 170]}
df = pd.DataFrame(data)

#绘制箱线图
sns.boxplot(x='gender', y='height', data=df)
plt.title('Height Data')
plt.show()

以上示例只是其中一部分，数据可视化的方式和种类非常多，具体使用哪种方式取决于数据的特点和需要展示的内容。

---