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

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

במחשב יש מספר זיכרונות. זיכרון זה בעצם המון תאים שמאפשרים לאחסן מידע. התאים האלו הם כמו דליים שיכולים לאחסן ערכים. כמו שאמרתי קודם הערכים האלה יכולים להיות או 0 או 1 או במילים אחרות או במצב כבוי (0) או במצב דלוק (1). הם נקראים ביטים. כדי להגיד למחשב לעשות משהו אנחנו צריכים לתת לו ערכים להכניס בביטים הללו. הבעיה היא שלבני האדם קשה לחשוב במושגים של 0 ו-1 ולכן היו צריכים דרך יותר פשוטה לייצג מידע. הדרך הזו היא אסמבלי (assembly). זו שפת תכנות היא אומרת למחשב מה הוא צריך לעשות כמו ה-0 וה-1 אבל בדרך הרבה יותר פשוטה לבני האדם להבין. אבל למרות הפשטות של אסמבלי ביחס לבסיס הבינארי היא גם לא כל כך מובנת לבני אדם. לכן המציאו שפות גבוהות יותר. השפות הללו שונות מאוד מאסמבלי. הן הרבה יותר פשוטות לבני האדם להבין והרבה פעמים הם ממש כמו שפה רגילה. יתרון נוסף לשפות הללו הוא שהן לא שפות שנותנות פקודות למחשב (למעבד) באופן ישיר כיוון שהוא לא יבין אותן. אלא הקוד שנכתב עובר תהליך שנקרא הידור שנעשה ע"י תוכנה אחרת שלוקחת את הקוד וממירה אותו לשפה שהמחשב יכול להבין השפה הבינארית. היום כמעט כל התוכנות שאתם מכירים נכתבו בעזרת השפות הגבוהות ואין כמעט אנשים "שמלכלכים" את ידיהם עם אסמבלי. חוץ מאנשים שיוצרים מערכות הפעלה אולי.
במאמר הזה אני הולך להסביר מושגים בסיסים שיש ברוב שפות התכנות המודרניות. כמו שאמרתי הקוד שאני אכתוב הוא קוד פסאודו (קוד להמחשה) לכן אי אפשר לעשות איתו הרבה הוא רק להמחשה.

אחד המושגים הבסיסיים ביותר בתכנות הוא המשתנה. משתנה הוא בדיוק כמו המשתנה שלמדתם עליו בשיעורי אלגברה. המשתנים הם בעצם מספר תווים שאתם בוחרים שאמורים לייצג משהו אחר. אפשר לדמיין אותם בתור קופסאות שיש עליהן תווית. התווית לא חשובה אתם יכולים לקרוא לקופסא איך שתרצו אבל כל פעם שתרצו את מה שיש בתוך הקופסא אתם תצטרכו להשתמש בשם שלה בשביל לקרוא לה. הנה דוגמא יש לכם קופסא שבתוכה יש חיטה השם שלה הוא "קופסא ראשונה" וקופסא נוספת שבה יש מלח והשם שלה הוא "קופסא עם מלח". כל פעם שתרצו מלח אתם פשוט תכתבו "קופסא עם מלח" בשביל לקבל מלח. משתנים הם אותו הדבר הנה משתנה לדוגמא:
five = 5
יצרתי עכשיו קופסא חדשה או משתנה חדש שקוראים לו five ובתוכו יש את המספר 5. עכשיו כל פעם שאני ארצה את המספר חמש אני פשוט אכתוב את השם של הקופסא שמכילה את המספר הזה, במקרה שלנו זה המילה five. בוא נראה למה זה יכול לשמש:
x = 4
יצרתי קופסא חדשה שנקראית x בתוכה יש את המספר 4.
y = 7
יצרתי קופסא חדשה שנקראית y בתוכה יש את המספר 7.
עכשיו אם אני ארצה למשל להוסיף את שני הקופסאות הללו ביחד ולהשים אותם בקופסא חדשה שקוראים לה sum
sum = x + y
עכשיו בקופסא sum יש לי את המספר 11 כי x (4) + y (7) = 11. פשוט לא? גם אם לא אל תתיאשו [IMG]http://images.***.co.il/smilies2/smile.gif[/IMG].
אז למה זה טוב? זה טוב להרבה דברים למשל אם אתם רוצים לכתוב מספר מאוד ארוך כמו למשל המספר מליון ואתם תצטרכו להשתמש בו מספר פעמים בתוכנה שלכם זה לא יהיה נוח במיוחד לכתוב את זה שוב ושוב. מה שתוכלו לעשות הוא פשוט להכניס אותו למשתנה שיחזיק לכם אותו וכל פעם שתרצו להשתמש בו פשוט תכתבו את השם של המשתנה לדוגמא:
mil = 1000000
נחמד לא זה יכול לחסוך לכם הרבה דברים. אבל עד עכשיו דיברנו על מספרים בתור הערכים שיכנסו במשתנים שלנו. אבל מה עם דברים אחרים הרי יהיה נחמד אם נוכל לאחסן שם טקסט לא? נחשו מה גם זה אפשרי :-). אבל כלל חשוב הטקסט חייב להיות עם גרשיים:
text = "hello world this is me out there" f
עכשיו כל פעם שנרצה לכתוב את המשפט הזו נוכל פשוט לכתוב text ויש לנו את המשפט הזה.

יש סוג נוסף של משתנים שעדיין לא הזכרתי הם נקראים מערכים. מערכים הם בעצם משתנים שמאפשרים להחזיק יותר מערך אחד. מה הכוונה למשל עם נרצה קופסא שתכיל צבעים אז נוכל ליצור משתנה שקוראים לו צבעים ובתוכו יהיו כל מיני ערכים כמו אדום ירוק כחול לבן:
colors = red,blue,green,gray
הדרך שבדרך כלל ניגשים בעזרת לדבר מסוים בתוך המשתנה הזה היא סוגריים מרובעים כמו למשל בדוגמא שלנו colors[blue] d או בעזרת המספר שלו ברשימה הזו. למשל הצבע blue הוא מספר שתיים ברשימה שלנו לכן נכתוב את השם של המשתנה ובסוגריים מרובעים את המיקום שלו colors[2] d.

חלק נוסף בתכנות שהוא מאוד משמעותי וחשוב זה בעצם ביצוע החלטות. בחיי היום יום שלכם אתם מבצעים החלטות אם ללכת לבית ספר בדרך כזו או אחרת אם ללכת לחבר או לשחק במחשב. אם אתם רוצים שהתוכנה שלכם תהיה עם מעט חוכמה אתם תהיו חייבים לתת לה את האפשרות להחליט החלטות מה הכוונה. למשל הנה תוכנה פשוטה שכתובה בקוד פאסודו כלומר קוד לא אמיתי שאמור להמחיש את הרעיון:
רחוב = אלנבי
מספר = 12
1) אם רחוב = אלנבי
2) אז תסע עד הרמזור
3) אם הרמזור אדם
אז תעצור
אם הוא ירוק
אז תסע עד הצומת ותפנה ימינה
אם שלט = רחוב + מספר
תעצור
1) אם רחוב לא = אלנבי
2) אל תצא

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

הכל טוב ויפה ונראה שאפשר לכתוב עם מה שלמדנו עד כה תוכנות די נחמדות אבל זה יהיה קצת קשה כי עדיין מדובר בכלים מאוד בסייסים ליצור איתם תוכנה. דבר אחד שמכונות עושות בצורה טובה מאוד ובני האדם לא כל כך מוצלחים בו הוא לחזור על פעולה מסויימת מספר רב של פעמים. למשל אם נרצה לכתוב תוכנה שמחכה לשעה 8 בשביל לכתוב "בוקר אור!". נוכל לעשות את זה בצורה הבאה:
זמן = זמן נוכחי
אם זמן = 08:00
תכתוב בוקר אור!
אם זמן לא = 08:00
תבדוק זמן
אם זמן = 08:00
תכתוב בוקר טוב!
אם זמן לא = 08:00
תבדוק זמן...
זה יכול להיות מעצבן לכתוב את זה בלי הפסקה עד שנכסה את כל שעות היממה. אז בשביל זה המציאו דבר שנקרא לולאות. מה שלולאות עושות זה פשוט עושות את אותו קטע קוד מספר רב של פעמים עד שהתנאי שלהם להתקיימות נפסק. למשל בדוגמא שלנו:
זמן = זמן נוכחי
כל עוד זמן לא = 08:00
תבדוק זמן
אם זמן = 08:00
תכתוב בוקר אור!
פשוט ויפה לא? עד פה למדתם כבר מה זה משתנים תנאים לולאות ומערכים. באופן תאורטי אפשר ליישם איתם כל תוכנה שתרצו. אבל זה לא נוח במיוחד לקרוא את זה. כי הרי רוב הקוד שתכתבו יהיה קצת יותר מאשר חמש שורות. ודבר חשוב בתכנות הוא קוד קריא. לכן יש דבר שנקרא פונקציות. פונקציות הם פשוט בלוקים של קוד שמקלים על החיים שלכם. למשל הנה תוכנה פשוטה שכותבת שורה חדשה למסך:
תכתוב כלום

