Đếm số lần xuất hiện của từng phần tử trong danh sách bằng Bộ đếm của Python

Kinh doanh

Trong Python, số lượng tất cả các phần tử trong một danh sách hoặc bộ mã có thể được lấy bằng cách sử dụng hàm tích hợp len () và số lượng của mỗi phần tử (số lần xuất hiện của mỗi phần tử) có thể được lấy bằng cách sử dụng phương thức count () .

Ngoài ra, lớp Counter của bộ sưu tập thư viện chuẩn Python có thể được sử dụng để lấy các phần tử theo thứ tự số lần xuất hiện.

Trong phần này, chúng ta sẽ thảo luận về những điều sau

  • Đếm tổng số phần tử:len()
  • Đếm số lượng của mỗi phần tử (số lần xuất hiện của mỗi phần tử):count()
  • Sử dụng.collections.Counter
  • Các phần tử được truy xuất theo thứ tự tần suất xuất hiện:most_common()
  • Đếm số lượng (loại) các phần tử không trùng nhau (phần tử duy nhất).
  • Đếm số phần tử thỏa mãn điều kiện.

Ngoài ra, như một ví dụ cụ thể, phần sau được giải thích bằng mã mẫu.

  • Đếm số lần xuất hiện của một từ trong một chuỗi.
  • Đếm số lần xuất hiện của một ký tự trong một chuỗi.

Mẫu là một danh sách, nhưng quá trình xử lý tương tự có thể được thực hiện với các bộ giá trị.

Đếm tổng số phần tử: len ()

Để đếm tổng số phần tử trong một danh sách hoặc bộ, hãy sử dụng hàm len () tích hợp sẵn.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(len(l))
# 7

Đếm số lượng của mỗi phần tử (số lần xuất hiện của mỗi phần tử): phương thức count ()

Để đếm số lượng của mỗi phần tử (số lần xuất hiện của mỗi phần tử), hãy sử dụng phương thức count () cho danh sách, bộ giá trị, v.v.

Nếu một giá trị không tồn tại dưới dạng phần tử được truyền dưới dạng đối số, thì giá trị 0 sẽ được trả về.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(l.count('a'))
# 4

print(l.count('b'))
# 1

print(l.count('c'))
# 2

print(l.count('d'))
# 0

Nếu bạn muốn nhận số lần xuất hiện của từng phần tử cùng một lúc, thì collection.Counter sau đây rất hữu ích.

Cách sử dụng bộ sưu tập.

Các bộ sưu tập thư viện chuẩn Python có một lớp Counter.

Counter () là một lớp con của kiểu từ điển dict, có dữ liệu ở dạng phần tử là khóa và xuất hiện dưới dạng giá trị.

import collections

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})

print(type(c))
# <class 'collections.Counter'>

print(issubclass(type(c), dict))
# True

Nếu một phần tử được chỉ định làm khóa, thì số phần tử có thể nhận được. Nếu một giá trị không tồn tại dưới dạng một phần tử được chỉ định, thì giá trị 0 sẽ được trả về.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Bạn cũng có thể sử dụng các phương thức loại từ điển như khóa (), giá trị (), mục (), v.v.

print(c.keys())
# dict_keys(['a', 'b', 'c'])

print(c.values())
# dict_values([4, 1, 2])

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

Các phương thức này trả về các đối tượng kiểu dict_keys, v.v … Chúng có thể được sử dụng như thể bạn muốn chạy câu lệnh for. Nếu bạn muốn chuyển đổi nó thành một danh sách, hãy sử dụng list ().

Lấy các phần tử theo thứ tự tần suất xuất hiện: phương thức most_common ()

Bộ đếm có phương thức most_common (), trả về một danh sách các bộ giá trị có dạng (phần tử, số lần xuất hiện) được sắp xếp theo số lần xuất hiện.

print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]

Phần tử có số lần xuất hiện cao nhất có thể nhận được bằng cách chỉ định một chỉ số, chẳng hạn như [0] cho số lần xuất hiện cao nhất và [-1] cho số lần xuất hiện thấp nhất. Nếu bạn chỉ muốn lấy các phần tử hoặc chỉ số lần xuất hiện, bạn có thể chỉ định thêm chỉ mục.

print(c.most_common()[0])
# ('a', 4)

print(c.most_common()[-1])
# ('b', 1)

print(c.most_common()[0][0])
# a

print(c.most_common()[0][1])
# 4

Nếu bạn muốn sắp xếp chúng theo thứ tự giảm dần số lần xuất hiện, hãy sử dụng lát cắt với số tăng được đặt thành -1.

print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]

Nếu đối số n được chỉ định cho phương thức most_common (), thì chỉ n phần tử có số lần xuất hiện cao nhất được trả về. Nếu nó bị bỏ qua, tất cả các phần tử.

print(c.most_common(2))
# [('a', 4), ('c', 2)]

Nếu bạn muốn một danh sách riêng các phần tử / sự xuất hiện được sắp xếp theo số lần xuất hiện, thay vì một bộ (phần tử, số lần xuất hiện), bạn có thể phân tích nó như sau

values, counts = zip(*c.most_common())

print(values)
# ('a', 'c', 'b')

print(counts)
# (4, 2, 1)

Hàm zip () tích hợp sẵn được sử dụng để chuyển đổi danh sách hai chiều (trong trường hợp này là danh sách các bộ giá trị), sau đó giải nén và giải nén nó.

Đếm số lượng (loại) các phần tử không trùng nhau (phần tử duy nhất).

Để đếm có bao nhiêu phần tử không chồng chéo (phần tử duy nhất) trong một danh sách hoặc bộ (có bao nhiêu kiểu), hãy sử dụng Counter hoặc set () như mô tả ở trên.

Số phần tử trong đối tượng Counter bằng số phần tử không trùng lặp trong danh sách ban đầu, có thể thu được bằng len ().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(len(c))
# 3

Bạn cũng có thể sử dụng set (), hàm tạo cho tập loại set, điều này sẽ dễ dàng hơn nếu bạn không cần đối tượng Counter.

Kiểu tập hợp là kiểu dữ liệu không có các phần tử trùng lặp. Chuyển một danh sách tới set () bỏ qua các giá trị trùng lặp và trả về một đối tượng thuộc loại set chỉ có các giá trị duy nhất dưới dạng phần tử. Số phần tử của kiểu này được lấy bởi len ().

print(set(l))
# {'a', 'c', 'b'}

print(len(set(l)))
# 3

Đếm số phần tử thỏa mãn điều kiện.

Để đếm số phần tử trong một danh sách hoặc bộ đáp ứng một điều kiện nhất định, hãy sử dụng ký hiệu hiểu danh sách hoặc biểu thức trình tạo.

Ví dụ: đếm số phần tử có giá trị âm cho danh sách số sau

l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

Áp dụng biểu thức điều kiện cho mỗi phần tử trong ký hiệu hiểu danh sách sẽ tạo ra một danh sách có các phần tử là boolean bool (true, false). Kiểu Boolean bool là một lớp con của kiểu số nguyên int, trong đó true được coi là 1 và false là 0. Do đó, số lượng giá trị true (số phần tử thỏa mãn điều kiện) có thể được tính bằng cách tính tổng bằng cách sử dụng sum. ().

print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]

print(sum([i < 0 for i in l]))
# 5

Nếu chúng ta thay thế [] trong ký hiệu hiểu danh sách bằng (), chúng ta nhận được một biểu thức trình tạo. Ký hiệu hiểu danh sách tạo ra một danh sách tất cả các phần tử được xử lý, trong khi biểu thức trình tạo xử lý các phần tử một cách tuần tự và do đó bộ nhớ hiệu quả hơn.

Khi biểu thức trình tạo là đối số duy nhất, () có thể được bỏ qua, vì vậy nó có thể được viết như trong trường hợp sau.

