Chức năng python nào được sử dụng để thêm tất cả các phần tử vào danh sách?

Chuyển đến nội dung chính

Giới thiệu về Python

Nắm vững kiến ​​thức cơ bản về phân tích dữ liệu với Python chỉ trong bốn giờ. Khóa học trực tuyến này sẽ giới thiệu giao diện Python và khám phá các gói phổ biến

Python trung cấp

Nâng cao kỹ năng khoa học dữ liệu của bạn bằng cách tạo trực quan hóa bằng Matplotlib và thao tác với DataFrames bằng gấu trúc

Có liên quan

Các tài nguyên hàng đầu năm 2022 để nâng cao kỹ năng dữ liệu của bạn

Nhận quyền truy cập vào các tài nguyên hoạt động hiệu quả nhất của chúng tôi từ năm 2022, bao gồm hội thảo trên web, bài đăng trên blog, sách trắng, bảng gian lận, hướng dẫn và bài viết, tất cả đều được thiết kế để giúp bạn nâng cao kỹ năng dữ liệu và mở rộng quy mô văn hóa dữ liệu của tổ chức bạn. Bắt đầu học hỏi và phát triển kiến ​​thức chuyên môn về dữ liệu của bạn ngay hôm nay

Dữ liệu văn bản trong Python Cheat Sheet

Chào mừng bạn đến với bảng gian lận của chúng tôi để làm việc với dữ liệu văn bản trong Python. Chúng tôi đã biên soạn một danh sách các hàm và gói hữu ích nhất để dọn dẹp, xử lý và phân tích dữ liệu văn bản trong Python, cùng với các ví dụ và giải thích rõ ràng, vì vậy bạn sẽ có mọi thứ cần biết về cách làm việc với dữ liệu văn bản trong Python.

Hướng dẫn về tập hợp và lý thuyết tập hợp trong Python

Tìm hiểu về bộ Python. chúng là gì, cách tạo chúng, khi nào sử dụng chúng, các chức năng tích hợp và mối quan hệ của chúng với các hoạt động lý thuyết thiết lập

Hướng dẫn về gấu trúc. Khung dữ liệu trong Python

Khám phá phân tích dữ liệu với Python. Pandas DataFrames giúp thao tác dữ liệu của bạn dễ dàng, từ việc chọn hoặc thay thế các cột và chỉ mục để định hình lại dữ liệu của bạn

Xem ThêmXem Thêm

Giả sử chúng ta cần ghi tuổi của 5 học sinh. Thay vì tạo 5 biến riêng biệt, chúng ta chỉ cần tạo một danh sách

Các phần tử của một danh sách

Tạo một danh sách Python

Một danh sách được tạo bằng Python bằng cách đặt các mục bên trong

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
5, được phân tách bằng dấu phẩy. Ví dụ,

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]

Ở đây, chúng tôi đã tạo một danh sách có tên số với 3 mục số nguyên

Một danh sách có thể có bất kỳ số lượng mục nào và chúng có thể thuộc các loại khác nhau [số nguyên, số float, chuỗi, v.v. ]. Ví dụ,

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]

Truy cập các phần tử danh sách Python

Trong Python, mỗi mục trong danh sách được liên kết với một số. Số được gọi là chỉ số danh sách

Chúng ta có thể truy cập các phần tử của một mảng bằng cách sử dụng số chỉ mục [0, 1, 2…]. Ví dụ,

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++

Trong ví dụ trên, chúng tôi đã sử dụng khả năng hiểu danh sách để tạo danh sách với mỗi mục được tăng theo lũy thừa của 2. Chú ý mã,

Hàm tích hợp sẵn của Python

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 là một cách hiệu quả và Pythonic để tính tổng danh sách các giá trị số. Cộng nhiều số lại với nhau là một bước trung gian phổ biến trong nhiều phép tính, vì vậy
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 là một công cụ khá tiện dụng cho lập trình viên Python

Là một trường hợp sử dụng bổ sung và thú vị, bạn có thể nối các danh sách và bộ dữ liệu bằng cách sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9, điều này có thể thuận tiện khi bạn cần làm phẳng một danh sách các danh sách

Trong hướng dẫn này, bạn sẽ học cách

  • Tính tổng các giá trị số bằng tay sử dụng các kỹ thuật và công cụ chung
  • Sử dụng
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9 của Python để thêm một số giá trị số một cách hiệu quả
  • Nối các danh sách và bộ dữ liệu với
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9
  • Sử dụng
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9 để tiếp cận các bài toán tổng kết phổ biến
  • Sử dụng các giá trị thích hợp cho các đối số trong
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9
  • Quyết định giữa
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9 và các công cụ thay thế để tổng hợp và nối các đối tượng

