关于Pandas的一些学习笔记

最新推荐文章于 2024-10-02 23:04:10 发布
最新推荐文章于 2024-10-02 23:04:10 发布
阅读量829 收藏 23
点赞数 19
文章标签： pandas 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45799204/article/details/140932057
版权

Pandas

  • Pandas是一个开源的数据分析和数据处理库，基于python编程语言的一个扩展程序库

  • Pandas提供易于使用的数据结构和数据分析工具，特别适用于处理结构化数据，如表格型数据

  • Pandas 是数据科学和分析领域中常用的工具之一，它使得用户能够轻松地从各种数据源中导入数据，并对数据进行高效的操作和分析

  • Pandas 是一个强大的分析结构化数据的工具集，基础是Numpy（提供高性能的举矩形运算）

Pandas特点
  • 处理各种数据结构，尤其是表格型数据，如 SQL 数据库或 Excel 表格
  • 数据结构：Series 和 DataFrame
  • 数据加载与保存：可以从各种数据源加载数据，包括 CSV 文件、Excel 表格、SQL
    数据库、JSON 文件等，并且可以将处理后的数据保存到这些格式中
  • 数据清洗与转换：提供了丰富的函数和方法，用于数据清洗、处理缺失值、重复值、异常值等，以及进行数据转换、重塑和合并操作
  • 数据分析与统计：提供了各种统计函数和方法，用于描述性统计、聚合操作、分组
    运算、透视表等数据分析任务
  • 数据可视化：结合 Matplotlib 库，可以进行数据可视化，绘制各种统计图表，如
    折线图、散点图、直方图等
数据结构
  • Series（一维数据）
    • Series 是一种类似于一维数组的对象，它由一组数据以及一组与之相关的数据标签（索引）组成
  • DataFrame(二维数据)
    • DataFrame 是一个表格型的数据结构，它含有一组有序的列，既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）
安装导入
#pip安装pandas
pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple
#安装成功后，我们就可以导入 pandas 模块使用：
import pandas as pd
Series特点
  • 一维数组：只有一个轴（或维度），类似于Python中的列表
  • 索引：每个Series都有一个索引，可以是整数、字符串类型，不指定索引将默认创建一个从0开始的整数索引
  • 数据类型：Series可以容纳不同数据类型的元素，包括整数、浮点数、字符串、python对象等
  • 操作：Series支持各种操作，如数学运算，统计分析、字符串处理等
  • 缺失数据：Series 可以包含缺失数据，使用NaN来表示缺失或无值
创建Series
  • 使用Series()构造函数创建Series对象，传递一个数据数组和一个可选的索引数组
import pandas as pd
import numpy as np
#使用列表创建Series
s = pd.Series([1, 2, 3, 4, 5])

#使用Numpy数组创建Series
s = pd.Series(np.array([1, 2, 3, 4, 5]))

