מבוא

1.1 הנדסת מחשבים ואתגרים חישוביים

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

1.2 משימות חישוביות פשוטות

לא מתחילים בקוד, אלא בשלוש שאלות: מה הנתון? מה הדרוש? מהם הצעדים שמובילים מן הנתון אל הדרוש? התשובה לשתי השאלות הראשונות היא ניתוח המשימה, והתשובה לשלישית היא ניסוח הפתרון.

לאותה משימה יכול להיות יותר מאלגוריתם נכון אחד, ויש טובים מאחרים.

1.3 שפת תכנות

המעבד מבין רק פקודות פשוטות מאוד, כתובות באפסים ואחדות, ואנחנו לא יכולים לכתוב כך תוכניות ארוכות. גם עברית וערבית אינן מתאימות, כי משפט בהן יכול להתפרש ביותר ממובן אחד. שפת תכנות היא הפשרה ביניהן.

בספר הזה נכתוב בשפת פייתון Python. תוכנית שנקראת מפרש קוראת את מה שכתבנו, בודקת תחילה שהכתיבה תקינה, ואז מבצעת את הפקודות אחת אחרי השנייה:

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

1.4 התוכנית: קריאה, כתיבה, הרצה, בדיקה ותיקון

העבודה על תוכנית אינה כתיבה חד-פעמית, אלא מעגל שחוזרים עליו עד שהיא נכונה. לעתים רחוקות תוכנית פועלת נכון כבר בפעם הראשונה, וזה רגיל:

קריאה. קוראים את התוכנית מלמעלה למטה, ומשערים מה היא תעשה לפני שמריצים אותה. הפקודה print מדפיסה על המסך את מה שבין הסוגריים. שורה שמתחילה בסימן # היא הערה: כתבנו אותה בשביל הקורא, והמפרש מתעלם ממנה. והסדר הוא התוכנית: אותן פקודות בסדר אחר נותנות פלט אחר.

print("Sensor test")
print("Reading:", 25)
# the next line runs last
print("Done")

Sensor test
Reading: 25
Done

print("Done")
print("Sensor test")
print("Reading:", 25)

Done
Sensor test
Reading: 25

כתיבה. כותבים פקודה אחת בכל שורה, ושומרים את התוכנית בקובץ שסיומת שמו .py.

print("Start")
    print("End")

IndentationError: unexpected indent

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

