Đếm số phần tử trong list Python

Your browser isn’t supported anymore. Update it to get the best YouTube experience and our latest features. Learn more

Remind me later

Đếm tần suất từ ​​trong một phần tử danh sách bằng Python là một nhiệm vụ tương đối phổ biến – đặc biệt là khi tạo dữ liệu phân phối cho histograms.

Trong bài viết này, chúng tôi sẽ hướng dẫn bạn Cách đếm số lần xuất hiện từ trong List Python đơn giản.

Sử dụng Pandas và Numpy

Cách ngắn nhất và dễ dàng nhất để nhận giá trị đếm ở định dạng dễ thao tác [DataFrame] là thông qua Numpy và Pandas. Chúng ta có thể bao bọc danh sách thành một mảng Numpy, sau đó gọi value_counts[] phương pháp của pd ví dụ [cũng có sẵn cho tất cả DataFrame trường hợp]:

import numpy as np import pandas as pd words = ['hello', 'goodbye', 'howdy', 'hello', 'hello', 'hi', 'bye'] pd.value_counts[np.array[words]]

Điều này dẫn đến một DataFrame nó bao gồm:

hello 3 goodbye 1 bye 1 howdy 1 hi 1 dtype: int64

Bạn có thể truy cập nó values để tự lấy số lượng, hoặc index để tự nhận các từ:

df = pd.value_counts[np.array[words]] print['Index:', df.index] print['Values:', df.values]

Kết quả này trong:

Index: Index[['hello', 'goodbye', 'bye', 'howdy', 'hi'], dtype="object"] Values: [3 1 1 1 1]

Sử dụng hàm số count[]

Cách để tính số lần xuất hiện từ trong danh sách là sử dụng đối tượng danh sách count[].

Các count[] là một hàm dựng sẵn lấy một phần tử làm đối số duy nhất của nó và trả về số lần phần tử đó xuất hiện trong danh sách.

Sự phức tạp của count[] là O[n]ở đầu n là số yếu tố có trong danh sách.

Đoạn mã dưới đây sử dụng count[] để lấy số lần xuất hiện cho một từ trong danh sách:

words = ['hello', 'goodbye', 'howdy', 'hello', 'hello', 'hi', 'bye'] print[f'"hello" appears {words.count["hello"]} time[s]'] print[f'"howdy" appears {words.count["howdy"]} time[s]']

Điều này sẽ cung cấp cho chúng tôi đầu ra giống như trước khi sử dụng các vòng lặp:

"hello" appears 3 time[s] "howdy" appears 1 time[s]

Các count[] phương pháp này cung cấp cho chúng tôi một cách dễ dàng để lấy số lượng từ xuất hiện trong danh sách cho từng từ riêng lẻ.

Sử dụng Counter

Các Counter cá thể lớp có thể được sử dụng để đếm các cá thể của các đối tượng khác. Bằng cách chuyển một danh sách vào phương thức khởi tạo của nó, chúng tôi khởi tạo một Counter nó trả về một từ điển của tất cả các phần tử và sự xuất hiện của chúng trong một danh sách.

Từ đó, để có được sự xuất hiện của một từ duy nhất, bạn có thể chỉ cần sử dụng từ đó làm khóa cho từ điển:

from collections import Counter words = ['hello', 'goodbye', 'howdy', 'hello', 'hello', 'hi', 'bye'] word_counts = Counter[words] print[f'"hello" appears {word_counts["hello"]} time[s]'] print[f'"howdy" appears {word_counts["howdy"]} time[s]']

Điều này có nghĩa là:

"hello" appears 3 time[s] "howdy" appears 1 time[s]

Sử dụng một vòng lặp và một biến bộ đếm

Cuối cùng, một cách tiếp cận bạo lực lặp lại từng từ trong danh sách, tăng dần bộ đếm khi từ đó được tìm thấy và trả về tổng số từ sẽ hoạt động!

Tất nhiên, phương pháp này trở nên kém hiệu quả hơn khi kích thước danh sách tăng lên, nó chỉ dễ hiểu và dễ thực hiện về mặt khái niệm.