#使用字典创建Series
s = pd.Series({'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5})
"""
a    1
b    2
c    3
d    4
e    5
dtype: int64
"""

# 创建Series并指定索引
s = pd.Series([1,2,3,4],index=['a','b','c','d'])
print(s['a']) # 返回索引标签 'a' 对应的元素
print(s['a':'c']) # 返回索引标签 'a' 到 'c' 之间的元素
"""
a    1
b    2
c    3
dtype: int64
"""
print(s[1:3])
"""
b    2
c    3
dtype: int64
"""
# 索引和值的关系
for index,value in s.items():
    print(index,value)
"""
a 1
b 2
c 3
d 4
"""

#切片语法访问Series一部分
print(s[:3]) # 返回前三个元素
# 为特定索引标签赋值
s['a'] = 10
print(s)
# 通过赋值给新的索引标签来添加元素
s['e'] = 5
# del删除指定索引标签的元素,删除单个，在原有基础上删除
del s['a']
# drop 方法删除一个或者多个索引标签，并返回一个新的Series
s_dropped = s.drop(['b'])
基本运算
  • 算数运算
series = pd.Series([10, 8, 7, 4, 2])
# 算数运算
result = series * 2  # 值乘以2

# 进行排序后叠加
d1 = dict(a=1, b=2, c=3, d=4, e=5)
d2 = dict(a=10, b=20, c=30, d=40, e=50)
s1 = pd.Series(d1)
s2 = pd.Series(d2)
print(s1 + s2)

# 过滤（默认是值）
filtered_series = series[series > 5] # # 选择大于5的元素

s = pd.Series(data=[1, 2, 3, 4, 4], index=['a', 'b', 'c', 'd', 'e'])
print(s[s>3])
"""
d    4
e    4
dtype: int64
"""

# 数学函数
import numpy as np
s = pd.Series([16,25,36])
r = np.sqrt(s) # 对每个元素取平方根
# 转换成整数
r = r.astype('int')
print(r)
属性和方法（有小括号方法，没有小括号属性）
属性和方法说明
index = Series.index获取索引
values = Series.values获取数据
stats = Series.describe()获取描述统计信息
max_index = Series.idxmax()获取最大值索引
min_index = Series.idxmin()获取最小值索引
Series.dtype数据类型
Series.shape形状
Series.size元素个数（看一维数组里面有几个）
Series.count()元素个数（方法）
Series.head()前几个元素，默认前五个
Series.tail()后几个元素，默认后五个
Series.sum()求和
Series.mean()平均值
Series.std()标准差
Series.min()最小值
Series.max()最大值
print( Series > 2)返回一个布尔 Series，其中的元素值大于 2
Series = Series.astype(‘float64’)将 Series 中的所有元素转换为float64类型，转换数据类型，生成一个复本返回
data = data.value_counts()统计次数
data = data.sort_values(ascending=True)升序排列，后边为False时候降序排序
data = data.iloc[1:4]选取从索引位置 1 开始到索引位置 4（但不包括索引位置 4）的行或元素
data.unique()去重
# s > 33 返回的是bool值，s[s>30]返回的是数值

s = pd.Series([11, 22, 33, 44, 55, 66, 77, 88])
print(s > 33)
print('*'*30)
print(s[s > 33])
"""
0    False
1    False
2    False
3     True
4     True
5     True
6     True
7     True
dtype: bool
******************************
3    44
4    55
5    66
6    77
7    88
dtype: int64
"""

DataFrame

  • 用于表示二维表格型数据,Pandas中的另一个核心数据结构
  • 既有行索引也有列索引，它可以被看做由 Series组成的字典（共同用一个索引）

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

data = {'calories': [420, 380, 390], 'duration': [50, 40, 45]}
df = pd.DataFrame(data, ['day1', 'day2', 'day3'])
print(df)
"""
calories  duration
day1       420        50
day2       380        40
day3       390        45"""
print("=" * 30)
print(df.loc['day2']['calories'])  # 380
print("=" * 30)
print(df.loc[['day1', 'day2']].loc['day2']['calories'])  # 380
创建DataFrame
# 使用列表创建（二维列表中的每个列表表示一行，需要指定列名）
data = [['Google',10],['Baidu',12],['Wiki',13]]
df = pd.DataFrame(data,columns=['Site','Age'])

# 字典创建（其中键作为列名，值作为列数据）
data = {'Site':['Google', 'Baidu', 'Wiki'], 'Age':[10, 12, 13]}
df = pd.DataFrame(data)

# 列表套字典（每个字典元素表示一行数据，每个字典里面的键是列名）
data = [{'Site':'Google','Age':10},{'Site':'Baidu','Age':10},{'Site':'Wiki'}]
df = pd.DataFrame(data)

# 字典套字典，其中外部字典的键作为列名，内部字典的键作为索引
di1 = {'a':1, 'b':2, 'c':3}
di2 = {'a':4, 'b':5, 'c':6}
di3 = {'k1':di1,'k2':di2}
df = pd.DataFrame(di3)
print(df)
"""
 k1  k2
a   1   4
b   2   5
c   3   6"""

# 使用ndarrays创建
ndarray_data = np.array([['Google', 10], ['Baidu', 12], ['Wiki', 13]])
df = pd.DataFrame(ndarray_data,columns=['Site','Age'])
print(df)
"""
     Site  Age
0  Google   10
1   Baidu   12
2    Wiki   13
"""

# 字典创建DataFrame
df = pd.DataFrame({'Column1':[1,2,3],'Column2':[4,5,6]})
#列表创建DataFrame
df = pd.DataFrame([[1,2,3],[4,5,6],[7,8,9]],columns=['Column1','Column2','Column3'])
# 通过Numpy数组创建DataFrame
df = pd.DataFrame(np.array([[1,2,3],[4,5,6],[7,8,9]]))
# Series创建DataFrame
s1 = pd.Series(['Alice','Bob','Charlie'])
s2 = pd.Series([25,30,35])
s3 = pd.Series(['New York','Jack','Mary'])
df = pd.DataFrame({'Name':s1,'Age':s2,'City':s3})
print(df)
"""
 Name  Age      City
0    Alice   25  New York
1      Bob   30      Jack
2  Charlie   35      Mary
"""
DataFrame 的属性和方法
属性和方法说明
df.loc[索引]返回指定行的数据，索引从 0 开始，返回结果其实就是一个DataFrame 数据
df.shape形状
df.columns列名
df.index索引
df.head()前几行数据，默认是前 5 行
df.tail()后几行数据，默认是后5行
df.info()数据信息
df.describe()描述统计信息
df.mean()求平均值
de.sum()求和
df.dtypes查看数据类型
df.astype (‘类型’)转换数据类型，df[‘Column’] = df[‘Column’].astype(‘float64’)
访问DataFrame元素

  • 两个数据作为一个参数进行包装，用列表放一起

  • 访问列

df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 
                  columns=['Column1', 'Column2', 'Column3'])

print(df['Column1'])  # 通过列名访问  

print(df.Column2)  # 通过属性访问,列名当属性

print(df.loc[:, 'Column1'])  # 通过列名访问

print(df.iloc[:, 0])  # 通过索引访问

print(df['Column1'][0])  # 访问单个元素
  • 访问行
print(df.loc[2, 'Column1'])# 通过行标签访问
修改DataFrame
  • 修改列数据：直接对列进行赋值
df['Column'] = [data1, data2, data3]
  • 添加新列：给新列赋值
df['NewColumn'] = [data1, data2, data3]
  • 添加新行：使用loc方法
df.loc[Index] = [data1, data2, data3]
删除DataFrame元素
#删除列：使用 drop 方法
df_dropped = df.drop('Column', axis=1)

#删除行：同样使用 drop 方法
df_dropped = df.drop(Index)
DataFrame统计分析
  • 描述性统计：使用**.describe()**查看数值列的统计摘要
  • 计算统计数据：使用聚合函数如 .sum()、.mean()、.max() 等
    • df[‘Column’].sum()
    • df.mean()
DataFrame索引操作
  • 重置索引：.reset_index()
df_reset = df.reset_index(drop=True)
  • 设置索引：.set_index()
df_set = df.set_index('Column')
  • 根据条件过滤DataFrame
df[(df['Column'] > 2) & (df['Column'] < 5)]

df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                  columns=['Column1', 'Column2', 'Column3'])
print(df)
a = df[(df['Column1'] > 5) & (df['Column2'] > 5)]
print(a)
"""
 Column1  Column2  Column3
0        1        2        3
1        4        5        6
2        7        8        9
   Column1  Column2  Column3
2        7        8        9
"""
DataFrame 的合并
  • 纵向合并：concat 看列名是否相同，没有此列的数据会用NAN代替
