Đếm đúng trong danh sách python

Chúng tôi có một mảng chứa các phần tử Boolean. Mục tiêu là xác định có bao nhiêu phần tử trong mảng đó là True

Giải pháp 1

Cách tiếp cận ngây thơ sẽ tạo ra một bộ đếm tổng và một vòng lặp for lặp qua từng phần tử trong mảng. Sau đó, chúng tôi kiểm tra xem phần tử đó có đúng không và nếu có, chúng tôi sẽ thêm nó vào bộ đếm

Sau khi hoàn thành ta được giá trị của biến sum, số phần tử True trong mảng

Giải pháp 2

Chúng ta có thể tiếp cận vấn đề một cách thông minh vì chúng ta không nhìn vào cách tiếp cận ngây thơ

Chúng tôi biết rằng Python coi giá trị Sai là 0 và bất kỳ giá trị nào khác là Đúng. Vì vậy, nếu đúng như vậy, chúng ta có thể sử dụng hàm đếm_nonzero[] của NumPy để giải quyết vấn đề

Hàm NumPy count_nonzero[] cho phép chúng ta tính toán tất cả các giá trị khác 0 trong một mảng đã cho. Hoặc, tôi có thể nói, nó sẽ cho phép chúng ta đếm số lượng giá trị True trong một mảng

Cú pháp hàm như hình

1

numpy. count_nonzero[ a , trục =None, *, keepdims=False]

ví dụ 1

Xem xét ví dụ dưới đây sử dụng hàm count_nonzero[] để xác định số phần tử khác 0 trong mảng

mảng = [1,2,0,3,4,0,5,6,7]
print["khác không", np. đếm_nonzero [mảng]]

Đoạn mã trên sẽ xác định số lượng các giá trị khác không và in kết quả như được hiển thị

1

khác không 7

ví dụ 2

Trường hợp tương tự áp dụng cho các giá trị Boolean như được hiển thị trong mảng bên dưới

1
2

arr = [[True, False, True], [True, False, False]]
in["khác không", np. count_nonzero[ arr ]]

Kết quả xuất ra như hình

1

khác không 3

Và với điều đó, chúng tôi đã giải quyết vấn đề ban đầu của mình

Phần kết luận

Cảm ơn bạn đã theo dõi hướng dẫn này, nơi chúng tôi trình bày cách sử dụng hàm count_nonzero[] để xác định số lượng phần tử True trong một mảng

❮ Liệt kê các phương thức

Thí dụ

Trả về số lần giá trị "anh đào" xuất hiện trong danh sách fruits

trái cây = ['táo', 'chuối', 'anh đào']

x = trái cây. đếm ["anh đào"]

Tự mình thử »

Định nghĩa và cách sử dụng

Phương thức count[] trả về số phần tử có giá trị được chỉ định

cú pháp

Giá trị tham số

Tham sốMô tảgiá trịBắt buộc. Bất kỳ loại nào [chuỗi, số, danh sách, bộ, v.v. ]. Giá trị cần tìm

Thêm ví dụ

Thí dụ

Trả về số lần giá trị 9 xuất hiện trong danh sách

điểm = [1, 4, 2, 9, 7, 8, 9, 3, 1]

x = điểm. đếm[9]

Tự mình thử »

❮ Liệt kê các phương thức

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 pháp

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

• Danh sách 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

Chúng ta có thể sử dụng số đếm trong danh sách Python không?

Đếm [] trả về gì trong Python?

Làm cách nào để đếm các phần tử trong danh sách bằng Python mà không có hàm đếm?