# 一 数据结构介绍********************
# 在pandas 中有两类非常重要的数据结构，1序列Series 和2 数据框DataFrame,
# Series 类似于numpy 中的一维数据，除了通吃一维数组可用的函数和方法，而且其可通过
#索引标签的方式获取数据，还具有索引的自动对齐功能；
# DataFrame 类似于numpy 中的二维数组，同样可以通用numpy 数组的函数和方法，二维还具有
# 其他灵活应用。
# 1 Series 的创建 类似一维数组==============
# 序列的创建主要有三种方式
# 方式1 通过一维数组创建序列
import numpy as np
import pandas as pd
arr1 = np.arange(10)
# print(arr1,type(arr1))
# [0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'>
s1 = pd.Series(arr1) #自动创建索引数据并自动补齐
# print(s1,type(s1))
# 0 0
# 1 1
# 2 2
# 3 3
# 4 4
# 5 5
# 6 6
# 7 7
# 8 8
# 9 9
# dtype: int32 <class 'pandas.core.series.Series'>
#自定义索引创建
# _s1 = pd.Series([2,4],index=["王","罗"])
_s1 = pd.Series({"王":2,"罗":4}) #一样的
# print(_s1)
# 王 2
# 罗 4
# dtype: int64
# 方式2 通过字典的方式创建序列 (字典的键代表纵轴索引)
dic1 = {"a":1,"b":2,"c":3,"d":4,"e":5}
s2 = pd.Series(dic1)
# print(s2,type(s2))
# a 1
# b 2
# c 3
# d 4
# e 5
# dtype: int64 <class 'pandas.core.series.Series'>
# 方式3 通过DataFrame 中的某一行或某一列创建序列
# 暂时略
# 2 DataFrame =====的创建 类似二维数组 带有横轴纵轴的索引##
# 数据框的创建主要有三种方式
# 方式1 通过二维数组创建数据框(横向 纵向加上类似索引数据)
arr2 = np.array(np.arange(12)).reshape(4,3)
# print(arr2,type(arr2))
# [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]] <class 'numpy.ndarray'>
df1 = pd.DataFrame(arr2)
# print(df1,type(df1))
# 0 1 2
# 0 0 1 2
# 1 3 4 5
# 2 6 7 8
# 3 9 10 11 <class 'pandas.core.frame.DataFrame'>
# 方式2 通过字典的方式创建数据框 (字典的键代表横轴索引)
# 以下以两种字典来创建数据框，
# 一个是字典列表，一个是嵌套字典
dic2 = {"a":[1,2,3,4],"b":[5,6,7,8],"c":[9,10,11,12],"d":[13,14,15,16]}
df2 = pd.DataFrame(dic2)
# print(df2,type(df2))
# a b c d
# 0 1 5 9 13
# 1 2 6 10 14
# 2 3 7 11 15
# 3 4 8 12 16 <class 'pandas.core.frame.DataFrame'>
# 一个是嵌套字典 外层字典的键对应横轴的索引 ，内层字典的键对应纵轴的索引
dic3 = {"A":{"a1":1,"b1":2,"c1":3,"d1":4},
"B":{"a2":5,"b2":6,"c2":7,"d2":8},
"C":{"a3":9,"b3":10,"c3":11,"d3":12}}
df3 = pd.DataFrame(dic3)
# print(df3,type(df3))
# A B C
# a1 1.0 NaN NaN
# a2 NaN 5.0 NaN
# a3 NaN NaN 9.0
# b1 2.0 NaN NaN
# b2 NaN 6.0 NaN
# b3 NaN NaN 10.0
# c1 3.0 NaN NaN
# c2 NaN 7.0 NaN
# c3 NaN NaN 11.0
# d1 4.0 NaN NaN
# d2 NaN 8.0 NaN
# d3 NaN NaN 12.0 <class 'pandas.core.frame.DataFrame'>
# 方式三 通过数据框的方式创建数据框（列的标签索引）
df4 = df3[["A","B"]] #截取一部分的形式
# print(df4,type(df4))
# A B
# a1 1.0 NaN
# a2 NaN 5.0
# a3 NaN NaN
# b1 2.0 NaN
# b2 NaN 6.0
# b3 NaN NaN
# c1 3.0 NaN
# c2 NaN 7.0
# c3 NaN NaN
# d1 4.0 NaN
# d2 NaN 8.0
# d3 NaN NaN <class 'pandas.core.frame.DataFrame'>
df5 = df3["C"] #截取一部分数据框
# print(df5,type(df5))
# a1 NaN
# a2 NaN
# a3 9.0
# b1 NaN
# b2 NaN
# b3 10.0
# c1 NaN
# c2 NaN
# c3 11.0
# d1 NaN
# d2 NaN
# d3 12.0
# Name: C, dtype: float64 <class 'pandas.core.series.Series'>
# 手动创建横轴纵轴索引的数据框
a = pd.DataFrame([[2,4,6,8], [12,14,16,18]], index=['语文', '数学'], columns=['周', '孔', '王', '李'])
# print(a)
# 周 孔 王 李
# 语文 2 4 6 8
# 数学 12 14 16 18
# 二 数据索引index********************
# 细致的朋友可能会发现一个现象，无论是序列也好，还是数据框也好，对象的最左边总有一个非
# 原始数据对象，这个是什么呢？不错这就是我们接下来要介绍的索引
# 在我们看来序列或数据框的索引有两大用处，一个数通过索引值或索引标签获取目标数据，
# 另一个是通过索引，可以是序列或数据框的计算，操作实现自动化对齐，下面我们具体应用下、
# 1 通过索引值或索引标签获Series(序列)取数据 ==============
s3 = pd.Series(np.array([1,1,2,3,5,8])) #序列自动生成一个从0开始的自增索引
# print(s3,type(s3))
# 0 1
# 1 1
# 2 2
# 3 3
# 4 5
# 5 8
# dtype: int32 <class 'pandas.core.series.Series'>
# 自定义添加索引
s3.index = ["a","b","c","d","e","f"] # 自定义更改索引值
# print(s3)
# a 1
# b 1
# c 2
# d 3
# e 5
# f 8
# dtype: int32
#序列Series 的切片简单应用
# 序列有了索引，就可以通过索引值或者索引标签进行数据的获取
# print(s3[3]) #第四个索引值获取的数据 值3
# print(s3["d"]) #索引d 这属于标签索引 是名称 对应的值3
# print(s3[[1,3,5]]) # 通过数组选取索引 对应的值
# b 1
# d 3
# f 8
# dtype: int32
# print(s3[["a","b","e","d"]])#多行的数据
# a 1
# b 1
# e 5
# d 3
# dtype: int32
# print(s3[:4]) #索引的值从0 到第3个 四个值数据
# a 1
# b 1
# c 2
# d 3
# dtype: int32
# print(s3["c":]) #从第c 个索引到最后
# c 2
# d 3
# e 5
# f 8
# dtype: int32
# print(s3["b":"e"])
# b 1
# c 2
# d 3
# e 5
# dtype: int32
# 注意 千万注意----------------======￥￥￥￥￥
# 如果通过索引标签获取数据的话，末端标签所对应的值是可以返回的，在一维数组中就无法通过索引
# 标签获取数据，这也是序列与一维数组的一个区别
# 2 自动化对齐 ============== 只要相同的索引值相加，不相同的为NaN
# 如果有两个序列，需要对这两个序列进行算数运算，这时索引的存在就体现了它的价值
# 自动化对齐
s4 = pd.Series(np.array([10,11,12,13,14,15]))
s4.index = ["a","b","c","d","e","f"]
# print(s4)
# a 10
# b 11
# c 12
# d 13
# e 14
# f 15
# dtype: int32
s5 = pd.Series(np.array([2,3,4,5,6,7]))
s5.index = ["a","c","g","b","d","f"]
# print(s5)
# a 2
# c 3
# g 4
# b 5
# d 6
# f 7
# dtype: int32
#序列之和
# print(s4 + s5) #自动补齐（只要相同的索引值相加，不相同的为NaM）
# a 12.0
# b 16.0
# c 15.0
# d 19.0
# e NaN
# f 22.0
# g NaN
# dtype: float64
#序列之间整除
# print(s4 //s5 ) #整除
# a 5.0
# b 2.0
# c 4.0
# d 2.0
# e NaN
# f 2.0
# g NaN
# dtype: float64
# 由于s5中没有对应的g索引，s6中没有对应的e索引，所以数据的运算会产生两个缺失值NaN。
# 注意，这里的算术结果就实现了两个序列索引的自动对齐，而非简单的将两个序列加总或相除。
# 对于数据框的对齐，不仅仅是行索引的自动对齐，同时也会自动对齐列索引（变量名）
# 数据框中同样有索引，而且数据框是二维数组的推广，所以其不仅有行索引，而且还存在列索引，
# 关于数据框中的索引相比于序列的应用要强大的多，这部分内容将放在数据查询中讲解。
#三 pandas 的应用********************
# 这里的查询数据相当于R语言里的subset功能，可以通过布尔索引有针对的
# 选取元数据的子集、指定行，指定列等，我们先导入一个students数据集
可以手动创建纵向索引 index 也可以创建横向列的colums
# 1 手动创建横轴纵轴索引的数据框
df6 = pd.DataFrame([[2,4,6,8], [12,14,16,18]], index=['语文', '数学'], columns=['周', '孔', '王', '李'])
# print(df6)
# 周 孔 王 李
# 语文 2 4 6 8
# 数学 12 14 16 18
df7 = pd.DataFrame([["小马","male",12,156,40,"上海",79],["小驴","male",14,166,50,"深圳",89]],index=[1,2],
columns=["name","sex","age","heigh","weight","address","grade"])
# print(df7)
# name sex age heigh weight address grade
# 1 小马 male 12 156 40 上海 79
# 2 小驴 male 14 166 50 深圳 89
# 2指定列排顺序 并可截取不同的列 方式一截取列 其实这种也行[:,[0,3]] (截取第1列和第4列)
df8 = pd.DataFrame(df7,columns=["name","age","sex"])
# print(df8)
# name age sex
# 1 小马 12 male
# 2 小驴 14 male
# 2-1 方式二截取列
df9 = df7[["name","age","sex"]]
# print(df9)
# 3 传入列在数据中找不到就会产生NA值
df10 = pd.DataFrame(df7,index=[1,2,3,4,5],columns=["name","age","sex","address"])
# print(df10)
# name age sex address
# 1 小马 12.0 male 上海
# 2 小驴 14.0 male 深圳
# 3 NaN NaN NaN NaN
# 4 NaN NaN NaN NaN
# 5 NaN NaN NaN NaN
# 4 嵌套字典（字典组成的字典）创建DataFrame ,不等长也可，自动填充NaN 外层键是列索引，内行键是行索引
dic4 = {
'name':{1:'小明',2:'小华',3:'小红',4:'小青',5:'小兰'},
'sex':{1:1,2:0,3:0,4:1,5:0},
'age':{2:28,3:38,4:48,5:8} #此时缺少索引1
}
df11 = pd.DataFrame(dic4)
# print(df11)
# name sex age
# 1 小明 1 NaN
# 2 小华 0 28.0
# 3 小红 0 38.0
# 4 小青 1 48.0
# 5 小兰 0 8.0
可截取不同的行 类似截取不同的行 对比截取不同的列 columns=["name","age","sex"]) ============
df12 = pd.DataFrame(df11,index=[2,3,4,5,6])
# print(df12)
# name sex age
# 2 小华 0.0 28.0
# 3 小红 0.0 38.0
# 4 小青 1.0 48.0
# 5 小兰 0.0 8.0
# 6 NaN NaN NaN
# ---
# 5 和Series 组成的字典，创建DataFrame同嵌套字典,指定内层字典键（行索引），没有的自动填充NaM
dic5 = {
"name":pd.Series(["小王","小罗","小张","小李","小刘"],
index=[1,2,3,4,5]),
"sex":pd.Series([1,1,1,0,0], index=[1,2,3,4,5]),
"age":pd.Series([20,31,33,22],index=[2,3,4,5])
}
df12 = pd.DataFrame(dic5)
# print(df12)
# name sex age
# 1 小王 1 NaN
# 2 小罗 1 20.0
# 3 小张 1 31.0
# 4 小李 0 33.0
# 5 小刘 0 22.0
# 6删除行默认 axis=0 删除列 axis=1
df13 = df12.drop([3],axis=0)#删除第三行按照标签索引查找
# print("删除行",df13)
# name sex age
# 1 小王 1 NaN
# 2 小罗 1 20.0
# 4 小李 0 33.0
# 5 小刘 0 22.0
df14 = df12.drop(["sex"],axis=1) #删除列
# print("删除列",df14)
# 删除行 name age
# 1 小王 NaN
# 2 小罗 20.0
# 3 小张 31.0
# 4 小李 33.0
# 5 小刘 22.0
# 7 遍历DataFrame #每一行的数据加上 列标题
# for index, row in df12.iterrows():
# print("index:",index)
# print("row:",row)
# row: name 小王
# sex 1
# age NaN
# Name: 1, dtype: object
# row: name 小罗
# sex 1
# age 20
# Name: 2, dtype: object
# row: name 小张
# sex 1
# age 31
# Name: 3, dtype: object
# row: name 小李
# sex 0
# age 33
# Name: 4, dtype: object
# row: name 小刘
# sex 0
# age 22
# Name: 5, dtype: object
# 8 查看相关 维度 类型 值 单值
# print("查看维度：",df12.shape) #查看维度： (5, 3)
# print("查看类型：",df12.dtypes)
# 查看类型： name object
# sex int64
# age float64
# dtype: object
# print("查看值：",df12.values)
# 查看值： [['小王' 1 nan]
# ['小罗' 1 20.0]
# ['小张' 1 31.0]
# ['小李' 0 33.0]
# ['小刘' 0 22.0]]
# print("查看单值：",df12["sex"][3]) # 查看单值： 1
# print(df12.head(2)) #显示头部2行，但是默认是5行
# name sex age
# 1 小王 1 NaN
# 2 小罗 1 20.0
# print(df12.tail(3)) #显示末尾3行，默认是5行
# name sex age
# 3 小张 1 31.0
# 4 小李 0 33.0
# 5 小刘 0 22.0
# print(df12.info()) #相关信息概况，行数，列数，列索引，列非空值个数，列类型，行类型,内存占用
# <class 'pandas.core.frame.DataFrame'>
# Int64Index: 5 entries, 1 to 5
# Data columns (total 3 columns):
# name 5 non-null object
# sex 5 non-null int64
# age 4 non-null float64
# dtypes: float64(1), int64(1), object(1)
# memory usage: 320.0+ bytes
# None
# print(df12.describe()) #快速综合统计结果，计数，均值，标准差，最大值，四分位数，最小值
# sex age
# count 5.000000 4.000000
# mean 0.600000 26.500000 #？？？？
# std 0.547723 6.454972 #？？？？
# min 0.000000 20.000000
# 25% 0.000000 21.500000
# 50% 1.000000 26.500000
# 75% 1.000000 31.500000
# max 1.000000 33.000000
# 四 索引查询 ********************
# 用于连续或不连续（行列有间隔）行列区块查询
# 解决了DataFrame 进行行标签查询的问题
# 两种查询方式：
# df.loc[行，列] 标签索引 自定义索引
# df.iloc[行，列] 位置索引，默认索引
# 参数书写顺序都是先行后列
dic5 = {
"name":pd.Series(["小王","小罗","小张","小李","小刘"],
index=[1,2,3,4,5]),
"sex":pd.Series([1,1,1,0,0], index=[1,2,3,4,5]),
"age":pd.Series([20,31,33,22],index=[2,3,4,5])
}
df15 = pd.DataFrame(dic5)
# 1 查询单行 df.loc[标签索引] ()
# print("标签单行索引",df15.loc[3])
# 标签单行索引 name 小张
# sex 1
# age 31
# Name: 3, dtype: object
# df15.iloc[位置索引]
# print("位置索引单行",df15.iloc[3])#索引第四个值
# 位置索引单行 name 小李
# sex 0
# age 33
# Name: 4, dtype: object
# 2 查询单列 前面机上冒号
# df.loc[:,"列名"] #标签索引
# df.iloc[:,索引数字] #位置索引
# print("标签索引单列name",df15.loc[:,"name"])
# 标签索引单列name 1 小王
# 2 小罗
# 3 小张
# 4 小李
# 5 小刘
# Name: name, dtype: object
# print("位置索引单列name",df15.iloc[:,0])
# 位置索引单列name 1 小王
# 2 小罗
# 3 小张
# 4 小李
# 5 小刘
# Name: name, dtype: object
# 3查询多行，双中括号
# print(df15.loc[[2,5]]) #读取第二行 和第五行
# name sex age
# 2 小罗 1 20.0
# 5 小刘 0 22.0
# print(df15.iloc[[2,4]]) #读取索引为2 和索引为4 对应的数据
# 3 小张 1 31.0
# 5 小刘 0 22.0
# 4 查询多列
# print(df15.loc[:,["name","age"]]) #标签索引
# name age
# 1 小王 NaN
# 2 小罗 20.0
# 3 小张 31.0
# 4 小李 33.0
# 5 小刘 22.0
# print(df15.iloc[:,[0,2]]) #位置索引
# name age
# 1 小王 NaN
# 2 小罗 20.0
# 3 小张 31.0
# 4 小李 33.0
# 5 小刘 22.0
# 5 查询单个单元格方法 [行，列]
# print(df15.loc[1,"name"]) #标签索引 第一行 name列
# 小王
# print(df15.at[1,"name"]) #标签索引 速度和效率会更高at 用法
# 小王
# 以下是位置索引
# print(df15.iloc[0,0])# 位置索引
# 小王
# 6 查询多个单元格
# 6-1 均是标签索引 就是写上标签的名字即可
# 一行多列Seires
# print(df15.loc[1,["name","sex"]]) # 标签索引
# name 小王
# sex 1
# Name: 1, dtype: object
# 多行一列
# print(df15.loc[[1,4],"sex"])#第一行和第四行 的sex 列
# 1 1
# 4 0
# Name: sex, dtype: int64
# 多行多列
# print(df15.loc[[1,3],["sex","age"]]) #标签索引
# sex age
# 1 1 NaN
# 3 1 31.0
# 6-2 查询多表格 是位置索引或是标签索引
# print(df15.iloc[0,[0,2]]) #第一行第一个数据 和一行和第3个数据
# name 小王
# age NaN
# Name: 1, dtype: object
# print(df15.iloc[[0,1],2]) #第一行和第二行，和第三宗地的结合部分数据
# 1 NaN
# 2 20.0
# Name: age, dtype: float64
# print(df15.iloc[[0,1],[0,2]]) #多行多列数据 按照索引第一行第二行 对应第一 第三列数据
# name age
# 1 小王 NaN
# 2 小罗 20.0
# 五 切片查询 ******************** 截取行 （冒号）：在最后，截取列 （冒号）：在最前
# 用于连续行列区块查询
# 比索引查询简单方便，单不能查询非连续行列区块
# 单个或不连续行列区块使用缩影查询，连续行列区块使用切片查询
# 切片查询的区间
# iloc 默认是位置索引是从左到右开区间（左包右不包）
# loc 自定义标签索引是从左到右闭区间（左包右也包）
# 因为标签索引不包含位置索引，使用时很难知道索引前后是什么
dic5 = {
"name":pd.Series(["小王","小罗","小张","小李","小刘"],
index=[1,2,3,4,5]),
"sex":pd.Series([1,1,1,0,0], index=[1,2,3,4,5]),
"age":pd.Series([20,31,33,22],index=[2,3,4,5])
}
df16 = pd.DataFrame(dic5)
# print(df16)
# name sex age
# 1 小王 1 NaN
# 2 小罗 1 20.0
# 3 小张 1 31.0
# 4 小李 0 33.0
# 5 小刘 0 22.0
# 1 选取一行
# print(df16.loc[2,:]) #标签索引 读取第二行
# print(df16.loc[2])
# print(df16.iloc[1,:])#位置索引 读取第二行
# print(df16.iloc[1])
# name 小罗
# sex 1
# age 20
# Name: 2, dtype: object
# 2 选取一列
# print(df16.loc[:,"name"]) #标签索引方式
# print(df16.iloc[:,0]) #位置索引方式
# 1 小王
# 2 小罗
# 3 小张
# 4 小李
# 5 小刘
# Name: name, dtype: object
# 3 切片选取连续多行 ？？？暂时有点不理解（自己理解是iloc 位置索引如果是3 包括前3个 0 1 2 ）
# print(df16.loc[:3:]) #左右全包从开始到3
# print(df16.iloc[:3,:]) #从开始的0 索引到2 共3个
# name sex age
# 1 小王 1 NaN
# 2 小罗 1 20.0
# 3 小张 1 31.0
# 4 切片选取连续多列
# print(df16.loc[:,"sex":"age"]) #注意是个冒号 标签名：标签名
# print(df16.iloc[:,1:3]) #列索引：列索引
# 5 切片选取多行多列的聚合
# print(df16.loc[2:4,"sex":"age"])
# print(df16.iloc[1:4,1:3]) #此时的4 是索引4 并不是标签4
# 六 过滤查询 ********************
# 通过列布尔值过滤、筛选查询 ，不通过索引而是通过值查询
# 用于结果索引不确定的查询
# 通过运算所得布尔值对查询结果进行过滤，
# 通过某列值过滤数据，返回布尔值
# 1 选取年龄大于30的 一列数据
# print(df16["age"]>=30)
# print(df16.loc[:,"age"]>=30)#（列的标签索引）age 这一列大于30
# 1 False
# 2 False
# 3 True
# 4 True
# 5 False
# Name: age, dtype: bool
# 2 布尔值做 DataFrame 参数，返回DataFrame对象
# print(df16[df16["age"]>=30])
# print(df16[df16.loc[:,"age"]>=30])#
# name sex age
# 3 小张 1 31.0
# 4 小李 0 33.0
# 3 布尔索引和切片结合 数据框["列名标签"]
# print(df16.loc[df16["age"]>30,"name":"age"]) #或者 name":])
# name sex age
# 3 小张 1 31.0
# 4 小李 0 33.0
# 4 多重条件过滤，逻辑运算
# & 且的意思；
# | 或 的意思；
# - 非的意思（或者用！= 判断）
# print((df16["age"] > 30) &(df16["sex"] == 1))
# print(df16[(df16["age"] > 30) &(df16["sex"] == 1)])
# name sex age
# 3 小张 1 31.0
# 5 where 过滤
# 5-1方式1 过滤 方法 通过布尔值判断过滤 去除NaN 的值
df17 = df16[["name","sex","age"]] #多列数据必须多个中括号
# print(df17)
dfbool = df17>=1 #返回DataFrame 类型的布尔值
# print(dfbool) #返回DataFrame 类型的布尔值
# name sex age
# 1 True True False
# 2 True True True
# 3 True True True
# 4 True False True
# 5 True False True
dNan = df17[dfbool] #当参数传来进来
# print(dNan)
# name sex age
# 1 小王 1.0 NaN
# 2 小罗 1.0 20.0
# 3 小张 1.0 31.0
# 4 小李 NaN 33.0
# 5 小刘 NaN 22.0
# 去掉含有缺失值的行
filter_NaN= dNan.dropna(how="any")
# print(filter_NaN)
# name sex age
# 2 小罗 1.0 20.0
# 3 小张 1.0 31.0
# 5-2 方式2 过滤方法还可以通过isin() 函数过滤取数据
NaN_bool = df16["sex"].isin([1]) #这个1是性别的标识符
# print(filter_bool)
# 1 True
# 2 True
# 3 True
# 4 False
# 5 False
# Name: sex, dtype: bool
df18= df16[NaN_bool]
# print(df18)
# name sex age
# 1 小王 1 NaN
# 2 小罗 1 20.0
# 3 小张 1 31.0
# 通过布尔值判断过滤 去除NaN 的值
filter_NaN1 = df18.dropna(how="any")
# print("去除NaN的数据",filter_NaN)
# 去除NaN的数据 name sex age
# 2 小罗 1.0 20.0
# 3 小张 1.0 31.0
# 七 修改 update ********************
# 凡是通过查询得到的值，直接赋值就可修改；
# 视图和副本：通过索引和切片返回的数据是原数据的视图，不是副本，任何对视图的修改全部会反应到源数据上，
# 想独立修改数据可以通过copy() 复制源数据的副本
# 类 list/ndarry 查询方式修改
# 1 增加或修改一列的数据
_df16 = df16.copy()
# _df16["heigh"] = [150,160,170,180,190] #增加了一列 heigh
# print(_df16)
# name sex age heigh
# 1 小王 1 NaN 150
# 2 小罗 1 20.0 160
# 3 小张 1 31.0 170
# 4 小李 0 33.0 180
# 5 小刘 0 22.0 190
_df16["heigh"]=170 #全变成170
# print(_df16)
# name sex age heigh
# 1 小王 1 NaN 170
# 2 小罗 1 20.0 170
# 3 小张 1 31.0 170
# 4 小李 0 33.0 170
# 5 小刘 0 22.0 170
# 2索引或切片查询方式修改
df19 = df16.loc[[1,3,5],["name","age"]] #标签索引 三行 两列 查看数据
# print(df19)
# name age
# 1 小王 NaN
# 3 小张 31.0
# 5 小刘 22.0
2-1 修改整个三行 2列的数据，注意不能有两个等号 不能再赋值变量
df16.loc[[1,3,5],["name","age"]]=[["wang",11],["zhang",22],["liu",33]] #1 3 5 三行，name age 两列
# _df19 = df16.loc[[1,3],["name","age"]]=[["wang",11],["zhang",22],["liu",33]] # 这样的话维度不够三行的数据 只有2行
# print(df16) #???????????????????????????应该不是一下这种类型 个人以为
# name sex age
# 1 wang 1 11.0
# 2 小罗 1 20.0
# 3 zhang 1 22.0
# 4 小李 0 33.0
# 5 liu 0 33.0
# 3 通过where 过滤修改
df20 = df16[df16>=1]
# print("s",df20)
# s name sex age
# 1 小王 1.0 NaN
# 2 小罗 1.0 20.0
# 3 小张 1.0 31.0
# 4 小李 NaN 33.0
# 5 小刘 NaN 22.0
# df21 = df16[df16>=1] = 2 #不能再混合数据勒种中修改非NaN 值
# print(df21) 报错 了
# 4 提取唯一数据类型数据（拷贝一下）
df16_2 = df16.loc[:,["name","age"]] #截取2列数据
df16_cp = df16_2.copy()
# print("df16_2",df16_2)
# df16_2 name age
# 1 小王 NaN
# 2 小罗 20.0
# 3 小张 31.0
# 4 小李 33.0
# 5 小刘 22.0
# print(df16_2>25)
# name age
# 1 True False
# 2 True False
# 3 True True
# 4 True True
# 5 True False
# print(df16_2[df16_2>25])
# name age
# 1 小王 NaN
# 2 小罗 NaN
# 3 小张 31.0
# 4 小李 33.0
# 5 小刘 NaN
# ？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
# df16_2[df16_2>25] = 88
# print(df16_2) #报错 TypeError：不能在非np类混合类型上进行布尔设置。nan值
# 八删除 Delete ********************
s6 = pd.Series(["wang","luo"],index=[2,3])
# print(s6)
# 2 wang
# 3 luo
# dtype: object
# 1 Series 对象的删除
s7 = s6.drop(2) #删除一行
# print(s7)
# 3 luo
# dtype: object
s8 = s6.drop([2,3]) ## 删除多行
# print(s8)
# Series([], dtype: object)
df21 = pd.DataFrame({"name":["wang","luo","zang"],"sex":[1,0,1],"age":[11,22,33]})
# print(df21)
# name sex age
# 0 wang 1 11
# 1 luo 0 22
# 2 zang 1 33
# 2 DataFrame 对象删除
# 2-1 删除单行和多行
# 默认是删除行，默认只改动视图
# df22 = df21.drop(0) #删除单行
# print(df22)
# name sex age
# 1 luo 0 22
# 2 zang 1 33
# df23 = df21.drop([0,2]) #删除多行
# print(df23)
# name sex age
# 1 luo 0 22
# 2-2 删除单列或者多列
# axis=1 删除列，默认axis=0删除行
# print(df21.drop("name",axis=1)) #s删除单列
# sex age
# 0 1 11
# 1 0 22
# 2 1 33
# print(df21.drop(["age","sex"],axis=1)) #删除多列
# name
# 0 wang
# 1 luo
# 2 zang
# 2-3 inplace=True,改动原数据，默认 inplace=False,只改动视图?????????
# print(df21.drop(["age","sex"],axis=1,inplace=False)) #设置为True 结果为None
# name
# 0 wang
# 1 luo
# 2 zang
# 2-4 DataFrame 对象的索引命名
df21.index.name = "row"
df21.columns.name = "col"
# print(df21)
# col name sex age
# row
# 0 wang 1 11
# 1 luo 0 22
# 2 zang 1 33