# df2接在df1的下边
pd.concat([df1, df2], ignore_index=True)


df1 = pd.DataFrame({'c1': ['aa', 'bb', 'cc']})
df2 = pd.DataFrame({'c2': ['dd', 'ee', 'ff']})
print(df1)
print(df2)
print("="*30)
df3 = pd.concat((df1, df2))
print(df3)
"""
   c1   c2
0   aa  NaN
1   bb  NaN
2   cc  NaN
0  NaN   dd
1  NaN   ee
2  NaN   ff"""
  • 横向合并:merge
pd.merge(df1, df2, on='Column')

df1 = pd.DataFrame({'name': ['tom', 'jack', 'rose'], 'chinese': [99, 88, 77]})
df2 = pd.DataFrame({'name': ['tom', 'jack', 'josn'], 'math': [94, 84, 74]})

df3 = pd.merge(df1, df2, on='name', how='left')  #补充左边的

df3 = pd.merge(df1, df2, on='name', how='right')  # 补充右边

df3 = pd.merge(df1, df2, on='name', how='outer')   # 全部包含
print(df3)
"""
 name  chinese  math
0   tom       99  94.0
1  jack       88  84.0
2  rose       77   NaN

name  chinese  math
0   tom     99.0    94
1  jack     88.0    84
2  josn      NaN    74

 name  chinese  math
0  jack     88.0  84.0
1  josn      NaN  74.0
2  rose     77.0   NaN
3   tom     99.0  94.0"""

索引和切片

  • DataFrame支持对行和列进行索引和切片操作
