Làm cách nào để bạn đếm các phần tử phổ biến trong danh sách python?

Các đối tượng Counter triển khai một phương thức trả về danh sách N phần tử phổ biến nhất và số lượng của chúng từ phổ biến nhất đến ít nhất

Các chỉ mục Python dựa trên số không, vì vậy mục đầu tiên trong danh sách có chỉ mục là 0 và mục cuối cùng có chỉ mục là -1 hoặc len(my_list) - 1

Nếu không có đối số nào được cung cấp cho phương thức most_common, nó sẽ liệt kê tất cả số lượng phần tử

Phương thức trả về một danh sách các bộ trong đó phần tử đầu tiên là mục danh sách và phần tử thứ hai là số lần xuất hiện

Bạn cũng có thể sử dụng phương pháp này để lấy N phần tử phổ biến nhất trong danh sách

Chúng tôi đã chuyển 2 làm đối số cho phương thức most_common(), vì vậy nó trả về 2 phần tử phổ biến nhất trong danh sách

Ngoài ra, bạn có thể sử dụng hàm most_common()1

Tìm phần tử phổ biến nhất trong Danh sách bằng max()

Để tìm phần tử phổ biến nhất trong danh sách

1. Sử dụng hàm most_common()1
2. Truyền đối số most_common()3 cho các hàm
3. Sử dụng phương pháp most_common()4 để đếm số lần xuất hiện của từng phần tử
4. Hàm most_common()1 sẽ trả về phần tử phổ biến nhất

Chúng tôi đã sử dụng hàm most_common()1 để lấy phần tử phổ biến nhất trong danh sách

Hàm trả về mục lớn nhất trong một lần lặp hoặc mục lớn nhất trong hai hoặc nhiều đối số

Hàm most_common()7 cũng nhận một đối số tùy chọn most_common()3

Đối số most_common()3 chỉ định hàm sắp xếp một đối số

Chúng tôi đã sử dụng lớp collections.Counter0 để chuyển đổi danh sách thành đối tượng collections.Counter1 để loại bỏ bất kỳ bản sao nào

Bạn có thể tưởng tượng rằng

1. Phương thức most_common()4 được gọi với mỗi phần tử trong collections.Counter1
2. Phương thức trả về số lần phần tử xuất hiện trong danh sách
3. Hàm most_common()1 trả về phần tử danh sách phổ biến nhất

Phương thức most_common()4 nhận một giá trị và trả về số lần giá trị được cung cấp xuất hiện trong danh sách

Ngoài ra, bạn có thể sử dụng phương pháp collections.Counter6

Tìm phần tử phổ biến nhất trong Danh sách bằng số liệu thống kê. chế độ()

Sử dụng phương pháp collections.Counter6 để tìm phần tử phổ biến nhất trong danh sách, e. g. collections.Counter8. Phương thức collections.Counter9 trả về giá trị phổ biến nhất trong lần lặp được cung cấp

Phương thức nhận một lần lặp và trả về giá trị phổ biến nhất trong lần lặp

Nếu có nhiều giá trị có cùng tần số, phương thức sẽ trả về giá trị gặp đầu tiên

Nếu iterable được cung cấp trống, phương thức sẽ đưa ra một ngoại lệ collections0

Trước Python v3. 8, phương pháp collections.Counter6 đưa ra một ngoại lệ collections0 nếu không có phần tử phổ biến nhất trong lần lặp, e. g. nếu hai cái đầu có cùng số lần xuất hiện

Lấy phần tử ít phổ biến nhất trong Danh sách bằng Python

Để có được phần tử ít phổ biến nhất trong danh sách

1. Sử dụng lớp collections.Counter() để đếm số lần xuất hiện của từng phần tử
2. Sử dụng phương pháp most_common() để lấy các phần tử phổ biến nhất và số lượng của chúng
3. Truy cập kết quả tại chỉ mục -1 để lấy phần tử ít phổ biến nhất

Chúng tôi đã sử dụng lớp collections.Counter để đếm số lần xuất hiện của từng mục trong danh sách

Lớp từ mô-đun collections là một lớp con của lớp dict

Về cơ bản, lớp này là ánh xạ của các cặp số khóa

Các đối tượng Counter triển khai một phương thức trả về danh sách N phần tử phổ biến nhất và số lượng của chúng từ phổ biến nhất đến ít nhất

Chúng tôi đã không cung cấp đối số cho N, vì vậy phương thức trả về tất cả các phần tử trong bộ đếm

Các phần tử có số lượng bằng nhau được sắp xếp theo giá trị gặp phải đầu tiên

Bước cuối cùng là truy cập danh sách tại chỉ mục -1

Các chỉ mục Python dựa trên số không, vì vậy mục đầu tiên trong danh sách có chỉ mục là 0 và mục cuối cùng có chỉ mục là -1 hoặc len(my_list) - 1