Kiến thức này sẽ giúp bạn tiếp cận và giải quyết hiệu quả các vấn đề tổng kết trong mã của mình bằng cách sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 hoặc các công cụ chuyên dụng và thay thế khác

Tiền thưởng miễn phí. Nhấp vào đây để nhận Bảng cheat Python và tìm hiểu kiến ​​thức cơ bản về Python 3, như làm việc với các kiểu dữ liệu, từ điển, danh sách và hàm Python

Tìm hiểu vấn đề tổng kết

Tính tổng các giá trị số với nhau là một vấn đề khá phổ biến trong lập trình. Ví dụ: giả sử bạn có một danh sách các số [1, 2, 3, 4, 5] và muốn cộng chúng lại với nhau để tính tổng của chúng. Với số học tiêu chuẩn, bạn sẽ làm một cái gì đó như thế này

1 + 2 + 3 + 4 + 5 = 15

Theo như toán học, biểu thức này khá đơn giản. Nó hướng dẫn bạn thực hiện một loạt các phép cộng ngắn cho đến khi bạn tìm được tổng của tất cả các số

Có thể thực hiện phép tính cụ thể này bằng tay, nhưng hãy tưởng tượng một số tình huống khác mà điều đó có thể không khả thi. Nếu bạn có một danh sách số đặc biệt dài, việc thêm bằng tay có thể không hiệu quả và dễ bị lỗi. Điều gì xảy ra nếu bạn thậm chí không biết có bao nhiêu mục trong danh sách?

Trong những tình huống như thế này, cho dù bạn có một danh sách dài hay ngắn các số, Python có thể khá hữu ích để giải các bài toán tính tổng

Nếu bạn muốn tính tổng các số bằng cách tạo giải pháp của riêng mình từ đầu, thì bạn có thể thử sử dụng vòng lặp

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
38

>>>

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
4

Tại đây, trước tiên bạn tạo

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
39 và khởi tạo nó thành
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
60. Biến này hoạt động như một bộ tích lũy trong đó bạn lưu trữ các kết quả trung gian cho đến khi bạn nhận được kết quả cuối cùng. Vòng lặp lặp qua
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
61 và cập nhật
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
39 bằng cách tích lũy từng giá trị liên tiếp bằng cách sử dụng phép gán tăng cường

Bạn cũng có thể bọc vòng lặp

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
38 trong một hàm. Bằng cách này, bạn có thể sử dụng lại mã cho các danh sách khác nhau

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
0

Trong

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
64, bạn lấy một iterable—cụ thể là danh sách các giá trị số—làm đối số và trả về tổng của các giá trị trong danh sách đầu vào. Nếu danh sách đầu vào trống, thì hàm trả về
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
60. Vòng lặp
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
38 giống với vòng lặp mà bạn đã thấy trước đây

Bạn cũng có thể sử dụng đệ quy thay vì lặp lại. Đệ quy là một kỹ thuật lập trình chức năng trong đó một hàm được gọi theo định nghĩa của chính nó. Nói cách khác, một hàm đệ quy gọi chính nó trong một vòng lặp

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15

Khi bạn định nghĩa một hàm đệ quy, bạn có nguy cơ chạy vào một vòng lặp vô hạn. Để ngăn chặn điều này, bạn cần xác định cả trường hợp cơ sở dừng đệ quy và trường hợp đệ quy để gọi hàm và bắt đầu vòng lặp ẩn

Trong ví dụ trên, trường hợp cơ sở ngụ ý rằng tổng của danh sách có độ dài bằng 0 là

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
60. Trường hợp đệ quy ngụ ý rằng tổng số tiền là giá trị đầu tiên,
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
68, cộng với tổng của các giá trị còn lại,
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
69. Bởi vì trường hợp đệ quy sử dụng một chuỗi ngắn hơn trên mỗi lần lặp, bạn sẽ gặp trường hợp cơ sở khi
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
61 là một danh sách có độ dài bằng không. Kết quả cuối cùng, bạn nhận được tổng của tất cả các mục trong danh sách đầu vào của mình,
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
61

Ghi chú. Trong ví dụ này, nếu bạn không kiểm tra danh sách đầu vào trống [trường hợp cơ sở của bạn], thì

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
64 sẽ không bao giờ chạy vào một vòng lặp đệ quy vô hạn. Khi danh sách
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
61 của bạn đạt đến độ dài
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
60, mã sẽ cố truy cập vào một mục từ danh sách trống, điều này làm tăng
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
35 và phá vỡ vòng lặp

Với kiểu triển khai này, bạn sẽ không bao giờ nhận được tổng từ chức năng này. Bạn sẽ nhận được một

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
35 mỗi lần

Một tùy chọn khác để tổng hợp danh sách các số trong Python là sử dụng

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37 từ
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
38. Để lấy tổng của một danh sách các số, bạn có thể chuyển
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
39 hoặc một hàm
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
80 thích hợp làm đối số đầu tiên cho
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37