data = {'Site': ['Google', 'Baidu', 'Wiki'], 'Age': [20, 22, 23]}
df = pd.DataFrame(data)
# 提取多列
print(df[['Site','Age']]) 
# 切片多行
print(df[1:3]) 
# 提取单列
print(df.loc[:,'Site']) 
"""
0    Google
1     Baidu
2      Wiki
Name: Site, dtype: object
"""
# 根据标签提取指定行列,（第二行开始的两列）
print(df.loc[1:2, ['Site', 'Age']])
# 根据索引提取指定行列（所有行，从第二列开始的全部）
print(df.iloc[:, 1:]) 
"""
  Age
0   20
1   22
2   23
"""


s1 = pd.Series(['tom', 'jack', 'rose'], ['001', '002', '003'])
s2 = pd.Series([99, 88, 77], ['001', '002', '003'])
s3 = pd.Series([65, 85, 74], ['001', '002', '003'])
df = pd.DataFrame({'name': s1, 'chinese': s2, 'math': s3})
print(df)
print("=" * 30)
# 提取一列
print(df['name'])
# 提取多列
print(df[['math','chinese']])
# 提取一行
print(df.loc['001'])
# 提取多行
print(df.loc[['001', '002']])
# 切片多行
print(df[1:3])
print(df.loc["002":"003", ['name', 'chinese']])
print(df.iloc[1:3, 0:2])  # 这些数字表示默认索引

CSV文件

  • CSV（Comma-Separated Values，逗号分隔值，也称为字符分隔值，
    因为分隔字符也可以不是逗号）

  • 以纯文本形式存储表格数据

  • CSV 是一种通用的、相对简单的文件格式，被商业和科学广泛应用

  • 打开csv文件

df = pd.read_csv('./data/nba.csv')
print(df.to_string())
  • to_string() ：全部读取，用于返回 DataFrame 类型的数据，如果不使用该函数，则输出结果为数据的前面 5 行和末尾 5 行，中间部分以 … 代替。
  • to_csv()方法：将DataFrame存储为csv文件
    • header=True:是否将DataFrame的列名（即DataFrame的header）写入CSV文件
    • index=True:是否将DataFrame的索引（行标签）也写入CSV文件
    • index_label='ind':当index=True时，这个参数允许你为索引列指定一个标签名（起一个标签名）
name = ['Google', 'Baidu','Taobao', 'Wiki']
site = ['www.google.com', 'www.baidu.com', 'www.taobao.com', 'www.wiki']
age = [90,40,80,98]
dict = {'name':name, 'site':site, 'age':age}
df = pd.DataFrame(dict)
# 保存dataframe
df.to_csv('site.csv',header=True,index=True,index_label='ind')

JSON文件

  • JSON（JavaScript Object Notation），是存储和交换文本信息的语法
  • JSON 比 XML 更小、更快，更易解析
  • 打开JSON文件打开JSON文件
df = pd.read_json('data/sites.json')
print(df.to_string())
  • 写入json文件
names = ['tom', 'jack', 'rose']
chinese = [90,99,89]
math = [100,98,97]
df = pd.DataFrame({'name':names,'chinese':chinese,'math':math})
# 写入json文件
df.to_json('data/sites2.json')

数据清洗

  • 数据清洗是对一些没有用的数据进行处理的过程
空值数据判断及删除：

  • 通过**isnull()** 、 **isna()**判断各个单元格是否为空，空值返回为True

  • 通过**dropna()**删除包含空数据的行或者指定列包含空数据的行(默认删除包含任何缺失值的行)

  • **na_values=[]**参数指定了哪些字符串应该被视为缺失值（NaN）

  • **dropna()**下属参数

    • how =‘ ’ ：any表示有一个空就全部删除，all表示所有都为空就删除
    # how 参数  any表示有一个空就全部删除，all表示所有都为空就删除
# df2 = df.dropna(how='all')
# df2 = df.dropna(how='any')
    • **subset=[]**参数：指定了需要检查缺失值的列
    #如果某一行在这两列中的任意一列存在缺失值（即NaN），那么整行都会被从DataFrame中删除
# subset参数指定了需要检查缺失值的列。
df2 = df.dropna(subset=['NUM_BEDROOMS','NUM_BATH'])
print("="*30)
print(df2)

df = pd.read_csv('data/property-data.csv')
print(df['NUM_BEDROOMS'])
print(df['NUM_BEDROOMS'].isnull())
"""
0    False
1    False
2     True
3    False
4    False
5     True
6    False
7    False
8    False
Name: NUM_BEDROOMS, dtype: bool"""