Chỉ số âm có thể được sử dụng để đếm ngược, e. g. dict4 trả về mục cuối cùng trong danh sách và dict5 trả về mục thứ hai cho mục cuối cùng

Phần tử danh sách tại chỉ mục -1 lưu mục ít phổ biến nhất và số lần xuất hiện của nó trong danh sách

Trong Python, bạn có thể đếm tổng số phần tử trong một danh sách hoặc bộ dữ liệu bằng hàm tích hợp sẵn

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))
# 

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

5 và số lần xuất hiện của một phần tử bằng phương thức

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))
# 

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

6

Ngoài ra, lớp

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))
# 

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

7 của các bộ sưu tập thư viện tiêu chuẩn có thể được sử dụng để đếm số lần xuất hiện của từng phần tử cùng một lúc

Bài viết này mô tả các nội dung sau

• Đếm tổng số phần tử.

  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))
  # 
  
  print(issubclass(type(c), dict))
  # True
  

  5
• Đếm số lần xuất hiện của một phần tử.

  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))
  # 
  
  print(issubclass(type(c), dict))
  # True
  

  6
• Cách sử dụng

  print(c['a'])
  # 4
  
  print(c['b'])
  # 1
  
  print(c['c'])
  # 2
  
  print(c['d'])
  # 0
  

  0
• Nhận các yếu tố phổ biến nhất.

  print(c['a'])
  # 4
  
  print(c['b'])
  # 1
  
  print(c['c'])
  # 2
  
  print(c['d'])
  # 0
  

  1
• Đếm các phần tử duy nhất
• Đếm các phần tử thỏa mãn điều kiện
• Đếm số lần xuất hiện của một từ trong chuỗi
• Đếm số lần xuất hiện của một ký tự trong chuỗi

Danh sách được sử dụng trong mã mẫu sau, nhưng bộ dữ liệu có thể được xử lý theo cách tương tự

Xem bài viết sau về cách đếm số ký tự/chuỗi con cụ thể trong một chuỗi

• Đếm ký tự và chuỗi trong Python

Liên kết được tài trợ

Đếm tổng số phần tử. 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)) # print(issubclass(type(c), dict)) # True 5

Bạn có thể đếm tổng số phần tử trong danh sách bằng hàm tích hợp sẵn

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))
# 

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

5

• Cách sử dụng len() trong Python

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

print(len(l))
# 7

nguồn.

Đếm số lần xuất hiện của một phần tử. 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)) # print(issubclass(type(c), dict)) # True 6

Bạn có thể đếm số lần xuất hiện của một phần tử trong danh sách bằng phương thức

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))
# 

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

6

Nếu một phần tử không tồn tại được thông qua, thì trả về

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

6

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

nguồn.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

0, được giải thích tiếp theo, rất hữu ích nếu bạn muốn đếm số lần xuất hiện của từng phần tử cùng một lúc

Cách sử dụng print(c['a']) # 4 print(c['b']) # 1 print(c['c']) # 2 print(c['d']) # 0 0

Lớp

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))
# 

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

7 được cung cấp trong các bộ sưu tập tiêu chuẩn của thư viện

Đối tượng

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))
# 

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

7 được tạo bằng cách chuyển danh sách tới

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)])

1

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))
# 

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

7 là một lớp con của từ điển

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)])

3, có các phần tử là khóa và số lượng của chúng là 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))
# 

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

nguồn.

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

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

6

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

nguồn.

Bạn cũng có thể sử dụng các phương thức

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)])

3 như

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)])

6,

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)])

7 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)])

8

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)])

nguồn.

Các phương thức này trả về các đối tượng kiểu

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)])

9, v.v. Bạn có thể sử dụng chúng như hiện tại nếu bạn muốn sử dụng vòng lặp

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

0. Nếu bạn muốn chuyển đổi nó thành một danh sách, hãy sử dụng

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

1

• Lặp lại từ điển (khóa và giá trị) với vòng lặp for trong Python

Nhận các yếu tố phổ biến nhất. print(c['a']) # 4 print(c['b']) # 1 print(c['c']) # 2 print(c['d']) # 0 1

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))
# 

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

7 có một phương thức

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

1 trả về một danh sách các bộ dữ liệu của

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

5 được sắp xếp theo số lượng

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

nguồn.

Bạn có thể lấy chỉ mục có số lần xuất hiện cao nhất bằng cách chỉ định chỉ mục là

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

6, chỉ mục có số lần xuất hiện thấp nhất là

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

7, v.v. Nếu bạn chỉ muốn lấy các phần tử hoặc chỉ số đếm, chỉ cần chỉ định chỉ mục sau nó

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

nguồn.

