python将时间按多少先后排序正确的是

导读：很多朋友问到关于python将时间按多少先后排序正确的是的相关问题，本文首席CTO笔记就来为大家做个详细解答，供大家参考，希望对大家有所帮助！一起来看看吧！

python中按文件时间顺序来排列一个文件夹下面的文件，如何实现？

建立一个字典，键是文件名，键值是时间属性，

然后用内置的sorted()函数，根据字典的值进行排序，返回一个有序的列表

假设字典名字叫folder，有序列表叫order

order = sorted(folder.items(),key=lambda e:e[1],reverse=False)

key = lambda e:e[1]表示按值进行排序，也就是你需要的按时间属性排序，e[0]则是按键名进行排序

reverse=False可以省略不写，默认是升序排列，reverse=True就是降序排列了

按时间先后顺序排列正确的是

下列中国古代朝代按时间先后排列正确的是,隋唐秦汉宋元明清

下列中国古代朝代顺序排列正确的一项是（　B　）

A. 隋唐-秦汉-宋元-明清  B. 秦汉-隋唐-宋元-明清  C. 宋元-隋唐-秦汉-明清  D. 明清-宋元-秦汉-隋唐

是指最新的时间排在最前，以此往下进行排序。与之相反的按时间升序排序。在实际应用中，各种评论一般默认排序是按时间降序排序。在实际很多应用中，经常需要进行排序，一般都是对象中的一个属性进行升序或降序，其中对时间进行排序是最常见一个属性。

排序的算法有很多，对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。

相关介绍：

排序依据 — 按以下三个选项之一进行排序：数据源顺序 — 数据源对数据进行自然排序的顺序。通常，对于关系数据源，这往往是按字母顺序 - 更具体而言，是采用自然排序顺序，其与字母顺序相同，但多位数字会作为单个字符进行排序。

因此，例如，如果按字母顺序排序，"z11"先于 "z2"，因为 "1" 的计算结果小于 "2"，但是如果按自然顺序排序，"z2"先于 "z11"，因为 "2" 的计算结果小于 "11"。

如果使用的是多维数据集，则该顺序是维度内成员的定义分层顺序。字母 — 字母表中的字母顺序。字段 — 基于另一个字段的关联值对数据进行排序。例如，您可按多种产品的总销售额对这些产品进行排序。按时间降序排序是指最新的时间排在最前，以此往下进行排序。

用python编写程序。问题如下：有两列数据，一列是时间，形式为2011/5/31 19:00,另一列是一个具体的数值

数据先导入，通常用csv。

然后是时间格式转换用time.strptime

转换完的时间可以直接取到hour,miniute,等属性，你直接按hour做当天平均值，再做月份的平均值。（其实可以一直计算，不用分开算）

最简单的办法是1个月的数据，全放在一起，按时间排序，然后按小时平均就可以了。

如果不想麻烦就这样

sum([v for t,v in data if t.hour==2]) /len([v for t,v in data if t.hour==2])

这句话就是计算2点的数据平均值

怎样用python将文件里储存的时间按时间范围分类并且统计时间个数，然后存放在另一个文件里？

1，把时间的类型，最后变成timestamp类型，好操作

2，用pandas 里面有.loc（）这个函数可以判断范围，可以参考我的博客--判断时间是不是在一个区间范围内：

网页链接

python如何对日期进行从小到大排序

其实直接sorted排序就行.如果要严谨的花, 改成用时间戳排序就是.

python几种经典排序方法的实现

class SortMethod:

'''

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

插入算法把要排序的数组分成两部分：

第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置）

第二部分就只包含这一个元素（即待插入元素）。

在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。

'''

def insert_sort(lists):

# 插入排序

count = len(lists)

for i in range(1, count):

key = lists[i]

j = i - 1

while j = 0:

if lists[j] key:

lists[j + 1] = lists[j]

lists[j] = key

j -= 1

return lists

'''

希尔排序 (Shell Sort) 是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因 DL．Shell 于 1959 年提出而得名。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。

'''

def shell_sort(lists):

# 希尔排序

count = len(lists)

step = 2

group = count / step

while group 0:

for i in range(0, group):

j = i + group

while j count:

k = j - group

key = lists[j]

while k = 0:

if lists[k] key:

lists[k + group] = lists[k]

lists[k] = key

k -= group

j += group

group /= step

return lists

'''

冒泡排序重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

'''