# 在CSV文件中可能表示缺失值的字符串（'n/a', 'na', '--'）
missing_values = ['n/a', 'na', '--']
# 通过na_values参数指定了哪些字符串应该被视为缺失值（NaN）
df = pd.read_csv('data/property-data.csv', na_values=missing_values)
print(df['NUM_BEDROOMS'])
print(df['NUM_BEDROOMS'].isnull())

# 从原始DataFrame df中删除所有包含至少一个缺失值的行得到的new_df
new_df = df.dropna()
print(new_df)
"""
 PID  ST_NUM ST_NAME OWN_OCCUPIED  NUM_BEDROOMS NUM_BATH   SQ_FT
0  100001000.0   104.0  PUTNAM            Y           3.0        1  1000.0"""
替换字段
  • fillna():替换一些空字段，默认返回一个新的DataFrame
# 替换空字段
df = pd.read_csv('data/property-data.csv')
#将所有空值变为12345
fd = df.fillna(12345)   
# 指定修改，返回指定的列
fd = df[['PID','ST_NUM']].fillna(12345)
# 详细指定每列数据的修改
fd = df[['PID','ST_NUM']].fillna({'PID':12345,'ST_NUM':23456}) 
print(fd)
  • 替换空单元格的常用方法是计算列的均值、中位数或者众数
    • mean()、median() 和 mode() 方法计算列的均值（所有值加起来的平均值）、中位数（排序后排在中间的数）和众数（出现频率最高的数）
数据格式错误
  • 将列中的所有单元格转换为相同格式的数据
  • to_datetime(df['Date'], format='mixed'):转换成datetime对象，
    • mixed是一种格式
    • format参数应该是一个具体的日期时间格式字符串，比如’%Y/%m/%d’
# 数据格式错误的单元格会使数据分析变得困难，甚至不可能
# 第三个日期格式错误
data = {
"Date": ['2020/12/01', '2020/12/02' , '20201226'],
"duration": [50, 40, 45]
}
df = pd.DataFrame(data, index = ["day1", "day2", "day3"])
# 将字符串转换为datatime对象，format 参数应该是一个具体的日期时间格式字符串，比如 '%Y/%m/%d'
df['Date'] = pd.to_datetime(df['Date'], format='mixed')
print(df.to_string())
错误数据替换或移除
person = { "name": ['Google', 'Runoob' , 'Taobao'], "age": [50, 200, 12345]}
df = pd.DataFrame(person)
for x in df.index:
    if df.loc[x, "age"] > 120:
        df.loc[x, "age"] = 120 # 修改数据
        df.drop(x,inplace=True) # 删除行,False为创建一个复本
print(df.to_string())
清洗重复数据
  • duplicated():如果对应的数据是重复的，duplicated() 会返回 True，否则返回 False
person = {
"name": ['Google', 'Baidu', 'Baidu', 'Taobao'],
"age": [50, 40, 40, 23]
}
df = pd.DataFrame(person)
print(df.duplicated())
"""
0    False
1    False
2     True
3    False
dtype: bool"""
  • drop_duplicates():删除重复数据
person = {
"name": ['Google', 'Baidu', 'Baidu', 'Taobao'],
"age": [50, 40, 40, 23]
}
df = pd.DataFrame(person)
df.drop_duplicates(inplace = True)
print(df.to_string())
"""
 name  age
0  Google   50
1   Baidu   40
3  Taobao   23"""
常用函数
读取数据
函数说明
pd.read_csv(filename)读取 CSV 文件
pd.read_excel(filename)读取 Excel 文件
pd.read_sql(query, connection_object)从 SQL 数据库读取数据
pd.read_json(json_string)从 JSON 字符串中读取数据
查看数据
函数说明
df.head(n)显示前 n 行数据
df.tail(n)显示后 n 行数据
df.info()显示数据的信息，包括列名、数据类型、缺失值等
df.describe()显示数据的基本统计信息，包括均值、方差、最大值、最小值等
df.shape显示数据的行数和列数
清洗数据
函数说明
df.dropna()删除包含缺失值的行或列
df.fillna(value)将缺失值替换为指定的值
df.replace(old_value, new_value)将指定值替换为新值
df.duplicated()检查是否有重复的数据
df.drop_duplicates()删除重复的数据
数据选择和切片
函数说明
df[column_name]选择指定的列
df.loc[row_index, column_name]通过标签选择数据
df.iloc[row_index, column_index]通过位置选择数据
df.ix[row_index, column_name]通过标签或位置选择数据
df.filter(items=[column_name1,column_name2])选择指定的列
df.filter(regex=‘regex’)选择列名匹配正则表达式的列
df.sample(n)随机选择 n 行数据
数据排序
函数说明
df.sort_values(column_name)按照指定列的值排序
df.sort_values([column_name1,column_name2], ascending=[True,False])按照多个列的值排序
df.sort_index()按照索引排序
数据分组和聚合
函数说明
df.groupby(column_name)按照指定列进行分组
df.aggregate(function_name)对分组后的数据进行聚合操作
df = pd.DataFrame({'class':['a','b','c','a','b','c','a','b','c'],
                    'mark':[1,2,3,1,2,3,1,2,3]})
