Tổng số bình phương Python

sum_sqdfFPR(>F)Intercept20037. 6130111. 0181. 4137881. 417921e-17C(thuốc, Tổng)2997. 4718603. 09. 0460338. 086388e-05C(bệnh, Sum)415. 8730462. 01. 8825871. 637355e-01C(thuốc, Sum). C(bệnh, Tổng)707. 2662596. 01. 0672253. 958458e-01Residual5080. 81666746. 0NaNNaN

Hàm tích hợp 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

Show

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ính tổng 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

>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
8

>>>

>>> numbers = [1, 2, 3, 4, 5]
>>> total = 0

>>> for number in numbers:
..     total += number
...

>>> total
15

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

>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
9 và khởi tạo nó thành
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
0. 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
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
1 và cập nhật
>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
9 bằng cách tích lũy từng giá trị liên tiếp bằng cách sử dụng một

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

>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
8 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

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0

Trong

>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
4, bạn lấy một —cụ thể là danh sách các giá trị số—làm đối số và trả về tổng giá trị trong danh sách đầu vào. Nếu danh sách đầu vào trống, thì hàm trả về
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
0. Vòng lặp
>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
8 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ở hàm ý rằng tổng của một danh sách có độ dài bằng 0 là

>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
0. Trường hợp đệ quy ngụ ý rằng tổng số tiền là giá trị đầu tiên,
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
8, cộng với tổng của các giá trị còn lại,
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
9. Bởi vì trường hợp đệ quy sử dụng một trình tự ngắn hơn trên mỗi lần lặp, bạn sẽ gặp trường hợp cơ sở khi
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
1 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,
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
1

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ơ bản của bạn), thì

>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
4 sẽ không bao giờ chạy vào một vòng lặp đệ quy vô hạn. Khi danh sách
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
1 của bạn đạt đến độ dài
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
0, mã sẽ cố truy cập một mục từ danh sách trống, điều này làm tăng
>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
5 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

>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
5 mỗi lần

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

>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7 từ. Để lấy tổng của một danh sách các số, bạn có thể chuyển một trong hai hoặc một hàm
>>> sum([x ** 2 for x in range(1, 6)])
55
0 thích hợp làm đối số đầu tiên cho
>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7

>>>

>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15

Bạn có thể gọi

>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7 kèm theo rút gọn hoặc gấp lại,
>>> sum([x ** 2 for x in range(1, 6)])
55
3 cùng với
>>> sum([x ** 2 for x in range(1, 6)])
55
4 làm đối số. Sau đó,
>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7 sử dụng hàm đầu vào để xử lý
>>> sum([x ** 2 for x in range(1, 6)])
55
4 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à

>>> sum([x ** 2 for x in range(1, 6)])
55
7, 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
>>> sum([x ** 2 for x in range(1, 6)])
55
4. Như một nhược điểm,
>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7 tăng a khi bạn gọi nó với một khoảng trống
>>> sum([x ** 2 for x in range(1, 6)])
55
4

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

>>> sum([x ** 2 for x in range(1, 6)])
55
0 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

>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7 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. 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. 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

>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7 tính tổng. Sử dụng
>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7 đượ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 làm chức năng 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ị

>>>

>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0

Ồ. 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
>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
8 hoặc cuộc gọi
>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7. Không giống như
>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6
7,
>>> 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
>>> sum(x ** 2 for x in range(1, 6))
55
0 khi bạn cung cấp một lần lặp trống. Thay vào đó, nó trả về một cách dễ hiểu là
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
0

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. >>> sum([x ** 2 for x in range(1, 6)])
    55
    
    4 là một đối số bắt buộc có thể giữ 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. >>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
    115
    
    >>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
    115
    
    8 là đố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à
    >>> sum([1, 2, 3, 4, 5])
    15
    
    >>> sum([])
    0
    
    0

Bên 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 thêm
>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8 cộng với các giá trị trong
>>> sum([x ** 2 for x in range(1, 6)])
55
4 từ trái sang phải. Các giá trị trong đầu vào
>>> sum([x ** 2 for x in range(1, 6)])
55
4 thường là số, nhưng bạn cũng có thể sử dụng danh sách và bộ dữ liệu. Đối số tùy chọn
>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8 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
>>> sum([x ** 2 for x in range(1, 6)])
55
4. Nó không thể lấy một chuỗi

Trong hai phần sau, bạn sẽ tìm hiểu những 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. >>> sum([x ** 2 for x in range(1, 6)]) 55 4

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 chung chung, có thể tái sử dụng và đa hình. Nhờ 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
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
00 và từ điển

>>>

>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6

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 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 giống như trong ví dụ

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
03

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ị

>>>

>>> sum([x ** 2 for x in range(1, 6)])
55

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ố

>>>

>>> sum(x ** 2 for x in range(1, 6))
55

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. >>> sum([1, 2, 3, 4, 5], 100) # Positional argument 115 >>> sum([1, 2, 3, 4, 5], start=100) # Keyword argument 115 8

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

>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8, 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

>>>

>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115

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

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
10 đến
>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8. 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
>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8 như một hoặc như một. 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

>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8 thì giá trị đó sẽ mặc định là
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
0. Giá trị mặc định của
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
0 đảm bảo hành vi dự kiến ​​​​trả về tổng của các giá trị đầu vào

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ư ,
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
20, và

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

>>>

>>> from decimal import Decimal
>>> from fractions import Fraction

>>> # Sum floating-point numbers
>>> sum([10.2, 12.5, 11.8])
34.5
>>> sum([10.2, 12.5, 11.8, float("inf")])
inf
>>> sum([10.2, 12.5, 11.8, float("nan")])
nan

>>> # Sum complex numbers
>>> sum([3 + 2j, 5 + 6j])
(8+8j)

>>> # Sum Decimal numbers
>>> sum([Decimal("10.2"), Decimal("12.5"), Decimal("11.8")])
Decimal('34.5')

>>> # Sum Fraction numbers
>>> sum([Fraction(51, 5), Fraction(25, 2), Fraction(59, 5)])
Fraction(69, 2)

Ở đâ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
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
25 và
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
26 trong các cuộc gọi
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
27 và
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
28. 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ề
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
25. 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 _______16_______26

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

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
20,
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
33 và
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
34. 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 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 điều đó, bạn cần cung cấp một giá trị thích hợp cho
>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
0

Trong những 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
>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8. Ví dụ: nếu bạn muốn nối các danh sách, thì
>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8 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

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
1

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
>>> sum(x ** 2 for x in range(1, 6))
55
0. Như thông báo ngoại lệ gợi ý, bạn nên sử dụng để nối các chuỗi trong Python. Bạn sẽ thấy các ví dụ về cách sử dụng phương pháp này sau này khi đến phần trên

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 nay, 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 bạn. 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ố

>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8 để 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

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
2

Bằng cách sử dụng

>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115
8, 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 , 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
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
55

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
3

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
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
55 để 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

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
4

Bên trong

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
58, 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, sau đó bạn nâng cao một
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
59 với một thông điệp mô tả. Trong ví dụ này, bạn sử dụng the để lưu trữ số điểm dữ liệu trong biến
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
60 để bạn không cần gọi lại
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
55. 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 gọi để tiếp cận các loại tính toán này

Trong mô-đun

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
62, bạn sẽ tìm thấy một chức năng gọi là

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
5

Hàm

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
65 có hành vi rất giống với hàm
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
58 mà bạn đã mã hóa trước đó. Khi bạn gọi
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
64 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
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
64, bạn sẽ nhận được một
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
69

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

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
58 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
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
58 với một mẫu trống, thì bạn sẽ nhận được
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
59 như mong đợi

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

Một vấn đề khác mà 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

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
74. 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

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
6

Với

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
74, 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
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
74. Bước cuối cùng là cộng 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 ____0_______9 trong một chức năng tùy chỉnh và cung cấp một kiểm tra thích hợp cho độ dài của các chuỗi đầu vào

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
7

Ở đây,

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
81 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ăng
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
59

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

