传递的索引是轴标签列表。因此，根据数据的不同，这可分为几种情况：

In [42]:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

来自ndarray

如果data是ndarray，则索引的长度必须与数据的长度相同。如果没有传递索引，将创建一个具有值的索引。[0, ..., len(data) - 1]

s = pd.Series(data, index=index) 在这里，data可以有很多不同的东西：

一个Python字典

一个ndarray

标量值（如5）

传递的索引是轴标签列表。

In [43]:

s = pd.Series(np.random.randn(5),index=['a', 'b', 'c', 'd', 'e'])
s

Out[43]:

a    0.752638
b    0.677576
c    0.070753
d   -1.030516
e    0.030880
dtype: float64

In [44]:

s.index

Out[44]:

Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

In [45]:

pd.Series(np.random.randn(5))

Out[45]:

0   -0.342847
1    0.595423
2   -0.287877
3   -0.742966
4   -0.738780
dtype: float64

从dict

注意当数据是dict，并且未传递Series索引时，如果您使用的是Python版本> = 3.6且Pandas版本> = 0.23 ，则索引将按dict的插入顺序排序。

如果您使用的是Python <3.6或Pandas <0.23，并且未传递Series索引，则索引将是词汇顺序的dict键列表。

In [89]:

d = {'b' : 1, 'a' : 0, 'c' : 2}
pd.Series(d).index

Out[89]:

Index(['a', 'b', 'c'], dtype='object')

In [87]:

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

Out[87]:

a    0.0
b    1.0
c    2.0
dtype: float64

如果传递索引，则将拉出与索引中的标签对应的数据中的值。空余的为NaN

In [48]:

pd.Series(d,index=['b', 'c', 'd', 'a'])

Out[48]:

b    1.0
c    2.0
d    NaN
a    0.0
dtype: float64

从标量值，如果data是标量值，则必须提供索引。将重复该值以匹配索引的长度。

In [49]:

pd.Series(5, index=['a', 'b', 'c', 'd', 'e'])

Out[49]:

a    5
b    5
c    5
d    5
e    5
dtype: int64

In [50]:

pd.Series([5.,3.,5.,3.,2], index=['a', 'b', 'c', 'd', 'e'])

Out[50]:

a    5.0
b    3.0
c    5.0
d    3.0
e    2.0
dtype: float64

Series行为与a非常相似ndarray，并且是大多数NumPy函数的有效参数。但是，切片等操作也会对索引进行切片。

In [51]:

Out[51]:

a    0.752638
b    0.677576
c    0.070753
d   -1.030516
e    0.030880
dtype: float64

In [52]:

s[0]

Out[52]:

0.75263790197081093

In [53]:

s[:3]

Out[53]:

a    0.752638
b    0.677576
c    0.070753
dtype: float64

In [54]:

s[s>s.median()]

Out[54]:

a    0.752638
b    0.677576
dtype: float64

In [55]:

s[[4, 3, 1]]

Out[55]:

e    0.030880
d   -1.030516
b    0.677576
dtype: float64

In [56]:

np.exp(s)

Out[56]:

a    2.122592
b    1.969099
c    1.073316
d    0.356823
e    1.031362
dtype: float64

Series类似于固定大小的dict，您可以通过索引标签获取和设置值

In [57]:

s['a']

Out[57]:

0.75263790197081093

In [58]:

s['e']

Out[58]:

0.030879785155672308

In [59]:

Out[59]:

a    0.752638
b    0.677576
c    0.070753
d   -1.030516
e    0.030880
dtype: float64

In [61]:

'e' in s

Out[61]:

True

In [62]:

'f' in s

Out[62]:

False

In [64]:

# 如果未包含标签，则会引发异常：
#s['f']

使用该get方法，缺少的标签将返回None或指定的默认值：

In [65]:

s.get('f')

In [66]:

s.get('f', np.nan)

Out[66]:

nan

使用Series¶进行矢量化操作和标签对齐

使用原始NumPy数组时，通常不需要循环使用value-by-value。

在pandas中使用Series时也是如此。系列也可以传递到大多数期待ndarray的NumPy方法。

In [72]:

Out[72]:

a    0.752638
b    0.677576
c    0.070753
d   -1.030516
e    0.030880
dtype: float64

In [69]:

s+s

Out[69]:

a    1.505276
b    1.355152
c    0.141507
d   -2.061032
e    0.061760
dtype: float64

In [70]:

s*2

Out[70]:

a    1.505276
b    1.355152
c    0.141507
d   -2.061032
e    0.061760
dtype: float64

In [71]:

np.exp(s)

Out[71]:

a    2.122592
b    1.969099
c    1.073316
d    0.356823
e    1.031362
dtype: float64

Series和ndarray之间的主要区别在于Series之间的操作会根据标签自动对齐数据。

因此，您可以在不考虑所涉及的系列是否具有相同标签的情况下编写计算。

In [77]:

s[1:]

Out[77]:

b    0.677576
c    0.070753
d   -1.030516
e    0.030880
dtype: float64

In [78]:

s[:-1]

Out[78]:

a    0.752638
b    0.677576
c    0.070753
d   -1.030516
dtype: float64

未对齐Series之间的操作结果将包含所涉及的索引的并集。

如果在一个系列或另一个系列中找不到标签，则结果将标记为缺失NaN。

In [79]:

s[1:]+s[:-1]

Out[79]:

a         NaN
b    1.355152
c    0.141507
d   -2.061032
e         NaN
dtype: float64

Series也可以有一个name属性：

name在许多情况下，Series将自动分配，特别是在拍摄一维DataFrame时，如下所示。

In [84]:

s = pd.Series(np.random.randn(5), name='something')
s

Out[84]:

0    0.070190
1    2.264641
2    0.416647
3   -1.156442
4   -0.259729
Name: something, dtype: float64

In [85]:

s.name

Out[85]:

'something'

版本0.18.0中的新功能。

您可以使用该pandas.Series.rename()方法重命名Series 。

In [86]:

s2 = s.rename("different")
s2

Out[86]:

0    0.070190
1    2.264641
2    0.416647
3   -1.156442
4   -0.259729
Name: different, dtype: float64

DataFrame是一个二维标记数据结构，具有可能不同类型的列。

您可以将其视为电子表格或SQL表，或Series对象的字典。

它通常是最常用的pandas对象。与Series类似，DataFrame接受许多不同类型的输入：

1D ndarray，list，dicts或Series的Dict

二维numpy.ndarray

结构化或记录 ndarray

一个 Series

另一个 DataFrame

除了数据，您还可以选择传递索引（行标签）和列（列标签）参数。

1、从Series或词典的词典

得到的指数将是工会的各种系列的指标。如果有任何嵌套的dicts，这些将首先转换为Series。

如果没有传递列，则列将是dict键的有序列表。

In [96]:

d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c'])}
df = pd.DataFrame(d)
df

Out[96]:

	one
a	1.0
b	2.0
c	3.0

In [97]:

d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}

In [98]:

df = pd.DataFrame(d)
df

Out[98]:

	one	two
a	1.0	1.0
b	2.0	2.0
c	3.0	3.0
d	NaN	4.0

In [99]:

pd.DataFrame(d, index=['d', 'b', 'a'])

Out[99]:

	one	two
d	NaN	4.0
b	2.0	2.0
a	1.0	1.0

In [100]:

pd.DataFrame(d, index=['d', 'b', 'a'],columns=['two','three'])

Out[100]:

	two	three
d	4.0	NaN
b	2.0	NaN
a	1.0	NaN

通过访问索引和列属性，可以分别访问行和列标签：

注意当一组特定的列与数据的dict一起传递时，传递的列将覆盖dict中的键。

In [102]:

df.index

Out[102]:

Index(['a', 'b', 'c', 'd'], dtype='object')

In [103]:

df.columns

Out[103]:

Index(['one', 'two'], dtype='object')

从ndarrays / lists的字典