print("Battery check")
print("Voltage: 9 V)

SyntaxError: unterminated string literal (detected at line 2)

print("Battery check")
Print("Voltage: 9 V")

Battery check
NameError: name 'Print' is not defined

print("Battery check")
print("Voltage: 9 V")
print("Current:", 9 / 100 + 200, "A")

Battery check
Voltage: 9 V
Current: 200.09 A

print("Battery check")
print("Voltage: 9 V")
print("Current:", 9 / (100 + 200), "A")

Battery check
Voltage: 9 V
Current: 0.03 A

print("A")
print()
print("B", "C")
print(2 + 3)
print("2 + 3")

1.5 סביבת הפיתוח ותוכנית ראשונה

תכנית הלימודים ממליצה להכיר שתי סביבות: סביבה מקוונת, וסביבה שמתקינים על המחשב. כאן נכיר את Google Colab ואת IDLE. יש סביבות נוספות כמו Visual Studio Code ו-PyCharm, ואותה תוכנית רצה בכולן.

התוכנית הראשונה שלנו היא שורה אחת. הפקודה print מדפיסה את מה שבין הסוגריים, ועוברת לשורה הבאה. טקסט בין מירכאות מודפס אות באות. ואם אין כלום בין הסוגריים, מודפסת שורה ריקה, כמו בתוכנית השנייה:

print("Hello from the lab")

Hello from the lab

print("Measuring station")
print("Power on")
print()
print("Ready")

Measuring station
Power on

Ready

מה שבין המירכאות מודפס כמו שהוא, ומה שאינו ביניהן מחושב תחילה. וכשמפרידים בין ערכים בפסיק, print מדפיסה אותם באותה שורה עם רווח ביניהם.

print("7 * 6")
print(7 * 6)
print("Seconds:", 24 * 60 * 60)

7 * 6
42
Seconds: 86400

print(“Power on”)

SyntaxError: invalid character '“' (U+201C)

1.6 העצם כמופע של מחלקה

פותחים את ארון המעבדה ומוצאים שנים-עשר רבי-מודדים מאותו דגם. לכולם אותם לחצנים ואותן יכולות, כי הם יוצרו לפי תכנון אחד. אבל כל רב-מודד הוא דבר נפרד: זה בתחום 20 V וקורא 11.9, וההוא כבוי.

מה שהעצם נושא נקרא תכונות, ומה שהוא יכול לעשות נקרא פעולות. העצמים חולקים את שמות התכונות ואת הפעולות, אבל ערכי התכונות הם של כל עצם לעצמו:

1.7 מחלקה קיימת: Turtle

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

חלון Turtle הוא מישור דו-ממדי עם שני צירים. הנקודה (0, 0) באמצע החלון, x גדל ימינה, ו-y גדל למעלה. כל נקודה נכתבת (x, y), ו-x תמיד ראשון. העצם נולד ב-(0, 0) וכיוונו ימינה. הפקודות forward ו-backward מזיזות אותו בכיוונו הנוכחי, והפקודות right ו-left מסובבות אותו במקומו, במעלות.

תוכנית Turtle ראשונה:

import turtle
pen = turtle.Turtle()
pen.forward(100)
print(pen.position())
turtle.done()

(100.00,0.00)

• import turtle מביאה את המודול המוכן, וכותבים אותה פעם אחת בתחילת התוכנית.
• pen = turtle.Turtle() יוצרת עצם חדש מן המחלקה Turtle, ונותנת לו את השם pen. את השם אנחנו בוחרים. turtle באות קטנה היא המודול, ו-Turtle באות גדולה היא המחלקה שבתוכו.
• ב-pen.forward(100) אנחנו נותנים לעצם פקודה: שם העצם, נקודה, שם הפעולה, ובין הסוגריים מה שהיא צריכה. כאן העצם מתקדם 100 צעדים.
• ב-print(pen.position()) אנחנו שואלים את העצם איפה הוא, ומדפיסים את התשובה.
• turtle.done() משאירה את החלון פתוח עד שנסגור אותו. בלעדיה החלון עלול להיסגר, בחלק מן הסביבות, מיד כשהתוכנית מסתיימת, ולא נספיק לראות את הציור.

תנועה וסיבוב:

הסיבוב עצמו אינו מצייר דבר ואינו משנה את המיקום: left משנה רק את הכיוון, וההתקדמות אחריה היא בכיוון החדש. והפקודה backward מחזירה את העצם לאחור על אותו קו בלי להסתובב, ולכן החץ נשאר מכוון למעלה:

import turtle
pen = turtle.Turtle()
pen.forward(100)
pen.left(90)
pen.forward(50)
pen.backward(20)
print(pen.position())
turtle.done()

(100.00,30.00)

import turtle
pen = turtle.Turtle()
pen.forward(100)
pen.right(90)
pen.forward(100)
pen.right(90)
pen.forward(100)
pen.right(90)
pen.forward(100)
pen.right(90)
turtle.done()

הרמת העט וצבע:

הפקודה penup מרימה את העט, והעצם זז אחריה בלי לצייר, והפקודה pendown מחזירה אותו לדף. יש להן שמות קצרים יותר: up ו-down. הפקודה color משנה את צבע העט, ושם הצבע הוא טקסט באנגלית בין מירכאות, והוא חל על כל מה שמצויר אחריה. נצייר בעזרתן סרגל בשני צבעים:

import turtle
pen = turtle.Turtle()
pen.color("green")
pen.forward(80)
pen.penup()
pen.forward(15)
pen.pendown()
pen.color("red")
pen.forward(40)
pen.up()
pen.forward(15)
pen.down()
pen.forward(40)
turtle.done()

מעבר לנקודה:

הפקודה goto(x, y) מעבירה את העצם ישירות לנקודה (x, y) בקו ישר, בלי לשנות את כיוונו. היא נוחה כשהקואורדינטות ידועות, כי אין צורך לחשב שום זווית:

import turtle
pen = turtle.Turtle()
pen.goto(50, 50)
pen.goto(100, 0)
pen.goto(150, 50)
pen.goto(200, 0)
print(pen.position())
turtle.done()

(200.00,0.00)

import turtle
pen = turtle.Turtle()
pen.forward(50)
pen.left(90)
pen.forward(30)
pen.backward(10)
print(pen.position())
turtle.done()

1.8 קריאת ממשק פשוט של מחלקה

כדי להשתמש ברב-מודד לא צריך לדעת מה יש בתוכו. מספיק להכיר את הלחצנים ואת השקעים. וכך גם במחלקה מוכנה.

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

קוראים כל שורה בשלוש שאלות. כמה פרמטרים הפעולה צריכה? מאיזה סוג? והאם היא עושה משהו או מחזירה ערך? הפעולה forward מזיזה את העצם ואינה מחזירה לנו דבר. הפעולה position אינה מזיזה דבר, אלא מחזירה ערך, ואם לא נשתמש בו הוא אובד. לכן השורה הרביעית בתוכנית הראשונה שלמטה אינה מדפיסה דבר, ומי שמדפיסה היא החמישית.

import turtle
pen = turtle.Turtle()
pen.forward(80)
pen.position()
print(pen.position())
turtle.done()

(80.00,0.00)

import turtle
pen = turtle.Turtle()
pen.forward
print(pen.position())
turtle.done()

(0.00,0.00)

שם ששונה באות אחת, או ערך מסוג אחר שמעבירים לפרמטר, עוצרים את התוכנית. הפעולה מבקשת מספר, והטקסט "100" אינו מספר, ולכן הודעת השגיאה השנייה נפתחת במילה TypeError, כלומר שגיאה בסוג הערך, והמשכה מתאר את החישוב הפנימי שנכשל:

import turtle
pen = turtle.Turtle()
pen.Forward(100)

AttributeError: 'Turtle' object has no attribute 'Forward'. Did you mean: 'forward'?

import turtle
pen = turtle.Turtle()
pen.forward("100")

TypeError: can't multiply sequence by non-int of type 'float'

התועלת האמיתית בקריאת הממשק היא שאפשר להשתמש בפעולה שלא ראינו מעולם. הנה פעולות נוספות מאותו ממשק:

import turtle
pen = turtle.Turtle()
pen.pensize(2)
pen.circle(40)
pen.up()
pen.goto(-28, 12)
pen.down()
pen.goto(28, 68)
pen.up()
pen.goto(-28, 68)
pen.down()
pen.goto(28, 12)
pen.up()
pen.goto(50, 30)
pen.write("Lamp")
pen.hideturtle()
turtle.done()

1.9 יצירת עצמים חדשים

בכל פעם שמזמנים את turtle.Turtle() נולד מופע חדש. לכל עצם המיקום, הכיוון והצבע שלו, ופקודה שניתנת לעצם אחד אינה משפיעה על אחרים. שם העצם שלפני הנקודה קובע מי מבצע:

import turtle
pen_a = turtle.Turtle()
pen_b = turtle.Turtle()
pen_a.color("red")
pen_b.color("blue")
pen_a.forward(100)
pen_b.left(90)
pen_b.forward(60)
print(pen_a.position())
print(pen_b.position())
turtle.done()

(100.00,0.00)
(0.00,60.00)

import turtle
clock = turtle.Turtle()
clock.color("blue")
clock.up()
clock.goto(4, 68)
clock.write("CLK")
clock.goto(0, 60)
clock.down()
clock.goto(0, 90)
clock.goto(40, 90)
clock.goto(40, 60)
clock.goto(80, 60)
clock.goto(80, 90)
clock.goto(120, 90)
clock.goto(120, 60)
clock.goto(160, 60)
clock.hideturtle()
data = turtle.Turtle()
data.color("red")
data.up()
data.goto(4, 6)
data.write("DATA")
data.goto(0, 0)
data.down()
data.goto(80, 0)
data.goto(80, 30)
data.goto(160, 30)
data.hideturtle()
turtle.done()

import turtle
pen_a = turtle.Turtle()
pen_b = pen_a
pen_a.forward(100)
pen_b.left(90)
pen_b.forward(50)
print(pen_a.position())
print(pen_b.position())
turtle.done()

(100.00,50.00)
(100.00,50.00)

import turtle
pen_a = turtle.Turtle()
pen_b = turtle.Turtle()
pen_a.goto(40, 40)
pen_b.backward(30)
pen_a.forward(10)
print(pen_a.position())
print(pen_b.position())
turtle.done()

import turtle

panel = turtle.Turtle()
panel.color("blue")
panel.pensize(2)
panel.up()
panel.goto(-200, 125)
panel.write("PANEL")
panel.goto(-200, 60)
panel.down()
panel.goto(-100, 60)
panel.goto(-100, 120)
panel.goto(-200, 120)
panel.goto(-200, 60)
panel.up()
panel.goto(-150, 60)
panel.down()
panel.goto(-150, 120)
panel.hideturtle()

wire = turtle.Turtle()
wire.up()
wire.goto(-100, 90)
wire.down()
wire.goto(120, 90)
wire.up()
wire.goto(-150, 60)
wire.down()
wire.goto(-150, -30)
wire.goto(150, -30)
wire.goto(150, 60)
wire.up()
wire.goto(0, 90)
wire.dot(8)
wire.down()
wire.goto(0, 35)
wire.up()
wire.goto(0, -30)
wire.dot(8)
wire.down()
wire.goto(0, 25)
wire.hideturtle()

cell = turtle.Turtle()
cell.color("red")
cell.pensize(3)
cell.up()
cell.goto(-25, 35)
cell.down()
cell.goto(25, 35)
cell.up()
cell.goto(-12, 25)
cell.down()
cell.goto(12, 25)
cell.up()
cell.goto(32, 24)
cell.write("BATTERY")
cell.hideturtle()

gauge = turtle.Turtle()
gauge.color("green")
gauge.pensize(2)
gauge.up()
gauge.goto(150, 60)
gauge.down()
gauge.circle(30)
gauge.up()
gauge.goto(150, 90)
gauge.down()
gauge.goto(168, 110)
gauge.up()
gauge.goto(125, 126)
gauge.write("GAUGE")
gauge.hideturtle()

turtle.done()

עיקרי הפרק:

• המחשב מבצע פקודות פשוטות במהירות עצומה ובלי הבנה, והחשיבה על הפתרון עלינו.
• מנתחים את המשימה לפני הקוד: הנתון, הדרוש, ואז צעדים שאינם משתמעים לשני פנים.
• העבודה על תוכנית היא מעגל: כתיבה, הרצה, בדיקה ותיקון. תוכנית שאינה מתלוננת אינה בהכרח נכונה.
• מחלקה היא תיאור כללי, ועצם הוא מופע מסוים שלה עם ערכי תכונות משלו.
• הממשק אומר לנו איך להשתמש במחלקה בלי לדעת מה יש בתוכה.
• כל זימון של turtle.Turtle() יוצר עצם חדש ועצמאי.

סיכום פקודות הפרק:

מילון מונחים:

print("Solar panel")
print("Battery")
print("Gauge")

שאלות לתרגול:

print("9 * 9")
print(9 * 9)
print()
print("Done", 9 + 9)

Print("Lab 3")
print("Voltage: 5 V)
    print("End")

print("Lab 3")
print("Voltage: 5 V")
print("End")

import turtle
pen = turtle.Turtle()
pen.forward(80)
pen.left(90)
pen.forward(40)
pen.right(90)
pen.forward(80)
pen.right(90)
pen.forward(40)
print(pen.position())
turtle.done()

import turtle
pen = turtle.Turtle()
pen.forward(120)
pen.left(90)
pen.forward(60)
pen.left(90)
pen.forward(120)
pen.left(90)
pen.forward(60)
turtle.done()

import turtle
pen = turtle.Turtle()
pen.left(90)
pen.forward(30)
pen.up()
pen.forward(20)
pen.down()
pen.forward(30)
pen.up()
pen.forward(20)
pen.down()
pen.forward(30)
print(pen.position())
turtle.done()

import turtle
pen = turtle.Turtle()
pen.up()
pen.dot(30, "red")
pen.forward(50)
pen.dot(30, "orange")
pen.forward(50)
pen.dot(30, "green")
pen.hideturtle()
turtle.done()

import turtle
plus = turtle.Turtle()
minus = turtle.Turtle()
plus.color("red")
minus.color("black")
plus.up()
plus.goto(0, 40)
plus.down()
plus.goto(120, 40)
plus.goto(120, 25)
minus.goto(120, 0)
minus.goto(120, 15)
print(plus.position())
print(minus.position())
turtle.done()

import turtle
pen = turtle.Turtle()
pen.pensize(4)
pen.up()
pen.goto(0, 100)
pen.down()
pen.goto(50, 100)
pen.goto(50, 50)
pen.goto(0, 50)
pen.goto(0, 0)
pen.goto(50, 0)
pen.hideturtle()
turtle.done()

import turtle
pen = turtle.Turtle()
pen.forward(60)
pen.left(60)
pen.forward(60)
pen.left(60)
pen.forward(60)
pen.left(60)
pen.forward(60)
pen.left(60)
pen.forward(60)
pen.left(60)
pen.forward(60)
pen.left(60)
turtle.done()