panda库------对数据进行操作---合并,转换,拼接

 1 >>> frame2
 2        addr  age   name
 3 0   beijing   12  zhang
 4 1  shanghai   24     li
 5 2  hangzhou   24    cao
 6 >>> frame1
 7        addr   name
 8 0   beijing  zhang
 9 1  shanghai     li
10 2  hangzhou    cao
11 3  shenzhen    han
12 >>> pd.merge(frame1,frame2)   以name列为连接进行拼接
13        addr   name  age
14 0   beijing  zhang   12
15 1  shanghai     li   24
16 2  hangzhou    cao   24
17 >>> pd.merge(frame1,frame2,on=‘name‘)     指定  列  和拼接方式
18      addr_x   name    addr_y  age
19 0   beijing  zhang   beijing   12
20 1  shanghai     li  shanghai   24
21 2  hangzhou    cao  hangzhou   24
22 >>> pd.merge(frame1,frame2,on=‘name‘,how=‘outer‘)
23      addr_x   name    addr_y   age
24 0   beijing  zhang   beijing  12.0
25 1  shanghai     li  shanghai  24.0
26 2  hangzhou    cao  hangzhou  24.0
27 3  shenzhen    han       NaN   NaN
28 >>> pd.merge(frame1,frame2,on=‘name‘,how=‘inner‘)
29      addr_x   name    addr_y  age
30 0   beijing  zhang   beijing   12
31 1  shanghai     li  shanghai   24
32 2  hangzhou    cao  hangzhou   24
33 >>> pd.merge(frame1,frame2,on=‘name‘,how=‘left‘)
34      addr_x   name    addr_y   age
35 0   beijing  zhang   beijing  12.0
36 1  shanghai     li  shanghai  24.0
37 2  hangzhou    cao  hangzhou  24.0
38 3  shenzhen    han       NaN   NaN
39 >>> pd.merge(frame1,frame2,on=‘name‘,how=‘right‘)
40      addr_x   name    addr_y  age
41 0   beijing  zhang   beijing   12
42 1  shanghai     li  shanghai   24
43 2  hangzhou    cao  hangzhou   24
44 >>> pd.merge(frame1,frame2,on=‘name‘,left_index=True)
45      addr_x   name    addr_y  age
46 0   beijing  zhang   beijing   12
47 1  shanghai     li  shanghai   24
48 2  hangzhou    cao  hangzhou   24
49 >>> pd.merge(frame1,frame2,on=‘name‘,right_index=True)
50      addr_x   name    addr_y  age
51 0   beijing  zhang   beijing   12
52 1  shanghai     li  shanghai   24
53 2  hangzhou    cao  hangzhou   24
54 >>> pd.merge(frame1,frame2,on=‘addr‘,right_index=True)
55        addr name_x  age name_y
56 0   beijing  zhang   12  zhang
57 1  shanghai     li   24     li
58 2  hangzhou    cao   24    cao
1 >>> frame1.columns=[‘addr1‘,‘name1‘]
2 >>> frame1.join(frame2)
3       addr1  name1      addr   age   name    修改掉重复的列名称,然后join()
4 0   beijing  zhang   beijing  12.0  zhang
5 1  shanghai     li  shanghai  24.0     li
6 2  hangzhou    cao  hangzhou  24.0    cao
7 3  shenzhen    han       NaN   NaN    NaN
 1 >>> array1
 2 array([[0, 1, 2],
 3        [3, 4, 5],
 4        [6, 7, 8]])
 5 >>> array1=np.arange(9).reshape((3,3))+6
 6 >>> array2=np.arange(9).reshape((3,3))
 7 >>> array1
 8 array([[ 6,  7,  8],
 9        [ 9, 10, 11],
10        [12, 13, 14]])
11 >>> np.concatenate([array1,array2],axis=1)   np模块中对元组进行concatenate()
12 array([[ 6,  7,  8,  0,  1,  2],
13        [ 9, 10, 11,  3,  4,  5],
14        [12, 13, 14,  6,  7,  8]])
15 >>> np.concatenate([array1,array2],axis=0)
16 array([[ 6,  7,  8],
17        [ 9, 10, 11],
18        [12, 13, 14],
19        [ 0,  1,  2],
20        [ 3,  4,  5],
21        [ 6,  7,  8]])
22 >>>
23 >>> np.concatenate([array1,array2])
24 array([[ 6,  7,  8],
25        [ 9, 10, 11],
26        [12, 13, 14],
27        [ 0,  1,  2],
28        [ 3,  4,  5],
29        [ 6,  7,  8]])
 1 >>> ser1=pd.Series(np.random.rand(4))   pd模块中也有concat()
 2 >>> ser1
 3 0    0.998915
 4 1    0.117503
 5 2    0.747180
 6 3    0.641508
 7 dtype: float64
 8 >>> ser1=pd.Series(np.random.rand(4)*100)
 9 >>> ser1
