Python统计list中各个元素出现的次数

列表count()函数调用方法

对象.count(参数)

count()方法操作示例

有列表[\'a\',\'iplaypython.com\',\'c\',\'b‘,\'a\']，想统计字符串\'a\'在列表中出现的次数，可以这样操作

>>> [\'a\',\'iplaypython.com\',\'c\',\'b\',\'a\'].count(\'a\')

2

其返回值就是要统计参数出现的次数。在应用的时候最好是把列表赋给一个变量，之后再用count()方法来操作比较好。

当对象是一个嵌套的列表时，要查找嵌套列表中的列表参数count()方法同样可以完成

>>> x = [1,2,\'a\',[1,2],[1,2]]

>>> x.count([1,2])

2

>>> x.count(1)

1

>>> x.count(\'a\')

1

 

 

1. 计算字母和数字出现的次数
 
str=\'abc123abc456aa\'
d={}
for x in str:
    print x
    if not x in d:
        d[x]=1
    else:
        d[x]=d[x]+1
 
print d
 
{\'a\': 4, \'c\': 2, \'b\': 2, \'1\': 1, \'3\': 1, \'2\': 1, \'5\': 1, \'4\': 1, \'6\': 1}


#!/usr/bin/python3

str="ABCdefabcdefabc"
str=str.lower()
str_list=list(str)
char_dict={}

for char1 in str:
      if char1 in char_dict:
          count=char_dict[char1]
      else:
         count=0
     count=count+1
     char_dict[char1]=count
 print(char_dict)



a = "aAsmr3idd4bgs7Dlsf9eAF"

请将a字符串的数字取出，并输出成一个新的字符串。

请统计a字符串出现的每个字母的出现次数（忽略大小写，a与A是同一个字母），并输出成一个字典。 例 {\'a\':3,\'b\':1}

请去除a字符串多次出现的字母，仅留最先出现的一个,大小写不敏感。例 \'aAsmr3idd4bgs7Dlsf9eAF\'，经过去除后，输出 \'asmr3id4bg7lf9e\'

a = "aAsmr3idd4bgs7Dlsf9eAF"

def fun1_2(x): #1&2

    x = x.lower() #大小写转换

    num = []

    dic = {}

    for i in x:

        if i.isdigit():  #判断如果为数字，请将a字符串的数字取出，并输出一个新的字符串

            num.append(i)

        else:   #2 请统计a字符串出现每个字母的出现次数（忽视大小写），并输出一个字典。例：{\'a\':3,\'b\':1}

            if i in dic:
                        continue
            else:
                dic[i] = x.count(i)  

    new = \'\'.join(num)

    print "the new numbers string is: " + new

    print "the dictionary is: %s" % dic

fun1_2(a)

 

 

def fun3(x):

    x = x.lower()

    new3 = []

    for i in x:

        if i in new3:

                continue
        else:
            new3.append(i)

    print \'\'.join(new3)

fun3(a)

 

三种方法：

①直接使用dict

②使用defaultdict

③使用Counter


ps:`int()`函数默认返回0


①dict

1. text = "I\'m a hand some boy!"
2.  
3. frequency = {}
4.  
5. for word in text.split():
6.    if word not in frequency:
7.        frequency[word] = 1
8.    else:
9.        frequency[word] += 1

②defaultdict

1. import collections
2.  
3. frequency = collections.defaultdict(int)
4.  
5. text = "I\'m a hand some boy!"
6.  
7. for word in text.split():
8.    frequency[word] += 1


③Counter

1. import collections
2.  
3. text = "I\'m a hand some boy!"
4. frequency = collections.Counter(text.split())


现有列表如下：
[6, 7, 5, 9, 4, 1, 8, 6, 2, 9]
希望统计各个元素出现的次数，可以看作一个词频统计的问题。
我们希望最终得到一个这样的结果：{6:2, 7:1...}即 {某个元素：出现的次数...}
首先要将这些元素作为字典的键，建立一个初值为空的字典：


>>> from random import randint

>>> l = [randint(1,10) for x in xrange(10)]

>>> l
[6, 7, 5, 9, 4, 1, 8, 6, 2, 9]

>>> d = dict.fromkeys(l, 0)
>>> d
{1: 0, 2: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0}

# 现在的任务是需要将d中每个键所对应的值统计出来
>>> for x in l:
>>>     d[x] += 1
>>> d

{1: 1, 2: 1, 4: 1, 5: 1, 6: 2, 7: 1, 8: 1, 9: 2}

# 这就统计完了所有的元素出现的次数



另外一种方法，利用collections模块中的Counter对象


>>> from collections import Counter

# 这个Counter可以直接接受一个列表，将它转化为统计完成的结果

>>> d = Counter(l)
>>> d
Counter({6: 2, 9: 2, 1: 1, 2: 1, 4: 1, 5: 1, 7: 1, 8: 1})
# 该Counter对象是字典对象的子类，也可以通过键来访问对应值
>>> d[6]
2
# Counter对象方便之处在于它内置有most_common(n)方法，可以直接统计出前n个最高词频
>>> d.most_common(2)
[(6, 2), (9, 2)]


用python做词频统计

import string
import time

path=\'C:\\Users\\ZHANGSHUAILING\\Desktop\\Walden.txt\'

with open(path,\'r\') as text:
    words=[raw_word.strip(string.punctuation).lower() for raw_word in text.read().split()]
    words_index=set(words)
    counts_dict={index:words.count(index) for index in words_index}
for word in sorted(counts_dict,key=lambda x:counts_dict[x],reverse=True):
    time.sleep(2)
    print (\'{}--{} times\'.format(word,counts_dict[word]))


{\'the\': 2154, \'and\': 1394, \'to\': 1080, \'of\': 871, \'a\': 861, \'his\': 639, \'The\': 637, \'in\': 515, \'he\': 461, \'with\': 310, \'that\': 308, \'you\': 295, \'for\': 280, \'A\': 269, \'was\': 258, \'him\': 246, \'I\': 234, \'had\': 220, \'as\': 217, \'not\': 215, \'by\': 196, \'on\': 189, \'it\': 178, \'be\': 164, \'at\': 153, \'from\': 149, \'they\': 149, \'but\': 149, \'is\': 144, \'her\': 144, \'their\': 143, \'who\': 131, \'all\': 121, \'one\': 119, \'which\': 119,}#部分结果展示


import re,collections
def get_words(file):
    with open (file) as f:
        words_box=[]
        for line in f:                         
            if re.match(r\'[a-zA-Z0-9]*\',line):#避免中文影响
                words_box.extend(line.strip().split())               
    return collections.Counter(words_box)
print(get_nums(\'emma.txt\')+get_nums(\'伊索寓言.txt\'))


import re,collections
def get_words(file):
    with open (file) as f:
        words_box=[]
        for line in f:                         
                if re.match(r\'[a-zA-Z0-9]\',line):
                    words_box.extend(line.strip().split())               
    return collections.Counter(words_box)
a=get_nums(\'emma.txt\')+get_nums(\'伊索寓言.txt\')
print(a.most_common(10))

python 计数方法小结


方法一： 遍历法


def get_counts(sequence):
    counts = {}
    for x in sequence:
        if x in counts:
            counts[x] += 1
        else:
            counts[x] = 1
    return counts
这是最常规的方法，一个一个数咯


方法二： defaultdict


这里用到了coollections 库


from collections import defaultdict


def get_counts2(sequence):
    counts = defaultdict(int) #所有值被初始化为0
    for x in sequence:
        counts[x] += 1
    return counts
最后得到的是 元素：个数 的一个字典


方法三：value_counts()


这个方法是pandas 中的 ，所以使用时候需要先导入pandas ,该方法会对元素计数，并按从大到小的顺序排列


tz_counts = frame[\'tz\'].value_counts()
tz_counts[:10]


>>>
America/New_York       1251
                        521
America/Chicago         400
America/Los_Angeles     382
America/Denver          191
Europe/London            74
Asia/Tokyo               37
Pacific/Honolulu         36
Europe/Madrid            35
America/Sao_Paulo        33
Name: tz, dtype: int64
我们看一下官方文档中的说明


Series.value_counts(normalize=False, sort=True, ascending=False, bins=None, dropna=True)[source]?
Returns object containing counts of unique values.
1
2
这里说明一下返回的数据是Series 格式的


总的来说 方法一最为普通 如果数据量比较大的话 非常费时间 ，方法三对数据的格式有要求 ，所以推荐使用方法二


python - 统计一个字符串中的每一个字符出现了多少次(先将字符串转换为列表再统计)


#coding=utf-8

#统计一个字符串中的每一个字符出现了多少次

#定义一个字符串
str = \'abbcccdddd\'

#在字符串的每一个字符之间插入一个空格组成一个新的字符串

str = \' \'.join(str)

#打印新的字符串看看

print(\'str = \',str)

#将新字符串按空格分割成一个列表

li = str.split(\' \')


#打印新的列表


print(\'li = \',li)


#统计每一个字符出现的次数:

#方式一

for i in set(li):
    if li.count(i) >= 1:
        print(\'%s 出现了%d 次!\'%(i, li.count(i)))


print(\'*\'*50)

#方式二

from collections import Counter
res = Counter(li)
print(res)

运行结果:

(\'str = \', \'a b b c c c d d d d\')
(\'li = \', [\'a\', \'b\', \'b\', \'c\', \'c\', \'c\', \'d\', \'d\', \'d\', \'d\'])
a 出现了1 次!
c 出现了3 次!
b 出现了2 次!
d 出现了4 次!
**************************************************
Counter({\'d\': 4, \'c\': 3, \'b\': 2, \'a\': 1})


Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

count()方法语法：

str.count(sub, start= 0,end=len(string))

参数
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值

该方法返回子字符串在字符串中出现的次数。

#!/usr/bin/python
 
str = "this is string example....wow!!!";
 
sub = "i";

print "str.count(sub, 4, 40) : ", str.count(sub, 4, 40)

sub = "wow";

print "str.count(sub) : ", str.count(sub)

#定义统计字符串的方法


def calcu_sub_str_num(mom_str,sun_str):
  print(\'打印母字符串：\',mom_str)   #打印出母字符串
  print( \'打印子字符串：\',sun_str)  #打印出子字符串
  print(\'打印母字符串长度：\',len(mom_str)) #打印出母字符串长度
  print( \'打印子字符串长度：\',len(sun_str))  #打印出子字符串长度
  count = 0                                  #定义计数器初始值
  #使用循环遍历字符串，第一次循环，通过切片获取下标从0开始与子字符串长度一致的字符串，并与字符串比较，如果等于子字符串count+1
  #第二次循环，通过切片获取下标从1开始与子字符串长度一致的字符串，并与字符串比较，如果等于子字符串则count+1，以此类推直到遍历完成
  for i in range(len(mom_str)-1): #因为i的下标从0开始，所以len（mom_str）-1
      if mom_str[i:i+len(sun_str)] == sun_str:
          count+=1
  return count


mom_str = input(\'please input mother string:\') #使用input获取输入母字符串
sun_str = input(\'please input child string:\') #使用input获取输入子字符串
print(\'子字符串在母字符串中出现的次数：%d\'%calcu_sub_str_num(mom_str,sun_str))#%d为数字占位符

 

例8：使用zip方法构建元素为元组的列表


In [91]: zip(\'xyz\',\'123\')


Out[91]: [(\'x\', \'1\'), (\'y\', \'2\'), (\'z\',\'3\')]


In [92]: zip(\'xyz\',\'1234\')


Out[92]: [(\'x\', \'1\'), (\'y\', \'2\'), (\'z\',\'3\')]


In [93]: zip(\'xyzm\',\'564\')


Out[93]: [(\'x\', \'5\'), (\'y\', \'6\'), (\'z\',\'4\')]


In [94]: zip(\'xyz\',\'123\',\'abc\')


Out[94]: [(\'x\', \'1\', \'a\'), (\'y\', \'2\', \'b\'),(\'z\', \'3\', \'c\')]


例9：使用dict(zip())快速构建字典


In [95]: dict(zip(\'xyz\',\'123\'))


Out[95]: {\'x\': \'1\', \'y\': \'2\', \'z\': \'3\'}
--------------------- 

1) 使用字典dict()


循环遍历出一个可迭代对象中的元素,如果字典没有该元素,那么就让该元素作为字典的键,并将该键赋值为1,如果存在就将该元素对应的值加1.


lists = [\'a\',\'a\',\'b\',5,6,7,5]
        count_dict = dict()
        for item in lists:
            if item in count_dict:
                count_dict[item] += 1
            else:
                count_dict[item] = 1

2) 使用defaultdict()

defaultdict(parameter)可以接受一个类型参数,如str,int等,但传递进来的类型参数，不是用来约束值的类型，更不是约束键的类型，而是当键不存在的话,实现一种值的初始化

defaultdict(int)：初始化为 0
defaultdict(float)：初始化为 0.0
defaultdict(str)：初始化为 ”
from collections import defaultdict
        lists = [\'a\', \'a\', \'b\', 5, 6, 7, 5]
        count_dict = defaultdict(int)
        for item in lists:
            count_dict[item] += 1

3)使用集合(set)和列表(list)

先使用set去重,然后循环的把每一个元素和每一个元素对应的次数lists.count(item)组成一个元组放在列表里面

lists = [\'a\', \'a\', \'b\', 5, 6, 7, 5]
count_set = set(lists)
count_list = list()
for item in count_set:
      count_list.append((item,lists.count(item)))

4)使用Counter

Counter是一个容器对象,主要的作用是用来统计散列对象,可以使用三种方式来初始化

参数里面参数可迭代对象 Counter("success")

传入关键字参数Counter((s=3,c=2,e=1,u=1))

传入字典 Counter({"s":3,"c"=2,"e"=1,"u"=1})

Counter()对象还有几个可以调用的方法,代码里面分别进行了说明

from collections import Counter
lists = [\'a\', \'a\', \'b\', 5, 6, 7, 5]
a = Counter(lists)
print(a)  # Counter({\'a\': 2, 5: 2, \'b\': 1, 6: 1, 7: 1})

a.elements() # 获取a中所有的键,返回的是一个对象,我们可以通过list来转化它

a.most_common(2) # 前两个出现频率最高的元素已经他们的次数,返回的是列表里面嵌套元组

a[\'zz\']  # 访问不存在的时候,默认返回0

a.update("aa5bzz") # 更新被统计的对象,即原有的计数值与新增的相加,而不是替换

a.subtrct("aaa5z") # 实现与原有的计数值相减,结果运行为0和负值

 

 

 

 

• 利用Python字典统计
• 利用Python的collection包下Counter类统计
• 利用Python的pandas包下的value_counts类统计

 

字典统计

a = [1, 2, 3, 1, 1, 2]
dict = {}
for key in a:
    dict[key] = dict.get(key, 0) + 1
print(dict)

 

 

collection包下Counter类统计

 

from collections import Counter
a = [1, 2, 3, 1, 1, 2]
result = Counter(a)
print(result)

 

pandas包下的value_counts方法统计

import pandas as pd
a = pd.DataFrame([[1,2,3],
                  [3,1,3],
                  [1,2,1]])
result = a.apply(pd.value_counts)
print(result)