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
- Sử dụng hàm
most_common[]
1 - Truyền đối số
most_common[]
3 cho các hàm - 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ử - 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.Counter
0 để chuyển đổi danh sách thành đối tượng collections.Counter
1 để loại bỏ bất kỳ bản sao nào
Bạn có thể tưởng tượng rằng
- Phương thức
most_common[]
4 được gọi với mỗi phần tử trongcollections.Counter
1 - Phương thức trả về số lần phần tử xuất hiện trong danh sách
- 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.Counter
6
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.Counter
6 để tìm phần tử phổ biến nhất trong danh sách, e. g. collections.Counter
8. Phương thức collections.Counter
9 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ệ collections
0
Trước Python v3. 8, phương pháp collections.Counter
6 đưa ra một ngoại lệ collections
0 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
- Sử dụng lớp
collections.Counter[]
để đếm số lần xuất hiện của từng phần tử - 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 - 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. dict
4 trả về mục cuối cùng trong danh sách và dict
5 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
6Ngoà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úcBài viết này mô tả các nội dung sau
- Đếm tổng số phần tử.
5import 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
- Đếm số lần xuất hiện của một phần tử.
6import 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
- Cách sử dụng
0print[c['a']] # 4 print[c['b']] # 1 print[c['c']] # 2 print[c['d']] # 0
- Nhận các yếu tố phổ biến nhất.
1print[c['a']] # 4 print[c['b']] # 1 print[c['c']] # 2 print[c['d']] # 0
- Đế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
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
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
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
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
6Nế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
6l = ['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úcCách sử dụng print[c['a']]
# 4
print[c['b']]
# 1
print[c['c']]
# 2
print[c['d']]
# 0
0
print[c['a']]
# 4
print[c['b']]
# 1
print[c['c']]
# 2
print[c['d']]
# 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]]]
1import 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
6print[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]]]
8print[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
print[c['a']]
# 4
print[c['b']]
# 1
print[c['c']]
# 2
print[c['d']]
# 0
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ượngprint[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]]
8print[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
5Số 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
5l = ['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
0nguồ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ơnprint[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
5l = ['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
1nguồ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
2nguồ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]]
6l = ['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
3nguồ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]]
8l = ['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
4nguồ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
5nguồ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
6nguồ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
7nguồ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
8nguồ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ệnSau đâ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ául = ['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
9nguồ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]
4import 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
0nguồ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áchimport 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
1nguồ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
2nguồ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