10 0     8.818592
11 1    42.317816
12 2    43.274021
13 3    23.245148
14 dtype: float64
15 >>> ser2=pd.Series(np.random.rand(4)*100,index=[5,6,7,8])
16 >>> ser2
17 5    58.416554
18 6    11.840838
19 7    38.146851
20 8     0.135517
21 dtype: float64
22 >>> pd.concat([ser1,ser2])
23 0     8.818592
24 1    42.317816
25 2    43.274021
26 3    23.245148
27 5    58.416554
28 6    11.840838
29 7    38.146851
30 8     0.135517
31 dtype: float64
32 >>> pd.concat([ser1,ser2],axis=1)
33            0          1
34 0   8.818592        NaN
35 1  42.317816        NaN
36 2  43.274021        NaN
37 3  23.245148        NaN
38 5        NaN  58.416554
39 6        NaN  11.840838
40 7        NaN  38.146851
41 8        NaN   0.135517
 1 >> pd.concat([ser1,ser2],axis=1,keys=[1,2])
 2            1          2
 3 0   8.818592        NaN
 4 1  42.317816  79.632793
 5 2  43.274021  96.700070
 6 3  23.245148  64.573269
 7 4        NaN  68.629709
 8 >>> ser2.index=[2,4,5,6]
 9 >>> ser2
10 2    79.632793
11 4    96.700070
12 5    64.573269
13 6    68.629709
14 dtype: float64
15 >>> ser1.combine_first(ser2)    对缺额的数据进行填充  combin_first()
16 0     8.818592
17 1    42.317816
18 2    43.274021
19 3    23.245148
20 4    96.700070
21 5    64.573269
22 6    68.629709
23 dtype: float64
 1 >>> ser1
 2 0    a
 3 1    b
 4 2    c
 5 3    d
 6 dtype: object
 7 >>> ser2
 8 2    0
 9 4    1
10 5    2
11 6    3
12 dtype: int32
13 >>> ser2.combine_first(ser1)   ser1在后
14 0    a
15 1    b
16 2    0
17 3    d
18 4    1
19 5    2
20 6    3
21 dtype: object
22 >>> ser1[:2].combine_first(ser2)  ser1在前
23 0    a
24 1    b
25 2    0
26 4    1
27 5    2
28 6    3
29 dtype: object
 1 >>> frame1=pd.DataFrame({‘name‘:[‘zhang‘,‘li‘,‘wang‘],‘age‘:[12,45,34],‘addr‘:[‘beijing‘,‘shanghai‘,‘shenzhen‘]})
 2 >>> frame1
 3        addr  age   name
 4 0   beijing   12  zhang
 5 1  shanghai   45     li
 6 2  shenzhen   34   wang
 7 >>> frame1.stack()        frame的进栈和出栈
 8 0  addr     beijing
 9    age           12
10    name       zhang
11 1  addr    shanghai
12    age           45
13    name          li
14 2  addr    shenzhen
15    age           34
16    name        wang
17 dtype: object
18 >>> frame1.stack().unstack()
19        addr age   name
20 0   beijing  12  zhang
21 1  shanghai  45     li
22 2  shenzhen  34   wang
23 >>> frame1.stack().unstack(0)   列和索引转换
24             0         1         2
25 addr  beijing  shanghai  shenzhen
26 age        12        45        34
27 name    zhang        li      wang
 1 >>> longframe=pd.DataFrame({‘color‘:[‘white‘,‘white‘,‘white‘,‘red‘,‘red‘,‘red‘,‘black‘,‘black‘,‘black‘],‘item‘:[‘ball‘,‘pen‘,‘mug‘,‘ball‘,‘pen‘,‘mug‘,‘ball‘,‘pen‘,‘mug‘],‘value‘:np.random.rand(9)})
 2 >>> longframe
 3    color  item     value        对冗余的消除,将longframe转换为wideframe
 4 0  white  ball  0.260358
 5 1  white   pen  0.543955
 6 2  white   mug  0.456874
 7 3    red  ball  0.967021
 8 4    red   pen  0.657271
 9 5    red   mug  0.984256
10 6  black  ball  0.550236
11 7  black   pen  0.731625
12 8  black   mug  0.006728
13 >>> wideframe=longframe.pivot(‘color‘,‘item‘)
14 >>> wideframe
15           value
16 item       ball       mug       pen
17 color
18 black  0.550236  0.006728  0.731625
19 red    0.967021  0.984256  0.657271
20 white  0.260358  0.456874  0.543955
21 >>> frame1
22        addr  age   name
23 0   beijing   12  zhang
24 1  shanghai   12     li
25 2   beijing   12   wang
26 >>> del frame[‘addr‘]
27 Traceback (most recent call last):
28   File "<pyshell#103>", line 1, in <module>
29     del frame[‘addr‘]
30 NameError: name ‘frame‘ is not defined
31 >>> del frame1[‘addr‘]
32 >>> frame1
33    age   name
34 0   12  zhang
35 1   12     li
36 2   12   wang
时间: 2024-10-22 12:04:09

panda库------对数据进行操作---合并,转换,拼接的相关文章

mysql基本认识【关系型数据库和nosql、mysql操作流程和体系,库操作,表操作,数据的操作,字符集的操作,以及php作为client操作数据库】对连接本身没有疑问