>>>

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
3

Bạn có thể gọi

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37 bằng cách giảm hoặc gấp,
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
83 cùng với
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
84 làm đối số. Sau đó,
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37 sử dụng hàm đầu vào để xử lý
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
84 và trả về một giá trị tích lũy duy nhất

Trong ví dụ đầu tiên, hàm rút gọn là

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
87, lấy hai số và cộng chúng lại với nhau. Kết quả cuối cùng là tổng của các số trong đầu vào
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
84. Như một nhược điểm,
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37 tăng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
90 khi bạn gọi nó bằng một
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
84 trống

Trong ví dụ thứ hai, hàm rút gọn là hàm

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
80 trả về phép cộng hai số

Vì các phép tính tổng như thế này là phổ biến trong lập trình nên viết mã một hàm mới mỗi khi bạn cần tính tổng một số số là công việc lặp đi lặp lại nhiều lần. Ngoài ra, sử dụng

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37 không phải là giải pháp dễ đọc nhất dành cho bạn

Python cung cấp một chức năng tích hợp chuyên dụng để giải quyết vấn đề này. Chức năng được gọi thuận tiện là

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9. Vì đây là hàm tích hợp nên bạn có thể sử dụng trực tiếp trong mã của mình mà không cần nhập bất kỳ thứ gì

Loại bỏ các quảng cáo

Bắt đầu với
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 của Python

Khả năng đọc là một trong những nguyên tắc quan trọng nhất đằng sau triết lý của Python. Hình dung những gì bạn đang yêu cầu một vòng lặp thực hiện khi tính tổng một danh sách các giá trị. Bạn muốn nó lặp qua một số số, tích chúng trong một biến trung gian và trả về tổng cuối cùng. Tuy nhiên, bạn có thể tưởng tượng ra một phiên bản tổng kết dễ đọc hơn mà không cần vòng lặp. Bạn muốn Python lấy một số số và tính tổng chúng lại với nhau

Bây giờ hãy nghĩ về cách

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37 tính tổng. Việc sử dụng
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37 được cho là khó đọc hơn và ít đơn giản hơn so với giải pháp dựa trên vòng lặp

Đây là lý do tại sao Python 2. 3 đã thêm

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 dưới dạng hàm tích hợp để cung cấp giải pháp Pythonic cho bài toán tổng kết. Alex Martelli đã đóng góp hàm này, ngày nay là cú pháp ưa thích để tổng hợp danh sách các giá trị

>>>

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
6

Ồ. Thật gọn gàng, phải không? . Sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 dễ đọc hơn nhiều so với vòng lặp
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
38 hoặc cuộc gọi
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37. Không giống như
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
37,
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 không tăng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
90 khi bạn cung cấp một lần lặp trống. Thay vào đó, nó trả về
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
60 một cách dễ hiểu

Bạn có thể gọi

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 với hai đối số sau

  1. languages = ["Python", "Swift", "C++"]
    
    # access item at index 0
    print[languages[0]]   # Python
    
    # access item at index 2
    print[languages[2]]   # C++
    84 là một đối số bắt buộc có thể chứa bất kỳ Python iterable nào. Iterable thường chứa các giá trị số nhưng cũng có thể chứa danh sách hoặc bộ dữ liệu
  2. >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    88 là một đối số tùy chọn có thể chứa giá trị ban đầu. Giá trị này sau đó được thêm vào kết quả cuối cùng. Nó mặc định là
    # A list with 3 integers
    numbers = [1, 2, 5]
    
    print[numbers]
    
    # Output: [1, 2, 5]
    60

Nội bộ, ________ 49 quảng cáo ________ 688 cộng với các giá trị trong ________ 384 từ trái sang phải. Các giá trị trong đầu vào

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
84 thường là các số, nhưng bạn cũng có thể sử dụng các danh sách và bộ dữ liệu. Đối số tùy chọn
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88 có thể chấp nhận một số, danh sách hoặc bộ dữ liệu, tùy thuộc vào những gì được truyền cho
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
84. Nó không thể lấy một chuỗi

Trong hai phần sau, bạn sẽ tìm hiểu kiến ​​thức cơ bản về cách sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 trong mã của mình

Đối số bắt buộc.
languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
84

Việc chấp nhận bất kỳ Python nào có thể lặp lại làm đối số đầu tiên của nó làm cho

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 trở nên chung chung, có thể tái sử dụng và đa hình. Do tính năng này, bạn có thể sử dụng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 với danh sách, bộ dữ liệu, bộ, đối tượng
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
000 và từ điển

>>>

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
3

