宝塔服务器面板，一键全能部署及管理，送你10850元礼包，点我领取
楔子
pandas是一个很强大的库，但是在使用的过程中难免会遇见各种奇葩的异常，而这些异常却又很难让人定位到底是哪一步出了问题。下面就来看看pandas中的一些令人感到费解的异常吧，看看你有没有遇到过，如果没有的话，那么说明你pandas可能用的不够多哦。
ヽ(￣ω￣(￣ω￣〃)ゝ一起来看看
1. SettingWithCopyWarning:
当然这不是个异常，而是一个警告，这个警告相信大多数人都遇到过，尤其是初学pandas的时候。这个警告具体内容如下：
SettingWithCopyWarning:
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead
See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/......
我们来复现一下这个警告：
import pandas as pd
df = pd.DataFrame({"name": ["mashiro", "koishi", "satori", "kurisu"],
"age": [17, 16, 17, 19],
"adult": [None, None, None, None]})
print(df)
"""
name age adult
0 mashiro 17 None
1 koishi 16 None
2 satori 17 None
3 kurisu 19 None
"""
# 我现在想将df中age > 18对应的audit设置为True
# 但是会发现没有效果，并且SettingWithCopyWarning就是由这一行代码引发的
df[df["age"] > 16]["adult"] = True
print(df)
"""
name age adult
0 mashiro 17 None
1 koishi 16 None
2 satori 17 None
3 kurisu 19 None
"""
为什么会出现这个原因呢？因为df[df["age"] > 16]得到的是原始DataFrame的一份拷贝，因此其相应的操作不会影响原来的DataFrame。尽管这样的操作是允许的，但是却无法得到正确的结果，因此pandas弹出了一个警告。
# 真正的做法是使用loc或者iloc
df.loc[df["age"] > 18, "adult"] = True
print(df)
"""
name age adult
0 mashiro 17 None
1 koishi 16 None
2 satori 17 None
3 kurisu 19 None
"""
2. TypeError: ‘Series’ objects are mutable, thus they cannot be hashed
这个异常实际上比较常见了，说白了就是你不小心把loc或者iloc给丢掉了，我们还用上面的例子
try:
df[df["age"] > 18, "adult"] = True
except Exception as e:
print(e) # 'Series' objects are mutable, thus they cannot be hashed
3. ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all()
我们知道，像if a:，not a之类的，本质上都是调用a的__bool__方法，可以理解为bool(a)
class A:
def __bool__(self):
return True
if A():
print("123")
else:
print("456")
print(bool(A()))
"""
123
True
"""
# 由于A的__bool__返回了True, 所以bool(A())为True
# 我们将其改为False
A.__bool__ = lambda self: False
print(bool(A())) # False
但是对于一个Series或者numpy中的array不可以这么做。
import pandas as pd
s = pd.Series([True, False])
try:
bool(s)
except Exception as e:
print(e) # The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
try:
if s.values: # 得到一个numpy中的array
pass
except Exception as e:
print(e) # The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
"""
对于一个Series对象来说，不可以使用其布尔值，应当使用 s.all()、s.any()或者np.all(s)、np.any(s)
但是对于numpy中的array来讲，如果这个array里面的元素不止一个，那么也不可以使用其布尔值，但如果该array中只有一个元素的话是个例外
此时：if np.array([123]) 等价于 if 123
因此如果使用其布尔值的话，最好使用np.all()或者np.any()将一个序列变成单个布尔值
"""
# 但如果只是希望像列表一样，如果该Series对象里面有值就是真，否则就是假
# 那么建议通过 if len(s):这种方式来判断
# 同理DataFrame也是如此
4. 布尔你咋啦？
我们知道，可以对两个类型为bool的Series对象进行 与、或、非 等操作，但是结果真的一定是我们想要的吗？
import pandas as pd
s1 = pd.Series([True, True, True])
s2 = pd.Series([True, False, True], index=[1, 2, 3])
print(s1 & s2)
"""
0 False
1 True
2 False
3 False
dtype: bool
"""
# 我们看到与运算之后，长度变成了4，究其原因就是两个Series索引不同造成的
# 而Series的很多操作都是基于索引进行对齐的，并不是简简单单地按照顺序
# 但如果对应的索引一样的话，那么也可以认为就是按照顺序从上到下
# 但如果索引不一样的话，pandas是怎么做的呢？答案是使用reindex
# 首先找到两个Series对象中出现的所有不重复索引
index = s1.index | s2.index
print(index) # Int64Index([0, 1, 2, 3], dtype='int64')
# 使用reindex进行对齐, 不存在的使用NaN代替，当然我们也可以指定fill_value进行填充
# 比如fill_value=False
print(s1.reindex(index))
"""
0 True
1 True
2 True
3 NaN
dtype: object
"""
print(s2.reindex(index))
"""
0 NaN
1 True
2 False
3 True
dtype: object
"""
# 所以s1 & s2最终等价于 s1.reindex(index) & s2.reindex(index)
# 因此即使两者个数不同也是没有问题的
s1 = pd.Series([True, True, True, True])
s2 = pd.Series([True, True, True], index=[1, 2, 3])
print(s1 & s2)
"""
0 False
1 True
2 True
3 True
dtype: bool
"""
总之pandas中很多操作，并不是我们想的那么简单，pandas的Series和DataFrame都具备索引的概念，通过索引来定位速度是非常快的。但是不注意就会造成陷阱，究其原因就是很多操作在定位的时候是基于索引来定位的，并不是简单的按照顺序。比如：s1 & s2，指的是s1和s2中相同索引对应的元素进行与运算，当然如果有对应不上的，事先已经通过reindex处理好了。
当然，如果我们不希望考虑索引的话，只是单纯的希望按照顺序进行位运算，该怎么做呢？办法有两种
import pandas as pd
s1 = pd.Series([True, True, True])
s2 = pd.Series([True, False, True], index=[1, 2, 3])
# 对Series使用reset_index即可，当然要指定drop=True，否则就变成DataFrame了
# 一旦reset_index之后两者索引从头到尾就是一致的了
print(s1.reset_index(drop=True) & s2.reset_index(drop=True))
"""
0 True
1 False
2 True
dtype: bool
"""
# 或者转成numpy中的array
# 我们知道Series等价于numpy中的n个array，分别存放索引、值等等
# 我们调用s.index即可拿到索引，s.values即可拿到值
print(s1.values & s2)
"""
1 True
2 False
3 True
dtype: bool
"""
# 如果其中是一个array的话，那么它没有索引的概念，索引此时也是单纯的一个一个对应进行运算
# 当然得到的结果也是一个Series，索引和运算的Series的索引保持一致
# 或者都转成array
print(s1.values & s2.values) # [ True False True]
# 但是注意：如果其中一方转成了array，那么此时就要求两个序列的布尔元素个数是必须相等的
# 此时就不会再通过reindex进行扩展了，因为array没有reindex
# 当然都转成array就更不用说了
我们说了很多关于索引的话题，之所以强调这一点，是因为这里面存在一个坑点。我们知道对于DataFrame对象来说，通过df[xxx]可以取得相应的数据，xxx的身份不同，取得的数据也不同
如果xxx是一个标量, 那么df[xxx]表示获取df的某一列，得到一个Series对象
如果xxx是一个列表或者numpy的narray, 那么xxx里面可以是该DataFrame对象的列名，表示获取指定的多个列，得到DataFrame对象
如果xxx是一个列表或者numpy的narray，那么这个xxx里面还可以是布尔值，并且其长度要和该DataFrame对象的行数相等，表示获取对应的行数。对应为True的保留，为False的不要，也是得到DataFrame对象
举个栗子
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
# 只有第一个为True，因此被保留了下来
print(df[[True, False, False]])
"""
a b
0 1 11
"""
try:
# 但此时指定的4个布尔值
print(df[[True, False, False, False]])
except Exception as e:
print(e) # Item wrong length 4 instead of 3.
"""
告诉我们个数不匹配
所以上面之所以说了索引，就是因为在做运算的的时候可能导致布尔值的个数最终和DataFrame的行数不匹配
从而在筛选指定记录的时候发生报错
"""
如果是Series也是可以的
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
flag = pd.Series([True, False, False])
print(df[flag])
"""
a b
0 1 11
"""
# 当然里面也可以是一个Series，当然这个Series不仅个数要匹配，索引也要匹配
# 我们知道df的索引是 0 1 2，那么该flag的索引也必须是0 1 2(但是顺序不要求)
flag.index = [1, 2, 3]
try:
df[flag]
except Exception as e:
print(e)
# Unalignable boolean Series provided as indexer (index of the boolean Series and of the indexed object do not match).
"""
我们看到报了上面那个错误，意思我们传递了bool类型的Series对象，但是其索引和DataFrame的索引不匹配
"""
# 我们再改一下
flag.index = [1, 2, 0]
print(flag)
"""
1 True
2 False
0 False
dtype: bool
"""
print(df[flag])
"""
a b
1 2 22
"""
# 我们看到此时布尔值True对应的索引为1，那么筛选的就不再是df中的第一行了
# 而是索引为1的行，也就是第二行。
# 因此尽管对Series的索引的值有要求，但是对顺序却并没有要求
# 所以这种情况下，筛选出来的数据可能就和我们想象的不一样，明明第一个是True，为啥却把DataFrame的第二行选出来了
# 原因就是，虽然第一个是True，但是它对应的索引是1
因此索引这个东西在定位数据的时候，会非常方便，因为我们可以直接通过索引去定位。但是在一些操作方面，我们关心的并不是它的索引，而是它的值，比如：s1 & s2，或者df[flag]，这个时候我们只是对内部的布尔值感兴趣，那么直接把s1、s2、flag这些变成numpy中的array之后，再去传递即可。此时就无需考虑索引啥的了。
5. 怎么给DataFrame添加字段呢？
给一个DataFrame添加一个字段，并附上初始值有以下几种方式。
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
# 可以给一个标量，然后会自动进行广播
df["c"] = "xx"
# 也可以是一个列表，如果里面只有一个元素，那么和标量是等价的
df["d"] = "yy"
print(df)
"""
a b c d
0 1 11 xx yy
1 2 22 xx yy
2 3 33 xx yy
"""
# 如果是列表里面有多个值，那么个数必须和df的行数匹配
# 否则会报出ValueError: Length of values does not match length of index
df["e"] = ["x", "y", "z"]
print(df)
"""
a b c d e
0 1 11 xx yy x
1 2 22 xx yy y
2 3 33 xx yy z
"""
# 还有一种办法是通过df.assign，这种办法可以同时创建多个列
df = df[["a", "b"]]
df = df.assign(
# 这里指定接收一个参数的函数，这个参数就是整个df
# 通过关键字参数，那么参数名就是列名
c=lambda x: x["a"] + 1,
d=lambda x: x["b"] * 2,
e=lambda x: ["i", "j", "k"],
f=lambda x: "哼哼"
)
print(df)
"""
a b c d e f
0 1 11 2 22 i 哼哼
1 2 22 3 44 j 哼哼
2 3 33 4 66 k 哼哼
"""
给一个DataFrame添加一个字段，同样存在索引的陷阱
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
df["c"] = pd.Series(["x", "y", "z"], index=[0, 2, 3])
print(df)
"""
a b c
0 1 11 x
1 2 22 NaN
2 3 33 y
"""
原因无需我再多解释，总而言之就是我们刚才说的那样，如果我们只关心值，不关心索引，那么就不要传递Series对象，直接传递numpy中的array或者列表即可，这样我们就根本不需要考虑索引对齐的问题。
传递一个一维序列是可以的，那么传递一个DataFrame对象会如何呢？
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
df1 = pd.DataFrame({"x": ["aa", 22, None], "y": [">>", "^^", "YY"]})
try:
# 因为df1有两个字段，这里我们只指定了一个
df["c"] = df1
except Exception as e:
print(e) # Wrong number of items passed 2, placement implies 1
# 我们知道df1["x"]是个Series，所以df["c"] = df1["x"]肯定没有错
# 但是df["c"] = df1[["x"]]呢？ df1[["x"]]显然是个DataFrame
df["c"] = df1[["x"]]
print(df)
"""
a b c
0 1 11 aa
1 2 22 22
2 3 33 None
"""
# 可以看到，如果DataFrame只有一个字段，那么等价于Series
# 最后，df["xx"] = xx 这种方式, 在xx是一维序列的前提下 完全等价于 df.loc[:, "xx"] = xx
# 但如果xx是一个DataFrame的话就不一样了
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
df1 = pd.DataFrame({"x": ["aa", 22, None], "y": [">>", "^^", "YY"]})
df.loc[:, "c"] = df1
print(df)
"""
a b c
0 1 11 NaN
1 2 22 NaN
2 3 33 NaN
"""
# 我们惊奇地发现它居然没有报错，但结果却是NaN
# 我们rename一下
df1 = df1.rename(columns={"y": "c"})
df.loc[:, "c"] = df1
print(df)
"""
a b c
0 1 11 >>
1 2 22 ^^
2 3 33 YY
"""
# 因此我们发现在使用df.loc[:, "xx"] = df1的时候
# 会自动去找df1中列名为"xx"的列，如果找不到就为NaN
如果给DataFrame添加多个字段的话，除了assign之外，还有什么办法呢？
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
df1 = pd.DataFrame({"x": ["aa", 22, None], "y": [">>", "^^", "YY"]})
df[["c", "d"]] = df1
print(df)
"""
a b c d
0 1 11 aa >>
1 2 22 22 ^^
2 3 33 None YY
"""
# 这里可以要求列名不一致，但是个数必须要匹配
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
df1 = pd.DataFrame({"x": ["aa", 22, None], "y": [">>", "^^", "YY"]})
# 但是对于loc来说，无法添加多个字段
# 添加一个字段是可以的，但是多个不行
try:
df.loc[:, ["c", "d"]] = df1
except Exception as e:
# loc表示筛选，而df的列中没有"c"和"d"
# 即使是df.loc[:, ["c"]]也不可以，但是df.loc[:, "c"]是可以的
print(e) # "None of [Index(['c', 'd'], dtype='object')] are in the [columns]"
# 所以df[["c", "d"]] = df1，如果列c、d不存在， 那么会自动添加
# 但是对于df.loc[:, ["c", "d"]] = df1，如果c、d不存在，则报错，注意：不是都不存在，而是只要有一个不存在就报错
# 如果是指定了不存在的索引，暂时不会报错，而是弹出一个警告
print(df.loc[[1, 11]])
"""
a b
1 2.0 22.0
11 NaN NaN
"""
# 我们看到指定了不存在的索引，那么自动为NaN
# 但同时会抛出一个FutureWarning:
"""
Passing list-likes to .loc or [] with any missing label will raise
KeyError in the future, you can use .reindex() as an alternative.
"""
# 意思是让我们先reindex一下
所以如果想添加多个字段，可以直接通过df[["c1", "c2"]] = df1的方式，但是注意：右边写的df1，所以右边需要也是一个DataFrame，并且两者列数相等
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3], "b": [11, 22, 33]})
df1 = pd.DataFrame({"x": ["aa", 22, None], "y": [">>", "^^", "YY"]})
# 这里我们本意是想创建两个字段，值都为None
# 但是很遗憾这样不可以
try:
# 右边的值也需要是一个DataFrame
df[["c", "d"]] = None
except Exception as e:
# 我们看到这里也同样报出了相应的错误
# 因此只有当右边的值是DataFrame的时候，df[["c", "d"]]才能具备创建新字段的能力
print(e) # "None of [Index(['c', 'd'], dtype='object')] are in the [columns]"
# 如果想创建多个新字段，并且还希望通过广播的方式赋上同一个值，那么上面做法是行不通的
# 解决办法是一个字段一个字段的创建，这样百分之百是没有任何问题的，既可以df["c"]也可以df.loc[:, "c"]
# 但是也可以通过我们之前说的assign
df = df.assign(
c=lambda x: None,
d=lambda x: None,
)
print(df)
"""
a b c d
0 1 11 None None
1 2 22 None None
2 3 33 None None
"""
# 除此之外，还有一个insert方法
# 这个方法接收：插入的位置、列名、值
# 比如我想在列c的后面插入一个新列age，值全部是18，该怎么做呢？
df.insert(df.columns.get_loc("c") + 1, "age", 18)
print(df)
"""
a b c age d
0 1 11 None 18 None
1 2 22 None 18 None
2 3 33 None 18 None
"""
# 我们看到insert这个方法是在本地进行操作的
# 关键是第一个参数，我们希望插在c的后面，那么就必须获取c所在的索引，当然也可以直接数出来
# 通过columns.get_loc即可获取，然后再加上1即可
6. ValueError: cannot compute isin with a duplicate axis.
这个错误当初也是把我搞懵逼了半天，在复现这个异常之前，我们先来聊聊非常常用的isin
isin我们一般是对Series对象使用，判断这个序列中每一个元素是不是在另一个序列里面，下面举例说明：
import pandas as pd
s = pd.Series(["a", "b", "c", "d"])
print(s.isin(["a", "c", "e"]))
"""
0 True
1 False
2 True
3 False
dtype: bool
"""
这个方法是我们经常使用的，但是你对DataFrame使用过isin吗？我们有时候需要判断两个序列，看这两个序列中的值是否在另外两个序列里面。
import pandas as pd
df1 = pd.DataFrame({"x": ["a", "b", "c", "d"], "y": [1, 2, 3, 4]})
df2 = pd.DataFrame({"x": ["a", "B", "c", "D"], "y": [1, 2, 4, 3]})
print(df1)
"""
x y
0 a 1
1 b 2
2 c 3
3 d 4
"""
print(df2)
"""
x y
0 a 1
1 B 2
2 c 4
3 D 3
"""
print(df1[["x"]].isin(df2))
# DataFrame中有两列，所以是两列布尔值
"""
x y
0 True True
1 False True
2 True False
3 False False
"""
# 我们来分析一下，对于df1来说，前两行肯定是没有问题的
# 但是第三行有点诡异，我们df1的第三行的y列是3，显然3是在df2的y列当中啊，为什么是False
# 同理第4行，"d"不在df2的x列中我们知道，但是y列的4很明显在df2的y列当中，为什么是False
估计有人猜到了，那就是对DataFrame使用isin的时候，多个列之间并不是独立的。事实上，DataFrame使用isin也是根据索引来的，我们举个栗子
import pandas as pd
df1 = pd.DataFrame({"x": ["a", "b", "c", "d"], "y": [1, 2, 3, 4]})
df2 = pd.DataFrame({"x": ["a", "b", "c", "d"], "y": [1, 2, 3, 4]})
# 两个一模一样的DataFrame对象
print(df1.isin(df2))
"""
x y
0 True True
1 True True
2 True True
3 True True
"""
# 结果没问题，但是我们将df2的索引改变一下
df2.index = [0, 1, 3, 2]
print(df1.isin(df2))
"""
x y
0 True True
1 True True
2 False False
3 False False
"""
# 此时我们就看到端倪了，对于DataFrame对象来讲，isin是判断对应索引的字段的值是否相同
但是问题又来了，因为这样显然不是我们期望的结果。因为即使df2中存在，但如果索引对不上的话也没有任何意义，因此我们可以手动设置索引。
import pandas as pd
df1 = pd.DataFrame({"x": ["a", "b", "c", "d"], "y": [1, 2, 3, 4]})
df2 = pd.DataFrame({"x": ["a", "b", "d", "c"], "y": [1, 2, 4, 3]})
# 我们将x和y设置为索引不就行了，加上drop=False表示设置索引的同时，还作为列
df1 = df1.set_index(["x", "y"], drop=False)
df2 = df2.set_index(["x", "y"], drop=False)
print(df1)
"""
x y
x y
a 1 a 1
b 2 b 2
c 3 c 3
d 4 d 4
"""
print(df2)
"""
x y
x y
a 1 a 1
b 2 b 2
d 4 d 4
c 3 c 3
"""
print(df1.isin(df2))
"""
x y
x y
a 1 True True
b 2 True True
c 3 True True
d 4 True True
"""
# 在通过all(axis=1)即可找到满足条件的值
print(df1.isin(df2).all(axis=1).values) # [ True True True True]
# 我们看到此时根据索引去找，就能够准确的定位了
# 不过细心的人可能已经发现了，这个索引是由x和y两列得到的，事实上索引如果匹配上了，那么值一定是相等的
# 所以此时就没必要在进行对比了
# 是的，所以我们可以换一种方法
df1 = pd.DataFrame({"x": ["a", "b", "c", "d"], "y": [1, 2, 3, 4]})
df2 = pd.DataFrame({"x": ["a", "b", "d", "c"], "y": [1, 2, 4, 3]})
# pandas中有一个Index类，Series和DataFrame的索引就是Index类型
# 当然Index分为好几种，但是它们继承自Index
print(type(df1.index)) # <class 'pandas.core.indexes.range.RangeIndex'>
# 根据x和y两列创建Index对象
index1 = pd.Index(df1[["x", "y"]])
index2 = pd.Index(df2[["x", "y"]])
print(index1) # Index([('a', 1), ('b', 2), ('c', 3), ('d', 4)], dtype='object')
print(index2) # Index([('a', 1), ('b', 2), ('d', 4), ('c', 3)], dtype='object')
# Index对象可以像集合一样，取并集、交集，当然此时我们可以直接使用isin
# 因为它们整体变成了一个元组，也就是说，此时是一个一维序列，对于一维序列可以直接使用isin
# 直接返回一个numpy中的array
print(index1.isin(index2)) # [ True True True True]
然而这么做有一个弊端，没错，我要复现我们上面的异常了
import pandas as pd
df1 = pd.DataFrame({"x": ["a", "b", "c", "d"], "y": [1, 2, 3, 4]})
df2 = pd.DataFrame({"x": ["a", "a", "c", "d"], "y": [1, 1, 3, 4]})
# 我们将x和y设置为索引不就行了，加上drop=False表示设置索引的同时，还作为列
df1 = df1.set_index(["x", "y"], drop=False)
df2 = df2.set_index(["x", "y"], drop=False)
try:
print(df1.isin(df2))
except Exception as e:
print(e) # cannot compute isin with a duplicate axis.
# 我们对一个DataFrame使用isin，那么要求isin里面的DataFrame的索引是不可以重复的，否则就会报出上面这个错误
# 解决办法是使用pd.Index
print(pd.Index(df1[["x", "y"]]).isin(pd.Index(df2[["x", "y"]]))) # [ True False True True]
# 然鹅，我记得pd.Index这种做法也不保险
# 由于索引的特殊性，好像这种情况我记得也报错，但是目前没有
# 因此最稳妥的办法是再转成Series
s1 = pd.Series(pd.Index(df1[["x", "y"]]))
s2 = pd.Series(pd.Index(df2[["x", "y"]]))
print(s1)
"""
0 (a, 1)
1 (b, 2)
2 (c, 3)
3 (d, 4)
dtype: object
"""
print(s2)
"""
0 (a, 1)
1 (a, 1)
2 (c, 3)
3 (d, 4)
dtype: object
"""
print(s1.isin(s2))
"""
0 True
1 False
2 True
3 True
dtype: bool
"""
# 这种做法是百分之百没有问题的
# 忘记说了，df1.isin(df2)的时候，两个列的名称一定要对应
df1 = pd.DataFrame({"x": ["a", "b", "c", "d"], "y": [1, 2, 3, 4]})
df2 = pd.DataFrame({"a": ["a", "a", "c", "d"], "y": [1, 1, 3, 4]})
print(df1.isin(df2))
"""
x y
0 False True
1 False False
2 False True
3 False True
"""
# 由于df2中没有x这一列，因此相当于NaN,所以结果为False
print(df1[["y"]].isin(df2))
"""
y
0 True
1 False
2 True
3 True
"""
# 会自动找df2中名称为y的列进行比较，因此记得注意列名
# 当然由于df1.isin(df2)在索引方面的局限性，我们一般也不会使用这种方法
# 而是会将DataFrame的每一个字段的值拼接成一个元组，整体得到一个Series对象
# 然后对Series对象使用isin，这是最正确的做法
7. ValueError: cannot set a frame with no defined index and a scalar
这个错误不是很常见，我们来看一下。
import pandas as pd
df = pd.DataFrame({"a": [1, 1, 1, 1], "b": [1, 1, 1, 1]})
df.loc[df["a"] > 2, "c"] = 1
print(df)
"""
a b c
0 1 1 NaN
1 1 1 NaN
2 1 1 NaN
3 1 1 NaN
"""
我们将df["a"] > 2的记录选出来，然后同时创建"c"这一列，并设置对应的记录为1。如果不满足条件，那么会自动为NaN，而我们没有满足条件的记录，所以全部为NaN
import pandas as pd
df = pd.DataFrame({"a": [1, 1, 1, 1], "b": [1, 1, 1, 1]})
df.loc[:, "c"] = 1
print(df)
"""
a b c
0 1 1 1
1 1 1 1
2 1 1 1
3 1 1 1
"""
上面这种赋值方式也是可以的，我们之前说，对于一维序列，df["xx"]等价于df.loc[:, "xx"]，但实际上还是有点区别的，那就是后者要求DataFrame不可以为空
import pandas as pd
df = pd.DataFrame({"a": [], "b": []})
print(df)
"""
Empty DataFrame
Columns: [a, b]
Index: []
"""
try:
df.loc[:, "c"] = 1
except Exception as e:
print(e) # cannot set a frame with no defined index and a scalar
# 空DataFrame的话，只能用df["c"] = 1的方式
df["c"] = 1
print(df)
"""
Empty DataFrame
Columns: [a, b, c]
Index: []
"""
8. ValueError: If using all scalar values, you must pass an index
这个错误应该遇见的比较少，我们看看这种错误是怎么发生的。
import pandas as pd
# 我们说通过字典构建DataFrame，value应该是序列，不应该是一个标量
try:
df = pd.DataFrame({"a": 123, "b": None})
except Exception as e:
print(e) # If using all scalar values, you must pass an index
# 如果传递标量的话，那么应该同时指定一个index, index是只有一个元素的列表，里面是一个索引
df = pd.DataFrame({"a": 123, "b": None}, index=["索引"])
print(df)
"""
a b
索引 123 None
"""
有待发掘。。。。
支付宝扫一扫
微信扫一扫