print(df)
print("-"*30)
df2 = df.groupby('class').aggregate('sum')  # 求和sum，最大值max,count
print(df2)
"""
class   mark      
a         3
b         6
c         9"""
数据选择和过滤
函数说明
df.loc[row_indexer, column_indexer]按标签选择行和列
df.iloc[row_indexer, column_indexer]按位置选择行和列
df[df[‘column_name’] > value]选择列中满足条件的行
df.query(‘column_name > value’)使用字符串表达式选择列中满足条件的行
数据统计和描述
函数说明
df.describe()计算基本统计信息，如均值、标准差、最小值、最大值等
df.mean()计算每列的平均值
df.median()计算每列的中位数
df.mode()计算每列的众数
df.count()计算每列非缺失值的数量
loc[]与iloc[]的介绍与区别
  • loc接收的是行、列的名称或者标签，
    • 在切片是按照闭区间切片，两边都可以取到，
    • 返回结果是一个DataFrame数据，
    • 返回指定行的数据，索引从0开始
  • iloc接收的是行、列的索引位置（下标从0开始），不能是字符，左闭右开
  • 相同点
    • 两者都接收两个参数，第一个参数是行的范围，第二个参数是列的范围
    • 两者都可以有行索引值没有列索引值，但有列索引值前必须得有行索引值，但loc[]行索引值只能为名称形式来取，不能按下标形式来取。iloc[]则相反
loc[]
  • 1、单个行名/列名 或 行名/列名的列表
import pandas as pd

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}

frame = pd.DataFrame(data)
frame.index = list('abcde')

# loc方法
# 1.读取第二行，行名为b
a = frame.loc['b']
# print(a)
"""
state    Ohio
year     2001
pop       1.7
Name: b, dtype: object
"""
# 转换成dataframe对象
b = frame.loc[['b']]
# print(b)
"""
  state  year  pop
b  Ohio  2001  1.7
"""
# 取第1、2列的第2与第5行，第1、2列的列名分别为’state’与’year’，
# 第2、5行的行名分别为’b’和’e’
c = frame.loc[['b', 'e'], ['state', 'year']]
# print(c)
  • 2.列名/行名的切片
# 读取第2列，列名为’year’
d = frame.loc[:, 'year']
print(d)
"""
a    2000
b    2001
c    2002
d    2001
e    2002
Name: year, dtype: int64
"""
# 取第2行第3列，第2行行名为’b’，第3列列名为’pop’
e = frame.loc['b', 'pop']
print(e)
"""1.7"""

# 读取dataframe某个区域，比如第3列的第2到第5行，第3列为"pop"列，第2到第5行即b行到e行。
f = frame.loc['b':'e','pop'] #返回的是<class 'pandas.core.series.Series'>对象。
print(f)
"""
b    1.7
c    3.6
d    2.4
e    2.9
Name: pop, dtype: float64
"""
f = frame.loc['b':'e',['pop']]
print(f)
"""
  pop
b  1.7
c  3.6
d  2.4
e  2.9"""

# 取第1、2列的第2到第5行，第1、2列的列名分别为’state’和’yea‘列，第2、5行的行名为’b’和‘e’行。
g = frame.loc['b':'e',['state','year']]
print(g)
"""
  state  year
b    Ohio  2001
c    Ohio  2002
d  Nevada  2001
e  Nevada  2002"""
  • 返回布尔型列表的表达式（判断或函数）
# 根据判断条件读取，取第3列大于2的。
h = frame.loc[frame['pop'] > 2, 'pop']  # 返回的是<class 'pandas.core.series.Series'>对象。
print(h)
"""
c    3.6
d    2.4
e    2.9
Name: pop, dtype: float64
"""
h = frame.loc[frame['pop'] > 2, ['pop']]  # 返回的是<class 'pandas.core.frame.DataFrame'>对象。
print(h)
"""
   pop
c  3.6
d  2.4
e  2.9
"""