Trong tất cả các ví dụ này,

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 tính toán tổng cộng của tất cả các giá trị trong đầu vào có thể lặp lại bất kể loại của chúng. Trong hai ví dụ về từ điển, cả hai lệnh gọi tới
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 đều trả về tổng các khóa của từ điển đầu vào. Ví dụ đầu tiên tính tổng các khóa theo mặc định và ví dụ thứ hai tính tổng các khóa do lệnh gọi
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
003 trên từ điển đầu vào

Nếu từ điển của bạn lưu trữ các số trong các giá trị của nó và bạn muốn tính tổng các giá trị này thay vì các khóa, thì bạn có thể thực hiện việc này bằng cách sử dụng

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
004 giống như trong ví dụ về
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
003

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

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 với khả năng hiểu danh sách làm đối số. Đây là một ví dụ tính tổng bình phương của một dải giá trị

>>>

languages = ["Python", "Swift", "C++"]

# access item at index 0
print[languages[0]]   # Python

# access item at index 2
print[languages[2]]   # C++
8

Trăn 2. 4 biểu thức trình tạo được thêm vào ngôn ngữ. Một lần nữa,

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 hoạt động như mong đợi khi bạn sử dụng biểu thức trình tạo làm đối số

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9

Ví dụ này cho thấy một trong những kỹ thuật Pythonic nhất để tiếp cận vấn đề tổng kết. Nó cung cấp một giải pháp thanh lịch, dễ đọc và hiệu quả trong một dòng mã

Loại bỏ các quảng cáo

Đối số tùy chọn.
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88

Đối số thứ hai và tùy chọn,

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88, cho phép bạn cung cấp một giá trị để khởi tạo quy trình tổng kết. Đối số này rất hữu ích khi bạn cần xử lý tuần tự các giá trị tích lũy

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
8

Tại đây, bạn cung cấp giá trị ban đầu từ

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
010 đến
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88. Hiệu ứng ròng là
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 thêm giá trị này vào tổng tích lũy của các giá trị trong lần lặp đầu vào. Lưu ý rằng bạn có thể cung cấp
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88 làm đối số vị trí hoặc làm đối số từ khóa. Tùy chọn thứ hai rõ ràng hơn và dễ đọc hơn

Nếu bạn không cung cấp giá trị cho

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88 thì giá trị đó sẽ mặc định là
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
60. Giá trị mặc định của
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
60 đảm bảo hành vi dự kiến ​​trả về tổng của các giá trị đầu vào

Tính tổng các giá trị số

Mục đích chính của

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 là cung cấp một cách Pythonic để cộng các giá trị số lại với nhau. Đến đây các bạn đã biết cách sử dụng hàm tính tổng các số nguyên. Ngoài ra, bạn có thể sử dụng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 với bất kỳ loại Python số nào khác, chẳng hạn như
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
019,
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
020,
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
021 và
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
022

Dưới đây là một vài ví dụ về việc sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 với các giá trị thuộc các loại số khác nhau

>>>

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
08

Ở đây, trước tiên bạn sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 với số dấu phẩy động. Cần lưu ý hành vi của hàm khi bạn sử dụng các ký hiệu đặc biệt
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
025 và
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
026 trong các cuộc gọi
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
027 và
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
028. Biểu tượng đầu tiên đại diện cho một giá trị vô hạn, vì vậy,
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 trả về
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
025. Biểu tượng thứ hai đại diện cho các giá trị NaN [không phải số]. Vì bạn không thể cộng các số với các số không phải là số, nên kết quả là bạn nhận được
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
026

Các ví dụ khác tính tổng các lần lặp của các số

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
020,
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
033 và
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
034. Trong mọi trường hợp,
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 trả về tổng tích lũy kết quả bằng cách sử dụng loại số thích hợp

trình tự nối

Mặc dù

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 chủ yếu nhằm mục đích hoạt động trên các giá trị số, nhưng bạn cũng có thể sử dụng hàm này để nối các chuỗi như danh sách và bộ dữ liệu. Để làm được điều đó, bạn cần cung cấp một giá trị thích hợp cho
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
00

Trong các ví dụ này, bạn sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 để nối các danh sách và bộ dữ liệu. Đây là một tính năng thú vị mà bạn có thể sử dụng để làm phẳng danh sách các danh sách hoặc một bộ gồm các bộ. Yêu cầu chính để các ví dụ này hoạt động là chọn một giá trị thích hợp cho
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88. Ví dụ: nếu bạn muốn nối các danh sách, thì
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88 cần giữ một danh sách

Trong các ví dụ trên,

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 đang thực hiện thao tác nối bên trong, do đó, nó chỉ hoạt động với các loại trình tự hỗ trợ nối, ngoại trừ các chuỗi

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
01

Khi bạn cố gắng sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 để nối các chuỗi, bạn sẽ nhận được một
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
90. Như thông báo ngoại lệ gợi ý, bạn nên sử dụng
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
044 để nối các chuỗi trong Python. Bạn sẽ thấy các ví dụ về việc sử dụng phương pháp này sau này khi đến phần Sử dụng các phương án thay thế cho
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9

