精华内容
下载资源
问答
  • python求和函数sum()详解

    万次阅读 多人点赞 2019-04-06 21:32:44
    python求和函数sum()详解 今天在学习的过程中,误用sum()函数,我又去查了查python sum()函数才恍然大悟。 我本来想算几个Int值相加的和,本以为很简单的事情,结果却很悲伤,例: >>>sum = sum(1,2,3) #...

    python求和函数sum()详解

    今天在学习的过程中,误用sum()函数,我又去查了查python sum()函数才恍然大悟。

    我本来想算几个Int值相加的和,本以为很简单的事情,结果却很悲伤,例:

    >>>sum = sum(1,2,3)         #结果很明显出现问题报错
    TypeError: sum expected at most 2 arguments, got 3
    

    傻乎乎的我以为只能算前两个数的和等于3,就又试了一下

    >>>sum = sum(1,2)           #结果还是报错
    TypeError: 'int' object is not iterable
    

    其实,我们所了解sum()函数语法是这样的
    sum(iterable[, start])

    其中

    • iterable – 可迭代对象,如:列表(list)、元组(tuple)、集合(set)、字典(dictionary)。

    • start – 指定相加的参数,如果没有设置这个值,默认为0。

    也就是说sum()最后求得的值 = 可迭代对象里面的数加起来的总和(字典:key值相加) + start的值(如果没写start的值,则默认为0) 所以,我所求的几个int值的和可以写成这样

    >>>sum = sum([1,2,3])             # in list
    6
    

    如果我们加上start的话,应该是这样的

    >>> sum = sum([1,2,3],5)          #in list +start
    11
    >>> sum = sum((1,2,3))            #in tuple
    6
    >>> sum = sum({1,2,3})            #in set
    6
    >>> sum = sum({1:5,2:6,3:7})      #in dictionary key
    6
    >>> sum = sum(range(1,4))         #in range()
    6      
    

    学习这些过后,我们就可以正确的运用sum()函数了。

    别指望着看一遍就能记住和整掌握什么 – 请看第二遍,第三遍。

    展开全文
  • numpy.sum()的使用

    万次阅读 多人点赞 2017-07-28 11:57:07
    numpy的sum函数可接受的形参是:sum(a, axis=None, dtype=None, out=None, keepdims=np._NoValue)a是要进行加法运算的向量/数组/矩阵 axis的值可以为None,也可以为整数和元组 其形参的注释如下: a : array_like ...

    (之前的文章写得不太严谨,根据网友们的提醒进行了一些修改~)
    numpy的sum函数可接受的参数是:

    sum(a, axis=None, dtype=None, out=None, keepdims=np._NoValue)

    在参数列表中:
    a是要进行加法运算的向量/数组/矩阵
    axis的值可以为None,也可以为整数和元组
    其形参的注释如下:

    a : array_like elements to sum.

    a:用于进行加法运算的数组形式的元素

    axis : None or int or tuple of ints, optional
    Axis or axes along which a sum is performed.
    The default, axis=None, will sum all of the elements of the input array.
    If axis is negative it counts from the last to the first axis.
    If axis is a tuple of ints, a sum is performed on all of the axes
    specified in the tuple instead of a single axis or all the axes as before.

    根据上文,可知:
    axis的取值有三种情况:1.None,2.整数, 3.整数元组。
    (在默认/缺省的情况下,axis取None)
    如果axis取None,即将数组/矩阵中的元素全部加起来,得到一个和。
    Example:

    >>> np.sum([0.5, 1.5])
    2.0
    >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
    1
    >>> np.sum([[0, 1], [0, 5]])
    6
    

    如果axis为整数,axis的取值不可大于数组/矩阵的维度,且axis的不同取值会产生不同的结果。
    先以2×2的二维矩阵为例:

    >>> np.sum([[0, 1], [0, 5]], axis=0)
    array([0, 6])
    >>> np.sum([[0, 1], [0, 5]], axis=1)
    array([1, 5])
    

    在上述例子中
    当axis为0时,是压缩行,即将每一列的元素相加,将矩阵压缩为一行
    当axis为1时,是压缩列,即将每一行的元素相加,将矩阵压缩为一列(这里的一列是为了方便理解说的,实际上,在控制台的输出中,仍然是以一行的形式输出的)
    具体理解如图:
    在这里插入图片描述
    当axis取负数的时候,对于二维矩阵,只能取-1和-2(不可超过矩阵的维度)。
    当axis=-1时,相当于axis=1的效果,当axis=-2时,相当于axis=0的效果。

    如果axis为整数元组(x,y),则是求出axis=x和axis=y情况下得到的和。
    继续以上面的2×2矩阵为例

    >>>np.sum([[0,1],[0,5]],axis=(0,1))
    >>>6
    >>>np.sum([[0,1],[0,5]],axis=(1,0))
    >>>6
    

    另外,需要注意的是:如果要输入两个数组/矩阵/向量进行相加,那么就要先把两个数组/矩阵/向量用一个括号括起来,形成一个元组,这样才能够进行相加。因为numpy.sum的运算实现本质是通过矩阵内部的运算实现的。

    当然,如果只是向量/数组之间做加法运算,可以直接让两个向量/数组相加,但前提是它们必须为numpy的array数组才可以,否则只是单纯的列表相加
    Example:

    >>>v1 = [1, 2]
    >>>v2 = [3, 4]
    >>>v1 + v2
    [1, 2, 3, 4]
    
    >>>v1 = numpy.array[1, 2]
    >>>v2 = numpy.array[3, 4]
    >>>v1 + v2
    [4, 6]
    
    展开全文
  • python sum_Python sum()

    千次阅读 2020-07-11 05:24:52
    python sumPython sum() function is used to get the sum of numbers of an iterable. Python sum()函数用于获取可迭代数的总和。 Python sum() (Python sum()) Python sum() function syntax is: Python sum...

    python sum

    Python sum() function is used to get the sum of numbers of an iterable.

    Python sum()函数用于获取可迭代数的总和。

    Python sum() (Python sum())

    Python sum() function syntax is:

    Python sum()函数语法为:

    sum(iterable[, start])

    start is an optional number with default value of 0. If start is provided, then the sum of start and all the numbers in the iterable is returned.

    start是一个可选数字,默认值为0。如果提供了start,则将返回start和可迭代对象中所有数字的总和。

    Python sum()数字列表 (Python sum() list of numbers)

    s = sum([1, 2, 3])
    print(s)
    
    s = sum([1, 2, 3], 10)
    print(s)

    Output:

    输出:

    6
    16

    Note that sum() method doesn’t take keyword arguments, so if we write sum([1, 2, 3], start=10) then it will throw exception as TypeError: sum() takes no keyword arguments.

    请注意,sum()方法不带关键字参数,因此,如果我们编写sum([1, 2, 3], start=10) ,它将抛出异常,因为TypeError: sum() takes no keyword arguments

    Python整数序列的总和 (Python sum of a sequence of integers)

    Since sum accepts iterable as argument, we can pass tuple, bytes of numbers too.

    由于sum接受iterable作为参数,因此我们也可以传递tuple ,数字字节。

    s = sum(bytes([1, 2]))
    print(s)
    
    s = sum(bytearray([1, 2]), 10)
    print(s)
    
    # sum of integers in different formats, tuple of numbers
    s = sum((1, 0b11, 0o17, 0xFF))
    print(s)
    
    s = sum((1, 0b11, 0o17, 0xFF), 0xF)
    print(s)

    Output:

    输出:

    3
    13
    274
    289

    Python的浮点数总和 (Python sum of floats)

    s = sum([1.5, 2.5, 3])
    print(s)

    Output: 7.0

    输出: 7.0

    If you want to add floating point values with extended precision, you can use math.fsum() function.

    如果要添加扩展精度的浮点值,则可以使用math.fsum()函数。

    Python的复数和 (Python sum of complex numbers)

    sum() function works with complex numbers too.

    sum()函数也适用于复数。

    s = sum([1 + 2j, 3 + 4j])
    print(s)
    
    s = sum([1 + 2j, 3 + 4j], 2 + 2j)
    print(s)
    
    s = sum([1 + 2j, 2, 1.5 - 2j])
    print(s)

    Output:

    输出:

    (4+6j)
    (6+8j)
    (4.5+0j)
    GitHub Repository.GitHub存储库中检出完整的python脚本和更多Python示例。

    Reference: Official Documentation

    参考: 官方文档

    翻译自: https://www.journaldev.com/23147/python-sum

    python sum

    展开全文
  • 【算法】2SUM/3SUM/4SUM问题

    万次阅读 2017-04-26 01:21:50
    之前就总结过一些Leetcode上各种sum问题,今天再拿出来完整得总结一番。 nSUM问题是指,在一个数组中,找出n个数相加和等于给定的数,这个叫做nSUM问题。 常见的有2SUM,3SUM,4SUM问题,还有各种SUM问题的变种....

    之前就总结过一些Leetcode上各种sum问题,今天再拿出来完整得总结一番。
    nSUM问题是指,在一个数组中,找出n个数相加和等于给定的数,这个叫做nSUM问题。
    常见的有2SUM,3SUM,4SUM问题,还有各种SUM问题的变种.
    Leetcode上SUM问题包括:
    1. 2SUM
    15. 3Sum
    16. 3Sum Closest
    18. 4Sum
    454. 4Sum II

    2SUM问题

    最常见的是2SUM问题(1. 2SUM),就是数组中找出两个数相加和为给定的数。
    这道题有两种思路:
    1. 一种思路从首尾搜索两个数的和,并逐步逼近。
    2. 另外一种思路是固定一个数A,看SUM-A是否在这个数组之中。

    对于第一种思路如下:

    此方法是先将数组从小到大排序
    设置两个指针,一个指向数组开头,一个指向数组结尾,从两边往中间走。直到扫到满足题意的为止或者两个指针相遇为止。
    此时这种搜索方法就是类似于杨氏矩阵的搜索方法,就是从 杨氏矩阵的左下角开始搜索,直到找到为止。
    如果此时题目条件变为如果没有找出最接近的2SUM和问题,解决方法跟上面是一样的
    用这种方法2SUM问题的时间复杂度是O(nlogn)的,主要在于排序的时间。

    第二种思路方法如下:

    对数组中的每个数建立一个map/hash_map 然后再扫一遍这个数组,判断target-nums[i]是否存在,如果存在则说明有,不存在继续找。当然这样做的话,需要处理一个细节:判重的问题。
    代码如下【注意因为题目中说一定有解所以才下面这样写,如果不一定有解,则还要再加一些判断】

    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,vector<int>> mark;
        for(int i=0;i<nums.size();i++)
            mark[nums[i]].push_back(i);
        for(int i = 0;i<nums.size();i++){
            if(target-nums[i] == nums[i]){
                if(mark[nums[i]].size() > 1){
                    vector<int> tmp{i,mark[nums[i]][1]};
                    return tmp;
                }
            }else{
                if(mark.find(target-nums[i]) != mark.end()){
                    vector<int> tmp{i,mark[target-nums[i]][0]};
                    return tmp;
                }
            }
        }
    }

    这种方法的时间复杂度为O(n)

    比较一下这两个方法:

    第一种方法的思路还是比较好的,鲁棒性好,而且写起来比较容易,但是因为预处理——排序的时间复杂度占了大头,所以其总时间复杂度为O(nlogn)
    第二种方法,时间复杂度低,但是需要处理重复情况,略麻烦

    3SUM问题

    然后对于3 Sum问题,解决方法就是最外层遍历一遍,等于选出一个数,
    之后的数组中转化为找和为target-nums[i]的2SUM问题。
    因为此时排序复杂度在3SUM问题中已经不占据主要复杂度了,所以直接采用思路1的方法就好。

    void two_sum(vector<int>& nums,int i,int target,vector<vector<int>> &result){
        int j = nums.size()-1;
        int b = i-1;
        while(i<j){
            if(nums[i]+nums[j] == target){
                result.push_back(vector<int>{nums[b],nums[i],nums[j]});
                //处理重复的情况
                i++;
                j--;
                while(i<j && nums[i] == nums[i-1]) i++;
                while(i<j && nums[j+1] == nums[j]) j--;
            }else{
                if(nums[i]+nums[j] < target)
                    i++;
                else
                    j--;
            }
        }
        return;
    }
    vector<vector<int>> threeSum(vector<int>& nums) {
        set<vector<int>> result;
        vector<vector<int>> result2;
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size();i++)
            if(i>0&&nums[i-1]== nums[i])
                continue;
            else
                two_sum(nums,i+1,-nums[i],result2);
    
        return result2;
    }

    对于3SUM问题,上面这个解法的时间复杂度为O(n2)
    其实对于3SUM问题,另外一种求解思路就是,先预处理一遍数组中两两相加的结果,然后再遍历每一个数nums[i],判断target-nums[i]是否在预处理的那个和中,不过这种方法的复杂度也是O(n2)主要是预处理的复杂度。

    4SUM问题

    对于4Sum问题又衍生出了两种思路:
    1. 先遍历第一个数,然后固定第一个数之后,转化为剩下元素的3SUM问题
    2. 先遍历两个数,求和,然后转化为剩下元素的2SUM问题

    第一种思路

    其算法复杂度是稳定的O(n3),最外层遍历一遍O(n),然后转为3SUM问题之后又是O(n2)。这种方法相当于4SUM调用3SUM,然后3SUM再调用2SUM,这样函数调用有点多,不方便

    具体写出来的形式,可以写成最外层两个循环,即固定为两个数之后,再化为2SUM。
    代码如下【这个代码我是抄的Discuss里的,我自己的是层层调用嵌套形式的写法,运行时间有点长】

    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> total;
        int n = nums.size();
        if(n<4)  return total;
        sort(nums.begin(),nums.end());
        for(int i=0;i<n-3;i++)
        {
            if(i>0&&nums[i]==nums[i-1]) continue;
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target) break;
            if(nums[i]+nums[n-3]+nums[n-2]+nums[n-1]<target) continue;
            for(int j=i+1;j<n-2;j++)
            {
                if(j>i+1&&nums[j]==nums[j-1]) continue;
                if(nums[i]+nums[j]+nums[j+1]+nums[j+2]>target) break;
                if(nums[i]+nums[j]+nums[n-2]+nums[n-1]<target) continue;
                int left=j+1,right=n-1;
                while(left<right){
                    int sum=nums[left]+nums[right]+nums[i]+nums[j];
                    if(sum<target) left++;
                    else if(sum>target) right--;
                    else{
                        total.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});
                        do{left++;}while(nums[left]==nums[left-1]&&left<right);
                        do{right--;}while(nums[right]==nums[right+1]&&left<right);
                    }
                }
            }
        }
        return total;
    }

    第二种思路

    因为本质上我们是最外层两个循环之后,找是否有target-now的值,我们可以事先做好预处理,即空间换时间,先循环两次,找出两个数所有可能的和,存到map里(这里可以unordered_map)。这两等于是两个O(n2)的时间复杂度相加和,所以最后时间复杂度为O(n2)
    但是此时需要有一个判重的问题,所以需要map中存如下数
    mp[num[i]+num[j]].push_back(make_pair(i,j));
    然后再判重。

    typedef pair<int,int> pii ;
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        unordered_map<int,vector<pii>> mark;
        set<vector<int>> res;
        vector<vector<int>> res2;
        if(nums.size()<4)
            return res2;
     //这个地方也可以不用排序的,排序是因为减少一些计算量,方便下面的循环判定提前跳出条件
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size();i++)
            for(int j=i+1;j<nums.size();j++)
                mark[nums[i]+nums[j]].push_back(make_pair(i,j));
    
    //注意注意这个地方有一个巨大的坑,中间的判断条件: i<nums.size()-3,会陷入到死循环中
    //因为nums.size()是一个unsigned的类型,其与int相运算,得到的还是unsigned!!!!!
    //所以如果nums.size()<3的话就会出现死循环,切记切记
        for(int i=0;i<nums.size()-3;i++){
        //先判定,提前跳出的情况
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target)
                break;
            for(int j=i+1;j<nums.size()-2;j++){
                if(mark.find(target-(nums[i]+nums[j])) != mark.end()){
                    for(auto &&x:mark[target-(nums[i]+nums[j])]){
                        if(x.first>j){
                            vector<int> tmp{nums[i],nums[j],nums[x.first],nums[x.second]};
                            res.insert(tmp);
                        }
                    }
                }
            }
        }
    
        for(auto &&x:res){
            res2.push_back(x);
        }
        return res2;
    }

    因为需要判重,所以最糟糕情况下其时间复杂度为O(n4)
    那么如果没有判重问题,是否就可以解决了呢?
    那就是454. 4Sum II问题
    这道题是在四个数组中,各选出一个数,使其和为某一定值。
    则可以按照上述方法,讲前两个数组所有可能的和做一个map,然后遍历后两个数组所有可能的和,所以这个是O(n2)的算法。

    nSUM问题的推广和复杂的分析

    按照上面的算法复杂度思路,4~6SUM问题,都可以用O(n3)来解决。

    比如对于6SUM问题,先用一个O(n3)的方法,将其中所有三个数相加的可能的情况都保存下来,这一步的时间复杂度是O(n3)。接下来用两种方法都行:
    1. 遍历三个数,然后看剩下的和是否在保存的可能性中。这一步的时间复杂度是O(n3)
    2. 直接在保存的可能性中遍历,遍历到SUM1之后,看target-SUM1是否也在这个可能性中。这一步的时间复杂度是O(n2)

    展开全文
  • 2sum/3sum/ksum 问题

    千次阅读 2016-04-25 16:53:50
    这个是面试中碰到的一个问题,还没有时间仔细实现,在网上一篇文章,转载一下,代码稍后补上。 网址: ...Summary for LeetCode 2Sum, 3Sum, 4Sum, K Sum Overview I summarize
  • np.sumsum的区别

    千次阅读 2019-01-05 10:28:02
    2. 在数组和矩阵中使用sum: 对数组b和矩阵c,代码b.sum(),np.sum(b),c.sum(),np.sum(c)都能将b、c中的所有元素求和并返回单个数值。 但是对于二维数组b,代码b.sum(axis=0)指定对数组b对每列求...
  • sum(sum(abs(y))) 中 sum(sum())什么意思?

    千次阅读 2016-12-19 21:30:55
    >> y=[1 3;2 5] y =  1 3  2 5 >> sum(y) ans =  3 8 >> sum(sum(y)) ans =  11 --------------------------------------------------
  • sum(sum()) 含义

    千次阅读 2018-08-01 10:29:25
    sum(sum(y)) 求矩阵y所有元素的和。 sum(y) 是对矩阵各个列求和 例如: y=[1 2 ; 3 4 ]   ====》 y = 1 2  3 4   ====》sum(y) = 4 6   ====sum(sum(y)) =10   参考:...
  • 以下链接均为我博客内对应博文,有解题思路和代码,不定时更新补充。...K sum的求和问题一般是这样子描述的:给你一组N个数字(比如 vector num), 然后给你一个目标常数(比如 int target) ,我们的目的是在这一堆
  • 关于累加器例如sum+=i与sum=sum+i的区别

    千次阅读 多人点赞 2018-04-14 11:29:06
    程序中往往我们都认为sum+=i与sum=sum+i是等价的,但在类型转换时是有区别的例如:下面是sum=sum+i的情况:编辑通不过,计算时发生类型转化,int类型不会转换成short类型,需要我们强制转化 short sum=0; short i=0...
  • sum(-1)和sum(1) 用途:求数组每一列的和,等价于 sum(axis=1) #关于axis的理解可以参考博主的另一篇文章【python】axis的理解 >>> import numpy as np >>> x = np.array([[0, 1], [1, 1], [2...
  • Path Sum

    千次阅读 2015-01-09 15:29:55
    Path Sum
  • 做过leetcode的人都知道, 里面有2sum, 3sum(closest), 4sum等问题, 这些也是面试里面经典的问题, 考察是否能够合理利用排序这个性质, 一步一步得到高效的算法. 经过总结, 本人觉得这些问题都可以使用一个通用的K sum...
  • 这几天在做LeetCode 里面有2sum, 3sum(closest), 4sum等问题, 这类问题是典型的递归思路解题,该这类问题的关键在于,在进行求和求解前,要先排序Arrays.sort()可实现,而本文则着重探讨关于KSum问题。 leetcode...
  • [LeetCode] 2Sum, 3Sum, 4Sum, 3SUm closet

    千次阅读 2013-10-27 09:31:52
    1. 2Sum: hash Table O(n*n) 2. 3Sum: 2Sum + 1 : O(n*n) for loop + 左右夹逼法:O(N*N) class Solution { public:  vector > threeSum(vector &num) {  // Note: The Solution object is ...
  • Opencv Mat元素求和sum

    万次阅读 2019-01-16 18:17:06
    sum函数声明: CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src); 其返回的是一个Scalar数据类型, Mat s = Mat::ones(3, 3, CV_8UC1); Scalar ss = sum(s); cout &lt;&lt; ss[0] &lt;&lt; ...
  • 人 sigmainfy — ...做过leetcode的人都知道, 里面有2sum, 3sum(closest), 4sum等问题, 这些也是面试里面经典的问题, 考察是否能够合理利用排序这个性质, 一步一步得到高效的算法. 经过总结, 本人觉得
  • mysql sum(1) sum(0) 区别

    千次阅读 2020-03-23 19:40:22
    sum(1) 相当于count(1) 求的就是行数统计 但可以在sum中使用 if,ifnull,case条件判断函数,指定具体行是否要统计,可用于分组查询同一字段的不同条件的统计 例如统计各班男女人数:select cid,sum(CASE WHEN sex...
  • python中的sum函数.sum(axis=1)

    万次阅读 多人点赞 2013-11-29 16:02:29
    看起来挺简单的样子,但是在给sum函数中加入参数。sum(a,axis=0)或者是.sum(axis=1) 就有点不解了 在我实验以后发现 我们平时用的sum应该是默认的axis=0 就是普通的相加  而当加入axis=1以后就是将一个矩阵...
  • sum(1,2)和sum(1)(2)
  • K sum

    千次阅读 2014-05-16 16:06:28
    这里有一个介绍的比较系统的Ksum文章 http://tech-wonderland.net/blog/summary-of-ksum-problems.html 前言: 做过leetcode的人都知道, 里面有2sum, 3sum(closest), 4sum等问题, 这些也是面试里面经典...
  • 经典公式sum=sum+i求和函数

    千次阅读 2017-08-01 16:18:27
    一.求和公式 ...经典求和公式:sum=sum+i;  初始化 ①i=1; ②sum=0; 二.实例:求1~100的和 Ⅰ错误代码 ①重复定义sum ②打印循环 Ⅱ.正确求和代码 ①使循环到最后一次,打印sum即可
  • Prefix Sum 总结

    千次阅读 2020-03-23 14:41:54
    Interval Sum Given an integer array (index from 0 to n-1, where n is the size of this array), and an query list. Each query has two integers[start, end]. For each query, calculate the sum number bet....
  • Numpy中sum函数(Python自带sum函数)的作用是对元素求和。 无参时,所有全加; axis=0,按列相加; axis=1,按行相加; 下边通过例子来说明其用法: #!/usr/bin/env python # -*- coding:utf-8 -*- from numpy...
  • sum : sum(iterable, [start=0] ) :求和运算参数说明:iterable:可迭代对象,如列表。start:指定相加的参数,如果没有设置这个值,默认为0list for sum()print(sum([0,1,2])) # 无第二个参数,默认为0 结果=3print...
  • python中sum()和np.sum()

    千次阅读 2019-06-05 19:43:04
    偶然发现对于二维array数组,求数组所有元素之和,必须用np.sum(array) sum(sum(array))求的不是所有元素之和,找了半天错误,原来是这里出问题了
  • md5sum与sha1sum命令

    千次阅读 2016-10-03 21:00:30
    转载自 ... md5sum与sha1sum命令用于对文件进行校验和,如: $ md5sum a.txt f377aaac2f5d73e805212e5d6249cf5b4b4d8ce2 a.txt md5sum命令也可以接受多个文件或通配符,如: $ md5sum file1

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 267,887
精华内容 107,154
关键字:

sum