copy_copyright - CSDN
精华内容
参与话题
  • python中copy()和deepcopy()详解

    万次阅读 多人点赞 2018-03-30 10:43:40
    参考文章 http://iaman.actor/blog/2016/04/17/copy-in-python **首先直接上结论: —–我们寻常意义的复制就是深复制,即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对...

    参考文章 http://iaman.actor/blog/2016/04/17/copy-in-python
    这里写图片描述

    **首先直接上结论: —–我们寻常意义的复制就是深复制,即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。
    —–而浅复制并不会产生一个独立的对象单独存在,他只是将原有的数据块打上一个新标签,所以当其中一个标签被改变的时候,数据块就会发生变化,另一个标签也会随之改变。这就和我们寻常意义上的复制有所不同了。**

    对于简单的 object,用 shallow copy 和 deep copy 没区别

    复杂的 object, 如 list 中套着 list 的情况,shallow copy 中的 子list,并未从原 object 真的「独立」出来。也就是说,如果你改变原 object 的子 list 中的一个元素,你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。

    看不懂文字没关系我们来看代码:

    >>> import copy
    >>> origin = [1, 2, [3, 4]]
    #origin 里边有三个元素:1, 2,[3, 4]
    >>> cop1 = copy.copy(origin)
    >>> cop2 = copy.deepcopy(origin)
    >>> cop1 == cop2
    True
    >>> cop1 is cop2
    False 
    #cop1 和 cop2 看上去相同,但已不再是同一个object
    >>> origin[2][0] = "hey!" 
    >>> origin
    [1, 2, ['hey!', 4]]
    >>> cop1
    [1, 2, ['hey!', 4]]
    >>> cop2
    [1, 2, [3, 4]]
    #把origin内的子list [3, 4] 改掉了一个元素,观察 cop1 和 cop2

    可以看到 cop1,也就是 shallow copy 跟着 origin 改变了。而 cop2 ,也就是 deep copy 并没有变。

    似乎 deep copy 更加符合我们对「复制」的直觉定义: 一旦复制出来了,就应该是独立的了。如果我们想要的是一个字面意义的「copy」,那就直接用 deep_copy 即可。

    那么为什么会有 shallow copy 这样的「假」 copy 存在呢? 这就是有意思的地方了。

    python的数据存储方式
    Python 存储变量的方法跟其他 OOP 语言不同。它与其说是把值赋给变量,不如说是给变量建立了一个到具体值的 reference。

    当在 Python 中 a = something 应该理解为给 something 贴上了一个标签 a。当再赋值给 a 的时候,就好象把 a 这个标签从原来的 something 上拿下来,贴到其他对象上,建立新的 reference。 这就解释了一些 Python 中可能遇到的诡异情况:

    >> a = [1, 2, 3]
    >>> b = a
    >>> a = [4, 5, 6] //赋新的值给 a
    >>> a
    [4, 5, 6]
    >>> b
    [1, 2, 3]
    # a 的值改变后,b 并没有随着 a 变
    
    >>> a = [1, 2, 3]
    >>> b = a
    >>> a[0], a[1], a[2] = 4, 5, 6 //改变原来 list 中的元素
    >>> a
    [4, 5, 6]
    >>> b
    [4, 5, 6]
    # a 的值改变后,b 随着 a 变了

    上面两段代码中,a 的值都发生了变化。区别在于,第一段代码中是直接赋给了 a 新的值(从 [1, 2, 3] 变为 [4, 5, 6]);而第二段则是把 list 中每个元素分别改变。

    而对 b 的影响则是不同的,一个没有让 b 的值发生改变,另一个变了。怎么用上边的道理来解释这个诡异的不同呢?

    首次把 [1, 2, 3] 看成一个物品。a = [1, 2, 3] 就相当于给这个物品上贴上 a 这个标签。而 b = a 就是给这个物品又贴上了一个 b 的标签。

    这里写图片描述
    第一种情况:

    a = [4, 5, 6] 就相当于把 a 标签从 [1 ,2, 3] 上撕下来,贴到了 [4, 5, 6] 上。

    在这个过程中,[1, 2, 3] 这个物品并没有消失。 b 自始至终都好好的贴在 [1, 2, 3] 上,既然这个 reference 也没有改变过。 b 的值自然不变。
    这里写图片描述

    第二种情况:

    a[0], a[1], a[2] = 4, 5, 6 则是直接改变了 [1, 2, 3] 这个物品本身。把它内部的每一部分都重新改装了一下。内部改装完毕后,[1, 2, 3] 本身变成了 [4, 5, 6]。

    而在此过程当中,a 和 b 都没有动,他们还贴在那个物品上。因此自然 a b 的值都变成了 [4, 5, 6]。

    搞明白这个之后就要问了,对于一个复杂对象的浅copy,在copy的时候到底发生了什么?
    再看一段代码:

    >>> import copy
    >>> origin = [1, 2, [3, 4]]
    #origin 里边有三个元素:1, 2,[3, 4]
    >>> cop1 = copy.copy(origin)
    >>> cop2 = copy.deepcopy(origin)
    >>> cop1 == cop2
    True
    >>> cop1 is cop2
    False 
    #cop1 和 cop2 看上去相同,但已不再是同一个object
    >>> origin[2][0] = "hey!" 
    >>> origin
    [1, 2, ['hey!', 4]]
    >>> cop1
    [1, 2, ['hey!', 4]]
    >>> cop2
    [1, 2, [3, 4]]
    #把origin内的子list [3, 4] 改掉了一个元素,观察 cop1 和 cop2

    学过docker的人应该对镜像这个概念不陌生,我们可以把镜像的概念套用在copy上面。

    概念图如下:
    这里写图片描述

    copy对于一个复杂对象的子对象并不会完全复制,什么是复杂对象的子对象呢?就比如序列里的嵌套序列,字典里的嵌套序列等都是复杂对象的子对象。对于子对象,python会把它当作一个公共镜像存储起来,所有对他的复制都被当成一个引用,所以说当其中一个引用将镜像改变了之后另一个引用使用镜像的时候镜像已经被改变了。

    所以说看这里的origin[2],也就是 [3, 4] 这个 list。根据 shallow copy 的定义,在 cop1[2] 指向的是同一个 list [3, 4]。那么,如果这里我们改变了这个 list,就会导致 origin 和 cop1 同时改变。这就是为什么上边 origin[2][0] = “hey!” 之后,cop1 也随之变成了 [1, 2, [‘hey!’, 4]]。

    而deepcopy概念图如下:
    这里写图片描述

    deepcopy的时候会将复杂对象的每一层复制一个单独的个体出来。
    这时候的 origin[2] 和 cop2[2] 虽然值都等于 [3, 4],但已经不是同一个 list了。即我们寻常意义上的复制。

    展开全文
  • copy 的使用

    2019-06-16 22:20:18
    copy是C++ STL 算法组件中的其中一个算法,其作用是将指定序列局部元素复制到另一个序列中。它拥有两个重载函数。其指定序列可以是容器或者数组,另一个序列也可以是容器或者数组。 例子代码: #include <...

    copy是C++ STL 算法组件中的其中一个算法,其作用是将指定序列局部元素复制到另一个序列中。它拥有两个重载函数。其指定序列可以是容器或者数组,另一个序列也可以是容器或者数组。

    例子代码:

    #include <iostream>
    #include <vector>
    using namespace std;
    void main()
    {
    	//创建两个容器 和 两个数组
    	vector<int> v = {1,2,3,4,5,6,7,8,9,10 };
    	vector<int> v2(10);
    	vector<int>::iterator vi;//迭代器
    	int arr[10] = { 11,12,13,14,15,16,17,18,19,20 };
    	int arr2[10] = { 0 };
    	
    	cout << "执行copy算法前:\n";
    	
    	// 输出 v
    	cout << "容器 v:   ";
    	for (vi = v.begin(); vi < v.end(); vi++) { cout << *vi << "\t"; }
    	cout << endl;
    	
    	// 输出 v2	
    	cout << "容器 v2:  ";
    	for (vi = v2.begin(); vi < v2.end(); vi++) { cout << *vi << "\t"; }
    	cout << endl;
    	
    	// 输出 arr	
    	cout << "数组 arr: ";
    	for (int i = 0; i<10; i++) { cout << arr[i] << "\t"; }
    	cout << endl;
    	
    	// 输出 arr2	
    	cout << "数组 arr2:";
    	for (int i = 0; i<10; i++) { cout << arr2[i] << "\t"; }
    	cout << endl;	
    
    	cout << "\n执行copy算法后:\n";
    	// STL copy算法
    	
    	// 1、拷贝源是容器,拷贝目标是容器
    	copy(v.begin(), v.begin() + 5, v2.begin());
    	
    	// 输出 v2	
    	cout << "容器 v2:  ";
    	for (vi = v2.begin(); vi < v2.end(); vi++) { cout << *vi << "\t"; }
    	cout << endl << endl;
    
    	// 2、拷贝源是容器,拷贝目标是数组
    	copy(v.begin(), v.end(), arr2);
    	
    	// 输出 arr	
    	cout << "数组 arr2:";
    	for (int i = 0; i<10; i++) { cout << arr2[i] << "\t"; }
    	cout << endl << endl;
    
    	// 3、拷贝源是数组,拷贝目标是容器
    	copy(arr, arr +5, v2.begin());
    	
    	// 输出 v2	
    	cout << "容器 v2:  ";
    	for (vi = v2.begin(); vi < v2.end(); vi++) { cout << *vi << "\t"; }
    	cout << endl << endl;
    
    	// 4、拷贝源是数组,拷贝目标是数组
    	copy(arr, arr + 9, arr2);
    	
    	// 输出 arr	
    	cout << "数组 arr2:";
    	for (int i = 0; i<10; i++) { cout << arr2[i] << "\t"; }
    	cout << endl << endl;
    
    	// 5、拷贝源与拷贝目标都是同一个数组
    	copy(v.begin(), v.begin()+4, v.begin()+5);
    	
    	// 输出 arr	
    	cout << "容器 v:   ";
    	for (vi = v.begin(); vi < v.end(); vi++) { cout << *vi << "\t"; }
    	cout << endl << endl;
    
    	// 6、拷贝源与拷贝目标都是同一个数组
    	copy(arr+5, arr +10, arr);
    	
    	// 输出 arr	
    	cout << "数组 arr: ";
    	for (int i = 0; i<10; i++) { cout << arr[i] << "\t"; }
    	cout << endl;
    }
    

    运行结果
    在这里插入图片描述
    如上,其拷贝源和拷贝目标都可以是相同或不同的容器或数组,。
    Copy 两个重载函数只是参数类型不同,实际实现效果是一样的
    Copy(拷贝源要拷贝的起始位置,拷贝源要拷贝的结束位置,拷贝目标要存放拷贝的内容的起始位置);

    但需要注意是拷贝元素的数量不能大于拷贝目标用于存放拷贝的内容的容量,例如拷贝源A 的元素个数为10,拷贝目标B的容量大小为5,将A的全部内容都拷贝B,编译器会报错,因为B的容量不足以放置A的所有元素。程序会终止。

    感谢您的浏览。

    展开全文
  • Python---copy()、deepcopy()与赋值的区别

    万次阅读 多人点赞 2017-11-22 16:04:35
    copy()与deepcopy()之间的主要区别是python对数据的存储方式。 首先直接上结论: —–我们寻常意义的复制就是深复制,即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经...

            copy()与deepcopy()之间的主要区别是python对数据的存储方式。

    首先直接上结论:

    —–深复制即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。 

    —–而等于赋值,并不会产生一个独立的对象单独存在,他只是将原有的数据块打上一个新标签,所以当其中一个标签被改变的时候,数据块就会发生变化,另一个标签也会随之改变。

    —–而浅复制要分两种情况进行讨论:

    1)当浅复制的值是不可变对象(数值,字符串,元组)和“等于赋值”的情况一样,对象的id值与浅复制原来的值相同

    2)当浅复制的值是可变对象(列表和元组)时会产生一个“不是那么独立的对象”存在。有两种情况:

    第一种情况:复制的 对象中无 复杂 子对象,原来值的改变并不会影响浅复制的值,同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。

    第二种情况复制的对象中有 复杂 子对象 (例如列表中的一个子元素是一个列表),如果不改变其中复杂子对象浅复制的值改变并不会影响原来的值。 但是改变原来的值 中的复杂子对象的值  会影响浅复制的值

    对于简单的 object,例如不可变对象(数值,字符串,元组),用 shallow copy 和 deep copy 没区别

    复杂的 object, 如 list 中套着 list 的情况,shallow copy 中的 子list,并未从原 object 真的「独立」出来。也就是说,如果你改变原 object 的子 list 中的一个元素,你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。

    当浅复制的值是不可变对象(数值,字符串,元组)时,代码如下:

    >>> a="1234567"
    >>> b=a
    >>> id(a)
    4367619440
    >>> id(b)
    4367619440
    >>> c=copy.copy(a)
    >>> id(c)
    4367619440
    >>> d=copy.deepcopy(a)
    >>> id(d)
    4367619440

    浅复制的值是可变对象(列表,字典)时,改变的值不是 复杂子对象 代码如下:

    >>> l1=[1,2,3]
    >>> l2=l1
    >>> l3=copy.copy(l1)
    >>> id(l1)
    4367654664
    >>> id(l2)
    4367654664
    >>> id(l3)
    4367628616
    >>> l1.append(55)
    >>> print(l1)
    [1, 2, 3, 55]
    >>> print(l3)
    [1, 2, 3]
    

    当浅复制的值是可变对象(列表,字典)时,改变的值是 复杂子对象 代码如下:

    >>> import copy
    >>> list1=[1,2,['a','b']]
    >>> list2=list1
    >>> list3=copy.copy(list2)
    >>> list4=copy.deepcopy(list3)
    >>> id(list1)
    4338414656
    >>> id(list2)
    4338414656
    >>> id(list3)
    4338415016
    >>> id(list4)
    4338414368
    >>> list1[2].append('a')
    >>> id(list1)
    4338414656
    >>> print list1
    [1, 2, ['a', 'b', 'a']]
    >>> print list3
    [1, 2, ['a', 'b', 'a']]
    >>> print list4
    [1, 2, ['a', 'b']]
    >>> list1.append(33)
    >>> id(list1)
    4338414656
    >>> id(list3)
    4338415016
    >>> print list1
    [1, 2, ['a', 'b', 'a'], 33]
    >>> print list3
    [1, 2, ['a', 'b', 'a']]

    代码说明:当改变 复杂子对象中的元素时,浅复制值发生了变化; 当改变的值不是复杂子对象,浅复制的值没有发生变化。因为 浅复制 ,复杂子对象的保存方式是 作为 引用 方式存储的,所以修改 浅复制的值 和原来的值都可以 改变 复杂子对象的值。


    python的数据存储方式

    Python 存储变量的方法跟其他 OOP 语言不同。它与其说是把值赋给变量,不如说是给变量建立了一个到具体值的 reference。

    当在 Python 中 a = something 应该理解为给 something 贴上了一个标签 a。当再赋值给 a 的时候,就好象把 a 这个标签从原来的 something 上拿下来,贴到其他对象上,建立新的 reference。 这就解释了一些 Python 中可能遇到的诡异情况:

    >> a = [1, 2, 3]
    >>> b = a
    >>> a = [4, 5, 6] //赋新的值给 a
    >>> a
    [4, 5, 6]
    >>> b
    [1, 2, 3]
    # a 的值改变后,b 并没有随着 a 变
    
    >>> a = [1, 2, 3]
    >>> b = a
    >>> a[0], a[1], a[2] = 4, 5, 6 //改变原来 list 中的元素
    >>> a
    [4, 5, 6]
    >>> b
    [4, 5, 6]
    # a 的值改变后,b 随着 a 变了

    上面两段代码中,a 的值都发生了变化。区别在于,第一段代码中是直接赋给了 a 新的值(从 [1, 2, 3] 变为 [4, 5, 6]);而第二段则是把 list 中每个元素分别改变。而对 b 的影响则是不同的,一个没有让 b 的值发生改变,另一个变了。怎么用上边的道理来解释这个诡异的不同呢?首次把 [1, 2, 3] 看成一个物品。a = [1, 2, 3] 就相当于给这个物品上贴上 a 这个标签。而 b = a 就是给这个物品又贴上了一个 b 的标签。 

    这里写图片描述 
    第一种情况:a = [4, 5, 6] 就相当于把 a 标签从 [1 ,2, 3] 上撕下来,贴到了 [4, 5, 6] 上。在这个过程中,[1, 2, 3] 这个物品并没有消失。 b 自始至终都好好的贴在 [1, 2, 3] 上,既然这个 reference 也没有改变过。 b 的值自然不变。

    这里写图片描述 

    第二种情况:a[0], a[1], a[2] = 4, 5, 6 则是直接改变了 [1, 2, 3] 这个物品本身。把它内部的每一部分都重新改装了一下。内部改装完毕后,[1, 2, 3] 本身变成了 [4, 5, 6]。而在此过程当中,a 和 b 都没有动,他们还贴在那个物品上。因此自然 a b 的值都变成了 [4, 5, 6]。

    搞明白这个之后就要问了,对于一个复杂对象的浅copy,在copy的时候到底发生了什么? 
    再看一段代码:

    >>> import copy
    >>> origin = [1, 2, [3, 4]]
    #origin 里边有三个元素:1, 2,[3, 4]
    >>> cop1 = copy.copy(origin)
    >>> cop2 = copy.deepcopy(origin)
    >>> cop1 == cop2
    True
    >>> cop1 is cop2
    False 
    #cop1 和 cop2 看上去相同,但已不再是同一个object
    >>> origin[2][0] = "hey!" 
    >>> origin
    [1, 2, ['hey!', 4]]
    >>> cop1
    [1, 2, ['hey!', 4]]
    >>> cop2
    [1, 2, [3, 4]]
    #把origin内的子list [3, 4] 改掉了一个元素,观察 cop1 和 cop2


    学过docker的人应该对镜像这个概念不陌生,我们可以把镜像的概念套用在copy上面。

    copy概念图如下: 
    这里写图片描述

    copy(浅复制)对于一个复杂对象的子对象并不会完全复制,什么是复杂对象的子对象呢?就比如序列里的嵌套序列字典里的嵌套序列等都是复杂对象的子对象。对于子对象,python会把它当作一个公共镜像存储起来,所有对他的复制都被当成一个引用,所以说当其中一个引用将镜像改变了之后另一个引用使用镜像的时候镜像已经被改变了

    所以说看这里的origin[2],也就是 [3, 4] 这个 list。根据 shallow copy 的定义,在 cop1[2] 指向的是同一个 list [3, 4]。那么,如果这里我们改变了这个 list,就会导致 origin 和 cop1 同时改变。这就是为什么上边 origin[2][0] = “hey!” 之后,cop1 也随之变成了 [1, 2, [‘hey!’, 4]]。

    deepcopy概念图如下: 
    这里写图片描述

    deepcopy的时候会将复杂对象的每一层复制一个单独的个体出来。 
    这时候的 origin[2] 和 cop2[2] 虽然值都等于 [3, 4],但已经不是同一个 list了。即我们寻常意义上的复制。

    参考文章  http://iaman.actor/blog/2016/04/17/copy-in-python



    展开全文
  • copy函数 复制函数

    千次阅读 2019-03-26 16:20:49
    头文件 #include<algorithm> 将a[0]~a[2]复制到b[5]~b[7] 并且覆盖掉原来的数据 (主要用于容器之间) copy(a.begin(),a.begin()+3,b.begin()+4);

    头文件 

    #include<algorithm>

    将a[0]~a[2]复制到b[5]~b[7] 并且覆盖掉原来的数据 (主要用于容器之间)

    copy(a.begin(),a.begin()+3,b.begin()+4);

     

    展开全文
  • Python-copy()与deepcopy()区别

    万次阅读 多人点赞 2016-08-12 13:53:08
    最近在实习,boss给布置了一个python的小任务,学习过程中发现copy()和deepcopy()这对好基友实在是有点过分,一开始还相爱着呢,不知道怎么回事就开始相杀了。 搞的博主就有点傻傻分不清啊,但是呢,本着一探...
  • PostgreSQL 之 copy 命令基础

    万次阅读 2018-01-26 00:15:48
    COPY命令概述 copy 命令用于表与文件(和标准输出,标准输入)之间的相互拷贝; copy to由表至文件,copy from由文件至表; copy 命令始终是到数据库服务端找文件,以超级用户执行导入导出权限要求很高,适合数据库...
  • copy和deepcopy

    千次阅读 2019-06-11 11:21:54
    总结一下,如果一个集合中的元素是字符串,copy之后则是两个互不相干的新集合,内存地址也不一样,修改任意一个另一个不会做出改变,但是如果其中的元素有数组的话,那么情况就不一样了,copy后虽然集合是两个完全新...
  • copy

    2016-10-11 16:34:00
    一个2年安卓开发者的一些忠告 编辑推荐:稀土掘金,这是一个针对技术开发者的一个应用,你可以在掘金上获取最新最优质的技术干货,不仅仅是Android知识、前端、后端以至于产品和设计都有涉猎,想成为全栈工程师的...
  • python中copy的使用

    万次阅读 2017-10-18 20:44:34
    接触python有一段时间了,一直没有系统的学习过,也对copy,deepcoy傻傻的分不清,故抽出时间来理一下。 copy仅拷贝对象本身,而不对中的子对象进行拷贝,故对子对象进行修改也会随着修改。 deepcopy是真正意义...
  • C++拷贝构造函数详解

    万次阅读 多人点赞 2011-02-23 13:39:00
    一. 什么是拷贝构造函数 首先对于普通类型的对象来说,它们之间的复制是很简单的,例如: int a = 100; int b = a;...而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量。...
  • 前端页面的一键copy功能

    万次阅读 2019-03-23 23:52:00
    浏览器提供了 copy 命令 ,可以复制选中的内容 document.execCommand("copy") 如果是输入框,可以通过 select() 方法,选中输入框的文本,然后调用 copy 命令,将文本复制到剪切板 但是 select() 方法只对 <...
  • 项目环境: jdk1.8+spring4.3.12 一、问题描述及试用场景: 在项目规范中,要求类名以DO为尾...由于以上要求,需要在各个bean直接进行copy数据,除了傻瓜式的set/get or constructor来copy数据外,spring提供了直...
  • STL算法之 copycopy_backward、copy_n

    千次阅读 2016-07-20 23:03:46
    这些函数都定义在stl_algobase.h里面,使用时只需要包含 ...copy :STL 的SGI版本中的copy函数声明如下:template , class OutputIterator> inline OutputIterator copy(InputIterator first, InputIterator last, O
  • 通过对C#文档中Array.Copy()和Buffer.BlockCopy()两个方法的整理,深刻理解其运行原理及实现方式。在理解了Array.Copy()之后,从而对List<T>的拷贝、插入、删除操作实现,有一个更深入的理解。 一、Array....
  • 什么是Zero-Copy

    万次阅读 多人点赞 2016-09-19 21:28:17
    概述 考虑这样一种常用的情形:你需要将静态内容(类似图片、文件)展示给用户。那么这个情形就意味着你需要先将静态内容从磁盘中拷贝出来放到一个内存buf中,然后将这个buf通过socket传输给用户,进而用户或者静态...
  • python模块 - copy模块

    千次阅读 2015-05-18 23:16:05
    该模块只提供了两个主要的方法:copy.copycopy.deepcopy,分别表示浅复制与深复制。 直接赋值,深拷贝和浅拷贝的区别 直接赋值:简单地拷贝对象的引用,两个对象的id相同。就是对象的引用(别名),就是给...
  • HDFS数据快速拷贝方案:FastCopy

    万次阅读 2016-10-30 11:07:33
    前言 我们在使用HDFS的时候,往往有的时候需要做一些临时的数据拷贝操作,如果是在同一个集群中的,我们直接用HDFS内部自带的cp这些命令即可;如果是跨集群的时候或者说待拷贝数据量规模非常大的时候,我们还可以...
  • 一、copy 头文件algorithm template &amp;lt;class InputIterator, class OutputIterator&amp;gt; OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result); 复制元素范围...
  • tcpcopy使用说明

    千次阅读 2014-05-13 14:32:14
    1 简介 XCopy是由网易主导,多家公司成员1参与开发的具有在线server流量复制功能的一系列开源软件的总称,目的是复制在线server流量...XCopy系列包括TCPCopy、UDPCopy、MysqlCopy等开源软件(这些软件都集成在tcpcop
  • PostgreSQL Copy 命令

    万次阅读 2017-07-27 09:07:08
    COPY -- 在表和文件之间拷贝数据 Synopsis COPY tablename [ ( column [, ...] ) ] FROM { 'filename' | STDIN } [ [ WITH ] [ BINARY ] [ OIDS ] [ DELIMITER [ AS ] 'delimiter' ] [ NULL [ AS ] 'null ...
1 2 3 4 5 ... 20
收藏数 1,582,909
精华内容 633,163
关键字:

copy