Thực hành với
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 của Python

Cho đến giờ, bạn đã học được những điều cơ bản khi làm việc với

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9. Bạn đã học cách sử dụng hàm này để cộng các giá trị số với nhau và cũng để nối các chuỗi như danh sách và bộ dữ liệu

Trong phần này, bạn sẽ xem xét thêm một số ví dụ về thời điểm và cách sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 trong mã của mình. Với những ví dụ thực tế này, bạn sẽ biết rằng hàm tích hợp sẵn này khá hữu ích khi bạn đang thực hiện các phép tính yêu cầu tìm tổng của một chuỗi số như một bước trung gian

Bạn cũng sẽ biết rằng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 có thể hữu ích khi bạn làm việc với danh sách và bộ dữ liệu. Một ví dụ đặc biệt mà bạn sẽ xem xét là khi bạn cần làm phẳng một danh sách các danh sách

Loại bỏ các quảng cáo

Tính toán các khoản tiền tích lũy

Ví dụ đầu tiên bạn sẽ viết mã liên quan đến cách tận dụng đối số

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88 để tính tổng các danh sách tích lũy các giá trị số

Giả sử bạn đang phát triển một hệ thống để quản lý việc bán một sản phẩm nhất định tại một số điểm bán hàng khác nhau. Mỗi ngày, bạn nhận được một báo cáo đơn vị đã bán từ mỗi điểm bán hàng. Bạn cần tính tổng cộng dồn một cách có hệ thống để biết cả công ty bán được bao nhiêu đơn vị trong tuần. Để giải quyết vấn đề này, bạn có thể sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
02

Bằng cách sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
88, bạn đặt một giá trị ban đầu để khởi tạo tổng, cho phép bạn thêm các đơn vị liên tiếp vào tổng phụ đã tính toán trước đó. Vào cuối tuần, bạn sẽ có tổng số đơn vị đã bán của công ty

Tính giá trị trung bình của một mẫu

Một trường hợp sử dụng thực tế khác của

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 là sử dụng nó như một phép tính trung gian trước khi thực hiện các phép tính tiếp theo. Ví dụ: giả sử bạn cần tính giá trị trung bình cộng của một mẫu giá trị số. Giá trị trung bình số học, còn được gọi là giá trị trung bình, là tổng của các giá trị chia cho số lượng giá trị hoặc điểm dữ liệu trong mẫu

Nếu bạn có mẫu [2, 3, 4, 2, 3, 6, 4, 2] và bạn muốn tính trung bình cộng bằng tay, thì bạn có thể giải phép toán này

[2 + 3 + 4 + 2 + 3 + 6 + 4 + 2]/8 = 3. 25

Nếu bạn muốn tăng tốc độ này bằng cách sử dụng Python, bạn có thể chia nó thành hai phần. Phần đầu tiên của phép tính này, khi bạn cộng các số lại với nhau, là một nhiệm vụ dành cho

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9. Phần tiếp theo của phép toán, nơi bạn đang chia cho 8, sử dụng số đếm trong mẫu của bạn. Để tính số chia của bạn, bạn có thể sử dụng
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
055

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
03

Tại đây, lệnh gọi tới

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 sẽ tính tổng các điểm dữ liệu trong mẫu của bạn. Tiếp theo, bạn sử dụng
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
055 để lấy số điểm dữ liệu. Cuối cùng, bạn thực hiện phép chia cần thiết để tính trung bình cộng của mẫu

Trong thực tế, bạn có thể muốn biến mã này thành một hàm với một số tính năng bổ sung, chẳng hạn như tên mô tả và kiểm tra các mẫu trống

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
04

Bên trong

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
058, trước tiên bạn kiểm tra xem mẫu đầu vào có bất kỳ điểm dữ liệu nào không. Nếu không, thì bạn tăng một
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
059 với một thông báo mô tả. Trong ví dụ này, bạn sử dụng toán tử hải mã để lưu trữ số lượng điểm dữ liệu trong biến
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
060 để bạn không cần gọi lại
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
055. Câu lệnh return tính giá trị trung bình cộng của mẫu và gửi nó trở lại mã gọi

Ghi chú. Tính toán giá trị trung bình của một mẫu dữ liệu là một hoạt động phổ biến trong thống kê và phân tích dữ liệu. Thư viện chuẩn Python cung cấp một mô-đun thuận tiện có tên là

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
062 để tiếp cận các loại tính toán này

Trong mô-đun

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
062, bạn sẽ tìm thấy một hàm có tên là
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
064

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
05

