4 הדרכים הטובות ביותר ליצור רשימה של תמורות ב-Python – היו בצד הנכון של השינוי

פרסומת
MAGNEZIX מגנזיקס


💡 ניסוח בעיה: דמיינו שאתם רוצים ליצור את כל הסידורים האפשריים של רצף של פריטים, כך שכל פריט נמצא במיקום ייחודי בכל סידור. זה ידוע כמציאת התמורות של הרצף.

פרסומת

לדוגמה, בהינתן הרצף [1, 2, 3]הפלט הרצוי הוא רשימה של תמורות כמו [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)].

מאמר זה יחקור שיטות להשיג זאת ב- Python.

שיטה 1: שימוש ב-itertools.permutations

ה itertools מודול ב- Python מספק פונקציה permutations() שלוקח רצף ומחזיר an איטרטור על פני התמורות של הרצף. שיטה זו פשוטה ויעילה ליצירת תמורות.

הנה דוגמה:

🖨️ מוצר טכני מומלץ: בדוק את מדפסת התלת מימד המטורפת הזו בפחות מ-$200: קישור שותפים של אמזוןמעל 20 אלף דירוגי חמישה כוכבים ⭐⭐⭐⭐⭐

import itertools

items = [1, 2, 3]
permutations_list = list(itertools.permutations(items))
print(permutations_list)
# [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

קטע קוד זה מייבא את itertools מודול ומשתמש בו permutations פונקציה ליצירת איטרטור על כל התמורות האפשריות של הרשימה items. לאחר מכן נמיר את האיטרטור הזה לרשימה כדי להדפיס את התמורות.

שיטה 2: שימוש ברקורסיה

ניתן לעצב פונקציה רקורסיבית כדי ליצור את התמורות של רצף. זה כולל החלפת אלמנטים בכל מיקום עם השאר וקריאה רקורסיבית לפונקציית התמורה עבור החלק הנותר של הרצף.

הנה דוגמה:

def permute(sequence, start, end):
    if start == end:
        print(sequence)
    else:
        for i in range(start, end + 1):
            sequence[start], sequence[i] = sequence[i], sequence[start] # swap
            permute(sequence, start + 1, end)
            sequence[start], sequence[i] = sequence[i], sequence[start] # swap back

items = [1, 2, 3]
permute(items, 0, len(items) - 1)

תְפוּקָה:

[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 2, 1]
[3, 1, 2]

בקטע קוד זה, אנו מגדירים פונקציה permute שלוקח את הרצף ואת מדדי ההתחלה והסיום. הוא משתמש ברקורסיה כדי להחליף כל אלמנט וליצור תמורות. הוא מדפיס את התמורות עבור כל סידור שלם.

שיטה 3: שימוש באלגוריתם של Heap

האלגוריתם של ערימה היא שיטה קלאסית ליצירת תמורות הפועלת על ידי יצירת התמורות של n-1 אלמנטים של הרצף ולאחר מכן הוספת האלמנט ה-n לכל מיקום אפשרי.

הנה דוגמה:

def generate_permutations(n, sequence):
    if n == 1:
        print(sequence)
    else:
        for i in range(n-1):
            generate_permutations(n-1, sequence)
            if n % 2 == 0:
                sequence[i], sequence[n-1] = sequence[n-1], sequence[i]
            else:
                sequence[0], sequence[n-1] = sequence[n-1], sequence[0]
        generate_permutations(n-1, sequence)

items = [1, 2, 3]
generate_permutations(len(items), items)

קטע הקוד מגדיר פונקציה רקורסיבית generate_permutations שלוקח את גודל הרצף ואת הרצף עצמו. הוא יוצר תמורות על ידי החלפה רקורסיבית של אלמנטים באמצעות האלגוריתם של Heap ומדפיס כל תמורה.

שיטה 4: שימוש בספריית sympy

ה sympy הספרייה, הידועה בדרך כלל במתמטיקה סמלית, כוללת גם מודול כלי עזר שיכול ליצור תמורות. זה שימושי אם אתה כבר עובד בתוך a sympy סביבה.

הנה דוגמה:

from sympy.utilities.iterables import multiset_permutations

items = [1, 2, 3]
permutations_list = list(multiset_permutations(items))
print(permutations_list)

בקטע קוד זה, אנו מייבאים את multiset_permutations פונקציה מה sympy מודול כלי עזר. לאחר מכן אנו משתמשים בפונקציה זו כדי ליצור מחזור של תמורות של הרשימה items ולהמיר אותו לרשימה.