1.关系型数据库永久性保存数据的仓库php的变量只是php脚本执行期间,临时性保存变量的空间[使用内存空间临时保存] 关系型数据库:利用二者的关系来描述实体的信息.[利用二维表字段名和字段值来进行描述][关系型数据库根本不是可以使用外键将两个表构建成关联的意思,而是实现描述实体的二维表的形式] nosql:not only sql[sql表示操作关系型数据的语言]所以nosql指的就是非关系型数据库[典型的是键值对型的数据(redis.memcache)][nosql可以视情况添加信息,不需要对

mysql数据表操作&amp;库操作

首先登陆mysql:mysql -uroot -proot -P3306 -h127.0.0.1 查看所有的库:show databases; 进入一个库:use database; 显示所在的库:select database(); 开始进行数据表操作: 1,创建数据表:create table user( id smallint unsigned aotu_crement not null primary key,  //id,整型无符号位非空主键 idNum varchar(20) uni

Python数据分析库pandas ------ merge、concatenation 、pd.concat合并与拼接

对于合并操作,熟悉SQL的读者可以将其理解为JOIN操作,它使用一个或多个键把多行数据 结合在一起. 事实上,跟关系型数据库打交道的开发人员通常使用SQL的JOIN查询,用几个表共有的引用 值(键)从不同 的表获取数据.以这些键为基础,我们能够获取到列表形式的新数据,这些数据是对几个表中的数据进行组合 得到的.pandas库中这类操作叫作合并,执行合并操作的函数为 merge(). 1 import pandas as pd 2 import numpy as np 3 4 frame1 = p

oracle中的数据集合操作

一.数据更新操作 DML语法中主要包括两个内容:查询与更新,更新主要包括:增加数据.修改数据.删除数据.其中这些操作是离不开查询的.         1.增加数据 语法:INSERT INTO 表名称 [(字段名称1, 字段名称2,-)] VALUES(数据1,数据2-..): 注意:     1.对于字符串需要使用""括起来     2.对于时间可以使用to_date()进行转换     3.数字就直接写 范例:向myemp表中插入一条数据 INSERT INTO myemp(emp

JAVASE02-Unit08: 文本数据IO操作 、 异常处理

Unit08: 文本数据IO操作 . 异常处理 * java.io.ObjectOutputStream * 对象输出流,作用是进行对象序列化 package day08; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; import java.util.ArrayList; import java.util.List; /** * java.io.Ob

iOS开发UI篇—自定义瀑布流控件(蘑菇街数据刷新操作)

iOS开发UI篇—自定义瀑布流控件(蘑菇街数据刷新操作) 一.简单说明 使用数据刷新框架: 该框架提供了两种刷新的方法,一个是使用block回调(存在循环引用问题,_ _weak),一个是使用调用. 问题:在进行下拉刷新之前,应该要清空之前的所有数据(在刷新数据这个方法中). 移除正在显示的cell: (1)把字典中的所有的值,都从屏幕上移除 (2)清除字典中的所有元素 (3)清除cell的frame,每个位置的cell的frame都要重新计算 (4)清除可复用的缓存池. 该部分的代码如下: 1

如何处理大量数据并发操作

文件缓存,数据库缓存,优化sql,数据分流,数据库表的横向和纵向划分,优化代码结构! 锁述的概 一. 为什么要引入锁 多个用户同时对数据库的并发操作时会带来以下数据不一致的问题: 丢失更新 A,B两个用户读同一数据并进行修改,其中一个用户的修改结果破坏了另一个修改的结果,比如订票系统 脏读 A用户修改了数据,随后B用户又读出该数据,但A用户因为某些原因取消了对数据的修改,数据恢复原值,此时B得到的数据就与数据库内的数据产生了不一致 不可重复读 A用户读取数据,随后B用户读出该数据并修改,此时A用

案例:Oracle非常规恢复ODU恢复PACKAGE/VIEW/DBLINK等数据脚本操作

Oracle非常规恢复,通过ODU工具恢复包,过程,函数,视图,触发器等数据 当数据库不能拉起来时候,我们可以通过odu找回丢失的数据,今天客户出要求,需要我帮忙找回不能起来库中的包,过程,函数,视图,触发器等之类东西.这些东西都是存在system空间中,存在一些系统的基表中,我们如果能够拿到这些基表的数据然后进行处理,原则上就可以得到客户需要的东西 一.恢复PROCEDURE/FUNCTION/PACKAGE/PACKAGE BODY/TRIGGER/TYPE/TYPE BODY中的数据 1.

SQL Server 跨库同步数据

最近有个需求是要跨库进行数据同步,两个数据库分布在两台物理计算机上,自动定期同步可以通过SQL Server代理作业来实现,但是前提是需要编写一个存储过程来实现同步逻辑处理.这里的存储过程用的不是opendatasource,而是用的链接服务器来实现的.存储过程创建在IP1:192.168.0.3服务器上,需要将视图v_custom的客户信息同步到IP2:192.168.0.10服务器上的t_custom表中.逻辑是如果不存在则插入,存在则更新字段. 1 create PROCEDURE [db