Đoạn mã dưới đây sử dụng cách tiếp cận này trong count_occurrence[] phương pháp:

def count_occurrence[words, word_to_count]: count = 0 for word in words: if word == word_to_count: # update counter variable count = count + 1 return count words = ['hello', 'goodbye', 'howdy', 'hello', 'hello', 'hi', 'bye'] print[f'"hello" appears {count_occurrence[words, "hello"]} time[s]'] print[f'"howdy" appears {count_occurrence[words, "howdy"]} time[s]']

Nếu bạn chạy mã này, bạn sẽ thấy đầu ra này:

"hello" appears 3 time[s] "howdy" appears 1 time[s]

Nhiệm vụ có thể được chia nhỏ thành việc tìm kiếm các lần xuất hiện cho tất cả các từ và chúng tôi sẽ làm các điểm chuẩn cho cả hai, bắt đầu với tất cả các từ:

import numpy as np import pandas as pd import collections def pdNumpy[words]: def _pdNumpy[]: return pd.value_counts[np.array[words]] return _pdNumpy def countFunction[words]: def _countFunction[]: counts = [] for word in words: counts.append[words.count[word]] return counts return _countFunction def counterObject[words]: def _counterObject[]: return collections.Counter[words] return _counterObject import timeit words = ['hello', 'goodbye', 'howdy', 'hello', 'hello', 'hi', 'bye'] print["Time to execute:n"] print["Pandas/Numpy: %ss" % timeit.Timer[pdNumpy[words]].timeit[1000]] print["count[]: %ss" % timeit.Timer[countFunction[words]].timeit[1000]] print["Counter: %ss" % timeit.Timer[counterObject[words]].timeit[1000]]

Kết quả là:

Time to execute: Pandas/Numpy: 0.33886080000047514s count[]: 0.0009540999999444466s Counter: 0.0019409999995332328s

Các count[] Phương thức này cực kỳ nhanh so với các biến thể khác, tuy nhiên, nó không cung cấp cho chúng ta các nhãn được liên kết với số lượng như hai phương pháp còn lại.

Nếu bạn cần nhãn – Counter làm tốt hơn quá trình không hiệu quả là gói danh sách trong một mảng Numpy và sau đó đếm.

Mặt khác, bạn có thể sử dụng các phương pháp của DataFrame để sắp xếp hoặc thao tác khác mà bạn không thể làm khác. Counter cũng có một số phương pháp độc đáo.

Cuối cùng, bạn có thể sử dụng Counter để tạo từ điển và biến từ điển thành DataFrame cũng như, để tận dụng tốc độ của Counter và tính linh hoạt của DataFrameS:

df = pd.DataFrame.from_dict[[Counter[words]]].T

Nếu bạn không cần nhãn – count[] là con đường để đi.

Ngoài ra, nếu bạn đang tìm kiếm một từ duy nhất:

import numpy as np import pandas as pd import collections def countFunction[words, word_to_search]: def _countFunction[]: return words.count[word_to_search] return _countFunction def counterObject[words, word_to_search]: def _counterObject[]: return collections.Counter[words][word_to_search] return _counterObject def bruteForce[words, word_to_search]: def _bruteForce[]: counts = [] count = 0 for word in words: if word == word_to_search: # update counter variable count = count + 1 counts.append[count] return counts return _bruteForce import timeit words = ['hello', 'goodbye', 'howdy', 'hello', 'hello', 'hi', 'bye'] print["Time to execute:n"] print["count[]: %ss" % timeit.Timer[countFunction[words, 'hello']].timeit[1000]] print["Counter: %ss" % timeit.Timer[counterObject[words, 'hello']].timeit[1000]] print["Brute Force: %ss" % timeit.Timer[bruteForce[words, 'hello']].timeit[1000]]

Kết quả là:

Time to execute: count[]: 0.0001573999998072395s Counter: 0.0019498999999996158s Brute Force: 0.0005682000000888365s

Trên đây là tổng hợp thông tin giải đáp về Cách đếm số lần xuất hiện từ trong List Python đơn giản. Hy vọng thông qua bài viết, bạn đã có cái nhìn tổng quan để cân nhắc phương án phù hợp cho bạn. Cảm ơn bạn đã theo dõi, đừng quên ủng họ tôi bằng một Like và Share tới ezerror.com nhé ! 😉