print(sum((i < 0 for i in l)))
# 5

print(sum(i < 0 for i in l))
# 5

Nếu bạn muốn đếm số giá trị sai (số phần tử không thỏa mãn điều kiện), hãy sử dụng not. Lưu ý rằng & gt; có mức độ ưu tiên cao hơn không (nó được tính trước), vì vậy dấu ngoặc đơn () trong (i & lt; 0) trong ví dụ sau là không cần thiết.

print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]

print(sum(not (i < 0) for i in l))
# 6

Tất nhiên, bản thân các điều kiện có thể được thay đổi.

print(sum(i >= 0 for i in l))
# 6

Một số ví dụ khác được hiển thị bên dưới.

Ví dụ về lấy số phần tử lẻ cho một danh sách các số.

print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]

print(sum(i % 2 == 1 for i in l))
# 6

Ví dụ về điều kiện cho một danh sách các chuỗi.

l = ['apple', 'orange', 'banana']

print([s.endswith('e') for s in l])
# [True, True, False]

print(sum(s.endswith('e') for s in l))
# 2

Bộ đếm dùng để đếm dựa trên số lần xuất hiện. items () truy xuất một bộ giá trị (phần tử, số lần xuất hiện) và số lần xuất hiện xác định điều kiện.

Sau đây là một ví dụ về trích xuất các phần tử có từ hai lần xuất hiện trở lên và đếm tổng số lần xuất hiện. Trong ví dụ này, có bốn a và hai c, tổng cộng là sáu.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']

print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]

print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6

Sau đây là một ví dụ về trích xuất các loại phần tử có từ hai lần xuất hiện trở lên và đếm số lần xuất hiện. Trong ví dụ này, có hai loại, a và c.

print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']

print([i[1] >= 2 for i in c.items()])
# [True, False, True]

print(sum(i[1] >= 2 for i in c.items()))
# 2

Đếm số lần xuất hiện của một từ trong một chuỗi.

Ví dụ cụ thể, hãy đếm số lần xuất hiện của một từ trong một chuỗi.

Đầu tiên, hãy thay thế các dấu phẩy và dấu chấm không cần thiết bằng một chuỗi trống bằng phương thức Replace (), sau đó xóa chúng. Sau đó, sử dụng phương thức split () để tạo một danh sách được phân tách bằng dấu cách.

s = 'government of the people, by the people, for the people.'

s_remove = s.replace(',', '').replace('.', '')

print(s_remove)
# government of the people by the people for the people

word_list = s_remove.split()

print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']

Nếu bạn có thể lập một danh sách, bạn có thể nhận được số lần mỗi từ xuất hiện, loại từ xuất hiện và most_common () trong các bộ sưu tập.Counter để nhận từ xuất hiện nhiều lần nhất.

print(word_list.count('people'))
# 3

print(len(set(word_list)))
# 6

c = collections.Counter(word_list)

print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})

print(c.most_common()[0][0])
# the

Trên đây là một quá trình rất đơn giản, vì vậy tốt hơn nên sử dụng các thư viện như NLTK để xử lý ngôn ngữ tự nhiên phức tạp hơn.

Ngoài ra, trong trường hợp văn bản tiếng Nhật, không thể sử dụng split () để tách văn bản vì không có sự phân tách từ rõ ràng. Ví dụ, bạn có thể sử dụng thư viện Janome để đạt được điều này.

Đếm số lần xuất hiện của một ký tự trong một chuỗi.

Vì các chuỗi cũng là một kiểu chuỗi, chúng có thể được sử dụng với phương thức count () hoặc được truyền như một đối số cho phương thức khởi tạo của collection.Counter ().

s = 'supercalifragilisticexpialidocious'

print(s.count('p'))
# 2

c = collections.Counter(s)

print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})

Ví dụ về truy xuất 5 ký tự xuất hiện thường xuyên nhất.

print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]

values, counts = zip(*c.most_common(5))

print(values)
# ('i', 's', 'c', 'a', 'l')
Copied title and URL