Hàm

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
065 có hành vi rất giống với hàm
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
058 mà bạn đã mã hóa trước đó. Khi bạn gọi
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
064 với một mẫu giá trị số, bạn sẽ nhận được giá trị trung bình cộng của dữ liệu đầu vào. Khi bạn chuyển một danh sách trống tới
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
064, bạn sẽ nhận được một
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
069

Lưu ý rằng khi bạn gọi

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
058 với một mẫu thích hợp, bạn sẽ nhận được giá trị trung bình mong muốn. Nếu bạn gọi
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
058 với một mẫu trống, thì bạn sẽ nhận được một
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
059 như mong đợi

Tìm Tích vô hướng của hai dãy

Một vấn đề khác bạn có thể giải bằng cách sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 là tìm tích vô hướng của hai chuỗi giá trị số có độ dài bằng nhau. Tích vô hướng là tổng đại số của các tích của mỗi cặp giá trị trong chuỗi đầu vào. Ví dụ: nếu bạn có các chuỗi [1, 2, 3] và [4, 5, 6], thì bạn có thể tính tích vô hướng của chúng bằng tay bằng cách sử dụng phép cộng và phép nhân

1 × 4 + 2 × 5 + 3 × 6 = 32

Để trích xuất các cặp giá trị liên tiếp từ chuỗi đầu vào, bạn có thể sử dụng

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
074. Sau đó, bạn có thể sử dụng biểu thức trình tạo để nhân từng cặp giá trị. Cuối cùng,
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 có thể tính tổng các tích

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
06

Với

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
074, bạn tạo một danh sách các bộ dữ liệu với các giá trị từ mỗi chuỗi đầu vào. Biểu thức trình tạo lặp qua từng bộ trong khi nhân các cặp giá trị liên tiếp được sắp xếp trước đó bởi
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
074. Bước cuối cùng là thêm các sản phẩm lại với nhau bằng cách sử dụng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9

Mã trong ví dụ trên hoạt động. Tuy nhiên, tích vô hướng được xác định cho các chuỗi có độ dài bằng nhau, vậy điều gì xảy ra nếu bạn cung cấp các chuỗi có độ dài khác nhau?

Để giải quyết khả năng này, bạn có thể kết thúc lệnh gọi tới

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 trong một chức năng tùy chỉnh và cung cấp kiểm tra thích hợp về độ dài của các chuỗi đầu vào

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
07

Ở đây,

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
081 lấy hai chuỗi làm đối số và trả về tích vô hướng tương ứng của chúng. Nếu các chuỗi đầu vào có độ dài khác nhau, thì hàm sẽ tạo ra một
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
059

Nhúng chức năng vào chức năng tùy chỉnh cho phép bạn sử dụng lại mã. Nó cũng cung cấp cho bạn cơ hội để đặt tên cho chức năng một cách mô tả để người dùng biết chức năng đó làm gì chỉ bằng cách đọc tên của nó

Loại bỏ các quảng cáo

Làm phẳng một danh sách các danh sách

Làm phẳng một danh sách các danh sách là một nhiệm vụ phổ biến trong Python. Giả sử bạn có một danh sách các danh sách và cần làm phẳng danh sách đó thành một danh sách duy nhất chứa tất cả các mục từ danh sách lồng nhau ban đầu. Bạn có thể sử dụng bất kỳ cách tiếp cận nào để làm phẳng danh sách trong Python. Ví dụ: bạn có thể sử dụng vòng lặp

# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
38, như trong đoạn mã sau

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
08

Bên trong

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
084, vòng lặp lặp lại trên tất cả các danh sách lồng nhau có trong
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
085. Sau đó, nó nối chúng trong
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
086 bằng cách sử dụng thao tác gán tăng cường [
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
087]. Kết quả là bạn nhận được một danh sách phẳng với tất cả các mục từ danh sách lồng nhau ban đầu

Nhưng chờ đã. Bạn đã học cách sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 để nối các chuỗi trong hướng dẫn này. Bạn có thể sử dụng tính năng đó để làm phẳng một danh sách các danh sách như bạn đã làm trong ví dụ trên không? . Đây là cách

>>>

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
09

Nó thật nhanh. Một dòng mã và

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
089 hiện là một danh sách cố định. Tuy nhiên, sử dụng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 dường như không phải là giải pháp nhanh nhất

Một nhược điểm quan trọng của bất kỳ giải pháp nào ngụ ý nối là đằng sau hậu trường, mỗi bước trung gian sẽ tạo ra một danh sách mới. Điều này có thể khá lãng phí về mặt sử dụng bộ nhớ. Danh sách cuối cùng được trả về chỉ là danh sách được tạo gần đây nhất trong số tất cả các danh sách đã được tạo ở mỗi vòng nối. Thay vào đó, sử dụng tính năng hiểu danh sách đảm bảo rằng bạn chỉ tạo và trả về một danh sách

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
0