>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
8, như trong đoạn mã sau

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
8

Bên trong

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
84, vòng lặp lặp lại trên tất cả các danh sách lồng nhau có trong
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
85. Sau đó, nó nối chúng trong
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
86 bằng cách sử dụng thao tác gán tăng cường (
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
87). 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

>>>

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
9

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

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
89 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

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
84 hiệu quả hơn và ít lãng phí hơn về mặt sử dụng bộ nhớ. Tuy nhiên, có thể khó đọc và hiểu

Sử dụng

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
92 có lẽ là cách dễ đọc và Pythonic 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

>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
84 này, ai đó đang đọc mã của bạn có thể thấy rằng hàm lặp lại sau mỗi
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
94 trong
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
85. Bên trong vòng lặp
>>> from functools import reduce
>>> from operator import add

>>> reduce(add, [1, 2, 3, 4, 5])
15

>>> reduce(add, [])
Traceback (most recent call last):
    ...
TypeError: reduce() of empty sequence with no initial value

>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
8 đầu tiên này, nó lặp lại qua từng
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
97 trong
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
94 để cuối cùng đưa vào danh sách
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
86 mới với
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
92. 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à hàm này có thể giúp bạn cải thiện độ chính xác chung của các phép tính 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 tình huống 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

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. Bạn đã học được trong hướng dẫn này 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

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
>>> 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 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 riê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 trong số học dấu phẩy động. Ví dụ sau phát hiện ra giới hạn 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 trong 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 phẩy độ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 khá xa so 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 để nối hoặc xâu chuỗi một loạt các lần lặp lại, 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à tạo một mục mang lại 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ừ
>>> sum([1, 2, 3, 4, 5])
15

>>> sum([])
0
1 bằng cách sử dụng. 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 một danh sách gồm 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 trình 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
06 có thể làm việc với chúng và tạo trình lặp 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 để tạo danh sách cố định mong muốn

Nối các chuỗi với >>> def sum_numbers(numbers): .. total = 0 .. for number in numbers: .. total += number .. return total ... >>> sum_numbers([1, 2, 3, 4, 5]) 15 >>> sum_numbers([]) 0 44

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à
>>> def sum_numbers(numbers):
..     total = 0
..     for number in numbers:
..         total += number
..     return total
...

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

>>> sum_numbers([])
0
44. 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 tích hợp sẵn của Python để 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ố
    >>> sum([x ** 2 for x in range(1, 6)])
    55
    
    4 và
    >>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
    115
    
    >>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
    115
    
    8 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ính tổng 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

Tổng số bình phương Python

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

Giới thiệu về Leodanis Pozo Ramos

Tổng số bình phương Python
Tổng số bình phương Python

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à

Tổng số bình phương Python

Aldren

Tổng số bình phương Python

Bartosz

Tổng số bình phương Python

Joanna

Tổng số bình phương Python

Gia-cốp

Tổng số bình phương Python

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 Pythonistas chuyên gia

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

Chuyên gia 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 Pythonistas chuyên gia

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. 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

Tổng bình phương trong Python là gì?

1. Tổng bình phương (SST) – Tổng bình phương sự khác biệt giữa các điểm dữ liệu riêng lẻ (y i ) và . 2. Tổng hồi quy bình phương (SSR) – Tổng bình phương chênh lệch giữa các điểm dữ liệu dự đoán (ŷi) và giá trị trung bình của biến phản hồi (y). . 2. Sum of Squares Regression (SSR) – The sum of squared differences between predicted data points (ŷi) and the mean of the response variable(y).

TSS trong Python là gì?

Tổng bình phương (TSS) trong python.

Tổng số trong tổng bình phương là bao nhiêu?

Tổng bình phương là bao nhiêu? . Tổng SS = Σ(Yi – giá trị trung bình của Y) 2. Ghi chú. Sigma (Σ) là một thuật ngữ toán học để tính tổng hoặc “cộng. ” Nó bảo bạn cộng tất cả các kết quả có thể có từ phần còn lại của phương trình.