精华内容
下载资源
问答
我要提问

  • java 交集 并集 补集_Java中多个集合的交集，并集和差集

     2021-02-26 13:39:25
    一、交集java中交集使用 A.retainAll(B) ,交集的结果在集合A中。1 import org.junit.Test;23 import java.util.HashSet;4 import java.util.Set;56 /**7 * 交集8 *9 * @author zhongtao on 2018/5/3010 */11 public ... 
    一、交集
    java中交集使用 A.retainAll(B) ,交集的结果在集合A中。
    48304ba5e6f9fe08f3fa1abda7d326ab.png
    1 import org.junit.Test;
    2
    3 import java.util.HashSet;
    4 import java.util.Set;
    5
    6 /**
    7  * 交集
    8  *
    9  * @author zhongtao on 2018/5/30
    10  */
    11 public class Intersection {
    12     /**
    13      * 测试简单交集
    14      */
    15     @Test
    16     public void testSet() {
    17         Set set1 = new HashSet<>();
    18         Set set2 = new HashSet<>();
    19
    20         set1.add("a");
    21         set1.add("b");
    22         set1.add("c");
    23
    24         set2.add("c");
    25         set2.add("d");
    26         set2.add("e");
    27
    28         //交集
    29         set1.retainAll(set2);
    30         System.out.println("交集是 " + set1);  //交集是 [c]
    31     }
    32 }
    48304ba5e6f9fe08f3fa1abda7d326ab.png
    二、并集
    并集使用addAll，A.addAll(B) 因为set本身就去重，所有直接全部添加到一个集合中取并集。
    48304ba5e6f9fe08f3fa1abda7d326ab.png
    1 import org.junit.Test;
    2
    3 import java.util.HashSet;
    4 import java.util.Set;
    5
    6 /**
    7  * 并集
    8  *
    9  * @author zhongtao on 2018/5/31
    10  */
    11 public class UnionSet {
    12     /**
    13      * 并集测试
    14      */
    15     @Test
    16     public void testUnionSet() {
    17         Set set1 = new HashSet<>();
    18         Set set2 = new HashSet<>();
    19
    20         set1.add("a");
    21         set1.add("b");
    22         set1.add("c");
    23
    24         set2.add("b");
    25         set2.add("c");
    26         set2.add("d");
    27
    28         set1.addAll(set2);
    29         System.out.println("并集是" + set1); //并集是[a, b, c, d]
    30     }
    31 }
    48304ba5e6f9fe08f3fa1abda7d326ab.png
    三、差集
    差集使用removeAll方法，去掉一集合中包含的另一个集合的值。A.removeAll(B)。
    48304ba5e6f9fe08f3fa1abda7d326ab.png
    1 import org.junit.Test;
    2
    3 import java.util.HashSet;
    4 import java.util.Set;
    5
    6 /**
    7  * 差集
    8  *
    9  * @author zhongtao on 2018/5/31
    10  */
    11 public class DifferenceSet {
    12     /**
    13      * 差集测试
    14      */
    15     @Test
    16     public void testDifferenceSet() {
    17         Set set1 = new HashSet<>();
    18         Set set2 = new HashSet<>();
    19
    20         set1.add("a");
    21         set1.add("b");
    22         set1.add("c");
    23         set1.add("d");
    24
    25         set2.add("c");
    26         set2.add("d");
    27         set2.add("e");
    28         set2.add("f");
    29
    30         set1.removeAll(set2);
    31         System.out.println("差集是 " + set1); //差集是 [a, b]
    32     }
    33 }
    收起
    展开全文

  • 数据库 - 交集、并集和补集

     2019-10-25 11:22:40
    交集、并集和补集 更新时间：2019-10-09 16:52:19 编辑我的收藏 本文为您介绍UNION、UNOIN ALL、UNION DISTINCT并集，INTERSECT、INTERSECT ALL、INTERSECT DISTINCT交集，EXCEPT、EXCEPT ALL、EXCEPT DISTINCT补... 
    交集、并集和补集
    


    更新时间：2019-10-09 16:52:19
    


    编辑我的收藏
    


    本文为您介绍UNION、UNOIN ALL、UNION DISTINCT并集，INTERSECT、INTERSECT ALL、INTERSECT DISTINCT交集，EXCEPT、EXCEPT ALL、EXCEPT DISTINCT补集等SQL语法。
    


    语法格式如下。
    


    select_statement UNION ALL select_statement;