Phiên bản mới này của

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
084 hiệu quả hơn và ít lãng phí hơn về mặt sử dụng bộ nhớ. Tuy nhiên, cách hiểu lồng nhau có thể khó đọc và hiểu

Sử dụng

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
092 có lẽ là cách Pythonic dễ đọc nhất để làm phẳng một danh sách các danh sách

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
1

Trong phiên bản

# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
084 này, ai đó đang đọc mã của bạn có thể thấy rằng hàm này lặp lại mỗi
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
094 trong
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
085. Bên trong vòng lặp
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
38 đầu tiên này, nó lặp lại qua từng
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
097 trong
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
094 để cuối cùng điền vào danh sách
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
086 mới với
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
092. Cũng giống như cách hiểu trước đó, giải pháp này chỉ tạo một danh sách trong quy trình. Một lợi thế của giải pháp này là nó rất dễ đọc

Sử dụng các lựa chọn thay thế cho
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9

Như bạn đã học,

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 rất hữu ích khi làm việc với các giá trị số nói chung. Tuy nhiên, khi làm việc với các số dấu phẩy động, Python cung cấp một công cụ thay thế. Trong
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
03, bạn sẽ tìm thấy một hàm có tên là
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
04 có thể giúp bạn cải thiện độ chính xác chung của các tính toán dấu phẩy động của mình

Bạn có thể có một nhiệm vụ mà bạn muốn nối hoặc xâu chuỗi một số lần lặp lại để bạn có thể làm việc với chúng như một. Đối với trường hợp này, bạn có thể xem chức năng của mô-đun

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
05
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
06

Bạn cũng có thể có một nhiệm vụ mà bạn muốn nối một danh sách các chuỗi. Trong hướng dẫn này, bạn đã học được rằng không có cách nào sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 để nối các chuỗi. Chức năng này không được xây dựng để nối chuỗi. Cách thay thế Pythonic nhất là sử dụng
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
044

Tính tổng các số dấu phẩy động.
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
09

Nếu mã của bạn liên tục tính tổng các số có dấu phẩy động bằng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9, thì bạn nên cân nhắc sử dụng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
09 để thay thế. Hàm này thực hiện các phép tính dấu phẩy động cẩn thận hơn so với
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9, giúp cải thiện độ chính xác của phép tính của bạn

Theo tài liệu của nó,

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
04 “tránh mất độ chính xác bằng cách theo dõi nhiều tổng từng phần trung gian. ” Tài liệu cung cấp ví dụ sau

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
2

Với

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
04, bạn sẽ nhận được kết quả chính xác hơn. Tuy nhiên, bạn nên lưu ý rằng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
04 không giải quyết được lỗi biểu diễn trong số học dấu phẩy động. Ví dụ sau phát hiện ra hạn chế này

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
3

Trong các ví dụ này, cả hai hàm đều trả về cùng một kết quả. Điều này là do không thể biểu diễn chính xác cả hai giá trị

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
16 và
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
17 ở dạng dấu phẩy động nhị phân

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
4

Tuy nhiên, không giống như

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9,
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
04 có thể giúp bạn giảm lan truyền lỗi dấu chấm động khi bạn cộng các số rất lớn và rất nhỏ lại với nhau

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
5

Ồ. Ví dụ thứ hai khá bất ngờ và hoàn toàn đánh bại

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9. Với
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9, kết quả là bạn nhận được
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
22. Điều này khác xa với kết quả chính xác của
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
23, khi bạn nhận được với
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
04

Loại bỏ các quảng cáo

Nối các Iterable với
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
25

Nếu bạn đang tìm kiếm một công cụ hữu ích để ghép nối hoặc xâu chuỗi một loạt các lần lặp, thì hãy cân nhắc sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
06 từ
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
05. Hàm này có thể nhận nhiều lần lặp và xây dựng một trình lặp tạo ra các mục từ mục đầu tiên, từ mục thứ hai, v.v. cho đến khi nó sử dụng hết tất cả các lần lặp đầu vào

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
6

Khi bạn gọi

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
06, bạn nhận được một trình vòng lặp của các mục từ các vòng lặp đầu vào. Trong ví dụ này, bạn truy cập các mục liên tiếp từ
# A list with 3 integers
numbers = [1, 2, 5]

print[numbers]

# Output: [1, 2, 5]
61 bằng cách sử dụng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
30. Thay vào đó, nếu bạn muốn làm việc với một danh sách, thì bạn có thể sử dụng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
31 để sử dụng trình vòng lặp và trả về một danh sách Python thông thường

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
06 cũng là một lựa chọn tốt để làm phẳng danh sách các danh sách trong Python

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
7

Để làm phẳng danh sách các danh sách có

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
06, bạn cần sử dụng toán tử giải nén lặp lại [
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
34]. Toán tử này giải nén tất cả các iterable đầu vào để
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
06 có thể làm việc với chúng và tạo iterator tương ứng. Bước cuối cùng là gọi
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
31 để xây dựng danh sách phẳng mong muốn