Nếu bạn muốn sắp xếp theo thứ tự giảm dần, hãy sử dụng các lát cắt với số gia được đặt thành

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

8

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

nguồn.

Nếu đối số

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

9 được chỉ định cho phương thức

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

1, thì chỉ các phần tử

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

9 có nhiều lần xuất hiện nhất được trả về. Nếu nó bị bỏ qua, tất cả các phần tử được trả về

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

nguồn.

Nếu bạn muốn có một danh sách các phần tử riêng biệt và số lượng của chúng được sắp xếp theo số lần xuất hiện, thay vì một bộ gồm _______30_______5, bạn có thể làm như sau

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

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

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

nguồn.

Nó sử dụng chức năng tích hợp sẵn

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

3 để chuyển đổi danh sách 2D (trong trường hợp này là danh sách các bộ dữ liệu) và giải nén và giải nén nó. Xem các bài viết sau để biết chi tiết

• Hoán đổi danh sách 2D trong Python (hoán đổi hàng và cột)
• Giải nén một bộ và liệt kê trong Python

Liên kết được tài trợ

Đếm các phần tử duy nhất

Nếu bạn muốn đếm các phần tử duy nhất trong danh sách hoặc bộ dữ liệu, hãy sử dụng

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))
# 

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

7 hoặ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

5

Số phần tử trong đối tượng

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))
# 

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

7 bằng với số phần tử duy nhất trong danh sách ban đầu. Nó có thể thu được với

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))
# 

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

5

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

0

nguồn.

Bạn cũng có thể sử dụng

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

8. Nếu bạn không cần đối tượng

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))
# 

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

7, thì việc sử dụng

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

8 sẽ dễ dàng hơn

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

8 là kiểu dữ liệu không có các phần tử trùng lặp và

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

5 trả về một đối tượng

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

8 với các giá trị duy nhất khi một danh sách được truyền. Bạn có thể lấy số phần tử trong

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

8 với

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))
# 

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

5

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

1

nguồn.

Để biết thêm thông tin về cách kiểm tra, loại bỏ và trích xuất các phần tử trùng lặp trong danh sách, hãy xem các bài viết sau

• Kiểm tra xem danh sách có chứa các phần tử trùng lặp trong Python không
• Xóa/trích xuất các phần tử trùng lặp khỏi danh sách trong Python

Đếm các phần tử thỏa mãn điều kiện

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

• Liệt kê khả năng hiểu trong Python

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

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

2

nguồn.

Áp dụng một biểu thức có điều kiện cho từng phần tử với khả năng hiểu danh sách sẽ trả về một danh sách có các phần tử thuộc loại

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

6 (

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

7,

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

8)

Kiểu boolean

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

6 là một lớp con của kiểu số nguyên

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

0.

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

7 được coi là

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

2 và

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

8 là

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

6. Bạn có thể đếm số

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

7 (số phần tử thỏa mãn điều kiện) bằng

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

6

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

3

nguồn.

Nếu

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

7 trong cách hiểu danh sách được thay thế bằng

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

8, nó sẽ trở thành biểu thức trình tạo. Khi biểu thức trình tạo là đối số duy nhất, có thể bỏ qua

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

8

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

4

nguồn.

Sử dụng

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

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

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

0 nếu bạn muốn đếm số lượng của

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

8 (số phần tử không thỏa mãn điều kiện)

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

5

nguồn.

Tất nhiên, bạn có thể thay đổi các điều kiện

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

6

nguồn.

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

Đếm số lượng phần tử lẻ cho một danh sách các số

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

7

nguồn.

Ví dụ cho một danh sách các chuỗi

• Trích xuất và thay thế các phần tử đáp ứng điều kiện của danh sách chuỗi trong Python

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

8

nguồn.

Sử dụng

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

0 để đặt số lần xuất hiện làm điều kiện

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

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

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

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

3 và hai

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

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

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

4, vì vậy tổng cộng là sáu

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

9

nguồn.

Sau đây là một ví dụ về trích xuất các giá trị của các phần tử có hai hoặc nhiều lần xuất hiện và đếm số lượng của chúng. Trong ví dụ này, có hai giá trị,

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

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

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

3 và

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

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

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

4

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))
# 

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

0

nguồn.

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

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

Đầu tiên,

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

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

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

7 và

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

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

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

8 không cần thiết được thay thế bằng một chuỗi trống bằng cách sử dụng phương thức

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

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

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

9 và bị xóa. Sau đó, sử dụng phương pháp

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

00 để tạo danh sách được phân tách bằng dấu cách

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))
# 

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

1

nguồn.

Nếu bạn tạo một danh sách, bạn có thể nhận được số lần xuất hiện, v.v. như trong các ví dụ trước

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))
# 

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

2

nguồn.

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