精华内容
下载资源
问答
  • 一、交集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-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用法

    展开全文
  • 题目:利用单链表求集合的交集并集和补集 要求:使用泛型 /**利用单链表求集合的交集并集和补集 * 要求:使用泛型 * @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());
    	}
    }
    
    

    测试效果图:
    在这里插入图片描述

    展开全文
  • 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

    展开全文
  • 本文为您介绍UNION、UNOIN ALL、UNION DISTINCT并集,INTERSECT、INTERSECT ALL、INTERSECT DISTINCT交集,EXCEPT、EXCEPT ALL、EXCEPT DISTINCT补集等SQL语法。 语法格式 select_statement UNION ALL select_...
  • 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...
  • ######################################## 用grep map 获取两个列表的交集并集补集#######################################my @a=("a","b","c","d","e");my @b=("b","g","f","e");print "列表a数...
  • 2个List: AB,各自的size()都是几万的级别,有什么算法可以高效地计算出它们的交集并集和补集并集为例,很容易想到下面的算法: A.removeAll(B); A.addAll(B); 但是实验发现,removeAlladdAll效率...
  • 集合:求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(...
  • 还在自己写算法?直接调用官方函数就完事了! 【数组间交集】 C = intersect(A,B) 【数组间并集】 C = union(A,B) 【数组间补集】 C = setdiff(A,B)
  • 这次课程我们来为大家复习一下集合中的交集和并集,还有补集,到底考试的时候是怎么进行考察的呢?基本概念只有两个集合以上才能进行交集,并集和补集的求解,一个集合不会进行交集,并集和补集的运算。交集:顾名.....
  • 这次课程我们来为大家复习一下集合中的交集和并集,还有补集,到底考试的时候是怎么进行考察的呢?基本概念只有两个集合以上才能进行交集,并集和补集的求解,一个集合不会进行交集,并集和补集的运算。交集:...
  • 集合运算就是将多个结果组合成一个结果,其包括: INTERSECT (交集),返回两个查询共有的记录。【A∩B 只取AB相同的部分,只取一次】 UNION ALL (并集),返回各个查询的所有记录,包括重复记录...
  • //输入集合A、B全集C,求两集合的交集并集补集、差集 /* 并集:以属于A或属于B的元素为元素的集合成为A与B的并(集) 交集: 以属于A且属于B的元素为元素的集合成为A与B的交(集) 差:以属于A而不...
  • _': 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 = ...
  • 给定两个文件 a.txt b.txt ,每行是一个记录(假设没有重复),要求输出两集合的交集并集、差集,输出的结果只包括唯一项。交集定义为同时出现在两个文件中的记录项,并集定义为出现在任何一个文件中的记录项,...
  • 一、交集并集、差集和补集的概念 注意:在集合论数学的其他分支中,存在补集的两种定义:相对补集绝对补集。 1、相对补集 若A B 是集合,则A 在B 中的相对补集是这样一个集合:其元素属于B但不属于A,B -...
  • 【实验目的】掌握用计算机求集合的交、并、差和补运算的方法。 【实验内容】编程实现集合的交、并、差和补运算。 【实验原理方法】 (1)用数组A,B,C,E表示集合。输入数组A,B,E(全集),输入数据时要求...
  • 并集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',...
  • 原文件如下: 问题如下: 统计两个文件中,单词... 求出文件b (文件a 交集 文件b) 的补集 1,统计单词频数 2,统计ip频数 3,求出两个文件的交集 4,求出文件b (补集) (文件a 交集 文件b) ...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 150
精华内容 60
关键字:

交集和并集补集