精华内容
下载资源
问答
  • , nan, nan], [ 0.25 , 0.4 , 0.64 , 0.84 , nan]]) 我需要为每一行找到最大值的列,但最大值必须小于1. 在上面的数组中,第0行应该返回Nan. 第2行应返回1. 第3行应该返回3. 我不知道如何在argmax上对此进行调整. ...

    我有一个numpy数组:

    myArray

    array([[ 1. , nan, nan, nan, nan],

    [ 1. , nan, nan, nan, nan],

    [ 0.63 , 0.79 , 1. , nan, nan],

    [ 0.25 , 0.4 , 0.64 , 0.84 , nan]])

    我需要为每一行找到最大值的列数,但最大值必须小于1.

    在上面的数组中,第0行应该返回Nan.

    第2行应返回1.

    第3行应该返回3.

    我不知道如何在argmax上对此进行调整.

    解决方法:

    这是np.where的一种方法 –

    m = a < 1 # Mask of elems < 1 and non-NaNs

    # Set NaNs and elems > 1 to global minimum values minus 1,

    # so that when used with argmax those would be ignored

    idx0 = np.where(m, a,np.nanmin(a)-1).argmax(1)

    # Look for rows with no non-NaN and < 1 elems and set those in o/p as NaNs

    idx = np.where(m.any(1), idx0, np.nan)

    样品运行 –

    In [97]: a

    Out[97]:

    array([[ 1. , nan, nan, nan, nan],

    [ 1. , nan, nan, nan, nan],

    [ 0.63, 0.79, 1. , nan, nan],

    [ 0.25, 0.4 , 0.64, 0.84, nan]])

    In [98]: m = a < 1

    In [99]: idx0 = np.where(m, a,np.nanmin(a)-1).argmax(1)

    In [100]: idx0

    Out[100]: array([0, 0, 1, 3])

    In [101]: np.where(m.any(1), idx0, np.nan)

    Out[101]: array([ nan, nan, 1., 3.])

    标签:python,numpy

    来源: https://codeday.me/bug/20190522/1154539.html

    展开全文
  • 简介 Python是一门十分通用的语言,特别是在数据分析和机器学习方面有很大的应用。本文主要讲解了python的基础入门知识,为初学者简单的提供入门方法,下面将进行简要介绍。一.变量与运算符 1.注释 在python中#表示...

    ecb999e686f3fca38b6f43bc6eb380c8.png

    简介

    Python是一门十分通用的语言,特别是在数据分析和机器学习方面有很大的应用。本文主要讲解了python的基础入门知识,为初学者简单的提供入门方法,下面将进行简要介绍。

    一.变量与运算符

    1.注释

    在python中#表示注释,作用于整行。''' ''' 或者 """ """ 表示区间注释,在三引号之间的所有内容被注释。

    2.运算符

    算术运算符:操作符 名称 示例

    +1 + 1

    -2 - 1

    *3 * 4

    /3 / 4

    // 整除(地板除)3 // 4

    % 取余 3 % 4

    **2 ** 3

    逻辑运算符:操作符 名称 示例

    and(3 > 2) and (3 < 5)

    or(1 > 3) or (9 < 2)

    notnot (2 > 1)

    位运算符: 操作符 名称 示例

    ~ 按位取反 ~4

    & 按位与 4 & 5

    ` ` 按位或 ^ 按位异或 4 ^ 5

    << 左移 4 << 2

    >> 右移 4 >> 2

    比较运算符:操作符 名称 示例

    > 大于 2 > 1

    >= 大于等于 2 >= 4

    < 小于 1 < 2

    <= 小于等于 5 <= 2

    == 等于 3 == 4

    != 不等于 3 != 5

    3.变量和赋值

    在使用变量之前,需要对其先赋值。变量名可以包括字母、数字、下划线、但变量名不能以数字开头。Python 变量名是大小写敏感的,foo != Foo。

    4.数据类型与转换

    类型 名称 示例

    int 整型 <class 'int'> -876, 10

    float 浮点型<class 'float'> 3.149, 11.11

    bool 布尔型<class 'bool'> True, False

    类型转换:

    • 转换为整型 int(x, base=10)
    • 转换为字符串 str(object='')
    • 转换为浮点型 float(x)

    5.print()

    print(*objects, sep=' ', end='n', file=sys.stdout, flush=False)
    • 将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按str()方式进行转换为字符串输出;
    • 关键字参数sep是实现分隔符,比如多个参数输出时想要输出中间的分隔字符;
    • 关键字参数end是输出结束时的字符,默认是换行符n
    • 关键字参数file是定义流输出的文件,可以是标准的系统输出sys.stdout,也可以重定义为别的文件;
    • 关键字参数flush是立即把内容输出到流文件,不作缓存。

    二.位运算

    1.反码原码和补码

    二进制有三种不同的表示形式:原码、反码和补码,计算机内部使用补码来表示。

    原码:就是其二进制表示(注意,有一位符号位)。

    反码:正数的反码就是原码,负数的反码是符号位不变,其余位取反(对应正数按位取反)。

    补码:正数的补码就是原码,负数的补码是反码+1。

    符号位:最高位为符号位,0表示正数,1表示负数。在位运算中符号位也参与运算。

    2.按位运算

    3. 利用位运算实现快速计算

    通过 <<,>> 快速计算2的倍数问题。
    通过 ^ 快速交换两个整数。 通过 ^ 快速交换两个整数。
    通过 a & (-a) 快速获取a的最后为 1 位置的整数

    4. 利用位运算实现整数集合

    一个数的二进制表示可以看作是一个集合(0 表示不在集合中,1 表示在集合中)。

    比如集合 {1, 3, 4, 8},可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。

    • Python中bin一个负数(十进制表示),输出的是它的原码的二进制表示加上个负号。
    • Python中的整型是补码形式存储的。
    • Python中整型是不限制长度的不会超范围溢出。

    所以为了获得负数(十进制表示)的补码,需要手动将其和十六进制数0xffffffff进行按位与操作,再交给bin()进行输出,得到的才是负数的补码表示。

    展开全文
  • 微信公众号:龙跃十二 ... python中对于字符串的表示和其他语言基本一样,都是用string来表示字符串,不同的是,python在使用字符串的时候同样不需要定义。字符串的表示:先举一个例子:str = "hello wor...
    微信公众号:龙跃十二
    持续更新,欢迎关注!
    用心分享,共同成长
    没有什么比你每天进步一点点更实在了

    本文已经收录至我的GitHub,欢迎大家踊跃star 。 GitHub

    我是小玉,一个平平无奇的小天才! python中对于字符串的表示和其他语言基本一样,都是用string来表示字符串,不同的是,python在使用字符串的时候同样不需要定义。

    字符串的表示:

    先举一个例子:

    str = "hello world!"
    

    这就是一句python的字符串表达式。 需要注意的是,在使用字符串的时候,我们需要将字符串用引号引起来,单引号和双引号均可。 注: 1、这里的引号不能混合使用 例如:

    str = "hello world!'
    

    2、相同类型的引号不可嵌套使用。 例如:

    str = "hello "this" world!"
    

    3、引号不可以换行使用。 例如:

    str = "hello 
           world!"
    

    这些做法都是不正确的,虽然是很简单的问题,但是很多人在使用的时候总会忽略。 那么就产生一个问题,如果要在一个字符串中引用其他字符串怎么办? 学会这一招:

    str = "hello 'this' world!"
    

    这样就可以直接使用,但必须保证引号是成对出现的哦。

    转义字符:

    通常情况下,我们一般使用 表示转义字符,使用r可以让反斜杠不发生转义。

    格式化字符串:

    占位符: 1、%s占位符,表示一个任意的字符 2、%f浮点数的占位符 3、%d整数的占位符 字符串前加f来创建一个格式化字符串,格式化字符串中可以直接嵌入变量。 字符串可以用+运算符连接在一起,用*运算符重复 举个例子:

    s = 小玉
    print('欢迎'+s+'光临')
    print('欢迎',s,'光临')
    print('欢迎%s光临'%s)
    print(f'欢迎{s}光临')
    

    ad324249e79a302a4d24b9a44a21c023.png

    你明白了吗?觉着小玉的分享还不错就点个关注吧。

    展开全文
  • 十大排序算法(python) 在计算机编程时,我们经常需要对一系列进行排序,在这里,我将列出十种不同的排序算法,给出它们的python代码,并计算出它们的时间复杂度。0排序算法说明0.1排序的定义 对一序列对象根据...

    十大排序算法(python)

    在计算机编程时,我们经常需要对一系列数进行排序,在这里,我将列出十种不同的排序算法,给出它们的python代码,并计算出它们的时间复杂度。

    0排序算法说明

    0.1排序的定义

    对一序列对象根据某个关键字进行排序。

    0.2 术语说明

    稳定 :如果a原本在b前面,而a=b,排序之后a仍然在b的前面;

    不稳定 :如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;

    内排序 :所有排序操作都在内存中完成;

    外排序 :由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行;

    时间复杂度 : 一个算法执行所耗费的时间。

    空间复杂度 :运行完一个程序所需内存的大小。

    0.3 算法总结

    4273433554b9ced9da20b22d94107abd.png

    名词解释:

    · n: 数据规模

    · k: “桶”的个数

    · In-place: 占用常数内存,不占用额外内存

    · Out-place: 占用额外内存1

    0.4算法分类

    961d72dc5c364b8c47b33ea698d49345.png

    Figure 1注:我使用的shell排序是交换排序,当然也可以用插入排序

    0.5比较和非比较的区别

    常见的快速排序、归并排序、堆排序、冒泡排序 等属于比较排序 。在排序的最终结果里,元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较,才能确定自己的位置 。

    在冒泡排序之类的排序中,问题规模为n,又因为需要比较n次,所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中,问题规模通过分治法消减为logN次,所以时间复杂度平均O(nlogn)。

    比较排序的优势是,适用于各种规模的数据,也不在乎数据的分布,都能进行排序。可以说,比较排序适用于一切需要排序的情况。

    计数排序、基数排序、桶排序则属于非比较排序 。非比较排序是通过确定每个元素之前,应该有多少个元素来排序。针对数组arr,计算arr[i]之前有多少个元素,则唯一确定了arr[i]在排序后数组中的位置 。

    非比较排序只要确定每个元素之前的已有的元素个数即可,所有一次遍历即可解决。算法时间复杂度O(n)。

    非比较排序时间复杂度底,但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。[1]

    1冒泡排序(bubble sort)

    冒泡排序通过重复走访要排序的数列,依次比较数列中相邻的两个数,如果逆序,则将这两个数交换,变为顺序。算法终止的条件是对数列中的任意两个数我们都不可交换它们的位置,也就是数列中所有数都为顺序。在操作n次之后,整个数列将按从小到大的顺序排列。在每一次操作中,我们需要比较O(n)次,共执行n次,算法的时间复杂度为O(n^2)。

    算法描述:从第一个数开始,依次比较相邻两个数,如果第一个数大于第二个数,则交换它们之间的位置。在经过一轮操作后,最大的数将被移动到数列最右端。我们继续对剩下的n-1个数进行操作,从而可以将这n-1个数中最大的数移动到剩下的数最右端。重复进行,直到遍历完整个数列,算法终止。

    def bubble_sort(n):
        '''冒泡排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        i=len(n)
        while i > 1:
            j=0
            while j < i-1:
                if n[j]<=n[j+1]:
                    j+=1
                else:
                    n[j],n[j+1]=n[j+1],n[j]#不是正序则交换两数
                    j+=1
            i-=1
        return n

    2选择排序(selection sort)

    选择排序是从未排序数列中选择最小的数,存放到排序数列中的起始位置,然后再选出第二小的数,附在已排序数列的最后。这样我们就可以将数列从小到大地进行排序。算法终止的条件是遍历完原数列。我们每次操作需要在原数列中比较O(n)次,共执行n次,算法的时间复杂度为O(n^2)。

    算法描述:我们从原数列中选出最小的数,将其导出(pop,缩短原列表长度,可以减少运算时间),并将其返回到一个新数列中。重复操作,直到原数列中不含元素,算法终止。

    def selection_sort(n):
        '''选择排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        s=[]#输出列表
        i=0
        while i < len(n):
            min_num=n[i]
            for j in range(i,len(n)):
                if n[j]<min_num:
                    min_num=n[j]
            n.remove(min_num)
            s.append(min_num)
        return s
    

    3插入排序(insertion sort)

    插入排序是先构建一个有序数列,然后从无序数列中选出一个数,将其插入到有序数列对应位置中。插入时需要比较O(n)次,共需操作n次,算法的时间复杂度为O(n^2)

    算法描述:选出原数列第一个元素作为有序数列的起始,然后从原数列中选出下一个数,将所选出的数从后向前与有序数列中的数进行比较,若小于则与有序数列中的前一个数进行比较,直到选出的数大于有序数列中的某个数,此时我们将选出的数插入到有序数列的中的那个数之后。依次遍历整个原数列,遍历结束,算法终止。

    def insertion_sort(n):
        '''插入排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        s=[n[0]]
        i=1
        while i < len(n):
            j=-1
            if n[i]>=s[j]:
                s.append(n[i])
            elif n[i]<=s[0]:
                s.insert(0,n[i])
            else:
                while n[i] < s[j]:
                    if n[i] >= s[j-1]:
                        s.insert(j,n[i])
                    j-=1
            i+=1
        return s
    

    4希尔排序(shell sort)

    希尔排序是通过将原数列进行多次分组,在每一组内部进行排序。它会优先比较距离比较远的元素,从而可以使操作次数大幅下降。希尔排序是对原数列按一定增量分组,对每组进行排序;随着增量逐渐减少,每组包含的数越来越多,当增量减至1时,整个文件恰被分成一组,算法终止。每次操作需要比较n次共需操作 次,算法的时间复杂度为O(nlogn)。

    算法描述:我们先选择增量gap=len(n)//2,每次操作后依次后缩小增量为gap=gap//2,直到gap=1。然后我们根据增量对原数列进行分组,在每组内部使用冒泡排序算法进行排序(也可以使用插入排序算法,插入排序算法更快)。当增量为1时,程序进行最后一次操作,之后算法终止。

    def shell_sort(n):
        '''希尔排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        gap=len(n)//2#间距
        while gap > 0:
            for i in range(gap,len(n)):
                j=i
                while j>=gap:
                    if n[j] < n[j-gap]:
                        n[j],n[j-gap]=n[j-gap],n[j]
                        j-=gap
                    else:
                        break
            gap=gap//2
        return n
    

    5归并排序(merge sort)

    归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法,将原数列进行分组,分为左右两个数列,然后继续对左右两个数列进行分组,直到每组所含元素为1。然后对每个子序列进行排序,将有序的子数列合并,然后继续排序,直到得到完全有序的原数列。即先使每个子序列有序,再使子序列段间有序,最终返回一个完全有序的数列。分组需要操作 次,每次操作排序需要n次,算法时间复杂度为O(nlogn)

    算法描述:将原数列进行分组,分为左右两个数列,然后继续对左右两个数列分别采用归并排序。最后将两个排序好的子序列合并成一个最终的排序序列 。算法终止,直到递归结束。

    def merge_sort(n):
        '''归并排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        if len(n)==1:
            return n
        mid=len(n)//2
        left=merge_sort(n[:mid])
        right=merge_sort(n[mid:])
        s=[]#输出列表
        while left and right:
            if left[0]<right[0]:
                s.append(left.pop(0))
            else:
                s.append(right.pop(0))
        if left:
            s.extend(left)
        if right:
            s.extend(right)
        return s

    6快速排序(quick sort)

    快速排序是通过先选出一个数,将所有小于等于它的数放到它的左边,将所有大于等于它的数放到它的右边。重复操作直到数列有序。我们发现在一次操作后就确定了一个数的位置,每次操作需要比较O(n)次,需要操作 次(以每个递归循环为参考对象),算法时间复杂度为O(nlogn)

    算法描述:以某个数为参考对象将一个数列分为左右两个部分,然后从数列左边开始查找,直到找到一个大于该数的数,记录它的位置为左标,再从数列右边开始查找,直到找到一个小于该数的数,记录它的位置为右标,将左右标数互换。继续执行算法,直到左右标相遇,最后将该数与左标数互换,此时该数满足:数列中所有小于等于它的数在它的左边,所有大于等于它的数在它的右边,该次算法结束。我们再对左右两个数列分别进行快速排序。算法完全终止,直到每个数列所含元素个数为1个,最后返回一个有序的数列。

    def quick_sort(n,l,r):#l:left,r:right
        '''快速排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        if l>=r:
            return n
        i,j=l,r
        while True:
            while l<=r and n[l]<n[i]:
                l+=1
            while l<=r and n[r]>=n[i]:
                r-=1
            if l>r:
                break
            n[l],n[r]=n[r],n[l]
        n[i],n[l]=n[l],n[i]
        quick_sort(n,i,l-1)
        quick_sort(n,l+1,j)
        return n

    [2]

    7堆排序(heap sort)

    堆排序是是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。在每次操作后,原数列返回一个最大值,在每次操作中,需比较 次,算法的时间复杂度为O(nlogn)。[1]

    算法描述:我们可以对堆编写一个索引,原数列中的每个值都有相应的索引与它对应。然后用列表模拟堆,编写一个操作,每次返回列表中的最大值。然后将所有最大值逆序排列即可得到一个有序的数列。

    ba1cb3dbf18ca95244ade08f456344b1.png
    def heap_sort(n):
        '''堆排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        s=[]
        while len(n)>0:
            k=0
            while len(n)>2**k-1:
                k+=1
            while k>1:
                for i in range(2**(k-2)-1,2**(k-1)-1):
                    if len(n)>=2*i+2:
                        if n[i]<n[2*i+1]:
                            n[i],n[2*i+1]=n[2*i+1],n[i]
                    if len(n)>=2*i+3:
                        if n[i]<n[2*i+2]:
                            n[i],n[2*i+2]=n[2*i+2],n[i]
                k-=1
            n[0],n[len(n)-1]=n[len(n)-1],n[0]
            s.append(n.pop())
        s.reverse()
        return s

    8计数排序(counting sort)

    计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。假设需要k个键来储存数列中的值,我们可以得到算法的时间复杂度为O(n+k)。

    算法描述:我们将数列中的最大值最小值拿出,将k设置为最大值与最小值之差。对每个在原数列中的数,统计它出现的次数,并将其赋值给相应的键。最后将键按照值次序依次加入到一个新列表中。

    def counting_sort(n):
        '''计数排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        a=min(n)
        b=max(n)#这里偷懒了,用了内置函数,这样的话就可以不断取出最小值最大值然后放入一个新列表中
        s=list(range(a,b+1))
        d=dict.fromkeys(s,0)
        for i in n:
            if i in d:
                d[i]+=1
        sss=[]
        for j in range(a,b+1):
            while j in d:
                if d[j]==0:
                    del d[j]
                else:
                    sss.append(j)
                    d[j]-=1
        return sss

    9桶排序(bucket sort)

    桶排序是计数排序的升级版。我们将数据分到有限数量的桶中(k个),对每个桶再分别排序。算法时间复杂度为O(n+k)

    算法描述:先进行分组,然后对每组中的数用计数排序进行排序。

    import math
    def bucket_sort(n):
        '''桶排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        k=math.ceil(math.sqrt(len(n)))
        max_num=max(n)
        min_num=min(n)
        num=math.ceil((max_num-min_num)/k)
        s=[]
        for i in range(k-1):
            s.append(list(range(i*num,(i+1)*num)))
        s.append(list(range((i+1)*num,max_num+1)))
        sss=[]
        for j in s:
            d=dict.fromkeys(j,0)
            for i in n:
                if i in d:
                    d[i]+=1
            for t in range(min(j),max(j)+1):
                while t in d:
                    if d[t]==0:
                        del d[t]
                    else:
                        sss.append(t)
                        d[t]-=1
            
        return sss

    10基数排序(radix sort)

    基数排序是对每一位进行排序,从最低位到最高位依次进行排序。这样每次操作后都会使得它前面的数在某位(i位)大于它的,程序迭代到最高位时,该数前面的数就一定会比它大。算法时间复杂度为O(kn),k为数组中最大数的位数。

    算法描述:对数列中的每个数进行操作,得到它第i次操作时的第i位(从右往左),然后将数列中的数通过第i位排序,重复进行直到i达到最大值k。算法终止。

    def radix_sort(n):
        '''基数排序
        
        对列表进行排序,并返回一个排序好的列表
        :param n: 列表对象
        :return: 排序结果列表
        '''
        k=0
        while max(n)>10**k-1:
            k+=1
        j=1
        while j<k+1:
            i=0
            s=[]
            for iii in range(10):
                s.append([])  
            while i <len(n):
                k1=n[i]%10**j
                k2=k1//10**(j-1)
                s[k2].append(n[i])
                i+=1
            n=[]
            for i1 in s:
                n.extend(i1)
            j+=1
        return n

    11检验

    我编写了一个程序,程序中载入了系统模块random(用于生成随机数)、time(用于记录每种算法的执行时间)。载入了我们编写的十种算法,用于测试每种算法的效率。

    11.1我们取1000个在1000000之内的随机数,分别用不同的算法对其排序,记录每种算法的排序时间。

    结果如下:

    5ca900b687608064588afdf1f8dec85a.png

    在这种情况下,我们发现希尔排序算法与归并排序算法表现很好,而快速排序与堆排序表现不行(在我的算法中,原因未知)。而计数排序、桶排序,基数排序则是因为在样本相对离散的情况下,执行效率会很低。

    11.2我们再取1000个在1000之内的随机数,分别用不同的算法对其排序,记录每种算法的排序时间。

    结果如下:

    198bdb1d6cebd2f5df188c62ab512053.png

    在这种情况下,我们发现希尔排序算法与归并排序算法表现依旧很好,而快速排序与堆排序表现依旧不行。但是这一次计数排序、桶排序,基数排序在样本相对集中的情况下,执行效率提升了很多。(在我的算法中,桶排序执行效率低于计数排序,这个原因未知)

    还望诸位大佬赐教。

    检验代码

    import random,time,bubble_sort,selection_sort,insertion_sort,bucket_sort,copy
    import shell_sort,heap_sort,merge_sort,quick_sort,counting_sort,radix_sort
    g=[]
    i=0
    while i <1000:
        k=random.randint(1,10**6)
        g.append(k)
        i+=1
    print(g)
    s=copy.deepcopy(g)
    t1=time.time()
    print('bubble_sort:')
    bubble_sort.bubble_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('selection_sort:')
    selection_sort.selection_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('insertion_sort:')
    insertion_sort.insertion_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('shell_sort:')
    shell_sort.shell_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('merge_sort:')
    merge_sort.merge_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('quick_sort:')
    quick_sort.quick_sort(s,0,len(s)-1)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('heap_sort:')
    heap_sort.heap_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('counting_sort:')
    counting_sort.counting_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('bucket_sort:')
    bucket_sort.bucket_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)
    
    s=copy.deepcopy(g)
    t1=time.time()
    print('radix_sort:')
    radix_sort.radix_sort(s)
    t2=time.time()
    tt=t2-t1
    print(tt)

    注:[1]引自:

    https://blog.csdn.net/weixin_41190227/article/details/86600821?ops_request_misc=&request_id=&biz_id=102&utm_term=%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-86600821作者:Top_Spirit

    [2]快速排序算法的代码参考了:

    https://blog.csdn.net/weixin_36913190/article/details/80550347?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F%20python&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-80550347作者小海Code

    展开全文
  • 题目要求: 思路: 构建一个二叉树,节点有以下属性: self.left = None self.right = None self.val = val # 节点值 ...TreeNode(val) break return res 参考视频:LeetCode315 计算右侧小于当前元素的个数 BST解法
  • In [96]:df = pd.DataFrame({'a':randn(10), 'b':randn(10), 'c':randn(10)})dfOut[96]:a b c0 -0.849903 0.944912 1.2857901 -1.038706 1.445381 0.2510022 0.683135 -0.539052 -0.6224393 -1...
  • 所有的编程语言本质就是在解决运算逻辑,通过各种算法实现想要的各种功能,因此在学习Python编程语言时,不仅要掌握各种变量类型,深刻理解函数式编程的原理,还要彻底搞懂各类运算符的使用。通过千锋武汉Python培训...
  • 在使用python列表的时候,我们经常需要找到满足某个条件的的开始索引和结束索引,即满足某个条件的的区间范围,本文以寻找绝对值大于等于0且小于等于3的数值区间为例,代码如下所示:这是我在做项目写python代码...
  • Python标识符在 Python 里,标识符由字母、数字、下划线组成。在 Python 中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。Python 中的标识符是区分大小写的。以下划线开头的标识符是有特殊意义的...
  • Python有五个标准的数据类型Numbers(数字)String(字符串)List(列表)Tuple(元组)Dictionary(字典)Python支持四种不同的数字类型int(有符号整型)long(长整型[也可以代表八进制和十六进制])float(浮点型...
  • 三、Python中的进制转换 (一)Python中各进制的数的表示 在十进制、二进制、八进制、十六进制中,如果在不指明某个数使用的进制的情况下,是很难分清该数的大小的,比如111,在十进制、二进制、八进制、十六进制中都...
  • 第十二届蓝桥杯全国软件和信息技术专业人才大赛个人赛 (软件类)Python 组竞赛规则及说明1. 组别本次竞赛不分组别。所有研究生、重点本科、普通本科和高职高专院校均可报名该组,统一评奖。2. 竞赛赛程全国选拔赛时长...
  • 然后,您可以在这些标记的扇区中循环,计算对象的大小(以像素为单位),并在此基础上进行过滤。在即使你从Excel中提取数据,你实际上得到的是一个249x250像素的“图像”。Excel中的每个单元格实际上是一个...
  • 目前本人连python的门都还没有入...对于一个数,如果它不为素数,它是某个数的平方,或者被两个数相乘得到,而这两个数介于它开平方的两侧,即一个数大于它的平方数,一个数小于它的平方数。 代码实现: from math impo
  • 该数值为一个百分数,对某个数而言,该数的PERCENTRANK,为集合中小于值的数字个数,占所有数字数量的比例。 计算方式: 集合中小于该数的数字个数/(集合包含的数字个数-1) 2.在pandas中如何实现呢? df['age']....
  • –a[right]中的某个元素x(如a[left])对a[left]~a[right]进行划分,划分后的x所在位置的左段全小于等于x,右段全大于等于x,同时利用x所在的位置还可以计算出x是这批数据按升非降序排列的第几个。因此可以编制int ...
  • 学习:Python练习

    2013-04-23 21:38:00
    1、你想计算所有素数的一个无界的序列,或者小于某个阈值的所有素数的列表(可分别实现)。 ps:素数又称为质数,指在大于1和此自身外,不能被其他任何自然数整除的。 解答代码如下: import math def pd(n...
  • 这种称为阶跃函数,常见的激活函数有阶跃函数,sigmoid,ReLU,tanh函数阶跃函数阶跃函数的意义为,当输入数据大于某个值时输出值A,小于等于某个值时为B,表现为在某个值时输出突然变化,...
  • 这种称为阶跃函数,常见的激活函数有阶跃函数,sigmoid,ReLU,tanh函数阶跃函数阶跃函数的意义为,当输入数据大于某个值时输出值A,小于等于某个值时为B,表现为在某个值时输出突然变化,...
  • 3. 编写函数,若输入为小于100的,返回TRUE,大于100的,返回FALSE 4. 某个公司采用公用电话传递数据,数据是四位的整数,在传递过程中是加密的,加密规则如下: 每位数字都加上5,然后用和除以10的余数...
  • 一、理论知识: 要理解 Pearson 相关系数,首先要理解协方差(Covariance)。协方差表示两个变量 X,Y 间相互关系的数字特征,...如果某个 Xi小于 X¯,相应的 Yi 也小于¯Y¯,那么 COV(X,Y)COV(X,Y) 就是正值,...
  • 我程序这样写后,在运行时,跑到i(i是小于1000的某个数,每次运行都不一样)时,它就停住了,这是什么原因呢?应该怎样解决呢?task1和task2都是计算密集型的,而且执行时间都很短,几十毫秒左右,我这样的需求用多...
  • ,int left,int right)的功能是根据a[left]a[right]中的某个元素x(如a[left])对a[left]a[right]进行划分,划分后的x所在位置的左段全小于等于x,右段全大于等于x,同时利用x所在的位置还可以计算...
  • 1、用无限循环语句显示一系列数字(1、2、3、4、5……),并设置当用户按下某个按钮时(如ESC键)程序就会中止; 2、斐波那契数列、交换两个变量的值、从一组数据中找出最大最小值等; 3、让用户输入一些数字...
  • 在进行运算的时候,某个位置需要求得丑一定是前面某个乘以2、3或者5的结果,我们分别记录之前乘以2后能得到的最大丑M2,乘以3后能得到的最大丑M3,乘以5后能得到的最大丑M5,那么下一个丑一定是M2,M3...

空空如也

空空如也

1 2 3
收藏数 45
精华内容 18
关键字:

python计算小于某个数

python 订阅