基本数据结构——Series和Dataframe
目录
一、Series：
（一）创建：pandas.Series(data,index,dtype,name,copy)
1.用列表/ndarray创建：
2.用字典创建：
3.利用标量创建：
（二）索引
1.隐式索引：
2.显示索引：
3.查找、修改与切片：
（三）运算
（四）方法
1.s.head()/s.tail()
2.s.reindex(obj,fill_value)
二、Dataframe：
（一）创建
1.直接创建：pandas.DataFrame(data,index,columns,dtype,copy)
2.使用字典和列表
(1)列表嵌套
(2)列表套字典
(3)字典套列表
(4)字典嵌套
3.由 ndarray/serirs 创建：
（二）索引
1.选择列：
2.选择行：
（三）操作
1.增添、删除列和行
2.运算：
3.合并merge：
一、Series：
Series是一个一维数据结构，相当于是一组带有索引的一维数组，Python里可以将数组或字典转换成Series，Series 的数据类型可以不统一，不过日常使用一般都是统一的，否则也没什么意义，其最重要的就是 Index 与 Value 两个部分
几个主要参数：
- data：可以是列表、元组、字典、ndarray，（若为基本数据类型，可以用标量创建，指定索引）
- index：与数据的长度相同，其中对索引可以进行修改与重排等操作
- dtype：指定数据类型
- name：名称，未指定默认为None
（一）创建：pandas.Series(data,index,dtype,name,copy)
- data：数据，可以是列表、常量、数组、字典等对象
- index：若提供，索引和数据个数必须相同，
- dtype：强制设定数据类型
- name：名称
- copy：默认 False，拷贝修改时，ndarray和 series 会影响原对象（视图），其他数据类型拷贝不影响原对象
1.用列表/ndarray创建：
import pandas as pd
l=[1,1.5,['z'],'a'] # 列表，也可以是数组
obj = pd.Series(l)
print(obj)
# Series首字母大写，Python对这方面很严格，由于用惯了SQL所以出错了
0 1
1 1.5
2 [z]
3 a
dtype: object2.用字典创建：
其 Key 值作为索引
obj2 = pd.Series({'a':1,'b':2,'c':3},index=['b','c','d'])
print(obj2)
b 2.0
c 3.0
d NaN
dtype: float643.利用标量创建：
obj4=pd.Series(3,index=[1,2,3])
print(obj4)
1 3
2 3
3 3
dtype: int64
在创建Series后我们可以利用 obj.index 和 obj.values 获取Series的索引与数值（value 返回ndarray数组），并通过索引取到想要的值
obj2 = pd.Series({'a':1,'b':2,'c':3})
print(obj2)
print(obj2.index)
print(obj2.values)
print(obj2['b'])
a 1
b 2
c 3
dtype: int64
---------------
Index(['a', 'b', 'c'], dtype='object')
---------------
[1 2 3]
---------------
2.0（二）索引
Series有显式索引和隐式索引两种，通过索引可以进行对数据的访问和修改，对索引可以进行修改与重排等操作
1.隐式索引：
系统会默认创建从0开始递增的一系列整数索引作为下标，指定显式索引后，隐式索引仍有效，可以使用（但只要标签（显式索引）具有数值型数据时，不可使用隐式索引，会造成歧义导致冲突）
2.显示索引：
显示索引即序列的标签，可以通用 index 参数指定，其与数据的长度要相同
obj2 = pd.Series({'aa':1,'Aa':2,'ad':3,'ac':4})
print(obj2)
print(obj2.sort_index())
# 英语字符也可重排，与很多语言的排序方式一样，大写排前面，前面一列优先排列，甚至可以用汉字作为索引
aa 1
Aa 2
ad 3
ac 4
dtype: int64
Aa 2
aa 1
ac 4
ad 3
dtype: int64注：在用字典创建Series时，字典的键用来当做索引，若在用字典创建Series的同时指定了索引，将会按 index 参数的顺序输出值，若 index 里的值在字典的键中不存在，其值为NaN，相当于创建好序列后对索引重新编制
obj2 = pd.Series({'a':1,'b':1,'c':2})
obj3 = pd.Series({'a':1,'b':1,'c':2},index=['c','b','d','d'])
print(obj2)
print(obj3)
a 1
b 1
c 2
dtype: int64
c 2.0
b 1.0
d NaN
d NaN
dtype: float643.查找、修改与切片：
Series 可以通过显式索引与隐式索引的方式对元素查找和修改
查找：
obj2 = pd.Series({'a':1,'b':2,'c':3,'d':4})
print(obj2)
print((obj2[0],obj2['a']))
a 1
b 2
c 3
d 4
dtype: int64
(1, 1) # 显式索引与隐式索引都能用取多个值：
obj2 = pd.Series({'a':1,'b':2,'c':3,'d':4})
print(obj2)
print(obj2[['a','c']]) # 内部的中括号相当于列表
a 1
b 2
c 3
d 4
dtype: int64
a 1
c 3
dtype: int64修改：
obj2[0]=666
print(obj2)
a 666
b 2
c 3
d 4
dtype: int64索引方式iloc和loc：
print(obj2)
print(obj2.loc['a']) # 显式索引
print(obj2.iloc[0]) # 隐式索引
a 666
b 2
c 3
d 4
dtype: int64
666
666切片：可以用普通的位置索引切片，也可以使用其标签切片
print(obj2)
print(obj2[0:2]) # 左闭右开
print(obj2['a':'c']) # 两端闭合
a 666
b 2
c 3
d 4
dtype: int64
a 666
b 2
dtype: int64
a 666
b 2
c 3
dtype: int64
补充总结：
索引查找：index 存在数值类型时，使用位置索引进行查找定位可能会抛出异常，因为此时使用的是名称索引查找。
索引切片：切片默认使用的是位置切片，也可以使用名称切片，如下
obj2 = pd.Series({'a':1,'0':2,'102':3,'103':4})
print(obj2)
print(obj2[0:3])
print(obj2['0':'102'])
a 1
0 2
102 3
103 4
dtype: int64
a 1
0 2
102 3
dtype: int64
0 2
102 3
dtype: int64（三）运算
obj2 = pd.Series({'a':'z','b':2,'c':3,'d':4})
print(obj2)
print(obj2[0] * obj2[1]) # print(obj2 + 1)：所有元素+1，要数值型
a z
b 2
c 3
d 4
dtype: object
zz与 ndarray 不同，series 的运算是根据索引自动对齐的，其运算结果是所涉及索引的并集，即：同时出现在两个 series 的索引才会进行运算，取并集，若某索引只在其中一个 series 出现，则运算结果为 NaN ，可用 dropna 函数处理这些缺失值
obj2 = pd.Series({'a':1,'b':2,'c':3,'d':4})
print(obj2)
print(obj2[1:])
print(obj2[:-1])
print(obj2[1:]+obj2[:-1])
a 1
b 2
c 3
d 4
dtype: int64
b 2
c 3
d 4
dtype: int64
a 1
b 2
c 3
dtype: int64
a NaN
b 4.0
c 6.0
d NaN
dtype: float64
此外，还有一些属于Series的属性，如 obj.size 可显示 series 的大小，obj.values 以数组形式返回值等等
（四）方法
1.s.head()/s.tail()
首/末n行数据，默认5行
2.s.reindex(obj,fill_value)
重新指定索引，作用其实与 pd.series() 中的 index 参数作用类似，新索引与原索引不匹配的 value 为 NaN，或用 fill_value 填充
二、Dataframe：
Dataframe 是一个类似表格的二维结构，可以看作带索引的二维数组，因此也有数组的一些属性如 shape 等，而且每行、每列都是一个 series，所以也拥有 index 和 value ，此外还可以设置多级索引，DataFrame拥有一个有序的列column，每列的数据类型可以不相同，行和列均可删除或增加
DataFrame与数组有类似的属性，不同的是想查看每列的数据类型用 dtypes 而不是 dtype
（一）创建
Dataframe 创建方法丰富，可以由Series、ndarrays创建或由列表、字典、Series、数组组成的字典、列表，或另一个DataFrame转化而来，在日常使用可能会直接读取表格的数据，若指定索引，注意索引的长度必须和数据的长度相同，没有传递索引，会自动创建一个0开始的整数索引
1.直接创建：pandas.DataFrame(data,index,columns,dtype,copy)
t=('a','b','c','d')
df = pd.DataFrame(
{"Name": ["zxd","lqq","dog","cat"],
"Age": [22,17,88,24],
"Sex": ["male", "female", "male", "female"],},
index=t
)
print(df)
Name Age Sex
a zxd 22 male
b lqq 17 female
c dog 88 male
d cat 24 female2.使用字典和列表
使用字典、列表创建时，字典的 key 作为列名，值作为行，使用带由带字典创建，里面每个数组和列表的长度也需要相同
(1)列表嵌套
列表中的每个列表组和是一行数据
data[['a',1],['b',2],['c',3]]
df2 = pd.DataFrame(data,columns=['x','y'])
print(df2)
x y
0 a 1
1 b 2
2 c 3(2)列表套字典
内部的一个字典是一行数据，字典的 key 作为列名，缺失值为NaN
data=[{'a':1,'b':2},{'a':2,'c':3}]
df2 = pd.DataFrame(data)
# 内部可指定index、column等参数
print(df2)
a b c
0 1 2.0 NaN
1 2 NaN 3.0(3)字典套列表
字典的 key 为列名，value 为列的数据
df2 = pd.DataFrame({'Name':['zxd','lqq'] ,'Age':[22,17]})
print(df2)
Name Age
0 zxd 22
1 lqq 17(4)字典嵌套
df2 = pd.DataFrame({'a':{'Name': 'zxd','Age':22,'Sex':'male'},
'b':{'Name': 'lqq','Age':17,'Sex':'female'}
})
print(df2)
print(df2.T) # df2.T可打印其转置
a b
Name zxd lqq
Age 22 17
Sex male female
Name Age Sex
a zxd 22 male
b lqq 17 female3.由 ndarray/serirs 创建：
data={"name":pd.Series(['a','b','c']),
"age":pd.Series([18,19,20],dtype=float),
"gender":pd.Series(["m","f","m"]),
"salary":pd.Series([5000,6000])
}
print(pd.DataFrame(data))
name age gender salary
0 a 18.0 m 5000.0
1 b 19.0 f 6000.0
2 c 20.0 m NaN看得出，这种方法可以对不同列设定数据类型，缺失数据用 NaN 补齐，NaN 为浮点型数据
nd=np.eye(3)
df3=pd.DataFrame(nd)
print(df3)
0 1 2
0 1.0 0.0 0.0
1 0.0 1.0 0.0
2 0.0 0.0 1.0（二）索引
DataFrame同样支持索引，index 和 column都能作为索引，可以对行列进行筛选，也可以切
1.选择列：
可以通过列名选择列，直接 df[列名](或df.列名) 返回一个Series，多列不得使用 "列名1:列名2" 切片，会报错，只能用逗号隔开筛选所需列，不能使用数字筛选列
print(df2)
print(df2['a'])
print(df2.a)
print(df2[['a','b']]) # 多列
a b c d
Name zxd lqq dog cat
Age 22 17 88 24
Sex male female male female
----------
Name zxd
Age 22
Sex male
Name: a, dtype: object
----------
Name zxd
Age 22
Sex male
Name: a, dtype: object
----------
a b
Name zxd lqq
Age 22 17
Sex male female2.选择行：
可以用与Series索引相同的方式进行选择，但建议直接使用 loc 和 iloc 筛选某行，df [rowid1:rowid2]的方式易引起歧义，因此不太建议使用，如果单独写 df[1] 会报KeyError（须使用 iloc）
总结主要有以下几种方法：
print(df2)
# 选择行
print(df2[0:2])
# 使用标签，找出某几行某几列
print(df2.loc[['Name','Sex'],'a':'b']) # 行列可以进行切片
# 使用位置数组，找出某几行某几列
print(df2.iloc[0:1,0:2])
a b c d
Name zxd lqq dog cat
Age 22 17 88 24
Sex male female male female
a b c d
Name zxd lqq dog cat
Age 22 17 88 24
a b
Name zxd lqq
Sex male female
a b
Name zxd lqq列属性不能用 ":" +名称 单独切片（×），可以使用 column 方法或用 loc 与行结合，":" +隐式索引 默认对行进行切片，加 "," 连接可以筛选行列，要加上"[ ]"号，内部方括号定义了一个包含列名的Python列表，而外部方括号用于从pandas DataFrame中选择数据，如前面的示例所示。
此外，还可通过对某列的条件或布尔值筛选输出满足条件的行
（三）操作
1.增添、删除列和行
(1)增加列：df[new_column]=xx
(2)删除列：drop[column]/使用del
语法：drop(labels, axis...）
drop不会改变原 DataFrame，axis默认为0按列删除，del 会改变原 DataFrame
print(df2)
print(df2.drop('a',axis=1)) # axis=1：对列操作
print(df2)
del(df2['a'])
print(df2)
a b c d
Name zxd lqq dog cat
Age 22 17 88 24
Sex male female male female
b c d
Name lqq dog cat
Age 17 88 24
Sex female male female
a b c d
Name zxd lqq dog cat
Age 22 17 88 24
Sex male female male female
b c d
Name lqq dog cat
Age 17 88 24
Sex female male female(3)增加行与增加列类似，通过loc新建索引赋值：df.loc[new_row]=xx
(4)删除行：drop[row]
详细关于行列的增删改可参见另一篇文章： DataFrame对于行列的增加、修改和删除_dataframe增加列-CSDN博客
2.运算：
DataFrame的运算与Series的运算思想类似，都是取并集的思想，需要行列索引均相同时才能进行运算，否则结果为NaN
3.合并merge：
merge操作类似将数据库的两张表合并成一张表，语法：merge(left/right, how=‘inner’, on=None, left_on=None, right_on=None, left_index=False, right_index=False,copy=True, indicator=False)
几个主要参数：
- left,right:要merge的dataframe或者有名字的Series
- how：连接的类型，‘left’,‘right’,‘outer’,‘inner’
- on: join的key，要求left和right都需要有这个key才能用on，如果两个dataframe的列不一样，则用下面两个参数指定
- left_on/right_on: 在列名不同时，指定 left/right 的 df 或者 series 的 key
- left_index,right_index：使用 index，而不是column做连接
- indicator：为True时，它会自动给结果加一列“_merge"，内容为left_only、both等，可用于数据的筛选和操作
dleft = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value': np.random.randn(4)})
dright = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value': np.random.randn(4)})
print(dleft)
print('-'*10)
print(dright)
print('-'*10)
df=dleft.merge(dright,on='key',how='left')
print(df)
key value
0 A 1.312820
1 B 0.500399
2 C 0.067629
3 D 0.821197
----------
key value
0 B -0.046607
1 D -0.276745
2 E -0.588041
3 F -0.605433
----------
key value_x value_y
0 A 1.312820 NaN
1 B 0.500399 -0.046607
2 C 0.067629 NaN
3 D 0.821197 -0.276745
dleft2 = dleft.rename({'key':'keyLeft'}, axis=1)
dright2 = dright.rename({'key':'keyRight'}, axis=1) # 改列名
print(dleft2)
print('-'*10)
print(dright2)
print('-'*10)
df2=dleft2.merge(dright2,left_on='keyLeft',right_on='keyRight',how='inner')
keyLeft value
0 A -2.226263
1 B 0.992802
2 C -0.533558
3 D -1.397969
----------
keyRight value
0 B 0.797859
1 D -0.244322
2 E 1.066957
3 F 0.121177
----------
keyLeft value_x keyRight value_y
0 B 0.992802 B 0.797859
1 D -1.397969 D -0.244322除了merge，还有concat方法也可以进行合并