Series

Series的创建方式

用列表创建（最常用）

会自动创建一个0到N-1（N为数据的长度）的整数型索引0,1,2,3

4
1
import pandas as pd
2

3
s = pd.Series([1, 2, 3, 4])
4
print(s)

指定index(索引）

10
1
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
2
print(s)
3

4
"""
5
结果 ⬇️
6
a    10
7
b    20
8
c    30
9
dtype: int64
10
"""

用字典创建(非常常用）

1
1
s = pd.Series({'a': 1, 'b': 2, 'c': 3})

标量广播

8
1
s = pd.Series(5, index=[0, 1, 2, 3])
2
"""
3
0    5
4
1    5
5
2    5
6
3    5
7
dtype: int64
8
"""

用Numpy数组创建

4
1
import numpy as np
2

3
arr = np.array([1, 2, 3])
4
s = pd.Series(arr)

其实这种方式和列表类似，但是底层更高效。

Series常用属性

index

Series的索引对象，返回的是一个Index对象，是一个可迭代的对象，那么就可以用for 来遍历它

6
1
arrs = pd.Series([11,22,33,44,55],name="atguigu",index=["a","b","c","d","e"])
2
# print(arrs)
3
# index Series的索引对象
4
print(arrs.index)
5
for i in arrs.index:
6
    print(i)

values

Series的值，是一个ndarray数组

7
1
arrs = pd.Series([11,22,33,44,55],name="atguigu",index=["a","b","c","d","e"])
2
print(arrs.values)
3
print(type(arrs.values))
4
"""
5
[11 22 33 44 55]
6
<class 'numpy.ndarray'>
7
"""

ndim

Series的维度，永远是1，因为Series就是一维结构

2
1
arrs = pd.Series([11,22,33,44,55],name="atguigu",index=["a","b","c","d","e"])
2
print(arrs.ndim)

shape

Series的形状，永远是(n,) ，因为是一维的，类似于Numpy，用元组表示

xxxxxxxxxx
2
1
arrs = pd.Series([11,22,33,44,55],name="atguigu",index=["a","b","c","d","e"])
2
print(arrs.shape) # (5,)

size

Series的元素个数，和len()一样，有缺失值的话也统计

xxxxxxxxxx
2
1
arrs = pd.Series([11,22,33,44,55],name="atguigu",index=["a","b","c","d","e"])
2
print(arrs.size) # 5

dtype/dtypes

Series的元素类型，且Series里只能有一种dtype。在Series中，dtype和dtypes是一样的。

xxxxxxxxxx
2
1
arrs = pd.Series([11,22,33,44,55],name="atguigu",index=["a","b","c","d","e"])
2
print(arrs.dtype) # int64

name

Series的名字，在DataFrame中，就会变成列名。

xxxxxxxxxx
3
1
arrs = pd.Series([11,22,33,44,55],name="atguigu",index=["a","b","c","d","e"])
2
arrs.name = "成绩"
3
print(arrs.name) # 成绩

索引访问（重点）

loc[]

按照标签访问（也可以说是显示索引），如果是切片的话，一定记住，是两边都是闭区间。其实更像是dict 访问他的key，hhhhh

xxxxxxxxxx
4
1
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
2

3
print(s.loc['a'])      # 10
4
print(s.loc['a':'c'])  # 包含右边！

iloc[]

按照位置索引（也可以说是隐式索引），这里就和str 什么的一样了，都是左闭右开区间的，这里是和loc[] 这里不太一样的点。

xxxxxxxxxx
3
1
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
2
print(s.iloc[0])     # 10
3
print(s.iloc[0:2])   # 不包含右边

at[]

单标签访问（更快），只能取一个值，比loc更快

xxxxxxxxxx
2
1
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
2
print(s.at['a'])

iat[]

单个位置访问，比iloc[]更快

xxxxxxxxxx
2
1
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
2
print(s.iat[0])

Series常用方法

查看数据

head(n)

查看前n行，就是快速看看数据长啥样，如果不写，默认是5行

xxxxxxxxxx
10
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.head(5))
3
"""
4
a    11.0
5
b    22.0
6
c     NaN
7
d     NaN
8
e    44.0
9
dtype: float64
10
"""

tail(n)

看后n行，和head(n)类似，如果不写，默认是5行。但是也是从上往下显示的。

xxxxxxxxxx
9
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.tail(5))
3
"""
4
b    22.0
5
c     NaN
6
d     NaN
7
e    44.0
8
f    22.0
9
"""

判断&缺失值

isin() 是否在某个集合里

他会返回一个values 是 布尔类型的Series

xxxxxxxxxx
11
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.isin([11,22]))
3
"""
4
a     True
5
b     True
6
c    False
7
d    False
8
e    False
9
f     True
10
dtype: bool
11
"""

isna() 是否是缺失值

同样也是返回布尔类型的Series，来判断每一个value 是不是缺失值

xxxxxxxxxx
11
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.isna())
3
"""
4
a    False
5
b    False
6
c     True
7
d     True
8
e    False
9
f    False
10
dtype: bool
11
"""

统计计算

sum() 求和

求和，会自动忽略缺失值，有缺失值的话，都是float了

xxxxxxxxxx
2
1
s = pd.Series([1, 2, 3, 4, None])
2
print(s.sum())  # 10.0