Phần trước mình đã giới thiệu với mọi người các hàm xử lý chuỗi hay dùng trong Python, phần này chúng ta tiếp tục chuyển sang tìm hiểu về một số hàm xử lý list hay được sử dụng trong Python, và xem đối với Python nó có hỗ trợ chúng ta xử lý đa dạng không nhé!

1, list[].

Hàm này có tác dụng chuyển đổi kiểu dữ liệu của một biến sang dạng list.

Cú pháp:

list[data]

Trong đó, data là biến chứa tuple bạn cần chuyển đổi.

VD:

string = "Vu Thanh Tai" print[list[string]] # Ket Qua: ['V', 'u', ' ', 'T', 'h', 'a', 'n', 'h', ' ', 'T', 'a', 'i'] tup = ['A', 'B', 'C'] print[list[tup]] # Ket Qua: ['A', 'B', 'C']

2, len[].

Hàm này trả về số lượng phần tử có trong list.

Cú pháp:

len[list]

Trong đó, list là list mà các bạn cần đếm.

VD:

list = ['A', 'B', 'C'] print[len[list]] #Kết quả: 3

3, max[].

Hàm này sẽ trả về phần tử có giá trị lớn nhất trong list. Nếu là chuỗi thì nó sẽ trả về phần tử có độ dài chuỗi dài nhất, nếu là số thì nó sẽ trả về phần tử có số lớn nhất.

Cú pháp:

max[list]

Trong đó, list là list mà các bạn cần kiểm tra.

VD:

list = ['A', 'B', 'C'] print[max[list]] #Kết quả: C list = ['1', '3', '2'] print[max[list]] #Kết quả: 3

4, min[].

Hàm này sẽ trả về phần tử có giá trị nhỏ nhất trong list. Nếu là chuỗi thì nó sẽ trả về phần tử có độ dài chuỗi ngắn nhất, nếu là số thì nó sẽ trả về phần tử có số nhỏ nhất.

Cú pháp:

min[list]

Trong đó, list là list mà các bạn cần kiểm tra.

VD:

list = ['A', 'B', 'C'] print[min[list]] #Kết quả: A list = ['1', '3', '2'] print[max[list]] #Kết quả: 1

5, append[].

Phương thức này có tác dụng thêm phần vào cuối của một list.

Cú pháp:

mylist.append[obj]

Trong đó:

• mylist là list mà các bạn cần thêm phần tử.
• obj là phần tử mà bạn muốn thêm vào mylist.

VD: 

list = ['A', 'B', 'C'] list.append['D'] print[list] # Kết quả: ['A', 'B', 'C', 'D'] list.append[['E', 'F']] print[list] # Kết quả: ['A', 'B', 'C', 'D', ['E', 'F']]

6, extend[].

Hàm này có tác dụng kế thừa lại các phần tử của list2 và thêm vào trong list1.

Cú pháp:

list1.extend[list2]

Trong đó: 

• list1 là list mà bạn muốn kế thừa từ một list khác [ở đây là list2].
• list2 là list được sử dụng để cho list khác kết thừa [ở đây là list1].

VD:

list = ['A', 'B', 'C'] list.extend['D'] print[list] # Kết quả: ['A', 'B', 'C', 'D'] list.extend[['E', 'F']] print[list] # Kết quả: ['A', 'B', 'C', 'D', 'E', 'F']

Lưu ý: Ở đây mình đã cố tình để ví dụ của phương thức append[] và extend[] là giống nhau để cho các bạn thấy được sự khác biệt giữa 2 phương thức này [xem kỹ nhé! không nhận ra được thì comment mình sẽ trả lời :D].

7, count[].

Phương thức này có tác dụng đếm số lần xuất hiện của một thành phần trong list!

Cú pháp:

mylist.count[val]

Trong đó:

• mylist là list mà các bạn cần kiểm tra.
• val là phần tử mà bạn muốn tìm và đếm trong list mylist.

VD:

list = ['A', 'B', 'C'] print[list.count['A']] # Kết quả: 1

8, index[].

Phương thức này có tác dụng trả về index xuất hiện đầu tiên của phần tử mà bạn muốn tìm và nếu như không tìm thấy thì nó sẽ gọi exception.

Cú Pháp:

mylist.index[val]

Trong đó:

• mylist là list mà các bạn cần kiểm tra.
• val là phần tử mà bạn muốn tìm trong list mylist.

VD: 

list = ['A', 'B', 'C'] print[list.index['B']] # Kết quả: 1 print[list.index['D']] # Kết quả: ValueError: 'D' is not in list

9, insert[].

Phương thức có tác dụng thêm phần tử vào vị trí index của list, và các phần tử sau index đó sẽ được đẩy về phía sau.

Cú pháp:

mylist.insert[index, val]

Trong đó:

• mylist là list mà các bạn cần thêm.
• index là vị trí mà bạn muốn thêm phần tử val vào.
• val là phần tử mà bạn muốn thêm vào trong list mylist.

VD: 

list = ['A', 'B', 'C'] list.insert[0, 'Z'] print[list] # Kết quả: ['Z', 'A', 'B', 'C'] list.insert[2, 'D'] print[list] # Kết quả: ['Z', 'A', 'D', 'B', 'C']

10, reverse[].

Phương thức này có tác dụng đảo ngược vị trí của các phần tử trong list.

Cú pháp:

mylist.reverse[]

Trong đó, mylist là list mà các bạn muốn đảo ngược.

VD:

list = ['A', 'B', 'C'] list.reverse[] print[list] # Kết quả: ['C', 'B', 'A']

11, remove[].

Phương thức này có tác dụng xóa phần tử khỏi list.

Cú Pháp:

mylist.remove[val]

Trong đó:

• mylist là list mà các bạn cần xóa phần tử.
• val là phần tử mà bạn muốn muốn xóa trong list mylist.

VD: 

list = ['A', 'B', 'C'] list.remove['C'] print[list] # Kết quả: ['A', 'B']

12, pop[].

Phương thức này có tác dụng xóa bỏ phần tử trong list dựa trên index của nó.

Cú pháp:

mylist.pop[index]

Trong đó:

• mylist là list mà các bạn cần xóa phần tử.
• index là index của phần tử mà bạn muốn muốn xóa trong list mylist. Mặc định thì index = mylist[-1] [phần tử cuối cùng trong list].

VD:

list = ['A', 'B', 'C', 'D', 'E'] list.pop[] print[list] # Kết quả: ['A', 'B', 'C', 'D'] list.pop[2] print[list] # Kết quả: ['A', 'B', 'D']

13, sort[].

Phương thức này có tác dụng sắp xếp lại các phần tử trong list theo một thứ tự xác định.

Cú pháp:

mylist.sort[reverse, key]

Trong đó:

• mylist là list mà các bạn muốn sắp xếp.
• reverse là một boolean cấu hình kiểu sắp xếp. Nếu reverse = True thì list sẽ được sắp xếp từ lớn đến bé, nếu reverse = False thì list sẽ được sắp xếp theo thứ tự từ bé đến lớn. Mặc định thì reverse = False.
• key là callback def để xử lý list hoặc là một lamda function [thường được dùng để sắp xếp các list tuple hoặc dictionary].

VD: 

list = ['A', 'C', 'B', 'E', 'D'] list.sort[] print[list] # Kết quả: ['A', 'B', 'C', 'D', 'E'] list.sort[reverse=True] print[list] # Kết quả: ['E', 'D', 'C', 'B', 'A'] def custom_sort[elem]: return elem[1] list = [[1, 2], [5, 7], [7, 100], [4, 4]] list.sort[key=custom_sort] print[list] # Kết quả: [[1, 2], [4, 4], [5, 7], [7, 100]]

14, clear[].

Phương thức này có tác dụng xóa bỏ hết tất cả các phần tử trong list.

Cú pháp:

mylist.clear[]

Trong đó,  mylist là list mà bạn muốn xóa bỏ hết phần tử.

VD:

list = ['A', 'C', 'B', 'E', 'D'] list.clear[] print[list] # Kết quả: []