精华内容
下载资源
问答
  • 二位数组升序/降序

    2021-04-04 13:44:25
    题目要求:随机生成5行(代表五种商品) 12列(代表月份: 1-6 升序, 7-12 降序) 基于(mean=50,var=15)正态分布, 12 month: [‘Jan’,….,’Dec’] . sort 与 sorted 区别: sort 是应用在 list 上方法,...

    题目要求:随机生成5行(代表五种商品) 和12列(代表月份: 1-6 升序, 7-12 降序) 基于(mean=50,var=15)的正态分布, 12 month: [‘Jan’,….,’Dec’] .

    sort 与 sorted 区别:

    sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
    list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

    numpy.sort()

    在python自带的函数里,可以用d.sort(reverse=True)进行逆序排列,但是numpy里没有。

    (摘抄:https://blog.csdn.net/weixin_44493173/article/details/104797872)

    numpy.sort() 函数返回输入数组的排序副本。
    numpy.sort(a, axis, kind, order)

    • a: 要排序的数组
    • axis: 沿着它排序数组的轴,如果没有数组会被展开,沿着最后的轴排序, axis=0 按列排序,axis=1按行排序
    • kind: 默认为’quicksort’(快速排序)
    • order: 如果数组包含字段,则是要排序的字段
    import numpy as np
    data = np.random.normal(50,15,(5,12))
    data[:,:6] = np.sort(data[:,:6],axis=1)
    data[:,6:] = np.sort(-1*data[:,6:],axis=1)
    data[:,6:] = (-1*data[:,6:])
    print(data)
    
    >>> print(data)
    #排序前数组(5,12)
    [[43.29275371 43.74746567 53.19960014 42.56956502 47.33679495 24.4615871
      37.50231926 53.17129723 65.98121916 56.79957515 53.14567585 61.43944116]
     [62.69081071 33.28986386 26.95157823 64.11039552 63.92555467 70.02713121
      44.28527539 76.13802187 70.99535087 51.95125619 62.11789952 79.33187303]
     [63.89360434 42.88277999 52.90597666 70.66841773 33.4676427  49.55601098
      26.71702504 38.37770682 44.49507598 31.6670231  57.16650365 17.68617466]
     [65.9161031  45.85820838 70.49623725 63.47467278 48.89260932 36.87632429
      46.15858577 20.99893205 78.50914865 59.62730108 68.9861328  69.71171892]
     [42.21048028 60.07265734 35.90008337 63.13132146 59.43706595 56.23297227
      39.34466995 55.84720357 58.58786078 42.38502048 36.22277301 58.42135719]]
     #排序后的数组(5,12)
     [[24.4615871  42.56956502 43.29275371 43.74746567 47.33679495 53.19960014
      65.98121916 61.43944116 56.79957515 53.17129723 53.14567585 37.50231926]
     [26.95157823 33.28986386 62.69081071 63.92555467 64.11039552 70.02713121
      79.33187303 76.13802187 70.99535087 62.11789952 51.95125619 44.28527539]
     [33.4676427  42.88277999 49.55601098 52.90597666 63.89360434 70.66841773
      57.16650365 44.49507598 38.37770682 31.6670231  26.71702504 17.68617466]
     [36.87632429 45.85820838 48.89260932 63.47467278 65.9161031  70.49623725
      78.50914865 69.71171892 68.9861328  59.62730108 46.15858577 20.99893205]
     [35.90008337 42.21048028 56.23297227 59.43706595 60.07265734 63.13132146
      58.58786078 58.42135719 55.84720357 42.38502048 39.34466995 36.22277301]]
    

    Sorted

    sorted()是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。
    sorted(iterable,key=None, reverse=False)

    • iterable – 可迭代对象。
    • key-- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    • reverse – 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
    • 返回重新排序的列表。
    data = np.random.normal(50,15,(5,12))
    for j in range(len(data)):
        data[j,:6] = sorted(data[j,:6],reverse=False)
        data[j,6:] = sorted(data[j,6:],reverse=True)
    data
    
    >>> data
    #排序前
    array([[62.72644752, 60.89661032, 43.01480755, 49.23412262, 56.34745671,
            41.55121082, 41.27773   , 36.6217533 , 60.43254572, 24.21173332,
            65.93898664, 66.1615255 ],
           [73.90765466, 49.56544278, 33.54640934, 72.87580811, 63.26230978,
            57.67605875, 37.96857802, 69.46754382, 44.9545471 , 53.60030254,
            59.94972918, 42.07293609],
           [25.36462004, 50.14066819, 34.62876961, 33.605209  , 32.61303769,
            39.34966176, 61.65238714, 48.52667746, 49.72942391, 49.35843729,
            66.27717622, 63.40910313],
           [43.65073532, 70.90299218, 72.65429937, 49.97546661, 47.66300609,
            78.75056408, 71.25819506, 46.54673609, 58.34729649, 36.22747363,
            53.92145946, 69.62323717],
           [45.66130865, 54.55643377, 33.1749947 , 50.90374547, 62.82171333,
            26.64289327, 68.49028702, 32.10356401, 65.18960519, 45.33004559,
            46.85696639, 44.87165626]])
    #排序后
    array([[41.55121082, 43.01480755, 49.23412262, 56.34745671, 60.89661032,
            62.72644752, 66.1615255 , 65.93898664, 60.43254572, 41.27773   ,
            36.6217533 , 24.21173332],
           [33.54640934, 49.56544278, 57.67605875, 63.26230978, 72.87580811,
            73.90765466, 69.46754382, 59.94972918, 53.60030254, 44.9545471 ,
            42.07293609, 37.96857802],
           [25.36462004, 32.61303769, 33.605209  , 34.62876961, 39.34966176,
            50.14066819, 66.27717622, 63.40910313, 61.65238714, 49.72942391,
            49.35843729, 48.52667746],
           [43.65073532, 47.66300609, 49.97546661, 70.90299218, 72.65429937,
            78.75056408, 71.25819506, 69.62323717, 58.34729649, 53.92145946,
            46.54673609, 36.22747363],
           [26.64289327, 33.1749947 , 45.66130865, 50.90374547, 54.55643377,
            62.82171333, 68.49028702, 65.18960519, 46.85696639, 45.33004559,
            44.87165626, 32.10356401]])
    
    展开全文
  • 摘要:我经常将CollectionCollections这两者混一起了,弄得有点不明白,今天特地查看了资料,理一理他们之间的区别,加深了Collection接口Collections封装类的认识。一、 Collections 是java.util包中提供的一个...

    摘要:我经常将Collection和Collections这两者混一起了,弄得有点不明白,今天特地查看了资料,理一理他们之间的区别,加深了Collection接口和Collections封装类的认识。

    一、 Collections 是java.util包中提供的一个集合接口,我们用的最多的是它的直接接口List、Set,提供集合操作的实例方法和静态方法。Collections接口在Java 类库中有很多具体的实现。

    Collection

    ├List

    │├LinkedList

    │├ArrayList

    │└Vector

    │ └Stack

    └Set

    JavaSDK不提供直接继承自Collections接口,Java SDK提供的类都是继承自Collection的“子接口”,例如List、Set

    19d820bb5247b6a112b38091cc5f1766.png

    二、Collections是java.util包中提供的一个封装类,类中包装了很多操作集合的静态方法,比如比较常用的:sort(List)、sort(List, Comparator super T>) 、binarySearch(List extends Comparable super T>>, T),该类不能实例化,它是一个工具类,可以直接调用里面的方法。

    三、Collections写了一个小案例,操作集合List,并对集合进行升序、降序排序:

    演示效果一:Collections.sort(List)方法的使用

    》升序排序

    8855636148f293d05ad64aba3dec73a2.png

    点击排序按钮,完成排序操作

    86aacd19985cb74899a5ab06b8874758.png

    protectedvoidsortNums() {

    if(!isSort) {

    for(String str : listArray) {

    list.add(str);

    }

    Collections.sort(list);//直接调用Collections静态sort()方法

    isSort = true;

    }

    newThread(newRunnable() {

    @Override

    publicvoidrun() {

    Message msg = newMessage();

    msg.what = 001;

    handler.sendMessage(msg);

    }

    }).start();

    }

    sort(List)仅能够对集合中的元素进行升序排序,需要进行其他指定字段或降序排序,需要实现Comparator接口的sort(List,Comparator)方法。

    演示效果二:sort(List, Comparator super T>) 方法的使用

    》降序排序

    64ea393bd7e5b8d1a23ede12242a0076.png

    Collections.sort(mList,newComparator() {//调用sort()方法,并实现Comparator接口中的compare()方法

    @Override

    publicintcompare(NewsBean lhs, NewsBean rhs) {

    intvalue = Integer.valueOf(rhs.getId())

    - Integer.valueOf(lhs.getId());

    Log.e("降序排序---------------》",""+ value);

    returnvalue;

    }

    });

    改为如下,则为升序排序

    Collections.sort(mList,newComparator() {//调用sort()方法,并实现Comparator接口中的compare()方法

    @Override

    publicintcompare(NewsBean lhs, NewsBean rhs) {

    intvalue = Integer.valueOf(lhs.getId())

    -Integer.valueOf(rhs.getId());

    Log.e("升序排序---------------》",""+ value);

    returnvalue;

    }

    });

    31ffb1d76b8f58e46142e56cf72cecf9.png

    展开全文
  • 原文发布时间为:2009-03-18 —— 来源于本人的百度文章 [由搬家工具导入]原理:升序和降序 只是 大于 和 小于 号的区别。比如:if(a[j] > a[j+1]) swap(a[j],a[j+1]) 为升序if(a[j] < a[j+1]) swap(a[j],a[j+...

    原文发布时间为:2009-03-18 —— 来源于本人的百度文章 [由搬家工具导入]

    原理:

    升序和降序 只是 大于 和 小于 号的区别。

    比如:

    if(a[j] > a[j+1])   swap(a[j],a[j+1]) 为升序

    if(a[j] < a[j+1])   swap(a[j],a[j+1]) 为降序

    那怎样做到用同一个方法呢。那么就要乘以一个值order,order为1时为升序,为-1时为降序,就可以写成如下形式:

    if(a[j]*order > a[j+1]*order)   swap(a[j],a[j+1])    order为1时为升序,为-1时为降序

    例子:

    using System;

    namespace sorts
    {
       public class Class1
        {
           public static void Main()//将数组的升序和降序排列分别储存在两个新数组中
           {
               int[] a = new int[] { 3, 4, 2, 8, 4, 5, 6 };
               int[] b = new int[a.Length];
               int[] c = new int[a.Length];

               //for (int i = 0; i < a.Length; i++)
               //{
               //    int j = i;
               //    int k = i;
               //    int temp = a[i];
               //    while (j > 0 && b[j - 1] > temp)//升序
               //    {
               //        b[j] = b[j - 1];
               //        j--;
               //    }
               //    while (k > 0 && c[k - 1] < temp)//降序
               //    {
               //        c[k] = c[k - 1];
               //        k--;
               //    }
               //    c[k] = b[j] = temp;
               //}

               InsertSort(a,b, 1);
               InsertSort(a,c, -1);
               Output(a);
               Output(b);
               Output(c);
               Console.ReadLine();
           }

           public static void Output(int[] arr)
           {
               for (int i = 0; i < arr.Length; i++)
                   Console.Write("{0} ", arr[i]);
               Console.WriteLine();
           }

           public static void InsertSort(int[] oldArr, int[] newArr, int order)
           {

               for (int i = 0; i < oldArr.Length; i++)
               {
                   int j = i;
                   int temp = oldArr[i];
                   while (j > 0 && newArr[j - 1] * order > temp * order)
                   {
                       newArr[j] = newArr[j - 1];
                       j--;
                   }
                   newArr[j] = temp;
               }
           }
       }

    }

    转载于:https://www.cnblogs.com/handboy/p/7153257.html

    展开全文
  • 相关免费学习推荐:python视频教程Python列表...这时候就可以使用list.sort方法内置函数sorted,本文就是介绍list.sort方法sorted内置函数使用方法和区别.一、list.sort方法list.sort方法会就地排序列表,也就...

    72c3473b18189cd27207af4d078bc44f.png

    相关免费学习推荐:python视频教程

    Python列表排序 list.sort方法和内置函数sorted

    很多时候我们获取到一个列表后,这个列表并不满足我们的需求,我们需要的是一个有特殊顺序的列表.

    这时候就可以使用list.sort方法和内置函数sorted,本文就是介绍list.sort方法和sorted内置函数的使用方法和区别.

    一、list.sort方法

    list.sort方法会就地排序列表,也就是说不会把原列表复制一份。这也是这个方法的返回值是None的原因,提醒您本方法不会新建一个列表。

    在这种情况下返回None其实是Python的一个惯例:如果一个函数或者方法对对象进行的是就地改动,那它就应该返回 None,好让调用者知道传入的参数发生了变动,而且并未产生新的对象。

    来看一下代码:# coding=utf-8

    list_a = [1, 2, 8, 3, 7, 9, 5, 7]

    # sort()方法没有返回值

    list_b = list_a.sort()

    print("list_a: ", list_a)

    print('list_b: ', list_b)

    运行结果:list_a: [1, 2, 3, 5, 7, 7, 8, 9]

    list_b: None

    用返回None来表示就地改动这个惯例有个弊端,那就是调用者无法将其串联起来。而返回一个新对象的方法则正好相反,它们可以链式调用,从而形成连贯接口。

    二、sorted内置函数

    与 list.sort 相反,内置函数sorted会新建一个列表作为返回值。

    这个方法可以接受任何形式的可迭代对象作为参数,甚至包括不可变序列或生成器,而不管sorted接受的是怎样的参数,它最后都会返回一个列表。

    代码示例:list_c = [1, 2, 8, 3, 7, 9, 5, 7]

    # sorted内置函数会返回一个排序后的新列表

    list_d = sorted(list_c)

    print("list_c: ", list_c)

    print('list_d: ', list_d)

    运行结果:list_c: [1, 2, 8, 3, 7, 9, 5, 7]

    list_d: [1, 2, 3, 5, 7, 7, 8, 9]

    可以看到,使用内置函数sorted时,返回了一个新的列表,而原列表没有发生改变。

    这有两种好处:

    1.如果我们即需要使用原列表,也需要使用排序后的列表,或者说我们要将一个非列表的可迭代对象排序成列表,sorted都可以做到

    2.有返回值时,我们可以进行链式调用# 可以对非列表的可迭代对象排序生成列表

    str_e = 'python'

    list_e = sorted(str_e)

    print(list_e)

    # 链式调用

    str_f = '-'.join(sorted(str_e)).upper().split('-')

    print(str_f)

    运行结果:['h', 'n', 'o', 'p', 't', 'y']

    ['H', 'N', 'O', 'P', 'T', 'Y']

    三、关键字参数key和reverse

    不管是 list.sort 方法还是 sorted 函数,都有两个可选的关键字参数:

    key:

    接收一个只有一个参数的函数,这个函数会被用在序列里的每一个元素上,所产生的结果将是排序算法依赖的对比关键字。

    比如说,在对一些字符串排序时,可以用 key=str.lower 来实现忽略大小写的排序,或者是用 key=len 进行基于字符串长度的排序。key的默认值是恒等函数,也就是默认用元素自己的值来排序。

    reverse:

    如果被设定为 True,被排序的序列里的元素会以降序输出(也就是说把最大值当作最小值来排序),reverse的默认值是 False.phone = ('HUAWEI', 'OPPO', 'MI', 'MEIZU', 'VIVO')

    # 按长度进行排序

    phone_list = sorted(phone, key=len)

    print(phone_list)

    phone_list_re = sorted(phone, key=len, reverse=True)

    print(phone_list_re)

    运行结果:['MI', 'OPPO', 'VIVO', 'MEIZU', 'HUAWEI']

    ['HUAWEI', 'MEIZU', 'OPPO', 'VIVO', 'MI']

    上面的代码中,第一次排序新建了一个按照长度排序的字符串列表。第二次排序是将按长度排序由升序变成了降序。

    细心的您应该可以发现,第二次的结果并不是第一次排序的结果的完全翻转。

    OPPO和VIVO的长度都是4,reverse=True后,它们的相对位置跟第一次排序是一样的。这是什么原因呢?

    sorted和list.sort背后的排序算法都是Timsort,它是一种自适应算法,会根据原始数据的顺序特点交替使用插入排序和归并排

    序,以达到最佳效率。

    Python的排序算法Timsort是稳定的(知道这一点就可以了),意思是就算两个元素比不出大小,在每次排序的结果里它们的相对位置是固定的。

    因为用到的排序算法是稳定的,也就是说在长度一样时,OPPO和VIVO的相对位置不会改变。

    关于list.sort()方法和sorted内置函数的使用,现在已经掌握了~相关免费学习推荐:python教程(视频)

    展开全文
  • 一、列表内建方法--sort() 作用:就地对列表排序(直接在原列表上做排序) 语法:  list.sort(func=None, key=None, ...执行完后会改变原来list,如果你不需要原来list,这种效率稍微高点 该方法没有返...
  • 前言MySQL 8.0终于支持降序索引了。其实,从语法上,MySQL 4就支持了,但...无图无真相,同一个建表语句,看看MySQL 5.78.0的区别。create table slowtech.t1(c1 int,c2 int,index idx_c1_c2(c1,c2 desc));MySQL ...
  • ArrayListLinkedList最主要的区别: 底层实现不同,arrayList采用的是数组(方便查询),LinkedList采用的是链表(方便增删); 关于默认初始容量: arrayList 的默认构造容量是10,超过1...
  • groupby having order by ... orderby从英文里理解就是行排序方式,默认升序降序DESC orderby后面必须列出排序字段名,可以是多个字段名。 ...
  • 有序集合是不是只有升序和降序? binary_sreach使用是什么搜索方式? 还有其他搜索方式吗? ![图片](https://img-ask.csdn.net/upload/201604/09/1460169192_570967.jpg)
  • ibatis sql中$#的区别

    千次阅读 2016-10-10 11:24:50
    但我现在想直接用一条sql语句(其它都是一样,只是刷选条件不一样),所以我想法是把刷选条件,以及刷选方式(升序降序)当成类似于变量方式,这样就比各自写sql要简单很多 问题现象:
  • order by ground by 区别

    千次阅读 2018-11-12 11:51:47
    order by 排序查询:asc升序 desc降序 select * from Student order by age根据学生年龄查询学生信息(默认是升序) ground by:分组查询 having只能用于ground by子句作用于组内 按照学号分组查询每个学号总...
  • group byorder by用法和区别

    万次阅读 多人点赞 2018-08-18 14:10:14
    使用order by,一般是用来,依照查询结果某一列(或多列)属性,进行排序(升序:ASC;降序:DESC;默认为升序)。 当排序列含空值时: ASC:排序列为空值元组最后显示。 DESC:排序列为空值元组最先显示。...
  • 说明:对一组数据进行排序(升序降序),在Java中有很多方式,可以自己手写排序算法(冒泡、快速、二叉树排序等),但一般都采用JDK为我们提供的现有的2个接口,ComparableComparator。 【二者的区别】 ...
  • MySql之排序

    2020-12-30 21:36:01
    数据排序数据排序分组函数单行处理函数cout所有count具体某个字段的区别count(*)count(具体的某个字段)区别分组函数也可以组合起来用分组查询group by having多字段分组查询havingwhere的选择总结一个完整的...
  • select * from t 是查询全部信息; select * from t ... by 就是做个排序了 ASC升序 desc降序 例如: select renterId from house.renter order by renterId desc; 对house.renter表renterId进行查
  • 排序有升序和降序之分,ASC表示升序排序,DESC表示降序排序。如果不指明排序顺序,默认排序顺序为升序ASC。如果要降序,必须书写DESC关键字  1.having只能用在group by之后,对分组后结果进行筛选...
  • 给基本类型排序可以直接调用Arrays.sort()Conllections.sort()方法直接排序,默认是升序的降序和对象排序需要重写相应方法。 二. publicintcompareTo(Student o) { returnthis.age - o.age; // 比较年龄...
  • sql之group byorder by的区别

    千次阅读 2018-05-28 15:49:09
    今天我们来讲讲sql的group byorder by的区别 order by 用于排序,一般与asc升序或desc降序一起使用(默认升序). 例:select * from TABLE order by column desc;(表示降序查询) group by 用于分类汇总,一般与聚合...
  • MySQL 8.0终于支持降序索引了。其实,从语法上,MySQL 4就支持了,但...无图无真相,同一个建表语句,看看MySQL 5.78.0的区别。create table slowtech.t1(c1 int,c2 int,index idx_c1_c2(c1,c2 desc));MySQL 5....
  • 前言mysql 8.0终于支持降序索引了。其实,从语法上,mysql 4就支持了,但...无图无真相,同一个建表语句,看看mysql 5.78.0的区别。create table slowtech.t1(c1 int,c2 int,index idx_c1_c2(c1,c2 desc));mysql ...
  • MySQL 8.0终于支持降序索引了。其实,从语法上,MySQL 4就...无图无真相,同一个建表语句,看看MySQL 5.78.0的区别。create table slowtech.t1(c1int,c2int,index idx_c1_c2(c1,c2 desc));提示,类似代码可左右...
  • by 年龄 查询学生表信息、按年龄的升序(默认、可缺省、从低到高)排列显示 也可以多条件排序、 比如 order by 年龄,成绩 desc 按年龄升序排列后、再按成绩降序排列 group by 分组查询、having 只能用于group b
  • order by 排序查询、asc升序、desc降序示例:select * from 学生表 order by 年龄 查询学生表信息、按年龄的升序(默认、可缺省、从低到高)排列显示也可以多条件排序、 比如 order by 年龄,成绩 desc 按年龄升序排列...
  • Python中sortsorted的区别

    千次阅读 2018-09-25 09:42:03
    本体: sort(cmp=None, key=None, reverse=False) ...reverse:True 降序 reverse:False 升序(默认为False) 区别: sort: 是容器函数,对列表(list)成员进行排序 并且改变是原列表 sorted: ...
  • matlab svd eig 的区别

    千次阅读 2019-05-10 11:41:44
    总得来说,SVD eig 得到特征值/奇异值是一样,eig排列是降序,svd排列是升序; SVD右奇异向量是A'*A特征向量 SVD左奇异向量是A*A'特征向量 另外,SVD可以用于非方阵分解,而eig只能用于方阵分解 ...
  • compare函数写法决定了排序是升序还是降序。需要#includestdlib.h> 例如: int compare(const void*a,const void*b){return *(*int)a-*(int*)b;} 示例:qsort(a,10,sizeof(int),compare) //假设已定
  • 浅谈group byorder by用法和区别

    千次阅读 2017-08-22 11:20:56
    转载出自于:group byorder by的区别和用法 前一段时间的面试,问道这个问题,不太清楚了,感觉有必要来总结一下。话不多说,直接开始吧! 一、order by的用法 使用order by,一般是用来,依照查询结果的某一...
  • 无图无真相,同一个建表语句,看看MySQL 5.78.0的区别。 create table slowtech.t1(c1 int,c2 int,index idx_c1_c2(c1,c2 desc)); MySQL 5.7 mysql> show create table slowtech.t1\G *************************...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 174
精华内容 69
关键字:

升序和降序的区别