# 根据函数读取，取第3列大于2的所有行与列
i = frame.loc[lambda x: x['pop'] > 2]
print(i)
"""
    state  year  pop
c    Ohio  2002  3.6
d  Nevada  2001  2.4
e  Nevada  2002  2.9"""
iloc方法
  • 1、单个下标 或 若干下标构成的列表，从0开始
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}

frame = pd.DataFrame(data)
frame.index = list('abcde')
# 取第2行的值。
a = frame.iloc[1]
print(a)  # <class ‘pandas.core.series.Series’>对象
"""
state    Ohio
year     2001
pop       1.7
Name: b, dtype: object"""
a = frame.iloc[[1]]
print(a)  # <class ‘pandas.core.frame.DataFrame’>对象
"""
state  year  pop
b  Ohio  2001  1.7"""

# 取第1、2列的第2与第5行。
b = frame.iloc[[1,4],[0,1]]
print(b)
"""
state  year
b    Ohio  2001
e  Nevada  2002"""
  • 2.下标的切片
# 取第二列的值
c = frame.iloc[:, 1]
print(c)
"""
a    2000
b    2001
c    2002
d    2001
e    2002
Name: year, dtype: int64"""
c = frame.iloc[:,[1]]
print(c)
"""
  year
a  2000
b  2001
c  2002
d  2001
e  2002"""

# 取第二行第三列
d = frame.iloc[1, 2]
print(d)
"""1.7"""

# 读取dataframe某个区域，比如第3列的第2到第5行
f = frame.iloc[1:5,[2]]
print(f)
"""
   pop
b  1.7
c  3.6
d  2.4
e  2.9"""

