字符统计

while True:
    try:
        str1 = input()#读取字符串
        str2 = list(str1)#转换list转存入str2
        str2 = set (str2)#去除重复项
        str2 = list(str2)#变回list
        a=[]
        for i in range (len(str2)):#计算每一项个数
            num =str1.count(str2[i])
            a.append((ord(str2[i]),num))#以（asc码，count个数）的形式添加入a里（a为list）用ord()转换为ASCII码
        a.sort(key=lambda x:x[0])#先ASCII 码升序排列
        a.sort(key=lambda x:x[1],reverse=True)#再出现次数降序排列，遇到相同的排序会预设按输入次序也就是上行ASCII的sort排序顺序
        str3=""
        for i in range (len(a)):
            str3 = str3+str(chr(a[i][0])) #用chr（）换回字母数字，打印结果
        print(str3)
    except:
        break

import collections
while True:
    try:
        input_ = input()
        letter_dict = collections.defaultdict(int)
        for i in input_:
            letter_dict[i]+=1
        result = sorted(sorted(letter_dict, key = ord), key = letter_dict.get, reverse = True)
        print(''.join(result))
    except:
        break

import sys
from collections import defaultdict


for s in sys.stdin:
    d = defaultdict(int)
    for c in s.strip():
        d[c] += 1
    chars = list(d.items())
    chars.sort(key=lambda x: ord(x[0]))
    chars.sort(key=lambda x: x[1], reverse=True)
    print("".join([x[0] for x in chars]))

# 思路：关键在于两次排序：给出现次数不同的字符按次数排序(次数由多——少)
#                    给出现次数相同的字符按ascii大小来排序(小_大)
while True:
    try:
        s = input().strip()
        dic = {}
        for ch in s:
            if ch in dic:
                dic[ch] += 1
            else:
                dic[ch] = 1
        dic = sorted(dic.items(), key=lambda x: x[0])  # 先按字符ASC排
        dic = sorted(dic, key=lambda x: x[1], reverse=True)  # 再按统计数目排
        print(''.join([k for (k, v) in dic]))
    except:
        break

# 2020年11月17日16:25:16
while True:
    try:
        string = input()
#       去重,去掉非统计字符
        new_string = []
        for i in range(len(string)):
            if string[i] not in new_string: 
#               只统计字母、数字、空格
                s = string[i]
                if s.isalpha()or s.isdigit()or s.isspace():
                    new_string.append(string[i])
#       利用lambda表达式降序排序，第一依据为出现次数，次数相同情况下，第二依据为ascii码的负值
        new_string.sort(key=lambda x:(string.count(x[0]), -ord(x[0])),reverse=True)
#       列表转字符串
        print("".join(new_string))
    except:
        break
        

字典计数，列表存储次数，按要求输出

while 1:
    try:
        st = input()
        # dic计数
        dic = dict()
        for i in st:
            dic[i] = dic.get(i,0)+1
        # 对dic值，去重后降序
        value_list = list(set([j for j in dic.values()]))
        value_list.sort(reverse=True)
        res = [ ]
        for m in value_list:
            # 若次数相同，对多个key做升序，即ASCII码由小到大
            temp = [k for k,v in dic.items() if v==m] 
            temp.sort(reverse=False)
            # 使用extend而非append
            res.extend(temp)
        print(''.join(res))
    except:
        break

from collections import defaultdict
while True:
    try:
        s, res = input().strip(), ''
        dd = defaultdict(int)
        for i in s:
            if i.isalpha()&nbs***bsp;i.isdigit()&nbs***bsp;i == ' ':
                dd[i] += 1
        tmp = sorted(dd.items(), key=lambda x: (-x[1], x[0]) )
        for i in tmp:
            res += i[0]
        print(res)
    except:
        break

while True:
    try:
        str = input()
        dicts = {}
        for i in str:
            if i.isspace()&nbs***bsp;i.isdigit()&nbs***bsp;i.isalpha():
                if i not in dicts:
                    dicts[i]=0
                dicts[i]+=1
        a = sorted(dicts.items(), key=lambda x:(-x[1],x[0]))
        res = []
        for i in a:
            res.append(i[0])
        print(''.join(res))
    except:
        break







可参考字典排序的知识
x:(-x[1],x[0]) 先按照字符的数量排序，当数量相等时，按照ASII码排序

while True:
    try:
        s = list(input())
        s2 = list(set(s))
        s2.sort()
        print("".join(sorted(s2, key=lambda x: -s.count(x))))
    except:
        break

while True:
    try:
        s1=input()
        sr=[]
        for s in s1:
            sr.append(s)
        ls=[]
        count=[]
        while not sr==[]:
            i=sr[0]
            count.append(sr.count(i))
            ls.append(i)
            while i in sr:
                sr.remove(i)
        for i in ls:
            m=[ord(i)]
            for j in ls[ls.index(i)+1:]:
                if count[ls.index(i)]==count[ls.index(j)]:
                    m.append(ord(j))
            m.sort()
            q=0
            for k in m:
                count[ls.index(chr(k))]-=0.001*q
                q+=1
        counted=sorted(count,reverse=True)
        jg=[]
        # for i in counted:
        #     for j in range(int(i)):
        #         jg.append(count.index(i))
        for i in counted:
            jg.append(count.index(i))
        for i in jg:
            print(ls[i],end='')
    except:
        break

while True:
    try:
        s = input()
        a = list(s)
        dit = {}
        for i in a:
            if i.isalpha()&nbs***bsp;i.isspace()&nbs***bsp;i.isdigit():
                if i in dit:
                    dit[i]+=1
                else:
                    dit[i]=1
            b = sorted(dit.items(),key = lambda x:x[1],reverse=True)
            ls = []
            for s,n in b:
                ls.append([s,n*256+256-ord(s)])#把值比较和码比较合并了，别的地方写的不好
            c = sorted(ls,key = lambda x:x[1],reverse=True)
            res = ''
            for i in c:
                res = res+i[0]
        print(res)
    except:
        break

import re
while 1:
    try:
        instr, mylist = list(map(ord,list(input()))), []
        for i in instr:
            if (-instr.count(i), i) not in mylist:
                mylist.append((-instr.count(i), i))
        value  = [a[1] for a in sorted(mylist)]
        allstr = ''.join(list(map(chr, value)))
        out    = list(re.findall(r'[a-zA-Z0-9\s]',allstr))
        print(''.join(out))
    except:
        break