精华内容
下载资源
问答
  • ls 按时间排序

    千次阅读 2020-05-07 11:23:42
    在linux系统中,使用ls命令按时间排序文件,其实很简单,如下: ls-altr 即可按时间排序当前目录下的文件。 附,ls命令的参数中文详解:-a 列出目录下的所有文件,包括以 . 开头的隐含文件。 -b 把文件名中不可输出...

    在linux系统中,使用ls命令按时间排序文件,其实很简单,如下:
    ls -altr
    即可按时间排序当前目录下的文件。

    附,ls命令的参数中文详解:
    -a 列出目录下的所有文件,包括以 . 开头的隐含文件。
    -b 把文件名中不可输出的字符用反斜杠加字符编号(就象在C语言里一样)的形式列出。
    -c 输出文件的 i 节点的修改时间,并以此排序。
    -d 将目录象文件一样显示,而不是显示其下的文件。
    -e 输出时间的全部信息,而不是输出简略信息。
    -f -U 对输出的文件不排序。
    -g 无用。
    -i 输出文件的 i 节点的索引信息。
    -k 以 k 字节的形式表示文件的大小。
    -l 列出文件的详细信息。
    -m 横向输出文件名,并以“,”作分格符。
    -n 用数字的 UID,GID 代替名称。
    -o 显示文件的除组信息外的详细信息。
    -p -F 在每个文件名后附上一个字符以说明该文件的类型,“*”表示可执行的普通文件;“/”表示目录;“@”表示符号链接;“|”表示FIFOs;“=”表示套接字(sockets)。
    -q 用?代替不可输出的字符。
    -r 对目录反向排序。
    -s 在每个文件名后输出该文件的大小。
    -t 以时间排序。
    -u 以文件上次被访问的时间排序。
    -x 按列输出,横向排序。
    -A 显示除 “.”和“..”外的所有文件。
    -B 不输出以 “~”结尾的备份文件。
    -C 按列输出,纵向排序。
    -G 输出文件的组的信息。
    -L 列出链接文件名而不是链接到的文件。
    -N 不限制文件长度。
    -Q 把输出的文件名用双引号括起来。
    -R 列出所有子目录下的文件。
    -S 以文件大小排序。
    -X 以文件的扩展名(最后一个 . 后的字符)排序。
    -1 一行只输出一个文件。

    ls实现列文件按时间排序

    1) ls -lt  时间最近的在前面
    2) ls -ltr 时间从前到后

    3) 利用

      ls -l | sort +7 (日期为第8列)  时间从前到后
    ls -l | sort -r +7 时间最近的在前面

    展开全文
  • pandas 之时间排序

    千次阅读 2020-03-15 12:15:59
    时间排序 在pandas中,有一个非常常用的函数 date_range,尤其是在处理时间序列数据时,这个函数的作用就是产生一个 DatetimeIndex,就是时间序列数据的索引。 pandas.date_range(start=None,end...

                                                                      时间排序

     

    在 pandas 中,有一个非常常用的函数 date_range,尤其是在处理时间序列数据时,这个函数的作用就是产生一个 DatetimeIndex,就是时间序列数据的索引。

     

    pandas.date_range(start=Noneend=Noneperiods=Nonefreq=Nonetz=Nonenormalize=Falsename=Noneclosed=None**kwargs) → pandas.core.indexes.datetimes.DatetimeIndex

    返回一个固定频率的DatetimeIndex。

    参数:

        start:str 或 datetime-like,可选,默认值是None,表示日期的起点。

        end:str 或 datetime-like,可选,默认值是None,表示日期的终点。

        periods:int,可选,默认值是None,表示你要从和这个函数产生多少个日期索引值(要生成的周期数);如果是None的话,那么 start 和 end 必须不能为 None。

        freq:str 或 DateOffset,默认 “D”,表示以自然日为单位,这个参数用来指定计时单位,比如 “5H”表示每隔5个小时计算一次。

    名称说明 
    B业务日频率 
    C自定义业务日频率 
    D日历天频率 
    W每周一次的频率 
    M月结束频率 
    SM月结频次(15次、月末) 
    BM

    业务月末频率

     
    CBM

    自定义业务月底频率

     
    MS月开始频率 
    SMS开始频率(1号、15号) 
    BMS

    业务月开始频率

     
    CBMS

    自定义业务月开始频率

     
    Q季度结束频率 
    BQ

    业务季度结束频率

     
    QS

    季度开始频

     
    BQS

    季度开始频率

     
    A, Y年底频率 
    BA, BY

    业务年度结束频率

     
    AS, YS

    年开始频

     
    BAS, BYS

    业务年度开始频率

     
    BH

    营业时间频率

     
    H每小时的频率 
    T, min

    每分钟的频率

     
    S每秒频率 
    L, ms毫秒 
    U, us微秒 
    N纳秒 

        tz:str 或 tzinfo,可选,返回本地化的DatetimeIndex的时区名称,例如' Asia/Hong_Kong '。默认情况下,生成的DatetimeIndex是与时区无关的。

    normalize:bool,默认 False。如果为 True 的话,那么在产生时间索引值之前会先把 start 和 end 都转化为当日的午夜 0 点。

    name:str,默认 None。给返回的时间索引指定一个名字。

    closed:{None, ‘left’, ‘right’},可选。默认值为 None,表示 start 和 end 这个区间端点是否包含在区间内,可以有三个值,“left” 表示左闭右开区间,“right” 表示左开右闭区间,None 表示两边都是闭区间。

    **kwargs:兼容性,对结果没影响。

    import pandas as pd, numpy as np
    
    # 创建时间序列(默认 freq="D")
    time_index = pd.date_range(start="2020-03-01", end="2020-03-15")
    print(time_index)
    # 运行结果:
    DatetimeIndex(['2020-03-01', '2020-03-02', '2020-03-03', '2020-03-04',
                   '2020-03-05', '2020-03-06', '2020-03-07', '2020-03-08',
                   '2020-03-09', '2020-03-10', '2020-03-11', '2020-03-12',
                   '2020-03-13', '2020-03-14', '2020-03-15'],
                  dtype='datetime64[ns]', freq='D')
    
    # 创建 10 个时间序列
    time_index02 = pd.date_range(start="2020-03-01", periods=10)
    print(time_index02)
    # 运行结果:
    DatetimeIndex(['2020-03-01', '2020-03-02', '2020-03-03', '2020-03-04',
                   '2020-03-05', '2020-03-06', '2020-03-07', '2020-03-08',
                   '2020-03-09', '2020-03-10'],
                  dtype='datetime64[ns]', freq='D')
    
    # 创建一个时间序列,步长 3 天
    time_index03 = pd.date_range(start="2020-03-01", periods=10, freq="3D")
    print(time_index03)
    # 运行结果:
    DatetimeIndex(['2020-03-01', '2020-03-04', '2020-03-07', '2020-03-10',
                   '2020-03-13', '2020-03-16', '2020-03-19', '2020-03-22',
                   '2020-03-25', '2020-03-28'],
                  dtype='datetime64[ns]', freq='3D')
    
    # 创建一个时间序列,以分钟为步长
    time_index04 = pd.date_range(start="2020-03-01", periods=10, freq="S")
    print(time_index04)
    # 运行结果:
    DatetimeIndex(['2020-03-01 00:00:00', '2020-03-01 00:00:01',
                   '2020-03-01 00:00:02', '2020-03-01 00:00:03',
                   '2020-03-01 00:00:04', '2020-03-01 00:00:05',
                   '2020-03-01 00:00:06', '2020-03-01 00:00:07',
                   '2020-03-01 00:00:08', '2020-03-01 00:00:09'],
                  dtype='datetime64[ns]', freq='S')
    
    data = np.random.randint(3000, 3010, 10)
    print(data)
    # 运行结果:
    [3001 3005 3001 3009 3002 3008 3002 3000 3001 3003]
    
    time_index05 = pd.Series(data, time_index04)
    print(time_index05)
    # 运行结果:
    2020-03-01 00:00:00    3001
    2020-03-01 00:00:01    3005
    2020-03-01 00:00:02    3001
    2020-03-01 00:00:03    3009
    2020-03-01 00:00:04    3002
    2020-03-01 00:00:05    3008
    2020-03-01 00:00:06    3002
    2020-03-01 00:00:07    3000
    2020-03-01 00:00:08    3001
    2020-03-01 00:00:09    3003
    Freq: S, dtype: int32

     

    展开全文
  • ## 现在我有一段json格式数组、在前端用jQuery通过里面的time来完成年月日排序、麻烦各位前辈帮帮忙支个招 var rows =[ {"title":"第一条title","time":"2008/08/27 05:30:45","data":"这是数据"}, {"title...
  • 线性时间排序 1.计数排序 2.基数排序 3.桶排序

    线性时间排序

      前面介绍的几种排序,都是能够在复杂度nlg(n)时间内排序n个数的算法,这些算法都是通过比较来决定它们的顺序,这类算法叫做比较排序 。下面介绍的几种算法用运算去排序,且它们的复杂度是线性时间。

    ——————————————————————————————————————

    1.计数排序

        计数排序采用的方法是:对每个元素x,去确定小于x的元素的个数,从而就可以知道元素x在输出数组中的哪个位置了。

      计数排序的一个重要性质是它是稳定的,即对于相同的两个数,排序后,还会保持它们在输入数组中的前后顺序,这也是下面基数排序的基础

      虽然复杂度比之间的算法减小了,但在算法实现过程中,它要求输入数组数据位于一个区间[0,k]内,因为要遍历数组,计算[0,k]间的每个数在输入数组中的个数,这也算是计数排序的缺点吧!
      下面是调试的程序,可直接运行,详细过程看下《算法导论》

    #include<STDIO.H>
    #define  K 10                   //数据在[0,K]之间  
    int A[]={2,7,3,5,3,2,9};
    int B[20]={0};                  //输出数组
    int C[20]={0};                  //计数数组
    int Length=sizeof(A)/sizeof(A[0])-1;         
    void Count_Sort(int *A,int *B,int k)
    {
       int j;
       for (j=0;j<=Length;j++)       //为每个数计个数
       {
    	   C[A[j]]=C[A[j]]+1;
       }
    
       for (j=1;j<=K;j++)           //计算有多少元素小于等于j
       {
    	   C[j]=C[j]+C[j-1];
       }
    
       for (j=Length;j>=0;j--)      //倒叙输出数组,保证了数据是稳定的  
       {
           B[C[A[j]]]=A[j];
           C[A[j]]=C[A[j]]-1;     //A[j]输出,对应计数数组元素减1。
       }
    }
    int main()
    {    
    	int i;
    	Count_Sort(A,B,K);
    	for (i=1;i<=Length+1;i++)
    	{
    		printf("%3d",B[i]);
    	}
    	printf("\n");
    	return 0;
    }

    ———————————————————————————————————

    2.基数排序

            基本思想:对N个d位的数据排序,与传统的想法不同,它是先从最低有效位开始排。
        

      这里必须保证每次排序是稳定的,即对相同的数据,输出的顺序必须与输入的顺序相同。


    实现例程:
    #include <STDIO.H>
    #include <string.h>
    int A[]={329,457,657,839,436,720,355};    //要排序的数组
    int Length=sizeof(A)/sizeof(A[0])-1;
    void Count_Sort(int *A2,int *B)    //计数排序
    {
    	int j;
        int C[10]={0};                 //计数数组,数字在[0,9]之间
    	for (j=0;j<=Length;j++)       //为每个数计个数
    	{
    		C[A2[j]]=C[A2[j]]+1;
    	}
    	
    	for (j=1;j<=10;j++)           //计算有多少元素小于等于j
    	{
    		C[j]=C[j]+C[j-1];
    	}
    	
    	for (j=Length;j>=0;j--)      //倒叙输出数组,保证了数据是稳定的  
    	{
    		B[C[A2[j]]]=A[j];       //参照C[A2[j]]的大小,对数组A[j]输出
    		C[A2[j]]=C[A2[j]]-1;
    	}
    }
    
    void Radix_Sort(int *A,int d)
    { 
    	int i,j,k,temp;
    	int A2[10]={0};               //存放各个位
        int B[20]={0};                  //输出数组
       for(i=1;i<=d;i++)
       {
    	   
    	   for (j=0;j<=Length;j++)
    	   {
    		   temp=A[j];
    		   k=i;
    		    while(k>1)
    			{
                    temp=temp/10;
    			   	k--;
    			}
    			A2[j]=temp%10;	    //取指定的位存到A2[j],等待排序
    	   }
    	   Count_Sort(A2,B);
           memcpy(A,&B[1],(Length+1)*4);   
       }	  
    }
    int main()
    {
       int j;
       Radix_Sort(A,3);
       for (j=0;j<=Length;j++)
       {
    	   printf("%5d\n",A[j]);
       }
    
    }

    ———————————————————————————————————————————————————————————————————————————

    3.桶排序

      桶排序是假设输入数据服从均匀分布,平均情况下也是线性时间。假设输入数据是由一个随机过程产生,该过程将元素均匀,独立地分布在[0,1)区间上。
      它将[0,1)区间划分为n个相同大小的子区间,称为“桶”,然后遍历输入的数据,分别放入到指定的桶中(放入桶中的同时,有个链表插入排序的过程)。最后依次把各个桶中数据输出即可。


    例程:
    #include <STDIO.H>
    #include <STDLIB.H>
    int A[]={78,17,39,26,72,94,21,12,23,68};//假如输入数据平均分布在[0,99]区间内
    int Length = sizeof(A)/sizeof(A[0])-1;
    typedef struct Node      //链表单元结构
    {
       int num;
       struct Node *next;
    }Node; 
    Node *Bucket[10]={0};       //分成10个桶,即10个小区间
    void Bucket_Sort(int *A)
    {
       int i;
       int a;
       Node * temp=NULL,*Pre_temp=NULL;
       for (i=0;i<=Length;i++)               //遍历输入数组,放入到指定的桶中
       {
    	   a = (int)(A[i]/10);
    	   if(Bucket[a] == 0)               
    	   {
    		  Bucket[a]=(Node *)malloc(sizeof(Node));
    		  Bucket[a]->num=A[i];
    		  Bucket[a]->next=NULL;
    	   }
    	   else                                 //对非空链表插入排序
    	   {   
    		   temp=Pre_temp=Bucket[a];
    		   while(A[i] > temp->num)
    		   {  
    			  Pre_temp=temp;
                  temp=temp->next;
    			  if (temp==NULL)
    			    break;
    		   }
    
    		   if (temp == NULL)            // 插入到最后一个位置
    		   {
    			   temp=(Node *)malloc(sizeof(Node));
    			   temp->num=A[i];
    			   temp->next=NULL;
    			   Pre_temp->next=temp;
    		   }
    		   else if (temp == Bucket[a])  //插入到第一个位置
    		   {
    			   temp=(Node *)malloc(sizeof(Node));
    			   temp->num=A[i];
    			   temp->next=Bucket[a];
    			   Bucket[a]=temp;
    		   }
    		   else                         //插入到中间位置
    		   {
    			   temp=(Node *)malloc(sizeof(Node));
    			   temp->num=A[i];
    			   temp->next=Pre_temp->next;
    			   Pre_temp->next=temp;    
    		   }
    	   }
    	   
       }
       
       
    }
    void Free_List(Node * head)      //释放链表结构内存
    {
    	Node *N=head;
         while (head!=NULL)
         {
    		 N=head->next;
    		 free(head);
    		 head=N;
         }
    }
    int main()
    {
    	Node * temp=NULL;
    	int i=1;
        Bucket_Sort(A);
        for(i=0;i<=9;i++)   //依次输出各个桶中的数据
    	{ 
    		temp=Bucket[i];
    		while(temp!=NULL)
    		{
    			printf("%3d\n",temp->num);
    			temp=temp->next;
    		}
    		Free_List(Bucket[i]);  //释放第i个桶的内存
    	}
    	return 0;
    }


     
    


    展开全文
  • mysql查询根据时间排序

    万次阅读 2018-08-10 15:48:34
    表数据: mysql查询根据时间排序,如果有相同时间则只查询出来一个 所以需要再判断,如果时间相同,则根据id进行降序排序

    表数据:

    mysql查询根据时间排序,如果有相同时间则只查询出来一个

    所以需要再判断,如果时间相同,则根据id进行降序排序

    展开全文
  • 这里的应用场景是 要先按照时间排序(Date类型),再按照flag排序(int类型),查询出来的结果只能按照时间排序,后面的flag排序规则不起作用 最后分析得出的结论是,order by的时候需要格式化一下时间才可以正常...
  • ls 按大小排序 按时间排序

    千次阅读 2016-04-21 11:20:35
    按大小排序 [root@localhost ~]# ll -Sh 按时间排序 [root@localhost ~]# ll -rt
  • python按时间排序 文件

    千次阅读 2018-11-07 11:13:12
    python按时间排序目录下的文件 python文件夹遍历,文件操作,获取文件修改创建时间可以参考另一篇博客。 如: os.path.getmtime() 函数是获取文件最后修改时间 os.path.getctime() 函数是获取文件最后创建时间 ...
  • Android对数据按照时间排序

    千次阅读 2017-07-18 12:00:50
    经常遇见一个列表,两个接口的情况,两个接口属于两个不同的表数据,那么数据拼接回来之后,并不是按照时间排序的,看起来就相当混乱,所以记录一下如何对数据按照时间排序。步骤一:格式化日期 public static Date ...
  • linux ls 按 文件名 大小 时间 排序

    千次阅读 2020-08-05 17:03:04
    linux ls命令中,-f 直接列出结果,而不进行排序(ls默认会以文件名排序);-S 基于文件大小进行排序;-t 基于文件修改时间进行排序;-r 将排序结果反向输出,例如:原本...3. 基于文件时间排序 # ls -tr ...
  •  在实际操作中会经常将时间数据以 varchar类型存入数据库,因为业务要求需要查询最近时间内的数据,所以需要根据时间排序   排序实例: SELECT * FROM 表名 ORDER BY 时间字段名 DESC; 降序 SELECT * FROM ...
  • git tag按照时间排序

    千次阅读 2019-01-22 14:59:13
    打标签 git tag -a v1.2.0 -m ...实现标签以及备注,按照打标签的时间排序,这个应该是最可能使用的,反正我版本多了之后,就是用这个命令查看。 git tag -n --sort=taggerdate --sort=key,关于key的值可以参考 ...
  • Linux:ls按照修改时间排序显示

    千次阅读 2019-04-24 16:39:03
    命令:ls ...-t sort by modification time 按修改时间排序(最新的在最前面) -r reverse order while sorting (反序) 举例: # 按照时间降序 ls -lt # 按照时间升序 ls -ltr 当然为了简便,...
  • Linux按时间排序文件

    千次阅读 2015-08-18 15:20:54
    > ls -alt # 按修改时间排序 > ls --sort=time -la # 等价于> ls -alt > ls -alc # 按创建时间排序 > ls -alu # 按访问时间排序   # 以上均可使用-r实现逆序排序 > ls -alrt # 按修改时间排序 ...
  • Java集合按时间排序

    千次阅读 2018-08-14 22:05:37
    * 根据时间排序 * @param list */ private static void ListSort(List&lt;BillHistoryEntity&gt; list) { Collections.sort(list, new Comparator&lt;BillHistoryEntity&gt;() { ...
  • python list 对时间排序小结。

    万次阅读 2016-07-20 16:42:03
    但是对时间排序有时可能会比较麻烦一点,对时间的大致思想是对时间字符串进行格式化。然后进行排序。 第一种排序方法是按照https://www.the5fire.com/python-sort-dict-in-list-by-time.html 的方法进行排序。 第...
  • LINUX的文件按时间排序

    千次阅读 2016-08-30 12:08:50
    > ls -alt # 按修改时间排序 > ls --sort=time -la # 等价于> ls -alt > ls -alc # 按创建时间排序 > ls -alu # 按访问时间排序   # 以上均可使用-r实现逆序排序 > ls -alrt # 按修改时间排序 ...
  • java8 List对象根据时间排序

    万次阅读 2019-05-14 21:00:52
    java8 List对象根据时间排序 直接上代码 rewardModelList 是我本地的 一个list ==List<实体> DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); SimpleDateFormat sdf = new SimpleDateFormat...
  • 通过lambda表达式根据对象中的时间排序 //根据时间排序 最小的时间排在第一个 List<HMDeduct> newHMDeduct = hmDeducts.stream().sorted(Comparator.comparing(HMDeduct::getCpyDate)).collect(Collectors.to...
  • django-查询按时间排序

    千次阅读 2018-07-12 17:56:00
    django-查询按时间排序 Meta类实现 class News(models.Model): title = models.CharField(max_length=35) desc = models.CharField(max_length=100) thumbnail = models.URLFiel...
  • js 数据按时间排序

    万次阅读 2019-06-12 10:04:22
    运用了sort()方法进行排序 说明 如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。要实现这一点,首先应把数组的元素都转换成字符串(如有必要)...
  • 在linux系统中,使用ls命令按时间排序文件,其实很简单,如下: #ls -tr 即可按时间排序当前目录下的文件。 附,ls命令的参数中文详解: -a 列出目录下的所有文件,包括以 . 开头的隐含文件。 -b 把文件名中...
  • Java中List集合数据根据时间排序

    千次阅读 2019-10-29 11:20:31
    * 根据时间排序 * @param list */ private static void ListSort(List<BillHistoryEntity> list) { Collections.sort(list, new Comparator<BillHistoryEntity>() { ...
  • Mysql时间排序

    万次阅读 2018-01-24 11:38:16
    mySQL里desc和asc的意思  desc是descend 降序意思  ... sql = "select 表内容名 from 数据库表名 Putout=true order by 读取的排序表名 asc" 例如 sql = "select * from user where Putout=true or
  • ACCESS格式化时间按时间排序

    千次阅读 2012-04-07 16:18:42
    在用ACCESS查询数据的时候,有时按时间排序时会出现如下情况: 2011-1-12会小于2011-1-2,为解决这个情况,可以在查询时格式化时间,函数如下:Format(time, 'yyyy-mm-dd') as newtime。其中,time是你要查询的字段...
  • 现有一个知识表(knowledge ),项目要求主页显示十条知识,显示规则为:前三条按浏览量排序,后七条按照发布时间排序。 解决方案: 建立一个视图(top_knowledge),语句如下: create or ...
  • linux 命令查看文件按照修改时间排序 1.按文件大小查看文件 a.降序:ls -lsh moudaen@morton:~$ ls -lsh total 20M 20M -rw-r–r-- 1 moudaen 65536 20M Nov 11 17:44 Gender.war 4.0K drwxr-xr-x 2 moudaen 65536 ...
  • Mybatis 时间排序让空值NULL排在后面

    千次阅读 2018-10-18 10:00:32
    有一张通知(notification)表;...2.先按发布时间排序再按创建时间排序,发布时间为空的要排在后面。 select * from notification; id content status create_time publiish_time 1 aaa on ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,089,248
精华内容 435,699
关键字:

时间排序