כל פעם שנרצה לעשות שורה אנחנו נצטרך לכתוב את הקוד הזה למשל שלוש שורות חדשות:
תכתוב כלום
תכתוב כלום
תכתוב כלום
אבל אם נשתמש בפונקציות אנחנו יכולים להקל על חיינו בהרבה כי נוכל פשוט להכניס את השלוש שורות החדשות לפונקציה וכל פעם שנרצה שלוש שורות פשוט נכתוב את הפונקציה:
פונקציה שלוש_שורות() {
תכתוב כלום
תכתוב כלום
תכתוב כלום
}
אין מה להיבהל אין כאן שום דבר מסובך. אנחנו כותבים פונקציה בשביל להכריז המילה הבאה הולכת להיות פונקציה. אנחנו קראנו לפונציה שלנו שלוש_שורות() הוספנו את ה-() בסוף בשביל לסמן שזו פונקציה. ואז כתבנו { בשביל להראות שמפה כל מה שאנחנו כותבים זה הפונקציה שלנו. ובסוף כתבנו } בשביל להגיד סיימנו את הפונקציה שלנו. עכשיו אנחנו יכולים לכתוב לנו תוכנה נחמדה:
ברכה = "בוקר אור"
תכתוב ברכה + "אבי"
שלוש_שורות()
תכתוב "שלום לך רציתי לשאול אותך מה קורה איתך? זמן רב לא דיברנו."
התוכנה הזו תעשה משהו כזה:
בוקר אור אבי



שלום לך רציתי לשאול אותך מה קורה איתך? זמן רב לא דיברנו.

פונקציות יכולות לקבל גם ערכים שעל פי יקרא משהו הערכים האלה הם משתנים פשוטים למשל:
פונקציה חיבור(משתנה) {
משתנה + משתנה
}

הפונציה הזו מכילה משתנה בין הסוגריים ואת המשתנה הזה היא מחברת לעצמו. כך שאם נקרא לפונקציה הזו עם הערך 2 למשל:
חיבור(2)
היא תחזיר לנו את הערך 4 כי 2+2 שווה 4.
התוכנות שכתבנו עד עכשיו היו פשוטות ונחמדות אבל אם נשלב את כל האלמנטים שלמדנו עד עכשיו נוכל להגיע לתוכנות מתקדמות מאוד. אז הנה תוכנה קצת יותר מתקדמת שמשלבת את כל האלמנטים שלמדנו עד עכשיו אני כבר מזהיר היא מעט מסובכת ואם לא הבנתם אני מציע שתחזרו על הנושאים פה.
התוכנה הזו הולכת לחשב את המחיר של מספר מוצרים:
קמח = 5
מים = 10
יוגורט = 7
חלב = 12
שום = 4
פונקציה חישוב(מוצר,כמות) {
מחיר = מוצר * כמות
}
מוצרים = מה שבחר הקונה
חישוב(מוצרים,כמות)

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

אחרי קריאת המאמר הזה אתם לא מתכנתים אבל אם תחליטו להמשיך וללמוד תכנות אני חושב שהמאמר הזה יכול לעזור לכם. כי אתם תבינו מושגים שאולי לא תצליחו להבין אחרת אני מקווה שעזרתי לפחות לחלקכם [IMG]http://images.***.co.il/smilies2/smile.gif[/IMG].

הקוד האחרון בדוגמאות שלנו בשפה שנקראית פיתון אני מציע לכם לקרוא את זה אבל זה כן יכול להיות מעט מסובך לכן אם יש חלקים לא מובנים זה בסדר גמור עד עכשיו למדנו רק את הבסיס והמשותף לכל שפות התכנות אבל יש דברים רבים נוספים שיש לכל שפת תכנות שלא דיברנו עליהן ואת זה תצטרכו ללמוד אז הנה הקוד:
flour = 5
water = 10
yogurt = 7
milk = 12
garlic = 4
def count(product,amount):
price = product * amount
return price
products = input("Enter products: ")
amount = raw_input("Enter amount: ")
count(products,int(amount))

קרדיט ל- smart_people_know_when_to