def bubble_sort(lists):

# 冒泡排序

count = len(lists)

for i in range(0, count):

for j in range(i + 1, count):

if lists[i] lists[j]:

temp = lists[j]

lists[j] = lists[i]

lists[i] = temp

return lists

'''

快速排序

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

'''

def quick_sort(lists, left, right):

# 快速排序

if left = right:

return lists

key = lists[left]

low = left

high = right

while left right:

while left right and lists[right] = key:

right -= 1

lists[left] = lists[right]

while left right and lists[left] = key:

left += 1

lists[right] = lists[left]

lists[right] = key

quick_sort(lists, low, left - 1)

quick_sort(lists, left + 1, high)

return lists

'''

直接选择排序

第 1 趟，在待排序记录 r[1] ~ r[n] 中选出最小的记录，将它与 r[1] 交换；

第 2 趟，在待排序记录 r[2] ~ r[n] 中选出最小的记录，将它与 r[2] 交换；

以此类推，第 i 趟在待排序记录 r[i] ~ r[n] 中选出最小的记录，将它与 r[i] 交换，使有序序列不断增长直到全部排序完毕。

'''

def select_sort(lists):

# 选择排序

count = len(lists)

for i in range(0, count):

min = i

for j in range(i + 1, count):

if lists[min] lists[j]:

min = j

temp = lists[min]

lists[min] = lists[i]

lists[i] = temp

return lists

'''

堆排序 (Heapsort) 是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。

可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即 A[PARENT[i]] = A[i]。

在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

'''

# 调整堆

def adjust_heap(lists, i, size):

lchild = 2 * i + 1

rchild = 2 * i + 2

max = i

if i size / 2:

if lchild size and lists[lchild] lists[max]:

max = lchild

if rchild size and lists[rchild] lists[max]:

max = rchild

if max != i:

lists[max], lists[i] = lists[i], lists[max]

adjust_heap(lists, max, size)

# 创建堆

def build_heap(lists, size):

for i in range(0, (size/2))[::-1]:

adjust_heap(lists, i, size)

# 堆排序

def heap_sort(lists):

size = len(lists)

build_heap(lists, size)

for i in range(0, size)[::-1]:

lists[0], lists[i] = lists[i], lists[0]

adjust_heap(lists, 0, i)

'''

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法 （Divide and Conquer） 的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并过程为：

比较 a[i] 和 a[j] 的大小，若 a[i]≤a[j]，则将第一个有序表中的元素 a[i] 复制到 r[k] 中，并令 i 和 k 分别加上 1；

否则将第二个有序表中的元素 a[j] 复制到 r[k] 中，并令 j 和 k 分别加上 1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到 r 中从下标 k 到下标 t 的单元。归并排序的算法我们通常用递归实现，先把待排序区间 [s,t] 以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间 [s,t]。

'''

def merge(left, right):

i, j = 0, 0

result = []

while i len(left) and j len(right):

if left[i] = right[j]:

result.append(left[i])

i += 1

else:

result.append(right[j])

j += 1

result += left[i:]

result += right[j:]

return result

def merge_sort(lists):

# 归并排序

if len(lists) = 1:

return lists

num = len(lists) / 2

left = merge_sort(lists[:num])

right = merge_sort(lists[num:])

return merge(left, right)

'''

基数排序 （radix sort） 属于“分配式排序” （distribution sort），又称“桶子法” （bucket sort） 或 bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序。

其时间复杂度为 O (nlog(r)m)，其中 r 为所采取的基数，而 m 为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

'''

import math

def radix_sort(lists, radix=10):

k = int(math.ceil(math.log(max(lists), radix)))

bucket = [[] for i in range(radix)]

for i in range(1, k+1):

for j in lists:

bucket[j/(radix**(i-1)) % (radix**i)].append(j)

del lists[:]

for z in bucket:

lists += z

del z[:]

return lists

---------------------

作者：CRazyDOgen

来源：CSDN

原文：

版权声明：本文为博主原创文章，转载请附上博文链接！

结语：以上就是首席CTO笔记为大家整理的关于python将时间按多少先后排序正确的是的相关内容解答汇总了，希望对您有所帮助！如果解决了您的问题欢迎分享给更多关注此问题的朋友喔～

以上内容为新媒号(sinv.com.cn)为大家提供！新媒号，坚持更新大家所需的互联网后端知识。希望您喜欢！