ndarrays必须都是相同的长度。如果传递索引，则它必须明显与数组的长度相同。

如果没有传递索引，结果将是range(n)，n数组长度在哪里。

In [105]:

d = {'one' : [1., 2., 3., 4.],
      'two' : [4., 3., 2., 1.]}

In [106]:

pd.DataFrame(d)

Out[106]:

	one	two
0	1.0	4.0
1	2.0	3.0
2	3.0	2.0
3	4.0	1.0

In [107]:

pd.DataFrame(d,index=['a', 'b', 'c', 'd'])

Out[107]:

	one	two
a	1.0	4.0
b	2.0	3.0
c	3.0	2.0
d	4.0	1.0

从结构化或记录数组

这种情况的处理方式与数组的字典相同。

In [117]:

data = np.zeros((2,))
data

Out[117]:

array([ 0.,  0.])

In [118]:

data = np.zeros((2,),dtype=[('A','i4'),('B', 'f4'),('C', 'a10')])
data

Out[118]:

array([(0,  0., b''), (0,  0., b'')],
      dtype=[('A', '<i4'), ('B', '<f4'), ('C', 'S10')])

In [124]:

data = [(1,2,'Hello'),(2,3,'World')]
data

Out[124]:

[(1, 2, 'Hello'), (2, 3, 'World')]

In [120]:

pd.DataFrame(data)

Out[120]:

	0	1	2
0	1	2	Hello
1	2	3	World

In [126]:

pd.DataFrame(data,index=['first','second'],columns=['C', 'A', 'B'])

Out[126]:

	C	A	B
first	1	2	Hello
second	2	3	World

In [125]:

pd.DataFrame(data, columns=['C', 'A', 'B'])

Out[125]:

	C	A	B
0	1	2	Hello
1	2	3	World

从dicts列表

In [129]:

data2 = [{'a': 1, 'b': 2}]
pd.Series(data2)

Out[129]:

0    {'a': 1, 'b': 2}
dtype: object

In [130]:

data2 = [{'a': 1, 'b': 2}]
pd.DataFrame(data2)

Out[130]:

	a	b
0	1	2

In [131]:

data2 = [{'a': 1, 'b': 2}, 
         {'a': 5, 'b': 10, 'c': 20}]
pd.DataFrame(data2)

Out[131]:

	a	b	c
0	1	2	NaN
1	5	10	20.0

行标签必须与行数相等，列标签可以不等，也可以不存在，不存在了所在列全部补充NaN

In [134]:

pd.DataFrame(data2, index=['first', 'second'])

Out[134]:

	a	b	c
first	1	2	NaN
second	5	10	20.0

In [137]:

pd.DataFrame(data2, columns=['a', 'e'])

Out[137]:

	a	e
0	1	NaN
1	5	NaN

从元组的词典，您可以通过传递元组字典自动创建多索引框架

In [139]:

pd.DataFrame({('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2}})

Out[139]:

		a
		b
A	B	1
A	C	2

In [138]:

pd.DataFrame({('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2},
     ('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4},
     ('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6},
     ('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8},
     ('b', 'b'): {('A', 'D'): 9, ('A', 'B'): 10}})

Out[138]:

		a			b
		a	b	c	a	b
A	B	4.0	1.0	5.0	8.0	10.0
	C	3.0	2.0	6.0	7.0	NaN
	D	NaN	NaN	NaN	NaN	9.0

从Series

结果将是一个与输入Series具有相同索引的DataFrame，以及一个列，

其名称是Series的原始名称（仅当没有提供其他列名时）。

日期时间

对于datetime64 [ns]类型，NaT表示缺少的值。这是一个伪本机标记值，可以由单个dtype（datetime64 [ns]）中的NumPy表示。

pandas对象提供NaT和之间的互操作性NaN。

官方练习 Pandas 数据结构简介 Series VS DataFrame

传递的索引是轴标签列表。因此，根据数据的不同，这可分为几种情况：

DataFrame是一个二维标记数据结构，具有可能不同类型的列。

猜你喜欢