select_statement UNION [DISTINCT] select_statement;
select_statement INTERSECT ALL select_statement;
select_statement INTERSECT [DISTINCT] select_statement;
select_statement EXCEPT ALL select_statement;
select_statement EXCEPT [DISTINCT] select_statement;
select_statement MINUS ALL select_statement;
select_statement MINUS [DISTINCT] select_statement;
    


    • UNION： 求两个数据集的并集，即将两个数据集合并成一个数据集。
      • 
	
    • INTERSECT：求两个数据集的交集，即输出两个数据集均包含的记录。
      • 
	
    • EXCEPT： 求第二个数据集在第一个数据集中的补集，即输出第一个数据集包含而第二个数据集不包含的记录。
      • 
	
    • MINUS（Oracle）： 等同于EXCEPT。
      • 

    带all的不取重，不带all默认取重， minus没用all用法
    收起
    展开全文

  • java算法编程题：利用单链表求集合的交集、并集和补集

     千次阅读 2019-09-28 22:11:05
    题目：利用单链表求集合的交集、并集和补集 要求：使用泛型 /**利用单链表求集合的交集、并集和补集 * 要求：使用泛型 * @author ZQL * */ public class SingleLinkedList<T> extends Object{ ... 
    题目：利用单链表求集合的交集、并集和补集
    
要求：使用泛型
    

    /**
 * 利用单链表求集合的交集、并集和补集
 * 要求：使用泛型
 * 
 * @author zql
 *
 */
public class SingleLinkedList<T> extends Object{

	/**
	 * 定义链表个数
	 */
	private int size;
	/**
	 * 头节点
	 */
	private Node<T> head;
	
	// 构造代码块在创建对象时被调用，每次创建对象都会调用一次，但是优先于构造函数执行
	{
		this.size = 0;
		this.head = null;
	}
	
	/**
	 * 定义一个无参构造函数，用于实例化头节点 
	 */
	public SingleLinkedList() {
		this.head = new Node<T>();
	}
	
	/**
	 * 定义一个添加集合元素到链表节点的构造函数
	 * 
	 * @param values
	 */
	public SingleLinkedList(T[] values) {
		this();
		this.set(values);
	}
	
	/**
	 * 链表的每个节点类
	 * 
	 * @param <T>
	 */
	public class Node<E> {
		/**
		 * 每个节点的数据
		 */
		private T data;
		/**
		 * 每个节点指向下一个节点的连接
		 */
		public Node<E> next;
		
		public Node() {
			this(null);
		}
		public Node(T data) {
			this.data = data;
		}
		public T getData() {
			return this.data;
		}
		public void setData(T data) {
			this.data = data;
		}
	}
	
	/**
	 * 设置每一个节点的数据
	 * 
	 * @param valuse
	 */
	public void set(T[] values) {
		if (values == null || values.length == 0) {
			throw new NullPointerException(this.getClass().getName() + "构造参数长度不能为0且不能为空");
		} else {
			Node<T> rear = this.head;
			// 给头节点设置第一个元素
			rear.setData(values[0]);
			// 节点数加一
			this.size++;
			for (int i = 1, len = values.length; i < len; i++) {
				// 数据为null不添加入节点
				if (values[i] == null) {
					continue;
				}
				rear.next = new Node<T>(values[i]);
				rear = rear.next;
				// 节点数加一
				this.size++;
			}
		}
	}
	
	/**
	 * 在链表头添加元素
	 * 
	 * @param n
	 * @return
	 */
	public void add(T value) {
		if (value == null) {
			throw new NullPointerException("添加的元素不能为空");
		}
		Node<T> newNode = new Node<T>(value);
		// 如果链表节点数为0，则头节点就是添加的新节点
		if (this.size == 0) {
			this.head = newNode;
		} else {
			// next指向原头节点
			newNode.next = this.head;
			// 将当前添加的节点设置为头节点
			this.head = newNode;
		}
		// 链表节点数加一
		this.size++;
	}
	
	/**
	 * 在链表头指定位置添加元素
	 * 
	 * @param i 从0开始，0表示添加进第一位，如果i大于等于size则添加进末尾节点
	 * @param n
	 */
	public void add(int i,T value) {
		Node<T> newNode = new Node<T>(value);
		if (value == null) {
			throw new NullPointerException("添加的元素不能为空");
		}
		if (i == 0) {
			add(value);
		} else {
			Node<T> front = this.head;
			// j<=i，只需查找到要插入的位置即可
			for (int j = 1; j <= i && j < this.size; j++) {
				// 找到要添加的位置
				if (j == i) {
					// 保存原链表添加位置的节点数据
					Node<T> temp = front.next;
					// 把新添加的节点接上
					front.next = newNode;
					// 把保存的节点数据连上
					front.next.next = temp;
				} else {
					front = front.next;
				}
			}
			// 插入最后一个位置
			if (i >= this.size) {
				front.next = newNode;
			}
			// 链表节点数加一
			this.size++;
		}
	}
	
	/**
	 * 根据索引获取节点数据
	 * 
	 * @param i 索引，从0开始
	 * @return
	 */
	public T get(int i) {
		if (i >= this.size || i < 0) {
			throw new ArrayIndexOutOfBoundsException("数组越界:" + i);
		}
		if (i == 0) {
			return this.head.data;
		}
		Node<T> current = this.head;
		for (int j = 1; j < this.size; j++) {
			if (i == j) {
				return current.next.data;
			}
			current = current.next;
		}
		return null;
	}
	
	/**
	 * 根据传入的值判断节点是否存在
	 * 
	 * @param value
	 * @return 存在返回true
	 */
	public boolean isExist(T value) {
		Node<T> current = this.head;
		while (current.next != null) {
			if (value.equals(current.getData())) {
				return true;
			} else {
				current = current.next;
			}
		}
		return false;
	}
	
	/**
	 * 求两个集合的并集
	 * 
	 * @param values
	 */
	public void merge(T[] values) {
		for (int i = 0, len = values.length; i < len; i++) {
			// 不存在就添加
			if (!this.isExist(values[i])) {
				this.add(values[i]);
			}
		}
	}
	
	/**
	 * 求两个集合的交集
	 * 
	 * @param values
	 */
	@SuppressWarnings("unchecked")
	public void intersection(T[] values,SingleLinkedList<T> s) {
		// 也可以使用list，我想复习一个数组扩容就没用
		// 泛型无法实例化，所以使用实例化Object强制转换方式
		T[] tArr = (T[]) new Object[10];
		int j = 0;
		for (int i = 0, len = values.length; i < len; i++) {
			// 存在就添加
			if (this.isExist(values[i])) {
				tArr[j++] = values[i];
				// 进行评定是否达到，数组的最大存储量
				if (j >= tArr.length) {
					// 扩容
					tArr = getNewArray(tArr);
				}
			}
		}
		// 清空数据
		s.clear();
		// 重新装数据
		s.set(tArr);
	}
	
	/**
	 * 数组的自动扩容，同时拷贝数据
	 * 
	 * @param arrs 原始的数组
	 * @return T [] 新的数组对象
	 * @说明: 本方法扩容的因子为 50%
	 */
	@SuppressWarnings("unchecked")
	private T[] getNewArray(T[] arrs) {
		int maxnum = (int) (arrs.length * 1.5);
		T[] newArr = (T[]) new Object[maxnum];
		// 拷贝数据
		int i = 0;
		// 迭代器 保证每个元素都会被迭代一次
		for (T x : arrs) {
			newArr[i++] = x;
		}
		return newArr;
	}
	
	/**
	 * 移除指定位置节点数据
	 * 
	 * @param i
	 */
	public void remove(int i) {
		if (i >= this.size || i < 0) {
			throw new ArrayIndexOutOfBoundsException("数组越界:" + i);
		}
		// 如果移除的节点是第一个节点
		if (i == 0) {
			this.head = this.head.next;
		} else {
			Node<T> front = this.head;
			for (int j = 1; j < i && front != null; j++) {
				front = front.next;
			}
			if (front.next != null) {
				front.next = front.next.next;
			}
		}
		// 节点数减一
		this.size--;
	}
	
	/**
	 * 根据传入的值移除所有和该值相同的节点
	 * 
	 * @param values
	 */
	public void remove(T value) {
		if (value == null) {
			throw new NullPointerException("移除的元素不能为空");
		}
		Node<T> front = this.head;
		// 要移除的位置
		int i = 0;
		// 是否触发过移除操作
		boolean isRemove = false;
		while (front != null) {
			if (front.getData().equals(value)) {
				this.remove(i);
				// 重置i
				i = 0;
				isRemove = true;
			}
			// 如果触发过移除操作，则重新赋予头节点，同时把是否触发过移除操作设为false
			if (isRemove) {
				front = this.head;
				isRemove = false;
			} else {
				i++;
				front = front.next;
			}
		}
	}
	
	/**
	 * 根据传入的数组移除所有和该数组元素值相同的节点
	 * 
	 * @param values
	 */
	public void removeAll(T[] values) {
		if (values != null && values.length != 0) {
			for (int i = 0, len = values.length; i < len; i++) {
				this.remove(values[i]);
			}
		}
	}
	
	/**
	 * 去掉链表中重复的值 
	 */
	@SuppressWarnings("unchecked")
	public void removeDuplicate() {
		T[] tArr = (T[]) new Object[this.size];
		int l = 0;
		Node<T> current = this.head;
		for (int i = 0; i < this.size; i++) {
			tArr[l++] = current.getData();
			current = current.next;
		}
		// 对数组去重，可以使用map或set集合，会更加简便
		for (int i = 0, len = tArr.length; i < len; i++) {
			// 等于null说明是重复的赋值为null就不需要再循循环了
			if (tArr[i] != null) {
				for (int j = i; j < len - 1; j++) {
					// 这里tArr[j+1]!=null同样是因为重复的已为null
					if (tArr[i] == tArr[j + 1] && tArr[j + 1] != null) {
						tArr[j + 1] = null;
					}
				}
			}
		}
		// 清空数据
		this.clear();
		// 重新装数据
		this.set(tArr);
	}
	
	/**
	 * 去泛型数组中重复的值 
	 * 
	 * @param tArr 要去重的泛型数组
	 * @return 返回去重后的Object类型数组
	 * <br/>不返回泛型数组是因为返回了也接收不了，因为java中的强制类型转换只是针对单个对象的，将整个数组转换成另外一种类型的数组是不行的
	 */
	public Object[] removeDuplicate(T[] tArr) {
		// 去掉的重复个数
		int count = 0;
		// 对数组去重，可以使用map或set集合，会更加简便
		for (int i = 0, len = tArr.length; i < len; i++) {
			// 等于null说明是重复的赋值为null就不需要再循循环了
			if (tArr[i] != null) {
				for (int j = i; j < len - 1; j++) {
					// 这里tArr[j+1]!=null同样是因为重复的已为null
					if (tArr[i] == tArr[j + 1] && tArr[j + 1] != null) {
						tArr[j + 1] = null;
						count++;
					}
				}
			}
		}
		if (count == 0) {
			return tArr;
		}
		// 拷贝去重后的数组
		Object[] newArr = new Object[tArr.length - count];
		int l = 0;
		for (int i = 0, len = tArr.length; i < len; i++) {
			if (tArr[i] != null) {
				newArr[l++] = tArr[i];
			}
		}
		return newArr;
	}
	
	/**
	 * 清空所有数据
	 * 
	 * @param i
	 */
	public void clear() {
		this.head = new Node<T>();
		this.size = 0;
	}
	
	/**
	 * 返回链表大小
	 * 
	 * @return
	 */
	public int size() {
		return this.size;
	}

	/**
	 * 判断链表是否为空
	 * 
	 * @return
	 */
	public boolean isEmpty(){
	    return (this.size == 0);
	}
	
	/**
	 * 打印节点信息
	 * 
	 * @return
	 */
	public String display() {
		String str = "{";
		if (this.head != null && this.size != 0) {
			str += this.head.getData() + ",";
			for (Node<T> p = this.head.next; p != null; p = p.next) {
				str += p.getData() + ",";
			}
			str = str.substring(0, str.length() - 1);
		}
		return str + "}";
	}
}


    

    测试类：
    

    public class Test {

	public static void main(String[] args) {
		System.out.println("----------求补集---------");
		complementarySet();
		System.out.println("----------求并集---------");
		unionSet();
		System.out.println("----------求交集---------");
		intersection();
	}
	
	/**
	 * 求补集
	 */
	public static void complementarySet() {
		String[] c1 = { "b", "c", "d", "e", "a" };
		String[] c2 = { "b", "c", "f", "g" };
		SingleLinkedList<String> s1 = new SingleLinkedList<String>(c1);
		SingleLinkedList<String> s2 = new SingleLinkedList<String>(c2);
		System.out.println("初始数据：" + s1.display());
		s1.add("a");
		System.out.println("添加头节点后的数据：" + s1.display());
		s1.add(5, "f");
		System.out.println("添加头节点后再在第6位插入后数据：" + s1.display());
		s1.removeDuplicate();
		System.out.println("去重后的数据：" + s1.display());
		// 补集：属于全集U不属于集合A的元素组成的集合称为集合A的补集
		System.out.print("全集U：" + s1.display());
		s1.removeAll(c2);
		System.out.println("，集合A：" + s2.display() + "，属于全集U不属于集合A的补集：" + s1.display());
		s1.clear();
		System.out.println("清空后：" + s1.display());
	}
	
	/**
	 * 求并集
	 */
	public static void unionSet() {
		String[] c1 = { "a", "b", "c", "d", "e", "a" };
		String[] c2 = { "b", "c", "f", "g" };
		SingleLinkedList<String> s2 = new SingleLinkedList<String>(c2);
		Object[] o1 = s2.removeDuplicate(c1);// 对数组进行去重
		String[] newC = new String[o1.length];
		for (int i = 0, len = o1.length; i < len; i++) {
			newC[i] = (String) o1[i];
		}
		// 其实也可以直接使c1，因为重复的元素已经变成null了
		SingleLinkedList<String> s1 = new SingleLinkedList<String>(newC);
		System.out.println("初始数据：" + s1.display());
		s1.add(5, "f");
		System.out.println("在第6位插入后数据：" + s1.display());
		// 补集：属于全集U不属于集合A的元素组成的集合称为集合A的补集
		System.out.print("集合A：" + s1.display());
		s1.merge(c2);
		System.out.println("，集合B：" + s2.display() + "，集合A和集合B的并集：" + s1.display());
	}
	
	/**
	 * 求交集
	 */
	public static void intersection() {
		String[] c1 = { "b", "c", "d", "e", "a" };
		String[] c2 = { "b", "c", "f", "g" };
		SingleLinkedList<String> s1 = new SingleLinkedList<String>(c1);
		SingleLinkedList<String> s2 = new SingleLinkedList<String>(c2);
		System.out.println("初始数据：" + s1.display());
		s1.add("a");
		System.out.println("添加头节点后的数据：" + s1.display());
		s1.add(5, "f");
		System.out.println("添加头节点后再在第6位插入后数据：" + s1.display());
		// 补集：属于全集U不属于集合A的元素组成的集合称为集合A的补集
		System.out.print("集合A：" + s1.display());
		s1.intersection(c2, s1);
		System.out.println("，集合B：" + s2.display() + "，集合A和集合B的交集：" + s1.display());
	}
}


    

    测试效果图：
    
在这里插入图片描述
    收起
    展开全文
    java单链表 单链表

  • python 求两个矩阵的交集、并集和补集

     千次阅读 2020-08-15 19:38:18
    python 求两个矩阵的交集、并集和补集 https://blog.csdn.net/u012759006/article/details/89642025?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth... 
    python 求两个矩阵的交集、并集和补集
    

    https://blog.csdn.net/u012759006/article/details/89642025?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight
    

    1、求交集
    

    a = [val for val in b if val in c]
    

    2、求并集
    

    a = np.array(list(set(b).union(set©)))
    

    3、求补集
    

    a = np.array(list(set(b) - set©))
    

    Python中numpy数组的拼接、合并https://blog.csdn.net/qq_39516859/article/details/80666070?utm_medium=distribute.pc_relevant.none-task-blog-utm_term-4&spm=1001.2101.3001.4242
    

    python 批量合并Excel表格数据https://blog.csdn.net/weixin_38819889/article/details/101681925?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159749035019725219922712%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=159749035019725219922712&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v3~pc_rank_v3-1-101681925.pc_ecpm_v3_pc_rank_v3&utm_term=python+%E8%A1%A8%E6%A0%BC%E7%9A%84%E5%90%88%E5%B9%B6+%E5%8E%BB%E9%87%8D%E5%A4%8D&spm=1018.2118.3001.4187
    

    python 合并多张excel 处理重复数据https://blog.csdn.net/ronando_lu/article/details/75282244?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-2.edu_weight&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-2.edu_weight
    

    利用Python实现csv文件的合并和去重https://blog.csdn.net/u012735708/article/details/83989842?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159749055019724848322357%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=159749055019724848322357&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v3~pc_rank_v3-1-83989842.pc_ecpm_v3_pc_rank_v3&utm_term=python+%E8%A1%A8%E6%A0%BCcsv%E7%9A%84%E5%90%88%E5%B9%B6+%E5%8E%BB%E9%87%8D%E5%A4%8D&spm=1018.2118.3001.4187
    

    [Python]python对csv去除重复行 python 2020.2.11https://blog.csdn.net/weixin_43847567/article/details/104854111?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight
    

    用pandas库的.drop_duplicates函数
    

    代码如下：
    

    1 import shutil
    
2 import pandas as pd
    
3
    
4
    
5 frame=pd.read_csv(‘E:/bdbk.csv’,engine=‘python’)
    
6 data = frame.drop_duplicates(subset=[‘名称’], keep=‘first’, inplace=False)
    
7 data.to_csv(‘E:/baike.csv’, encoding=‘utf8’)
    

    .drop_duplicates有三个参数
    

    DataFrame.drop_duplicates(subset=None, keep=‘first’, inplace=False)
    

    如subset=[‘A’,‘B’]去A列和B列重复的数据
    

    参数如下：
    

    subset : column label or sequence of labels, optional
    
用来指定特定的列，默认所有列
    
keep : {‘first’, ‘last’, False}, default ‘first’
    
删除重复项并保留第一次出现的项
    
inplace : boolean, default False
    
是直接在原来数据上修改还是保留一个副本
    

    Pandas重复值处理函数drop_duplicates()
    
https://blog.csdn.net/W_weiying/article/details/80394036
    
https://blog.csdn.net/W_weiying/article/details/80231896
    

    Python-pandas中的函数(列表拼接，更改行列名称，选取特定数据等）
    

    python numpy数组求多个筛选条件的结果的交集和并集https://blog.csdn.net/spring_willow/article/details/80779749?utm_source=blogxgwz2
    

    python pandas 更改DataFrame的行名或列名https://blog.csdn.net/weixin_43745169/article/details/89306686?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight
    

    NumPy与Pandas之间的区别？
    
https://blog.csdn.net/qq_41909938/article/details/93863588?utm_medium=distribute.pc_feed_404.none-task-blog-BlogCommendFromBaidu-2.nonecase&depth_1-utm_source=distribute.pc_feed_404.none-task-blog-BlogCommendFromBaidu-2.nonecas
    

        NumPy中的ndarray用于处理多维数值型数组，重点在于进行数值运算，无索引
    *Pandas中的Series类似于DataFrame的子集，DataFrame中的每一列都可以看作是一个Series，有索引，方便进行数据的查询，筛选，所以Pandas重点在于进行数据分析
    在数学与统计方法上，NumPy中的ndarray只能进行数值型统计，而Pandas中的DataFrame既可以进行数值型，也可以进行非数值型统计。基于可以容纳不同的数据类型而定

    

    1.NumPy
    
数值型，重点在于进行矩阵运算
    
ndarray
    

        所有元素的类型相同，存储元素时内存可以连续；Python里list中的元素类型任意，只能通过寻址方式找到下一个元素
    ndarray矩阵结构与matlab或者C++或者fortran都很不一样，没有行优先或者列优先的概念
    ndarray支持并行化运算（向量化运算）,类似于Matlab
    Numpy底层使用C语言编写，内部解除了GIL（全局解释器锁），其对数组的操作速度不受Python解释器的限制，效率远高于纯Python代码


pansdas是基于Numpy的一种工具,该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量快速便捷地处理数据的函数和方法。使Python成为强大而高效的数据分析环境的重要因素之一。
参看书：Series是一种类似于一维数组的对象，它由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。**小规模数据**


    类似于一维数组，索引对象的数据类型是一致的
    有了索引标签，方便实际问题中进行信息提取与筛选
    python字典类型的数据可以直接给Series对象
    Series可以运用ndarray或字典的几乎所有索引操作和函数，融合了字典和ndarray的优点。
DataFrame就是按照column和index组织起来的数据集合，类似于excel表格，也类似于基本的database结构。DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。

    

    Series类似于DataFrame的子集，从上表可以看出，每一列都对应这一个Series
    

    Python numpy，scipy，pandas，sklearn 这些库的区别是什么？https://blog.csdn.net/weixin_35702861/article/details/83181649?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight
    
Scipy库构建于NumPy之上，提供了一个用于在Python中进行科学计算的工具集，如数值计算的算法和一些功能函数，可以方便的处理数据。主要包含以下内容：
    

    统计
优化
集成
线性代数
傅里叶变换
信号和图像处理

    

    简述Python的Numpy,SciPy和Pandas,Matplotlib的区别https://blog.csdn.net/vict_wang/article/details/84744986?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weightScipy：
    

    方便、易于使用、专为科学和工程设计的Python工具包.它包括统计,优化,整合,线性代数模块,傅里叶变换,信号和图像处理,常微分方程求解器等等。基本可以代替Matlab，但是使用的话和数据处理的关系不大，数学系，或者工程系相对用的多一些。
    

    https://blog.csdn.net/SecondRound93/article/details/106619185?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-5.edu_weight&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-5.edu_weight
    收起
    展开全文

  • 交集、并集和补集（阿里大数据系列）

     2020-05-14 17:10:54
    本文为您介绍UNION、UNOIN ALL、UNION DISTINCT并集，INTERSECT、INTERSECT ALL、INTERSECT DISTINCT交集，EXCEPT、EXCEPT ALL、EXCEPT DISTINCT补集等SQL语法。 语法格式 select_statement UNION ALL select_... 
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    求两个列表的交集、并集和补集
    
                                    
                                2021-01-13 22:22:48
                            
    
                            
    
                                
    
                                    1、求交集 a = [3, 4, 5, 6] b = [1, 4, 6, 8] #以下几种方法是等效的 results_1= [x for x in b if x in set(a)] print('results_1:',results_1) results_2= list(set(a) & set(b)) print('results_2:',results...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        列表   
                                        python   
                                        大数据   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    grep和map计算两个集合交集、并集、补集
    
                                    
                                2019-09-28 14:41:19
                            
    
                            
    
                                
    
                                    ######################################## 用grep 和map 获取两个列表的交集并集、补集#######################################my @a=("a","b","c","d","e");my @b=("b","g","f","e");print "列表a数...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Java List的交集，并集和补集
    
                                    
                                2014-01-02 22:46:21
                            
    
                            
    
                                
    
                                    2个List： A和B，各自的size()都是几万的级别，有什么算法可以高效地计算出它们的交集，并集和补集    以并集为例，很容易想到下面的算法：  A.removeAll(B);  A.addAll(B);    但是实验发现，removeAll和addAll效率...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        java   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    集合：求A、B两个集合的交集、并集和补集的代码（C语言）
    
                                    
                                    
                                            万次阅读
                                            多人点赞
                                    
                                2013-10-21 14:59:18
                            
    
                            
    
                                
    
                                    集合：求A、B两个集合的交集、并集和补集的代码（C语言）     #include  #define N 100 main(){ 	int a[N],b[N],c[N],d[N]; 	int aa[N],bb[N]; 	int i,j,k=1; 	int x=1,y=1,z; 	int m,n; 	int flag; 	printf(...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    【Matlab】如何简单实现数组间交集，并集和补集？
    
                                    
                                2020-05-31 17:10:05
                            
    
                            
    
                                
    
                                    还在自己写算法？直接调用官方函数就完事了！ 【数组间交集】 C = intersect(A,B) 【数组间并集】 C = union(A,B) 【数组间补集】 C = setdiff(A,B)
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    大数据集合求交集_高一数学第一次月考内容复习之集合的交集并集与补集
    
                                    
                                2021-01-15 12:38:37
                            
    
                            
    
                                
    
                                    这次课程我们来为大家复习一下集合中的交集和并集，还有补集，到底考试的时候是怎么进行考察的呢？基本概念只有两个集合以上才能进行交集，并集和补集的求解，一个集合不会进行交集，并集和补集的运算。交集：顾名.....
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    2 字符串求交集_高一数学第一次月考内容复习之集合的交集并集与补集
    
                                    
                                2021-01-13 21:44:47
                            
    
                            
    
                                
    
                                    这次课程我们来为大家复习一下集合中的交集和并集，还有补集，到底考试的时候是怎么进行考察的呢？基本概念只有两个集合以上才能进行交集，并集和补集的求解，一个集合不会进行交集，并集和补集的运算。交集：...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    oracle 集合运算--交集、并集、补集、差集
    
                                    
                                2018-01-03 11:47:00
                            
    
                            
    
                                
    
                                    集合运算就是将多个结果集组合成一个结果集，其包括：      INTERSECT (交集)，返回两个查询共有的记录。【A∩B 只取A和B相同的部分，只取一次】          UNION ALL (并集)，返回各个查询的所有记录，包括重复记录...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    输入集合A、B和全集C，求两集合的交集、并集、补集、差集
    
                                    
                                2010-12-04 17:38:00
                            
    
                            
    
                                
    
                                    //输入集合A、B和全集C，求两集合的交集、并集、补集、差集    /*  并集：以属于A或属于B的元素为元素的集合成为A与B的并（集）   交集： 以属于A且属于B的元素为元素的集合成为A与B的交（集）   差：以属于A而不...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    python交集和补集的符号_python的交集、并集、差集
    
                                    
                                2020-11-30 02:58:02
                            
    
                            
    
                                
    
                                    _': a_list = [1, 2, 3, 4, 5] b_list = [1, 4, 5] ret_list = list(set(a_list)^set(b_list)) print(ret_list) 执行结果： 注：此方法中，两个list中的元素不能为字典 ②并集 if __name__ == '__main__': a_list = ...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    利用linux命令sort和uniq求两个文件的交集并集和补集
    
                                    
                                    
                                            千次阅读
                                    
                                2015-09-14 10:23:28
                            
    
                            
    
                                
    
                                    给定两个文件 a.txt 和 b.txt ，每行是一个记录（假设没有重复），要求输出两集合的交集、并集、差集，输出的结果只包括唯一项。交集定义为同时出现在两个文件中的记录项，并集定义为出现在任何一个文件中的记录项，...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    #2 javascript深入浅出--数组的交集、并集、差集和补集
    
                                    
                                2018-09-02 20:50:15
                            
    
                            
    
                                
    
                                    一、交集、并集、差集和补集的概念    注意：在集合论和数学的其他分支中，存在补集的两种定义:相对补集和绝对补集。  1、相对补集  若A 和B 是集合，则A 在B 中的相对补集是这样一个集合:其元素属于B但不属于A，B -...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    集合的交集、并集、补集、差运算的文件迅速处理
    
                                    
                                2018-11-27 16:53:45
                            
    
                            
    
                                
    
                                    【实验目的】掌握用计算机求集合的交、并、差和补运算的方法。  【实验内容】编程实现集合的交、并、差和补运算。  【实验原理和方法】  （1）用数组A，B，C，E表示集合。输入数组A，B，E（全集），输入数据时要求...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    python中交集并集用什么符号表示_python交集和补集的符号_python数组并集交集补集...
    
                                    
                                2021-01-29 04:50:59
                            
    
                            
    
                                
    
                                    并集a = ["a", "b", "c", "d"]b = ["b", "e"]c = ["a", "b", "c", "d", "e"]# 并# 合并数组a.extend(b)# 去重array = list(set(a))print(array)# 第二种方法array = list(set(a)|set(b))print(array)打印结果：['c',...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    linux: 多个文件内容（交集，并集，补集，单词个数统计）
    
                                    
                                    
                                            千次阅读
                                    
                                2018-08-04 15:29:44
                            
    
                            
    
                                
    
                                    原文件如下：    问题如下：  统计两个文件中，单词...	求出文件b 和 (文件a 交集 文件b) 的补集 1，统计单词频数      2，统计ip频数      3，求出两个文件的交集    4，求出文件b (补集) （文件a 交集 文件b）   ...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                

            


            

                

                

                    
                    
空空如也

                

            


            

                

                

                    
                    
空空如也

                

            


            

                


 

 
 
         

            
                     


                    
                        1 
                    
                    
                        2 
                    
                    
                        3 
                    
                    
                        4 
                    
                    
                        5 
                    
                        ... 
                    
                        8 
                    

                    
            
        

   

                

                

            


        

    

    

        

            

                收藏数
                    150
            

            

                精华内容
                    60
            

        

        

            
热门标签

            
        


        


        

            关键字：
交集和并集补集