# 取第1、2列的第2到第5行
e = frame.iloc[1:5,[0,1]]
print(e)
"""
 state  year
b    Ohio  2001
c    Ohio  2002
d  Nevada  2001
e  Nevada  2002"""
海鹏的打怪之路
关注
Pandas学习笔记1-Pandas基础
12-21
本篇学习笔记将深入探讨Pandas的基础知识，包括数据的读取与写入，以及核心数据结构Series和DataFrame。 首先，了解如何查看Pandas的版本。通过导入库并调用`pd.__version__`，可以获取当前安装的Pandas版本，例如`...
Pandas学习笔记
11-06
### Pandas学习笔记 #### 一、简单操作 ##### 1. Series 对象 - **创建**：可以通过列表、NumPy 数组或字典来创建一个 `Series` 对象。 - 使用列表创建： ```python s = pd.Series([12, -4, 7, 9]) ``` - ...
【pandas学习笔记(一)】pandas基本使用
12-21
【pandas学习笔记(一)】pandas基本使用 pandas是Python中广泛使用的数据分析库，它基于NumPy构建，提供了高效的数据结构，如Series（一维数组）和DataFrame（二维表格型数据结构）。pandas的主要功能是进行数据清洗...
Pandas学习笔记4-变形
01-20
原创文章 59获赞 76访问量 4361 关注 私信 展开阅读全文 作者：田纳尔多
numpy与pandas学习笔记
01-20
#导入numpy库 import numpy as np （1）创建矩阵： a=np.array([ [1,2,3], [2,3,4], [4,5,6]],dtype=np.int64) 函数 说明 np.ones((3,4)) ...左闭右开，步长为2 生成列表，reshape()改变行列形状为
Go基础学习08-并发安全型类型-通道（chan）深入研究
FLJS_T的博客
09-28 826
在前面学习中了解到对于单值变量，如：int、string；多值变量，如：map存在多协程对资源竞争的并发问题，为了解决并发性通常需要引入sync.Mutex解决。>对于通道的基本声明方式有三种：声明并初始化带缓冲的通道（ch1）；声明并初始化一个不带缓冲的通道（ch2）；仅仅声明一个通道（ch3） >什么是通道：==一个通道相当于一个先进先出（FIFO）的队列。也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。Select和for循环实现对channel的多次选
H.264学习笔记
zfenggo的博客
09-26 839
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
10.2学习
2401_87363162的博客
10-02 837
​ Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接⼝，那么Spring AOP会使⽤JDKProxy，去创建代理对象，⽽对于没有实现接⼝的对象，就⽆法使⽤ JDK Proxy 去进⾏代理了，这时候Spring AOP会使⽤基于asm框架字节流的Cglib动态代理 ，这时候Spring AOP会使⽤ Cglib ⽣成⼀个被代理对象的⼦类来作为代理。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
从0学习React（3）
qq_54432917的博客
09-29 620
在第一篇文章中，我们对index.tsx文件的每一行代码都做了简单的分析。通过第一篇文章的总结，我也大致知道了index.tsx里的很多语法。而第二篇文章，我对index.tsx文件的框架做了一个大致的分析，通过第二篇文章，我对index.tsx有了进一步的认识。按理来讲，第三篇文章我还是解析index.tsx文件，但是我发现，对于前两篇文章，其实我对语法的细节有很多不明白的点。因此这篇文章，我就把React的一些最基础的知识给梳理一下，帮助我更好的理解index.tsx的代码。
Go基础学习10-原子并发包sync.atomic的使用：CSA、Swap、atomic.Value......
最新发布
FLJS_T的博客
10-02 483
原子操作sync.atomic以及原子变量atomic.Value详细介绍。go中原生的支持原子操作的函数支持的变量类型int32、int64、uint32、uint64、uintptr，以及unsafe包中的Pointer。对于上述原子操作类型中的每一个，可以支持的数据类型有：==int32、int64、uint32、uint64、uintptr，以及unsafe包中的Pointer。但是否sync.Mutex变量能够保证操作的原子性。atomic.Value类型是开箱即用的，我们声明一个该类型的变量
6.824 Lab 2C 学习记录
kingsill的博客
09-29 294
最后10s，开始的时候，恢复网络，插入一个数据，等待这个数据被提交，如果超过这10s就报错。2C的test中的unreliable figure8算是给博主的迎头一棒，需要根据raft论文的figure8进行解决，leader。根据前任及博主自己的经验，unreliable figure8的除了上述这一点以外，需要对。博主由于之前的不严谨，给自己留下了很大的改进困难，最后不得不重构代码。进行一定的设计，可以参考课程里老师提出的意见。一下为博主的github仓库，需要的可以参考。有一定的考验，那么就需要对。
【DirectX sdk 学习使用】
qq_41610493的博客
10-01 308
设置包含目录：打开你的项目属性，导航到VC++目录，然后在包含目录中添加DirectX SDK的Include文件夹路径。设置库目录：同样在VC++目录中，在库目录中添加DirectX SDK的Lib文件夹路径。运行安装程序：下载完成后，找到下载的安装程序（通常是一个.exe文件），双击运行。选择安装路径：选择你希望安装DirectX SDK的路径，或者使用默认路径。如果你有任何问题或需要进一步的指导，请随时告诉我。接受许可协议：在安装向导中，阅读并接受许可协议。完成安装：点击“安装”按钮，等待安装完成。
Elasticsearch学习笔记(2）
m0_74293254的博客
09-28 1104
创建索引: 使用 PUT 请求来定义索引及其映射。创建文档: 使用 POST 请求将数据添加到索引。读取文档: 使用 GET 请求获取特定文档。更新文档: 使用 POST 加上 _update 操作来修改现有文档。删除文档: 使用 DELETE 请求删除指定文档。删除索引: 使用 DELETE 请求删除整个索引。请求方式：POST请求格式：/{索引库名}/_doc/文档id示例：POST /my_index/_doc/1 { "field": "value" }
Java Web核心技术阶段的学习要点
2401_87352036的博客
09-27 530
JavaWeb核心技术阶段的学习要点涵盖了多个关键技术和概念，这些技术和概念对于开发动Web应用程序至关重要。
QMake 学习记录
wxl5018的专栏
09-27 259
【代码】QMake 学习记录。
纯软件小白 学习DDR5
hello_new_life的博客
09-29 953
读写 driver前添加一个128位的临时存储位置“Burst Buffer”,我们用128条导线连接到128位缓冲区位置，接下来10位列地址被分成两部分，6bit用于多路复用器，4bit用于突发缓冲器。
学习笔记 | Golang基础，Go语言快速入门！
字节幺零二四的博客
09-28 970
本文将介绍 Go 语言的基础语法，包括环境配置、数据类型、流程控制、函数、结构体、接口、异常、文本处理、并发编程、网络编程等。
软件测试理论的详细学习要点和学习方向
2401_87352036的博客
09-30 369
软件测试理论的详细学习要点和学习方向可以从多个方面来探讨。
C++语言学习(1): std::endl 在做什么？
baiyu33的博客
10-01 133
字符，并且刷新缓冲。刷新缓冲肯定比不刷新缓冲慢。这就是为什么有些 guide 里提到，少用。
python pandas库学习笔记
07-28
- *2* [Pandas学习笔记](https://blog.csdn.net/qq_44732742/article/details/124660350)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值