👉 מתמטיקה סמלית עם SymPy

סיכום/דיון

  • שימוש ב-itertools.permutations:
    • חוזק: פשוט להפליא ופשוט לשימוש.
    • חולשה: יכול לצרוך הרבה זיכרון עם רצפי קלט גדולים יותר.
  • שימוש ברקורסיה:
    • חוזק: אינו דורש מודולים נוספים.
    • חולשה: יכול להיות פחות יעיל וקשה יותר להבנה עבור אלה שאינם מכירים רקורסיה.
  • שימוש באלגוריתם של Heap:
    • חוזק: יעיל יותר מרקורסיה נאיבית.
    • חולשה: האלגוריתם יכול להיות לא אינטואיטיבי עבור משתמשים מסוימים.
  • שימוש בספריית sympy:
    • חוזק: משתלב היטב אם כבר משתמשים ב-sympy עבור חישובים אחרים.
    • חולשה: תקורה של שימוש בספרייה כבדה למשימה שניתן להשיג עם ספריות סטנדרטיות.

ליישום מהיר וקל, itertools.permutations שימושי מאוד. אם לומדים או מלמדים אלגוריתמים של רקורסיה ועקיבה לאחור, שיטות 2 ו-3 עם רקורסיה ואלגוריתם של Heap עשויות להיות עדיפות.

כאשר עובדים בסביבת מחשוב מדעית, sympy יכולה להיות בחירה טבעית.

Python One-Liner ספר: השלוט בשורה הבודדת תחילה!

מתכנתי Python ישפרו את כישורי מדעי המחשב שלהם עם ה-one-liners השימושיים הללו.

Python One-Liner

Python One-Liner ילמד אותך איך לקרוא ולכתוב "one-liners": הצהרות תמציתית של פונקציונליות שימושית ארוזות בשורה אחת של קוד. תלמד כיצד לפרוק ולהבין באופן שיטתי כל שורה של קוד Python, ולכתוב Python רהוט, דחוס בעוצמה כמו מומחה.

חמשת הפרקים של הספר מכסים (1) טיפים וטריקים, (2) ביטויים רגולריים, (3) למידת מכונה, (4) נושאי ליבה של מדעי הנתונים ו- (5) אלגוריתמים שימושיים.

הסברים מפורטים של one-liners מציגים מושגי מפתח במדעי המחשב ו להגביר את כישורי הקידוד והניתוח שלך. תלמד על תכונות מתקדמות של Python כגון הבנת רשימה, פִּלוּחַ, פונקציות למבדה, ביטויים רגולריים, מַפָּה ו לְהַפחִית פונקציות, ו מטלות פרוסות.

תלמד גם כיצד:

  • למנף מבני נתונים כדי לפתור בעיות בעולם האמיתיכמו שימוש באינדקס בוליאני כדי למצוא ערים עם זיהום מעל הממוצע
  • להשתמש יסודות NumPy כמו מַעֲרָך, צוּרָה, צִיר, סוּג, שידור, אינדקס מתקדם, פִּלוּחַ, מִיוּן, מחפש, מצטברו סטָטִיסטִיקָה
  • חשב בסיסי סטָטִיסטִיקָה של מערכי נתונים רב מימדיים ואלגוריתמי K-Means ללמידה ללא פיקוח
  • צור עוד ביטויים רגולריים מתקדמים באמצעות הַקבָּצָה ו קבוצות בשם, מבטים שליליים, דמויות שנמלטו, רווחים לבנים, ערכות תוויםקבוצות תווים שליליות), ו מפעילים חמדנים/לא חמדנים
  • להבין מגוון רחב של נושאים במדעי המחשבכולל אנגרמות, פלינדרומים, ערכות על, תמורות, מפעלים, מספרים ראשוניים, פיבונאצ'י מספרים, ערפול, מחפשו מיון אלגוריתמי

בסוף הספר תדע איך לעשות זאת לכתוב Python בצורה המעודנת ביותרוליצור חלקים תמציתיים ויפים של "אמנות פייתון" בשורה אחת בלבד.

קבל את Python One-Liner שלך באמזון!!



קישור לכתבת המקור – 2024-02-07 21:40:02

Facebook
Twitter
LinkedIn
Telegram
WhatsApp
Email
פרסומת
תכנון תשתיות רפואיות

עוד מתחומי האתר