Nối các chuỗi với
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
044

Như bạn đã thấy,

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 không nối hoặc nối các chuỗi. Nếu bạn cần làm như vậy, thì công cụ ưa thích và nhanh nhất hiện có trong Python là
# empty list
my_list = []

# list with mixed data types
my_list = [1, "Hello", 3.4]
044. Phương thức này lấy một chuỗi các chuỗi làm đối số và trả về một chuỗi mới, được nối

>>>

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
8

Sử dụng

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
40 là cách Pythonic hiệu quả nhất để nối các chuỗi. Tại đây, bạn sử dụng danh sách các chuỗi làm đối số và tạo một chuỗi đơn từ đầu vào. Lưu ý rằng
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
40 sử dụng chuỗi mà bạn gọi phương thức này làm dấu tách trong quá trình nối. Trong ví dụ này, bạn gọi
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
40 trên một chuỗi bao gồm một ký tự khoảng trắng [
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
43], vì vậy các chuỗi ban đầu từ
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
44 được phân tách bằng dấu cách trong chuỗi cuối cùng của bạn

Phần kết luận

Giờ đây, bạn có thể sử dụng hàm có sẵn của Python

>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 để cộng nhiều giá trị số lại với nhau. Hàm này cung cấp một cách hiệu quả, dễ đọc và Pythonic để giải quyết các vấn đề tổng kết trong mã của bạn. Nếu bạn đang xử lý các phép tính toán yêu cầu tính tổng các giá trị số, thì
>>> def sum_numbers[numbers]:
..     if len[numbers] == 0:
..         return 0
..     return numbers[0] + sum_numbers[numbers[1:]]
...

>>> sum_numbers[[1, 2, 3, 4, 5]]
15
9 có thể là cứu cánh của bạn

Trong hướng dẫn này, bạn đã học cách

  • Tính tổng các giá trị số bằng các kỹ thuật và công cụ chung
  • Thêm một số giá trị số một cách hiệu quả bằng cách sử dụng
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9 của Python
  • Nối các chuỗi bằng cách sử dụng
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9
  • Sử dụng
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9 để tiếp cận các bài toán tổng kết phổ biến
  • Sử dụng các giá trị thích hợp cho các đối số
    languages = ["Python", "Swift", "C++"]
    
    # access item at index 0
    print[languages[0]]   # Python
    
    # access item at index 2
    print[languages[2]]   # C++
    84 và
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    88 trong
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9
  • Quyết định giữa
    >>> def sum_numbers[numbers]:
    ..     if len[numbers] == 0:
    ..         return 0
    ..     return numbers[0] + sum_numbers[numbers[1:]]
    ...
    
    >>> sum_numbers[[1, 2, 3, 4, 5]]
    15
    
    9 và các công cụ thay thế để tổng hợp và nối các đối tượng

Với kiến ​​thức này, giờ đây bạn có thể cộng nhiều giá trị số lại với nhau theo cách Pythonic, dễ đọc và hiệu quả

Đánh dấu là đã hoàn thành

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Gửi cho tôi thủ thuật Python »

Giới thiệu về Leodanis Pozo Ramos

Leodanis là một kỹ sư công nghiệp yêu thích Python và phát triển phần mềm. Anh ấy là một nhà phát triển Python tự học với hơn 6 năm kinh nghiệm. Anh ấy là một nhà văn đam mê kỹ thuật với số lượng bài báo được xuất bản ngày càng tăng trên Real Python và các trang web khác

» Tìm hiểu thêm về Leodanis

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Aldren

Bartosz

Joanna

Gia-cốp

Sadie

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonista chuyên gia

Nâng cao kỹ năng Python của bạn »

Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng các chuyên gia Pythonistas

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Hàm nào được sử dụng để thêm phần tử vào danh sách trong Python?

chắp thêm[] . thêm phần tử vào cuối danh sách. chèn[]. chèn phần tử trước chỉ mục đã cho. gia hạn[]. mở rộng danh sách bằng cách nối thêm các phần tử từ iterable. Nối danh sách. Chúng ta có thể sử dụng toán tử + để nối nhiều danh sách và tạo một danh sách mới.

bất kỳ [] và tất cả [] trong Python là gì?

Hàm any[] và all[] của Python đánh giá các mục trong danh sách để xem mục nào là đúng . Phương thức any[] trả về true nếu bất kỳ mục nào trong danh sách là đúng và hàm all[] trả về true nếu tất cả các mục trong danh sách đều đúng.

Chức năng nào của danh sách được sử dụng để thêm các phần tử vào danh sách?

append[] Được sử dụng để nối thêm và thêm phần tử vào Danh sách.

Chủ Đề