mean() 平均值

这里除的是有效值的数目，而不是长度，所以下面例子的值应该是2.5 而不是2

xxxxxxxxxx
2
1
s = pd.Series([1, 2, 3, 4, None])
2
print(s.mean()) # 2.5

min()/max()

这里就是求最大最小值，不多赘述。

var()/std()

这里是方差和标准差，这里粘贴一个比较好的介绍：方差标准差

median()/mode()

median(): 中位数，排序，最中间的一个或者两个

mode(): 众数，这里记得，可能会返回多个值

quantile(q)

分位数，根据q去定

descrone() 一键统计

返回常见的统计信息

count/mean/std/min/25%/50%/75%/max，也是一个Series

计数/去重

value_count()

非常常用，每个值出现的次数

xxxxxxxxxx
8
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.value_counts())
3
"""
4
22.0    2
5
11.0    1
6
44.0    1
7
Name: count, dtype: int64
8
"""

count()

统计非空的数量，不包含NaN/None/...

xxxxxxxxxx
2
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.count())

drop_duplicates()

去重（保留顺序）

打印出来的还是一个去除了重复项的Series，并且，缺失值都算一种

xxxxxxxxxx
2
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.drop_duplicates())

unique()

去重，不过返回的是一个ndarray

xxxxxxxxxx
8
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.unique())
3
print(type(s.unique()))
4

5
"""
6
[11. 22. nan 44.]
7
<class 'numpy.ndarray'>
8
"""

nunique()

去重后元素的个数,不包含缺失值

xxxxxxxxxx
2
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.nunique()) #3

排序&抽样

sample()

随机抽样,返回的也是一个Series

xxxxxxxxxx
8
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.sample())
3
print(type(s.sample()))
4
"""
5
d   NaN
6
dtype: float64
7
<class 'pandas.Series'>
8
"""

sort_index()

按照索引进行排序

xxxxxxxxxx
11
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','a'])
2
print(s.sort_index())
3
"""
4
a    11.0
5
a    22.0
6
b    22.0
7
c     NaN
8
d     NaN
9
e    44.0
10
dtype: float64
11
"""

sort_values()

按照值进行排序，缺失值都在后面排着

xxxxxxxxxx
11
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.sort_values())
3
"""
4
a    11.0
5
b    22.0
6
a    22.0
7
e    44.0
8
c     NaN
9
d     NaN
10
dtype: float64
11
"""

数据处理

replace() 替换值

xxxxxxxxxx
11
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(s.replace(22,"hahahah"))
3
"""
4
a       11.0
5
b    hahahah
6
c        NaN
7
d        NaN
8
e       44.0
9
a    hahahah
10
dtype: object
11
"""

to_frame()

转DataFrame

xxxxxxxxxx
2
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
print(type(s.to_frame())) # <class 'pandas.DataFrame'>

equals()

判断两个Series是否相等，必须index 和value 都相等才行

xxxxxxxxxx
3
1
arr1 = pd.Series([1,2,3])
2
arr2 = pd.Series([1,2,3])
3
print(arr1.equals(arr2)) # True

keys()

和index属性一样的作用，返回一个Index对象，不过多赘述

遍历

和字典差不多

xxxxxxxxxx
11
1
s = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
2
for i, v in s.items():
3
    print(i,v)
4
"""
5
a 11.0
6
b 22.0
7
c nan
8
d nan
9
e 44.0
10
f 22.0
11
"""

Series的布尔索引

其实我觉得就是用True/False 去筛选数据的

条件筛选

假如我们要筛选出s中大于20的数据，那么我们的条件就应该写 s > 20

xxxxxxxxxx
9
1
s = pd.Series([10, 20, 30, 40])
2
print(s>20)
3
"""
4
0    False
5
1    False
6
2     True
7
3     True
8
dtype: bool
9
"""

返回了一个Series，然后values 是布尔类型的数据，那么我们只需要把条件，放到中括号里，就是它的基本用法了,只保留了为True的数据，也是一个Series

xxxxxxxxxx
7
1
s = pd.Series([10, 20, 30, 40])
2
print(s[s > 20])
3
"""
4
2    30
5
3    40
6
dtype: int64
7
"""

多条件筛选

其实没有什么特别大的区别，就是把条件连接起来，不能用and 或者 or，必须用 &和 |，并且必须加括号。 这里必须需要注意 ，不然就报错！！！

xxxxxxxxxx
6
1
s = pd.Series([10, 20, 30, 40])
2
print(s[(s > 20) & (s < 40)])
3
"""
4
2    30
5
dtype: int64
6
"""

Series的运算

与标量运算

xxxxxxxxxx
10
1
import pandas as pd
2

3
s = pd.Series([1, 2, 3])
4
print(s + 10)
5
"""
6
0    11
7
1    12
8
2    13
9
dtype: int64
10
"""

Series与Series运算

会根据标签索引进行对位计算，索引没有匹配上的会用NaN填充。

xxxxxxxxxx
11
1
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
2
s2 = pd.Series([4, 5, 6], index=['b', 'c', 'd'])
3

4
print(s1 + s2)
5
"""
6
a    NaN
7
b    6.0
8
c    8.0
9
d    NaN
10
dtype: float64
11
"""