Hướng dẫn interleave in python - xen kẽ trong con trăn

Question

Để thực hiện hiệu quả, người ta cần đảm bảo đạt được hai điều: độ phức tạp tiệm cận tối thiểu về ký hiệu O lớn và các toán tử tính toán hiệu quả, tránh tính toán lặp đi lặp lại hoặc không cần thiết.

Nội dung chính Show

Sử dụng phao
Sử dụng số thập phân
Sử dụng str
Xóa Traling 0 nếu có mặt
Xây dựng vấn đề
Thay thế 1: Chuỗi đầu tiên S1 ngắn hơn
Thay thế 2: Bất kỳ chuỗi nào cũng có thể dài hơn
Thay thế 3: Sử dụng các thư viện bên ngoài
Đo lường hiệu suất
Đi đâu từ đây?
Xen kẽ trong Python là gì?
Làm thế nào để bạn in một ký tự kép trong Python?

Với vấn đề, không chắc là nó có thể được giải quyết bằng một thuật toán nhỏ hơn tuyến tính trên độ dài của các số đầu vào. Về mặt vận hành, cho rằng chúng tôi làm việc với định dạng thập phân, sẽ rất khó để chúng tôi có thể hưởng lợi từ một số tính toán (nhị phân) (nhị phân). Do đó, chúng tôi có lẽ tốt nhất với các hoạt động toán học nói chung.

Sử dụng phao

Một triển khai ngây thơ đầu tiên sẽ cố gắng thực thi chức năng trên các số điểm nổi:

def interleave_float(a: float, b: float) -> float:
    a_rest = a
    b_rest = b
    result = 0
    dst_pos = 1.0  # position of written digit
    while a_rest != 0 or b_rest != 0:
        dst_pos /= 10  # move decimal point of write
        a_rest *= 10  # move decimal point of read
        result += a_rest // 1 * dst_pos
        a_rest %= 1  # remove current digit

        dst_pos /= 10
        b_rest *= 10
        result += dst_pos * (b_rest // 1)
        b_rest %= 1

    return result

Tuy nhiên, một bài kiểm tra đơn giản cho thấy một vấn đề - độ chính xác hạn chế của số học điểm nổi đã bị bóp méo ở chữ số thứ 16-17 sau điểm nổi:

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

Sử dụng số thập phân

Một cách phổ biến để khắc phục vấn đề chính xác là sử dụng thập phân.decimal, việc thực hiện Python của số học thập phân cố định:

from decimal import Decimal, getcontext
getcontext().prec = 50  # increase number precision

def interleave_fixed(a: Decimal, b: Decimal) -> Decimal:
    a_rest = a
    b_rest = b
    result = 0
    dst_pos = Decimal(1)
    while a_rest != 0 or b_rest != 0:
        dst_pos *= Decimal(0.1)
        a_rest *= 10  # move decimal point
        result += a_rest // 1 * dst_pos
        a_rest %= 1  # remove current digit

        dst_pos *= Decimal(0.1)
        b_rest *= 10
        result += dst_pos * (b_rest // 1)
        b_rest %= 1

    return result

Điều này dường như hoạt động tốt hơn cho B, nhưng thật không may, nó cũng dẫn đến sự thiếu chính xác với cùng một chữ số trong kết quả. Sự thiếu chính xác này cũng được báo hiệu bằng cờ không chính xác trong bối cảnh sau khi tính toán:

>>> print(getcontext())
Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> a = Decimal(".987654321")
>>> b = Decimal(".1234567890123456789")
>>> print(a)
0.987654321
>>> print(b)
0.1234567890123456789
>>> print(f"Fixed:  {interleave_fixed(a, b)}")
Fixed:  0.91827364554637287146771953200668367263491993253785
>>> print(getcontext())
Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[Inexact, FloatOperation, Rounded], traps=[InvalidOperation, DivisionByZero, Overflow])

Sử dụng str

Một cách tiếp cận khác không nên áp đặt các giới hạn do độ chính xác (và bạn đã tự mình đưa ra) là thực hiện xử lý cú pháp với các chuỗi:

def interleave_str(a: str, b: str) -> str:
    result = "0."
    src_pos = 2  # position of read digit
    while len(a) > src_pos or len(b) > src_pos:
        result += a[src_pos] if len(a) > src_pos else "0"

        result += b[src_pos] if len(b) > src_pos else "0"

        src_pos += 1

    return result[:-1] if result.endswith("0") else result

Xóa Traling 0 nếu có mặt

Thuật toán không thực hiện xác thực, vì vậy bạn vẫn quyết định những gì bạn có thể muốn thêm. Tuy nhiên, kiểm tra điều này cho độ chính xác mong muốn:

>>> a = "0.987654321"
>>> b = "0.1234567890123456789"
>>> print(a)
0.987654321
>>> print(b)
0.1234567890123456789
>>> print(f"String: {interleave_str(a, b)}")
String: 0.91827364554637281900010203040506070809

... Nhưng người ta có thể làm gì với chuỗi kết quả? Có thể chuyển đổi nó thành một số thập phân một lần nữa? Phụ thuộc vào cách bạn muốn sử dụng kết quả.

Chuỗi xen kẽ

Nội phân Chính showShow

Xây dựng vấn đề
Thay thế 1: Chuỗi đầu tiên S1 ngắn hơn
Thay thế 2: Bất kỳ chuỗi nào cũng có thể dài hơn
Thay thế 3: Sử dụng các thư viện bên ngoài
Đo lường hiệu suất
Đi đâu từ đây?
Xen kẽ trong Python là gì?
Làm thế nào để bạn in một ký tự kép trong Python?

Nhân đôi mỗi chữ cái của một từ trong Python.

String = "Hello" in (Chuỗi*2) Chạy. Sự lặp lại chuỗi ..

String1 = "Hello" String2 = "World" in (String1+String2) chạy. Kết hợp chuỗi ..

input_String = input () output = "" for i in input_string: output = output + i*2. In (đầu ra) Nhập đầu vào bên dưới. Chạy. Dung dịch..

Chuỗi xen kẽ

Nội phân Chính show

Xây dựng vấn đề

Thay thế 1: Chuỗi đầu tiên S1 ngắn hơn

Thay thế 2: Bất kỳ chuỗi nào cũng có thể dài hơn

Thay thế 3: Sử dụng các thư viện bên ngoài

Đo lường hiệu suất

Đưa ra hai chuỗi, hãy viết một chương trình để hợp nhất hai chuỗi đã cho bằng cách thêm các ký tự theo thứ tự xen kẽ, bắt đầu với chuỗi đầu tiên. Nếu một chuỗi dài hơn chuỗi khác, hãy nối các ký tự bổ sung vào đầu chuỗi được hợp nhất.

Thay thế 1: Chuỗi đầu tiên S1 ngắn hơn

Thay thế 2: Bất kỳ chuỗi nào cũng có thể dài hơn

Thay thế 3: Sử dụng các thư viện bên ngoài

Đo lường hiệu suất

Chuỗi xen kẽ

Nhân đôi mỗi chữ cái của một từ trong Python.

String = "Hello" in (Chuỗi*2) Chạy. Sự lặp lại chuỗi ..

String1 = "Hello" String2 = "World" in (String1+String2) chạy. Kết hợp chuỗi ..

input_String = input () output = "" for i in input_string: output = output + i*2. In (đầu ra) Nhập đầu vào bên dưới. Chạy. Dung dịch..

Chuỗi xen kẽ

Nội phân Chính show

Xây dựng vấn đề

Xây dựng vấn đề
Thay thế 1: Chuỗi đầu tiên S1 ngắn hơn
Thay thế 2: Bất kỳ chuỗi nào cũng có thể dài hơn
Thay thế 3: Sử dụng các thư viện bên ngoài
Đo lường hiệu suất
Đi đâu từ đây?

Xây dựng vấn đề

Thay thế 1: Chuỗi đầu tiên S1 ngắn hơn

Thay thế 2: Bất kỳ chuỗi nào cũng có thể dài hơn: String

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

0 and string

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

1

Đầu ra: Chuỗi
>>> a = 0.987654321 >>> b = 0.1234567890123456789 >>> print(a) 0.987654321 >>> print(f"{b:.20}") # formatted to show higher precision 0.12345678901234567737 >>> print(f"Float: {interleave_float(a, b):.50}") Float: 0.91827364554637280757987127799424342811107635498047
2: String

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

2

Bị ám ảnh bởi việc tìm ra cách viết pythonic nhất bất kỳ đoạn mã nào (tốt nhất là trong một dòng mã), tôi nhanh chóng trở nên thất vọng vì dường như không có câu trả lời rất đơn giản, sạch sẽ và súc tích cho câu hỏi này.

Làm thế nào để xen kẽ hai chuỗi có độ dài thay đổi (python)?

Tuy nhiên, trong bài viết này, bạn sẽ học được một cách giải quyết vấn đề này mạnh mẽ và dễ hiểu và dễ hiểu (không có hỗ trợ thư viện bên ngoài). Vì vậy, hãy tiếp tục đọc.

Thay thế 1: Chuỗi đầu tiên S1 ngắn hơn

Giả sử chuỗi đầu tiên ngắn hơn cho chúng ta cơ hội để giải quyết vấn đề trong một lớp lót Python bằng cách sử dụng danh sách hiểu:

s1 = "AAA"
s2 = "BBBBB"

s = "".join([s1[i] + s2[i] for i in range(len(s1))]) + s2[len(s1):]
print(s)
# ABABABBB

Do việc thực hiện hiệu quả việc hiểu danh sách của Python, thì tùy chọn này cực kỳ nhanh - tôi nghi ngờ rằng có bất cứ điều gì nhanh hơn (vẫn có thể đọc được như nhau).

Chúng tôi kết hợp mọi ký tự của chuỗi ngắn hơn

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

3 với ký tự của chuỗi dài hơn

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

4 ở vị trí tương ứng. Điều này dẫn đến chuỗi xen kẽ một phần

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

5. Bây giờ, chúng tôi chỉ đơn giản là kết hợp điều này với các ký tự còn lại của chuỗi dài hơn

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

4.

Tuy nhiên, giải pháp này không hoạt động nếu chuỗi

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

3 cũng có thể dài hơn chuỗi

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

4.

Tại sao? Bởi vì trình thông dịch Python sẽ tăng chỉ số Erroras truy cập

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

9 là không thể.Index Erroras accessing

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

9 is not possible.

Thay thế 2: Bất kỳ chuỗi nào cũng có thể dài hơn

Nếu bạn không cho rằng một trong các chuỗi dài hơn chuỗi kia, vấn đề sẽ trở nên khó khăn hơn một chút. Tuy nhiên, vẫn có một giải pháp đơn giản và sạch sẽ cho vấn đề này (mà không sử dụng các thư viện bên ngoài). Nó không nằm trong một dòng mã duy nhất, nhưng nó có thể đọc được, nhanh chóng và nó không cần bất kỳ giả định độ dài nào:

s1 = "AAA"
s2 = "BBBBB"

s = list(s2)
for i,c in enumerate(s1):
    s.insert(i*2,c)
print("".join(s))
# ABABABBB

Đầu tiên, chúng tôi chuyển đổi chuỗi

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

4 thành danh sách các ký tự bằng hàm

from decimal import Decimal, getcontext
getcontext().prec = 50  # increase number precision

def interleave_fixed(a: Decimal, b: Decimal) -> Decimal:
    a_rest = a
    b_rest = b
    result = 0
    dst_pos = Decimal(1)
    while a_rest != 0 or b_rest != 0:
        dst_pos *= Decimal(0.1)
        a_rest *= 10  # move decimal point
        result += a_rest // 1 * dst_pos
        a_rest %= 1  # remove current digit

        dst_pos *= Decimal(0.1)
        b_rest *= 10
        result += dst_pos * (b_rest // 1)
        b_rest %= 1

    return result

1. Đây là cơ sở của giải pháp của chúng tôi.

Thứ hai, chúng tôi chèn các ký tự của chuỗi

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

3 tại các vị trí 0, 2, 4, bằng cách lặp trên tất cả các chỉ số

from decimal import Decimal, getcontext
getcontext().prec = 50  # increase number precision

def interleave_fixed(a: Decimal, b: Decimal) -> Decimal:
    a_rest = a
    b_rest = b
    result = 0
    dst_pos = Decimal(1)
    while a_rest != 0 or b_rest != 0:
        dst_pos *= Decimal(0.1)
        a_rest *= 10  # move decimal point
        result += a_rest // 1 * dst_pos
        a_rest %= 1  # remove current digit

        dst_pos *= Decimal(0.1)
        b_rest *= 10
        result += dst_pos * (b_rest // 1)
        b_rest %= 1

    return result

3 và ký tự

from decimal import Decimal, getcontext
getcontext().prec = 50  # increase number precision

def interleave_fixed(a: Decimal, b: Decimal) -> Decimal:
    a_rest = a
    b_rest = b
    result = 0
    dst_pos = Decimal(1)
    while a_rest != 0 or b_rest != 0:
        dst_pos *= Decimal(0.1)
        a_rest *= 10  # move decimal point
        result += a_rest // 1 * dst_pos
        a_rest %= 1  # remove current digit

        dst_pos *= Decimal(0.1)
        b_rest *= 10
        result += dst_pos * (b_rest // 1)
        b_rest %= 1

    return result

4 của chuỗi đầu tiên

>>> a = 0.987654321
>>> b = 0.1234567890123456789
>>> print(a)
0.987654321
>>> print(f"{b:.20}")  # formatted to show higher precision
0.12345678901234567737
>>> print(f"Float:  {interleave_float(a, b):.50}")
Float:  0.91827364554637280757987127799424342811107635498047

3. Bây giờ chúng tôi chèn các ký tự vào mọi vị trí khác của danh sách.

Thay thế 3: Sử dụng các thư viện bên ngoài

Các lập trình viên chuyên gia sử dụng rất nhiều thư viện bên ngoài vì nó làm cho mã của họ dễ đọc hơn, hiệu quả hơn và ngắn hơn. Điều gì sai với điều đó? Dưới đây là những gì một độc giả chuyên gia David của tôi (miễn phí) Cà phê Break Python khóa học email đề xuất:

import itertools


s1 = "AAA"
s2 = "BBBBB"

s = "".join([ x + y for x, y in itertools.zip_longest(s1, s2, fillvalue="")])
print(s)
# ABABABBB

Vấn đề với việc sử dụng hàm

from decimal import Decimal, getcontext
getcontext().prec = 50  # increase number precision

def interleave_fixed(a: Decimal, b: Decimal) -> Decimal:
    a_rest = a
    b_rest = b
    result = 0
    dst_pos = Decimal(1)
    while a_rest != 0 or b_rest != 0:
        dst_pos *= Decimal(0.1)
        a_rest *= 10  # move decimal point
        result += a_rest // 1 * dst_pos
        a_rest %= 1  # remove current digit

        dst_pos *= Decimal(0.1)
        b_rest *= 10
        result += dst_pos * (b_rest // 1)
        b_rest %= 1

    return result

6 tích hợp là số lượng các cặp được trả về bởi hàm

from decimal import Decimal, getcontext
getcontext().prec = 50  # increase number precision

def interleave_fixed(a: Decimal, b: Decimal) -> Decimal:
    a_rest = a
    b_rest = b
    result = 0
    dst_pos = Decimal(1)
    while a_rest != 0 or b_rest != 0:
        dst_pos *= Decimal(0.1)
        a_rest *= 10  # move decimal point
        result += a_rest // 1 * dst_pos
        a_rest %= 1  # remove current digit

        dst_pos *= Decimal(0.1)
        b_rest *= 10
        result += dst_pos * (b_rest // 1)
        b_rest %= 1

    return result

6 bằng với độ lặp lại ngắn hơn.

Đây là những gì độc giả trung thành của tôi David lập luận:

. Nó mở rộng ra một số ít có thể lặp lại với tham số

>>> print(getcontext())
Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> a = Decimal(".987654321")
>>> b = Decimal(".1234567890123456789")
>>> print(a)
0.987654321
>>> print(b)
0.1234567890123456789
>>> print(f"Fixed:  {interleave_fixed(a, b)}")
Fixed:  0.91827364554637287146771953200668367263491993253785
>>> print(getcontext())
Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[Inexact, FloatOperation, Rounded], traps=[InvalidOperation, DivisionByZero, Overflow])

1 - sử dụng [chuỗi trống] chứ không phải là

>>> print(getcontext())
Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> a = Decimal(".987654321")
>>> b = Decimal(".1234567890123456789")
>>> print(a)
0.987654321
>>> print(b)
0.1234567890123456789
>>> print(f"Fixed:  {interleave_fixed(a, b)}")
Fixed:  0.91827364554637287146771953200668367263491993253785
>>> print(getcontext())
Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[Inexact, FloatOperation, Rounded], traps=[InvalidOperation, DivisionByZero, Overflow])

2 mặc định, nếu không thì kết nối chuỗi tiếp theo sẽ thất bại!

Một lần nữa, nếu hỗ trợ thư viện được cho phép (nói cách khác: bạn không có trong một cuộc phỏng vấn mã hóa), đây là giải pháp ưa thích của tôi.

Đo lường hiệu suất

Sau khi xuất bản bài viết này, đồng tác giả Lukas của tôi (cuốn sách Cà phê Break Numpy,) đã trở lại với tôi với một phân tích hiệu suất tốt đẹp. Chức năng nào hoạt động tốt nhất? Tôi không muốn giữ kết quả thú vị vì bạn cũng có thể thấy chúng có giá trị:

import itertools
import matplotlib.pyplot as plt
plt.xkcd()


def interleave_strings_listcomprehension(s1, s2):  
    return "".join([s1[i] + s2[i] for i in range(len(s1))]) + s2[len(s1):]    
    

def interleave_strings_enumerate(s1, s2):
    s = list(s2)
    for i, c in enumerate(s1):
        s.insert(i*2, c)
    
    return "".join(s)
    
    
def interleave_strings_slicing(s1, s2):
    length_s1 = len(s1)
    length_s2 = len(s2)
    
    if length_s1 != length_s2:
        if length_s1 > length_s2:
            spaces_count = length_s1 - length_s2
            s2 = s2 + spaces_count * ' '
        else:
            spaces_count = length_s2 - length_s1
            s1 = s1 + spaces_count * ' '
    
    interleaved = len(s1) * 2 * ['']
    interleaved[::2] = s1
    interleaved[1::2] = s2
    
    return ''.join(interleaved).replace(' ', '')
    
    
def interleave_strings_zip(s1, s2):
    length_s1 = len(s1)
    length_s2 = len(s2)
    
    if length_s1 != length_s2:
        if length_s1 > length_s2:
            spaces_count = length_s1 - length_s2
            s2 = s2 + spaces_count * ' '
        else:
            spaces_count = length_s2 - length_s1
            s1 = s1 + spaces_count * ' '
    
    return "".join(i + j for i, j in zip(s1, s2)).replace(' ', '')

def interleave_zip_itertools(s1, s2):
    import itertools
    return "".join([ x + y for x, y in itertools.zip_longest(s1, s2, fillvalue="")])
    
    
    
    
import time

multiplicator = 1000
s1 = multiplicator * "AAA"
s2 = multiplicator * "BBBB"

# Test 1
start = time.perf_counter()
interleave_strings_listcomprehension(s1, s2)
end = time.perf_counter()
plt.bar(1,end - start, hatch=" ", label="List comprehension (Alt 1)")

# Test 2
start = time.perf_counter()
interleave_strings_enumerate(s1, s2)
end = time.perf_counter()
plt.bar(2,end - start, hatch="o", label="Enumerate (Alt 2)")

# Test 3
start = time.perf_counter()
interleave_strings_slicing(s1, s2)
end = time.perf_counter()
plt.bar(3,end - start, hatch="+", label="Slicing")

# Test 4
start = time.perf_counter()
interleave_strings_zip(s1, s2)
end = time.perf_counter()
plt.bar(4,end - start, hatch="/", label="Zip")

# Test 5
start = time.perf_counter()
interleave_zip_itertools(s1, s2)
end = time.perf_counter()
plt.bar(5,end - start, hatch="-", label="Zip Itertools (Alt 3)")


plt.xticks((),())
plt.ylabel("nanosecs")
plt.legend()
plt.tight_layout()
plt.savefig("plot.jpg")
plt.show()

Dưới đây là sơ đồ thanh kết quả so sánh thời gian chạy của các chức năng khác nhau:

Chức năng cắt vượt trội so với bất kỳ chức năng nào khác ít nhất 50%! Tôi biết rằng cắt lát là nhanh nhưng kết quả này đã thổi vào tâm trí tôi. Tôi cũng đã thử nghiệm kết quả cho các chuỗi thậm chí còn lớn hơn nhưng việc cắt lát dường như vẫn là sự thay thế nhanh nhất. Nó phải trả giá mà khả năng đọc phải chịu một chút so với giải pháp ITERTOOLS.

Đi đâu từ đây?

Nếu bạn cảm thấy như bạn có một giải pháp tốt sẽ rất thú vị cho độc giả của bài viết này, hãy để lại nhận xét bên dưới với giải pháp của bạn!

Có thể nhanh chóng hiểu và viết mã nguồn là một kỹ năng quan trọng của mỗi lập trình viên. Các công ty như Amazon, Google và Facebook đang phỏng vấn nổi tiếng mọi ứng viên - kiểm tra sự hiểu biết và trình độ của họ với mã nguồn. Ngày nay, hiểu mã Python nhanh là một trong những kỹ năng có giá trị nhất mà bạn có thể có với tư cách là một lập trình viên đầy tham vọng.

Để giúp bạn đạt được kỹ năng có giá trị này, chúng tôi đã tạo ra loạt sách Break Coffee Break Python. Kiểm tra chúng ra!

Trong khi làm việc như một nhà nghiên cứu trong các hệ thống phân tán, Tiến sĩ Christian Mayer đã tìm thấy tình yêu của mình đối với việc dạy các sinh viên khoa học máy tính.

Để giúp học sinh đạt được thành công cao hơn của Python, ông đã thành lập trang web giáo dục chương trình Finxter.com. Ông là tác giả của cuốn sách lập trình phổ biến Python Oneer (Nostarch 2020), đồng tác giả của loạt sách Break Break Python, những cuốn sách tự xuất bản, người đam mê khoa học máy tính, freelancer và chủ sở hữu của một trong 10 blog Python lớn nhất trên toàn thế giới.

Niềm đam mê của ông là viết, đọc và mã hóa.Nhưng niềm đam mê lớn nhất của anh là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ tăng cường các kỹ năng của họ.Bạn có thể tham gia học viện email miễn phí của anh ấy ở đây.

Xen kẽ trong Python là gì?

Khoa học dữ liệu thực tế bằng cách sử dụng Python giả sử chúng ta có hai chuỗi S và T, chúng ta phải tìm hai chuỗi xen kẽ, bắt đầu với chuỗi đầu tiên.Nếu có các ký tự còn lại trong một chuỗi, chúng sẽ được thêm vào cuối.Vì vậy, nếu đầu vào giống như s = "abcd", t = "pqrstu", thì đầu ra sẽ là "apbqcrdstu"If there are leftover characters in a string they will be added to the end. So, if the input is like s = "abcd", t = "pqrstu", then the output will be "apbqcrdstu"

Làm thế nào để bạn in một ký tự kép trong Python?

Nhân đôi mỗi chữ cái của một từ trong Python..

String = "Hello" in (Chuỗi*2) Chạy.Sự lặp lại chuỗi ..

String1 = "Hello" String2 = "World" in (String1+String2) chạy.Kết hợp chuỗi ..

input_String = input () output = "" for i in input_string: output = output + i*2.In (đầu ra) Nhập đầu vào bên dưới.Chạy.Dung dịch..

programming python Interleaving iterator Python Python riffle

Hướng dẫn interleave in python - xen kẽ trong con trăn

Sử dụng phao

Sử dụng số thập phân

Sử dụng str

Xóa Traling 0 nếu có mặt

Xây dựng vấn đề

Thay thế 1: Chuỗi đầu tiên S1 ngắn hơn

Thay thế 2: Bất kỳ chuỗi nào cũng có thể dài hơn

Thay thế 3: Sử dụng các thư viện bên ngoài

Đo lường hiệu suất

Đi đâu từ đây?

Xen kẽ trong Python là gì?

Làm thế nào để bạn in một ký tự kép trong Python?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội