5e

pandas中的那些让⼈有点懵逼的异常（坑向）

楔⼦

pandas是⼀个很强⼤的库，但是在使⽤的过程中难免会遇见各种奇葩的异常，⽽这些异常却⼜很难让⼈定位到底是哪⼀步出

了问题。下⾯就来看看pandas中的⼀些令⼈感到费解的异常吧，看看你有没有遇到过，如果没有的话，那么说明你pandas

可能⽤的不够多哦。

ヽ(￣￣(￣￣〃)ゝ⼀起来看看

gWithCopyWarning:

当然这不是个异常，⽽是⼀个警告，这个警告相信⼤多数⼈都遇到过，尤其是初学pandas的时候。这个警告具体内容如下：

1SettingWithCopyWarning:

2AvalueistryingtobetonacopyofaslicefromaDataFrame.

[row_indexer,col_indexer]=valueinstead

4

5Seethecaveatsinthedocumentation:/pandas-docs/......

我们来复现⼀下这个警告：

1importpandasaspd

2

3df=ame({"name":["mashiro","koishi","satori","kurisu"],

4"age":[17,16,17,19],

5"adult":[None,None,None,None]})

6

7print(df)

8"""

9nameageadult

100mashiro17None

111koishi16None

122satori17None

133kurisu19None

14"""

15#我现在想将df中age>18对应的audit设置为True

16

17#但是会发现没有效果，并且SettingWithCopyWarning就是由这⼀⾏代码引发的

18df[df["age"]>16]["adult"]=True

19print(df)

20"""

21nameageadult

220mashiro17None

231koishi16None

242satori17None

253kurisu19None

26"""

为什么会出现这个原因呢？因为df[df["age"]>16]得到的是原始DataFrame的⼀份拷贝，因此其相应的操作不会影响原来的

DataFrame。尽管这样的操作是允许的，但是却⽆法得到正确的结果，因此pandas弹出了⼀个警告。

1#真正的做法是使⽤loc或者iloc

[df["age"]>18,"adult"]=True

3print(df)

4"""

5nameageadult

60mashiro17None

71koishi16None

82satori17None

93kurisu19None

10"""

ror:'Series'objectsaremutable,thustheycannotbehashed

这个异常实际上⽐较常见了，说⽩了就是你不⼩⼼把loc或者iloc给丢掉了，我们还⽤上⾯的例⼦

1try:

2df[df["age"]>18,"adult"]=True

3exceptExceptiona:

4print(e)#'Series'objectsaremutable,thustheycannotbehashed

rror:,(),(),()()

我们知道，像ifa:，nota之类的，本质上都是调⽤a的__bool__⽅法，可以理解为bool(a)

1classA:

2

3def__bool__(lf):

4returnTrue

5

6

7ifA():

8print("123")

9el:

10print("456")

11print(bool(A()))

12"""

13123

14True

15"""

16

17

18#由于A的__bool__返回了True,所以bool(A())为True

19#我们将其改为Fal

20A.__bool__=lambdalf:Fal

21print(bool(A()))#Fal

但是对于⼀个Series或者numpy中的array不可以这么做。

1importpandasaspd

2

3s=([True,Fal])

4try:

5bool(s)

6exceptExceptiona:

7print(e)#,(),(),()().

8

9try:

1

0

:#得到⼀个numpy中的array

1

1

pass

1

2

exceptExceptiona:

1

3

print(e)#()()

1

4

1

5

1

6

"""

1

7

对于⼀个Series对象来说，不可以使⽤其布尔值，应当使⽤()、()或者(s)、(s)

1

8

1

9

但是对于numpy中的array来讲，如果这个array⾥⾯的元素不⽌⼀个，那么也不可以使⽤其布尔值，但如果该array中只有⼀个元素的话

是个例外

2

0

此时：([123])等价于if123

2

1

2

2

因此如果使⽤其布尔值的话，最好使⽤()或者()将⼀个序列变成单个布尔值

2

3

"""

2

4

2

5

#但如果只是希望像列表⼀样，如果该Series对象⾥⾯有值就是真，否则就是假

2

6

#那么建议通过iflen(s):这种⽅式来判断

2

7

#同理DataFrame也是如此

4.布尔你咋啦？

我们知道，可以对两个类型为bool的Series对象进⾏与、或、⾮等操作，但是结果真的⼀定是我们想要的吗？

1importpandasaspd

2

3s1=([True,True,True])

4s2=([True,Fal,True],index=[1,2,3])

5

6print(s1&s2)

7"""

80Fal

91True

102Fal

113Fal

12dtype:bool

13"""

14#我们看到与运算之后，长度变成了4，究其原因就是两个Series索引不同造成的

15#⽽Series的很多操作都是基于索引进⾏对齐的，并不是简简单单地按照顺序

16#但如果对应的索引⼀样的话，那么也可以认为就是按照顺序从上到下

17#但如果索引不⼀样的话，pandas是怎么做的呢？答案是使⽤reindex

18

19#⾸先找到两个Series对象中出现的所有不重复索引

20index=|

21print(index)#Int64Index([0,1,2,3],dtype='int64')

22

23#使⽤reindex进⾏对齐,不存在的使⽤NaN代替，当然我们也可以指定fill_value进⾏填充

24#⽐如fill_value=Fal

25print(x(index))

26"""

270True

281True

292True

303NaN

31dtype:object

32"""

33print(x(index))

34"""

350NaN

361True

372Fal

383True

39dtype:object

40"""

41

42#所以s1&s2最终等价于x(index)&x(index)

43#因此即使两者个数不同也是没有问题的

44s1=([True,True,True,True])

45s2=([True,True,True],index=[1,2,3])

46print(s1&s2)

47"""

480Fal

491True

502True

513True

52dtype:bool

53"""

总之pandas中很多操作，并不是我们想的那么简单，pandas的Series和DataFrame都具备索引的概念，通过索引来定位速度

是⾮常快的。但是不注意就会造成陷阱，究其原因就是很多操作在定位的时候是基于索引来定位的，并不是简单的按照顺

序。⽐如：s1&s2，指的是s1和s2中相同索引对应的元素进⾏与运算，当然如果有对应不上的，事先已经通过reindex处理

好了。

当然，如果我们不希望考虑索引的话，只是单纯的希望按照顺序进⾏位运算，该怎么做呢？办法有两种

1importpandasaspd

2

3s1=([True,True,True])

4s2=([True,Fal,True],index=[1,2,3])

5

6#对Series使⽤ret_index即可，当然要指定drop=True，否则就变成DataFrame了

7#⼀旦ret_index之后两者索引从头到尾就是⼀致的了

8print(_index(drop=True)&_index(drop=True))

9"""

100True

111Fal

122True

13dtype:bool

14"""

15

16#或者转成numpy中的array

17#我们知道Series等价于numpy中的n个array，分别存放索引、值等等

18#我们调⽤即可拿到索引，即可拿到值

19print(&s2)

20"""

211True

222Fal

233True

24dtype:bool

25"""

26#如果其中是⼀个array的话，那么它没有索引的概念，索引此时也是单纯的⼀个⼀个对应进⾏运算

27#当然得到的结果也是⼀个Series，索引和运算的Series的索引保持⼀致

28

29#或者都转成array

30print(&)#[TrueFalTrue]

31

32#但是注意：如果其中⼀⽅转成了array，那么此时就要求两个序列的布尔元素个数是必须相等的

33#此时就不会再通过reindex进⾏扩展了，因为array没有reindex

34#当然都转成array就更不⽤说了

我们说了很多关于索引的话题，之所以强调这⼀点，是因为这⾥⾯存在⼀个坑点。我们知道对于DataFrame对象来说，通过

df[xxx]可以取得相应的数据，xxx的⾝份不同，取得的数据也不同

如果xxx是⼀个标量,那么df[xxx]表⽰获取df的某⼀列，得到⼀个Series对象

如果xxx是⼀个列表或者numpy的narray,那么xxx⾥⾯可以是该DataFrame对象的列名，表⽰获取指定的多个列，得到

DataFrame对象

如果xxx是⼀个列表或者numpy的narray，那么这个xxx⾥⾯还可以是布尔值，并且其长度要和该DataFrame对象的⾏数相

等，表⽰获取对应的⾏数。对应为True的保留，为Fal的不要，也是得到DataFrame对象

举个栗⼦

1importpandasaspd

2

3df=ame({"a":[1,2,3],"b":[11,22,33]})

4

5

6#只有第⼀个为True，因此被保留了下来

7print(df[[True,Fal,Fal]])

8"""

9ab

100111

11"""

12

13try:

14#但此时指定的4个布尔值

15print(df[[True,Fal,Fal,Fal]])

16exceptExceptiona:

17print(e)#Itemwronglength4insteadof3.

18"""

19告诉我们个数不匹配

20所以上⾯之所以说了索引，就是因为在做运算的的时候可能导致布尔值的个数最终和DataFrame的⾏数不匹配

21从⽽在筛选指定记录的时候发⽣报错

22"""

如果是Series也是可以的

1importpandasaspd

2

3df=ame({"a":[1,2,3],"b":[11,22,33]})

4

5flag=([True,Fal,Fal])

6print(df[flag])

7"""

8ab

90111

10"""

11#当然⾥⾯也可以是⼀个Series，当然这个Series不仅个数要匹配，索引也要匹配

12#我们知道df的索引是012，那么该flag的索引也必须是012给未来的自己写一封信 (但是顺序不要求)

=[1,2,3]

14try:

15df[flag]

16exceptExceptiona:

17print(e)

18#UnalignablebooleanSeriesprovidedasindexer(indexofthebooleanSeriesandoftheindexedobjectdonotmatch).

19

20

21"""

22我们看到报了上⾯那个错误，意思我们传递了bool类型的Series对象，但是其索引和DataFrame的索引不匹配

23"""

24

25#我们再改⼀下

=[1,2,0]

27print(flag)

28"""

291True

302Fal

310Fal

32dtype:bool

33"""

34print(df[flag])

35"""

36ab

371222

38"""

39#我们看到此时布尔值True对应的索引为1，那么筛选的就不再是df中的第⼀⾏了

40#⽽是索引为1的⾏，也就是第⼆⾏。

41#因此尽管对Series的索引的值有要求，但是对顺序却并没有要求

42#所以这种情况下，筛选出来的数据可能就和我们想象的不⼀样，明明第⼀个是True，为啥却把DataFrame的第⼆⾏选出来了

43#原因就是，虽然第⼀个是True，但是它对应的索引是1

因此索引这个东西在定位数据的时候，会⾮常⽅便，因为我们可以直接通过索引去定位。但是在⼀些操作⽅⾯，我们关⼼的

并不是它的索引，⽽是它的值，⽐如：s1&s2，或者df[flag]，这个时候我们只是对内部的布尔值感兴趣，那么直接把s1、

s2、flag这些变成numpy中的array之后，再去传递即可。此时就⽆需考虑索引啥的了。

5.怎么给DataFrame添加字段呢？

给⼀个DataFrame添加⼀个字段，并附上初始值有以下⼏种⽅式。

1importpandasaspd

2

3df=ame({"a":[1,2,3],"b":[11,22,33]})

4

5#可以给⼀个标量，然后会⾃动进⾏⼴播

6df["c"]="xx"

7

8#也可以是⼀个列表，如果⾥⾯只有⼀个元素，那么和标量是等价的

9df["d"]="yy"

10print(df)

11"""

12abcd

130111xxyy

141222xxyy

152333xxyy

16"""

17

18#如果是列表⾥⾯有多个值，那么个数必须和df的⾏数匹配

19#否则会报出ValueError:Lengthofvaluesdoesnotmatchlengthofindex

20df["e"]=["x","y","z"]

21print(df)

22"""

23abcde

240111xxyyx

251222xxyyy

262333xxyyz

27"""

28

29#还有⼀种办法是通过，这种办法可以同时创建多个列

30df=df[["a","b"]]

31df=(

32#这⾥指定接收⼀个参数的函数，这个参数就是整个df

33#通过关键字参数，那么参数名就是列名

34c=lambdax:x["a"]+1,

35d=lambdax:x["b"]*2,

36e=lambdax:["i","j","k"],

37f=lambdax:"哼哼"

38)

39print(df)

40"""

41abcdef

420111222i哼哼

431222344j哼哼

442333466k哼哼

45"""

给⼀个DataFrame添加⼀个字段，同样存在索引的陷阱

1importpandasaspd

2

3df=ame({"a":[1,2,3],"b":[11,22,33]})

4

5df["c"]=(["x","y","z"],index=[0,2,3])

6print(df)

7"""

8abc

90111x

101222NaN

112333y

12"""

原因⽆需我再多解释，总⽽⾔之就是我们刚才说的那样，如果我们只关⼼值，不关⼼索引，那么就不要传递Series对象，直

接传递numpy中的array或者列表即可，这样我们就根本不需要考虑索引对齐的问题。

传递⼀个⼀维序列是可以的，那么传递⼀个DataFrame对象会浓妆淡抹 如何呢？

1importpandasaspd

2

3df=ame({"a":[1,2,3],"b":[11,22,33]})

4df1=ame({"x":["aa",22,None],"y":[">>","^^","YY"]})

5

6try:

7#因为df1有两个字段，这⾥我们只指定了⼀个

8df["c"]=df1

9exceptExceptiona:

10print(e)#Wrongnumberofitemspasd2,placementimplies1

11

12#我们知道df1["x"]是个Series，所以df["c"]=df1["x"]肯定没有错

13#但是df["c"]景物描写200字 =df1[["x"]]呢？df1[["x"]]显然是个DataFrame

14df["c"]=df1[["x"]]

15print(df)

16"""

17abc

180111aa

19122222

202333None

21"""

22#可以看到，如果DataFrame只有⼀个字段，那么等价于Series

23

24

25#最后，df["xx"]=xx这种⽅式,在xx是⼀维序列的前提下完全等价于[:,"xx"]=xx

26#但如果xx是⼀个DataFrame的话就不⼀样了

27df=ame({"a":[1,2,3],"b":[11,22,33]})

28df1=ame({"x":["aa",22,None],"y":[">>","^^","YY"]})

29

[:,"c"]=df1

31print(df)

32"""

33abc

340111NaN

351222NaN

362333NaN

37"""

38#我们惊奇地发现它居然没有报错，但结果却是NaN

39#我们rename⼀下

40df1=(columns={"y":"c"})

[:,"c"]=df1

42print(df)

43"""

44abc

450111>>

461222^^

472333YY

48"""

49#因此我们发现在使⽤[:,"xx"]=df1的时候

50#会⾃动去找df1中列名为"xx"的列，如果找不到就为NaN

如果给DataFrame添加多个字段的话，除了assign之外，还有什么办法呢？

1importpandasaspd

2

3df=ame({"a":[酒精灯怎么灭 1,2,3],"b":[11,22,33]})

4df1=ame({"x":["aa",22,None],"y":[">>","^^","YY"]})

5

6df[["c","d"]]=df1

7print(df)

8"""

9abcd

100111aa>>

11122222^^

122333NoneYY

13"""

14#这⾥可以要求列名不⼀致，但是个数必须要匹配

15

16

17df=ame({"a":[1,2,3],"b":[11,22,33]})

18df1=ame({"x":["aa",22,None],"y":[">>","^^","YY"]})

19#但是对于loc来说，⽆法添加多个字段

20#添加⼀个字段是可以的，但是多个不⾏

21try:

[:,["c","d"]]=df1

23exceptExceptiona:

24#loc表⽰筛选，⽽df的列中没有"c"和"d"

25#即使是[:,["c"]]也不可以，但是[:,"c"]是可以的

26print(e)#"Noneof[Index(['c','d'],dtype='object')]areinthe[columns]"

27

28#所以df[["c","d"]]=df1，如果列c、d不存在，那么会⾃动添加

29#但是对于[:,["c","d"]]=df1，如果c、d不存在，则报错，注意：不是都不存在，⽽是只要有⼀个不存在就报错

30#如果是指定了不存在的索引，暂时不会报错，⽽是弹出⼀个警告

31print([[1,11]])

32"""

33ab

3412.022.0

3511NaNNaN

36"""

37#我们看到指定了不存在的索引，那么⾃动为NaN

38#但同时会抛出⼀个FutureWarning:

39"""

[]withanymissinglabelwillrai

41KeyErrorinthefuture,x()asanalternative.

42"""

43#意思是让我们先reindex⼀下

所以如果想添加多个字段，可以直接通过df[["c1","c2"]]=df1的⽅式，但是注意：右边写的df1，所以右边需要也是⼀个

DataFrame，并且两者列数相等

1importpandasaspd

2

3df=ame({"a":[1,2,3],"b":[11,22,33]})

4df1=ame({"x":["aa",22,None],"y":[">>","^^","YY"]})

5

6#这⾥我们本意是想创建两个字段，值都为None

7#但是很遗憾这样不可以

8try:

9#右边的值也古代节日 需要是⼀个DataFrame

10df[["c","d"]]=None

11exceptExceptiona:

12#我们看到这⾥也同样报出了相应的错误

13#因此只有当右边的值是DataFrame的时候，df[["c","d"]]才能具备创建新字段的能⼒

14print(e)#"Noneof[Index(['c','d'],dtype='object')]areinthe[columns]"

15

16#如果想创建多个新字段，并且还希望通过⼴播的⽅式赋上同⼀个值，那么上⾯做法是⾏不通的

17#解决办法是⼀个字段⼀个字段的创建，这样百分之百是没有任何问题的，既可以df["c"]也可以[:,"c"]

18#但是也可以通过我们之前说的assign

19df=(

20c=lambdax:None,

21d=lambdax:None,

22)

23print(df)

24"""

25abcd

260111NoneNone

271222NoneNone

282333NoneNone

29"""

30

31#除此之外，还有⼀个inrt⽅法

32#这个⽅法接收：插⼊的位置、列名、值

33#⽐如我想在列c的后⾯插⼊⼀个新列age，值全部是18，该怎么做呢？

(_loc("c")+1,"age",18)

35print(df)

36"""

37abcaged

380111None18None

391222None18None

402333None18None

41"""

42#我们看到inrt这个⽅法是在本地进⾏操作的

43#关键是第⼀个参数，我们希望插在c的后⾯，那么就必须获取c所在的索引，当然也可以直接数出来

44#通过_loc即可获取，然后再加上1即可

rror:cannotcomputeisinwithaduplicateaxis.

这个错误当初也是把我搞懵逼了半天，在复现这个异常之前，我们先来聊聊⾮常常⽤的isin

isin我们⼀般是对Series对象使⽤，判断这个序列中每⼀个元素是不是在另⼀个序列⾥⾯，下⾯举例说明：

1importpandasaspd

2

3s=(["a","b","c","d"])

4print((["a","c","e"]))

5"""

60True

71Fal

82True

93Fal

10dtype:bool

11"""

这个⽅法是我们经常使⽤的，但是你对DataFrame使⽤过isin吗？我们有时候需要判断两个序列，看这两个序列中的值是否

在另外两个序列⾥⾯。

1importpandasaspd

2

3df1=ame({"x":["a","b","c","d"健康小妙招 ],"y":[1,2,3,4]})

4df2=ame({"x":["a","B","c","D"],"y":[1,2,4,3]})

5print(df1)

6"""

7xy

80a1

91b2

102c3

113d4

12"""

13print(df2)

14"""

15xy

160a1

171B2

182c4

193D3

20"""

21print(df1[["x"]].isin(df2))

22#DataFrame中有两列，所以是两列布尔值

23"""

24xy

250TrueTrue

261FalTrue

272TrueFal

283FalFal

29"""

30#我们来分析⼀下，对于df1来说，前两⾏肯定是没有问题的

31#但是第三⾏有点诡异，earr 我们df1的第三⾏的y列是3，显然3是在df2的y列当中啊，为什么是Fal

32#同理第4⾏，"d"不在df2的x列中我们知道，但是y列的4很明显在df2的y列当中，为什么是Fal

估计有⼈猜到了，那就是对DataFrame使⽤isin的时候，多个列之间并不是独⽴的。事实上，DataFrame使⽤isin也是根据索

引来的，我们举个栗⼦

1importpandasaspd

2

3df1=ame({"x":["a","b","c","d"],"y":[1,2,3,4]})

4df2=ame({"x":["a","b","c","d"],"y":[1,2,3,4]})

5#两个⼀模⼀样的DataFrame对象

6print((df2))

7"""

8xy

90TrueTrue

101TrueTrue

112TrueTrue

123TrueTrue

13"""

14#结果没问题，但是我们将df2的索引改变⼀下

=[0,1,3,2]

16print((df2))

17"""

18xy

190TrueTrue

201TrueTrue

212FalFal

223FalFal

23"""

24#此时我们就看到端倪了，对于DataFrame对象来讲，isin是判断对应索引的字段的值是否相同

但是问题⼜来了，因为这样显然不是我们期望的结果。因为即使df2中存在，但如果索引对不上的话也没有任何意义，因此我

们可以⼿动设置索引。

1importpandasaspd

2

3df1=ame({"x":["a","b","c","d"],"y":[1,2,3,4]})

4df2=ame({"x":["a","b","d","c"],"y":[1,2,4,3]})

5

6#我们将x和y设置为索引不就⾏了，加上drop=Fal表⽰设置索引的同时，还作为列

7df1=_index(["x","y"],drop=Fal)

8df2=_index(["x","y"],drop=Fal)

9print(df1)

10"""

11xy

12xy

13a1a1

14b2b2

15c3c3

16d4d4

17"""

18print(df2)

19"""

20xy

21xy

22a1a1

23b2b2

24d4d4

25c3c3

26"""

27

28print((df2))

29"""

30xy

31xy

32a1TrueTrue

33b2TrueTrue

34c3TrueTrue

35d4TrueTrue

36"""

37#在通过all(axis=1)即可找到满⾜条件的值

38print((df2).all(axis=1).values)#[TrueTrueTrueTrue]

39

40#我们看到此时根据索引去找，就能够准确的定位了

41#不过细⼼的⼈可能已经发现了，这个索引是由x和y两列得到的，事实上索引如果匹配上了，那么值⼀定是相等的

42#所以此时就没必要在进⾏对⽐了

43#是的，所以我们可以换⼀种⽅法

44df1=ame({"x":["a","b","c","d"],"y":[1,2,3,4]})

45df2=ame({"x":["a","b","d","c"],"y":[1,2,4,3]})

46

47#pandas中有⼀个Index类，Series和DataFrame的索引就是Index类型

48#当然Index分为好⼏种，但是它们继承⾃Index

49print(type())#

50#根据x和y两列创建Index对象

51index1=(df1[["x","y"]])

52index2=(df2[["x","y"]])

53print(index1)#Index([('a',1),('b',2),('c',3),('d',4)],dtype='object')

54print(index2)#Index([('a',1),('b',2),('d',4),('c',3)],dtype='object')

55

56#Index对象可以像集合⼀样，取并集、交集，当然此时我们可以直接使⽤isin

57#因为它们整体变成了⼀个元组，也就是说，此时是⼀个⼀维序列，对于⼀维序列可以直接使⽤isin

58#直接返回⼀个numpy中的array

59print((index2))#[TrueTrueTrueTrue]

然⽽这么做有⼀个弊端，没错，我要复现我们上⾯的异常了

1importpandasaspd

2

3df1=ame({"x":["a","b","c","d"],"y":[1,2,3,4]})

4df2=ame({"x":["a","a","c","d"],"y":[1,1,3,4]})

5

6#我们将x和y设置为索引不就⾏了，加上drop=Fal表⽰设置索引的同时，还作为列

6#我们将x和y设置为索引不就⾏了，加上drop=Fal表⽰设置索引的同时，还作为列

7df1=_index(["x","y"],drop=Fal)

8df2=_index(["x","y"],drop=Fal)

9

10try:

11print((df2))

12exceptExceptiona:

13print(e)#cannotcomputeisinwithaduplicateaxis.

14

15#我们对⼀个DataFrame使⽤isin，那么要求isin⾥⾯的DataFrame的索引是不可以重复的，否则就会报出上⾯这个错误

16#解决办法是使⽤

17print((df1[["x","y"]]).isin((df2[["x","y"]])))#[TrueFalTrueTrue]

18

19#然鹅，我记得这种做法也不保险

20#由于索引的特殊性，好像这种情况我记得也报错，但是⽬前没有

21#因此最稳妥的办法是再转成Series

22s1=((df1[["x","y"]]))

23s2=((df2[["x","y"]]))

24

25print(s1)

26"""

270(a,1)

281(b,2)

292(c,3)

303(d,4)

31dtype:object

32"""

33print(s2)

34"""

350(a,1)

361(a,1)

372(c,3)

383(d,4)

39dtype:object

40"""

41print((s2))

42"""

430True

441Fal

452True

463True

47dtype:bool

48"""

49#这种做法是百分之百没有问题的

50

51

52#忘记说了，(df2)的时候，两个列的名称⼀定要对应

53df1=ame({"x":["a","b","c","d"],"y":[1,2,3,4]})

54df2=ame({"a":["a","a","c","d"],"y":[1,1,3,4]})

55print((df2))

56"""

57xy

580FalTrue

591FalFal

602FalTrue

613FalTrue

62"""

63#由于df2中没有x这⼀列，因此相当于NaN,所以结果为Fal

64print(df1[["y"]].isin(df2))

65"""

66y

670True

681Fal

692True

703True

71"""

72#会⾃动找df2中名称为y的列进⾏⽐较，因此记得注意列名

73#当然由于(df2)在索引⽅⾯的局限性，我们⼀般也不会使⽤这种⽅法

74#⽽是会将DataFrame的每⼀个字段的值拼接成⼀个元组，整体得到⼀个Series对象

74#⽽是会将DataFrame的每⼀个字段的值拼接成⼀个元组，整体得到⼀个Series对象

75#然后对Series对象使⽤isin，这是最正确的做法

rror:cannottaframewithnodefinedindexandascalar

这个错误不是很常见，我们来看⼀下。

1importpandasaspd

2

3df=ame({"a":[1,1,1,1],"b":[1,1,1,1]})

4

[df["a"]>2,"c"]=1

6print(df)

7"""

8abc

9011NaN

10111NaN

11211NaN

12311NaN

13"""

我们将df["a"]>2的记录选出来，然后同时创建"c"这⼀列，并设置对应的记录为1。如果不满⾜条件，那么会⾃动为NaN，⽽

我们没有满⾜条件的记录，所以全部为NaN

1importpandasaspd

2

3df=ame({"a":[1,1,1,1],"b":[1,1,1,1]})

4

[:,"c"]=1

6print(df)

7"""

8abc

90111

101111

112111

123111

13"""

上⾯这种赋值⽅式也是可以的，我们之前说，对于⼀维序列，df["xx"]等价于[:,"xx"]，但实际上还是有点区别的，那就

是后者要求DataFrame不可以为空

1importpandasaspd

2

3df=ame({"a":[],"b":[]})

4print(df)

5"""

6EmptyDataFrame

7Columns:[a,b]

8Index:[]

9"""

10

11try:

[:,"c"]=1

13exceptExceptiona:

14print(e)#cannottaframewithnodefinedindexandascalar

15

16#空DataFrame的话，只能⽤df["c"]=1的⽅式

17df["c"]=1

18print(df)

19"""

20EmptyDataFrame

21Columns:[a,b,c]

22Index:[]

23"""

rror:Ifusingallscalarvalues,youmustpassanindex

这个错误应该遇见的⽐较少，我们看看这种错误是怎么发⽣的。

1importpandasaspd

2

3#我们说通过字典构建DataFrame，value应该是序列，不应该是⼀个标量

4try:

5df=ame({"a":123,"b":None})

6exceptExceptiona:

7print(e)#Ifusingallscalarvalues,youmustpassanindex

8

9#如果传递标量的话，那么应该同时指定⼀个index,index是只有⼀个元素的列表，⾥⾯是⼀个索引

10df=ame({"a":123,"b":None},index=["索引"])

11print(df)

12"""

13ab

14索引123None

15"""

有待发掘。。。。