programming python

Python tìm phần tử chung đầu tiên trong hai danh sách

Để kiểm tra xem hai danh sách có ít nhất một phần tử chung hay không, chúng ta sẽ lặp qua list1 và list2 và kiểm tra ít nhất một phần tử chung trong cả hai danh sách. Danh sách này là kiểu dữ liệu linh hoạt nhất có sẵn trong Python, có thể được viết dưới dạng danh sách các giá trị [mục] được phân tách bằng dấu phẩy giữa các dấu ngoặc vuông. Điều quan trọng về danh sách là các mục trong danh sách không nhất thiết phải cùng loại

Giả sử chúng ta có các đầu vào sau i. e. 2 danh sách -

[15, 45, 67, 30, 98]
[10, 8, 45, 48, 30]

Đầu ra phải như sau tôi. e. hai danh sách có ít nhất một phần tử chung -

Common Element Found

Kiểm tra xem hai danh sách có ít nhất một phần tử chung bằng cách sử dụng vòng lặp for

Chúng tôi đã sử dụng các vòng lặp lồng nhau để kiểm tra xem hai danh sách do người dùng nhập vào có ít nhất hai phần tử hay không. Cả hai danh sách đều được duyệt qua và phần tử chung được tìm thấy bằng cách sử dụng câu lệnh if. Phương thức input[] được sử dụng cho đầu vào của người dùng -

Thí dụ

đầu ra

Enter the size of the first List =5
Enter the Element of the first List =
15
45
67
30
98
Enter the size of the second List =7
Enter the Element of the second List =
10
8
45
48
30
86
67
Display Result = Common Element Found
Enter the size of the first List =5
Enter the Element of the first List =
10
20
30
40
50
Enter the size of the second List =5
Enter the Element of the second List=
23
39
45
67
89
Display Result = Common Element Not Found

Kiểm tra xem hai danh sách có ít nhất một phần tử chung hay không bằng cách sử dụng set_intersection[]

Chúng tôi đã sử dụng phương thức set_intersection[] để kiểm tra xem hai danh sách có ít nhất một phần tử chung hay không. Đầu tiên, các danh sách được chuyển đổi thành tập hợp và sau đó phương thức này được áp dụng để tìm các phần tử chung -

Thí dụ

đầu ra

List1 = [4, 10, 15, 20, 25, 30]
List2 = [12, 24, 25, 35, 45, 65]
Are common elements in both the lists? True

Kiểm tra xem hai danh sách có ít nhất một phần tử chung hay không bằng Set

Trong ví dụ này, chúng tôi đã sử dụng phương thức set[] để chuyển đổi danh sách thành set và sau đó toán tử & được sử dụng để tìm các phần tử chung. Do đó, chúng tôi chưa sử dụng phương thức set_intersection[] ở đây -

Thí dụ

đầu ra

List1 = [5, 10, 15, 20, 25, 30]
List2 = [12, 20, 30, 35, 40, 50]
Are common elements in both the lists? True

Ở trên, chúng ta đã thấy rằng True được trả về, vì cả hai danh sách đều có ít nhất một phần tử chung. Trong ví dụ này, phần tử chung là 30

Khi cần tìm phần tử chung xuất hiện lần đầu tiên giữa hai danh sách liên kết, một phương thức để thêm các phần tử vào danh sách được liên kết và một phương thức để lấy phần tử chung xuất hiện lần đầu tiên trong các danh sách được liên kết này được xác định

Dưới đây là một minh chứng cho điều tương tự -

Thí dụ

Bản thử trực tiếp

class Node:
   def __init__[self, data]:
      self.data = data
      self.next = None

class LinkedList_structure:
   def __init__[self]:
      self.head = None
      self.last_node = None

   def add_vals[self, data]:
      if self.last_node is None:
         self.head = Node[data]
         self.last_node = self.head
      else:
         self.last_node.next = Node[data]
         self.last_node = self.last_node.next

def first_common_val[list_1, list_2]:
   curr_1 = list_1.head
   while curr_1:
      data = curr_1.data
      curr_2 = list_2.head
      while curr_2:
         if data == curr_2.data:
            return data
         curr_2 = curr_2.next
      curr_1 = curr_1.next
   return None

my_list_1 = LinkedList_structure[]
my_list_2 = LinkedList_structure[]

my_list = input['Enter the elements of the first linked list : '].split[]
for elem in my_list:
   my_list_1.add_vals[int[elem]]

my_list = input['Enter the elements of the second linked list : '].split[]
for elem in my_list:
   my_list_2.add_vals[int[elem]]

common_vals = first_common_val[my_list_1, my_list_2]

if common_vals:
   print['The element that is present first in the first linked list and is common to both is {}.'.format[common]]
else:
   print['The two lists have no common elements']

đầu ra

Enter the elements of the first linked list : 45 67 89 123 45
Enter the elements of the second linked list : 34 56 78 99 0 11
The two lists have no common elements

Giải trình

Lớp 'Nút' được tạo
Một lớp 'LinkedList_structure' khác với các thuộc tính bắt buộc được tạo
Nó có chức năng 'init' được sử dụng để khởi tạo phần tử đầu tiên, i. e 'đầu' thành 'Không'
Một phương thức có tên ‘add_vals’ được định nghĩa, giúp thêm một giá trị vào ngăn xếp
Một phương thức khác có tên là 'first_common_val' được định nghĩa, giúp tìm giá trị chung đầu tiên được tìm thấy trong hai danh sách được liên kết

Trong bài viết này, bạn sẽ tìm hiểu cách định vị và trả về các phần tử chung của hai [2] danh sách trong Python
Để làm cho nó thú vị hơn, chúng tôi có kịch bản chạy sau
Bondi Brokers cung cấp hai [2] Trái phiếu Thị trường. 3 năm và 5 năm. Mỗi sản lượng khác nhau. Để xác định Bond nào phù hợp nhất với nhu cầu của khách hàng, họ cần tìm ra điểm chung giữa chúng. Họ đã yêu cầu sự giúp đỡ của bạn trong vấn đề này
💬 câu hỏi. Làm thế nào chúng ta sẽ viết mã Python để xác định vị trí và trả về những điểm tương đồng?
Chúng ta có thể hoàn thành nhiệm vụ này bằng một trong các tùy chọn sau
- Phương pháp 1. Sử dụng intersection[]
- Phương pháp 2. Sử dụng NumPy intersection1d[]
- Phương pháp 3. Sử dụng hiểu danh sách
- Phương pháp 4. Sử dụng hiểu danh sách với set[]
- Phương pháp 5. Sử dụng set[]
Phương pháp 1. Sử dụng giao lộ[]
Trong ví dụ này, phương pháp intersection[] so sánh hai [2] tập hợp, định vị các phần tử chung và trả về chúng dưới dạng một tập hợp mới trong khi vẫn giữ nguyên thứ tự
```
bond_3_yr = {2.56, 2.59, 2.68, 2.43, 2.47, 2.11}
bond_5_yr = {2.78, 2.59, 2.68, 2.58, 2.62, 2.65}
result = bond_3_yr.intersection[bond_5_yr]
print[result]
```
Mã này gọi phương thức intersection[] và chuyển
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
2 làm đối số. Các phần tử chung được định vị và lưu vào
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
3. Nội dung của
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
3 được xuất ra thiết bị đầu cuối
bộ trăn. giao lộ [] & "&" & Giải thích và Ví dụ & Thời gian chạy

Xem video này trên YouTube

đầu ra
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
5
Phương pháp 2. Sử dụng giao lộ1d[]
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
6 chấp nhận hai danh sách, so sánh và định vị các phần tử chung và trả về một danh sách đã sắp xếp
________số 8_______
Mã này gọi phương thức
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
6 và chuyển
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
8 và
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
2 làm đối số. Các phần tử chung được định vị, sắp xếp và lưu vào
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
3. Nội dung của
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
3 được xuất ra thiết bị đầu cuối
đầu ra
```
$ pip install numpy
```
2
Trước khi mã của chúng tôi thực thi thành công, một [1] thư viện mới sẽ yêu cầu cài đặt
- Thư viện NumPy hỗ trợ các mảng và ma trận nhiều chiều bên cạnh tập hợp các hàm toán học
Để cài đặt thư viện này, hãy điều hướng đến một thiết bị đầu cuối IDE. Tại dấu nhắc lệnh [
```
$ pip install numpy
```
3], hãy thực thi mã bên dưới. Đối với thiết bị đầu cuối được sử dụng trong ví dụ này, dấu nhắc lệnh là ký hiệu đô la [
```
$ pip install numpy
```
3]. Lời nhắc thiết bị đầu cuối của bạn có thể khác
```
$ pip install numpy
```
Nhấn phím
```
$ pip install numpy
```
5 trên bàn phím để bắt đầu quá trình cài đặt
Nếu quá trình cài đặt thành công, một thông báo sẽ hiển thị trong thiết bị đầu cuối cho biết điều tương tự
Vui lòng xem hướng dẫn cài đặt PyCharm để biết thư viện cần thiết
🌍 Hướng dẫn đề xuất. Cách cài đặt NumPy trên PyCharm
Phương pháp 3. Sử dụng hiểu danh sách
Một phương pháp khác để tìm các thành phần chú thích là sử dụng List Comprehension. Điều này định vị và trả về danh sách các phần tử phổ biến trong khi vẫn giữ nguyên thứ tự
```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in bond_5_yr]
print[result]
```
Mã này lặp qua từng phần tử và lưu các phần tử phổ biến được tìm thấy vào
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
3. Nội dung của
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
3 được xuất ra thiết bị đầu cuối
Giới thiệu đơn giản về hiểu danh sách trong Python

Xem video này trên YouTube
đầu ra
```
$ pip install numpy
```
8
Phương pháp 4. Sử dụng tính năng hiểu danh sách với Set
Một biến thể hiệu quả hơn của việc sử dụng khả năng hiểu danh sách để tìm các phần tử chung của hai danh sách
```
$ pip install numpy
```
9 và
```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in bond_5_yr]
print[result]
```
0 là chuyển đổi một danh sách thành một tập hợp sao cho toán tử thành viên thứ hai “
```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in bond_5_yr]
print[result]
```
1” trong biểu thức
```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in bond_5_yr]
print[result]
```
2 chỉ có hằng số thay vì độ phức tạp thời gian chạy tuyến tính
Cách tiếp cận này làm giảm độ phức tạp của thời gian chạy từ O[n²] mà không cần chuyển đổi đã đặt thành O[n] với chuyển đổi đã đặt
- ```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in bond_5_yr]
print[result]
```
  3 –> độ phức tạp thời gian chạy bậc hai O[n²]
- ```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in bond_5_yr]
print[result]
```
  2 –> độ phức tạp thời gian chạy tuyến tính O[n]
Đây là ví dụ mã bắt buộc giải quyết cùng một vấn đề hiệu quả hơn Phương pháp 3 mà không cần chuyển đổi
```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in bond_5_yr]
print[result]
```
5
```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in set[bond_5_yr]]
print[result]
# [2.59, 2.68]
```
Phương pháp 5. Sử dụng bộ[]
Phương pháp nhỏ gọn nhất là sử dụng set[]. Điều này so sánh các tập hợp và trả về các phần tử phổ biến. Thật không may, thứ tự không được bảo tồn
```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = set[bond_3_yr] & set[bond_5_yr]
print[result]
```
Mã này, như đã chỉ ra ở trên, lấy hai [2] Danh sách, so sánh và lưu các phần tử chung vào
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
3. Nội dung của
```
import numpy as np

bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = np.intersect1d[bond_3_yr, bond_5_yr]
print[result]
```
3 được xuất ra thiết bị đầu cuối
13 thao tác thiết lập mà Python Master nào cũng biết

Xem video này trên YouTube
đầu ra
```
bond_3_yr = [2.56, 2.59, 2.68, 2.43, 2.47, 2.11]
bond_5_yr = [2.78, 2.59, 2.68, 2.58, 2.62, 2.65]
result = [element for element in bond_3_yr if element in bond_5_yr]
print[result]
```
9
Tóm lược
Bốn [4] phương pháp tìm các phần tử phổ biến này sẽ cung cấp cho bạn đủ thông tin để chọn phương pháp tốt nhất cho các yêu cầu viết mã của bạn

Thí dụ

đầu ra

Thí dụ

đầu ra

Thí dụ

đầu ra

Thí dụ

đầu ra

Giải trình

Phương pháp 1. Sử dụng giao lộ[]

Phương pháp 2. Sử dụng giao lộ1d[]

Phương pháp 3. Sử dụng hiểu danh sách

Phương pháp 4. Sử dụng tính năng hiểu danh sách với Set

Phương pháp 5. Sử dụng bộ[]

Tóm lược

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề