ROSS RHEINGANS-YOO: היי, אני רוס.
וזה סמינר CS50.
זה ייקח לך מתכנות ב- C לתכנות בפייתון.
>> פייתון היא שפת scripting.
זה במידה רבה כמו C בתחביר, למרות שחלקם
של הפרטים הטכניים של איך תחביר שמקבל להורג
הם מעט שונים.
זה פחות חזק מאשר C במובנים מסוימים.
זה פחות הבעה ל איפה בדיוק במחשב שלך
זיכרון מקבל ערוך, איך זה מקבל ערוך,
כאשר הוא מקבל חופש, ו אלה מיני דברים.
>> זה שימושי יותר מאשר C במובנים מסוימים, כי זה יותר קל לתכנת ב.
השפה היא, לכמה אנשים, אינטואיטיבי יותר.
ובאמת, המטרה היא ל שזה יהיה מהר יותר לתכנת
ואולי איטי יותר לביצוע.
>> עכשיו, אם אתה חושב על את משך זמן
אתה בילה על המשפחה שלך כתיבה להגדיר בעיה
הקוד שלך נגד כמות הזמן שאתם מבלים
על הבעיה האחרונה שלך להגדיר ביצוע הקוד שלך,
היית מתאר לעצמי שאת השפה אשר היה במהירות כפולה כדי לכתוב,
ופעמים כאיטיות לביצוע, אולי להיות שיפור לעומת C במובנים מסוימים.
בוודאי כשאתה מנסה לכתוב תוכניות קטנות לעשות דברים קטנים,
פייתון היא שפה שימושית של בחירה.
>> ובסופו של זה סמינר, אני מקווה שאתה תמצאו
להיות מסוגל לעשות בחירה בפרויקטים עתידיים
על איזו שפה היא נכון לשימוש לא הרעיון,
ששפה אחת היא יותר לתקן כל הזמן.
כמה דברים על מה הוא הסמינר.
סמינר זה אינו מיועד ל ללמד אותך פייתון מאפס.
פייתון היא דומה מאוד ל- C, ואני מניח ש
כי אתה סטודנט CS50, או מישהו עם היכרות דומה עם ג
>> אם אתה סטודנט CS50 סביב בעיה להגדיר 6,
כך שיש לך לראות הרבה דברים בC, אני אתן לך
ההבדלים העיקריים, וחלק מהדברים
שהופך את פייתון שונה ומיוחד ושימושי,
אבל אני לא מתכוון ללכת ל מה היא שפת תכנות
ואיך לכתוב תוכניות.
עם זאת, סמינר זה ילמד לך לכתוב תוכניות פייתון
אם אתה אחד מכמה קבוצות אלה.
שוב אנו מסתכלים איך היית ליישם psets--
שצריך להיות 1-6 ב Python-- ומצביעים לספק
לתיעוד רשמי לעיון בעתיד.
הדבר השני שחשוב על איך לדבר זה מוקצה,
וידאו זה יהיה באינטרנט, באדיבות CS50,
כך שאתה לא צריך להרגיש כמו אתה צריך לקחת את הערות.
אתה תמיד יכול לחזור ולהסתכל על זה מאוחר יותר כנקודת התייחסות.
בנוסף השקופיות זמינים עכשיו
באתר זה, שאמור אקח לך לעשות doc גוגל.
זוהי גרסה מעט מקוצרת ממה שאני מראה על המסך.
>> אזהרה זהירה לפני אנחנו קופצים ב, Python 3
היא בשפה שונה מפייתון 2.
הם נראים הרבה זהים; יש הבדלים טכניים קלים מאוד
שיגרום תוכניות נכתב בפייתון 2
לא להיות מסוגל להיות מוצאים להורג בסביבת Python 3.
>> המכשיר מגיע עם CS50 פייטון, כברירת מחדל הוא משתמש בפייתון 2.
אתה יכול לבדוק זאת על ידי הקלדה בשורת הפקודה שלך
--version פיתון, שאמור פלט 2.7.6 על המכשיר הנוכחי.
נסה פייתון 3, אשר עושה עובד במכשיר,
אם ברירת מחדל של פייתון ל2.X.Y, או על המכשיר או על המכונות שלך.
אתה צריך להחליף את פייטון 3 בכל עת בהרצאה זו שאני כותב פייתון.
אם המחשב שלך הוא ריצת 2 כברירת מחדל, סוג
פייטון 3 כדי להיות מסוגל למעשה פעל יחד ולבצע את הדברים האלה.
>> בנוסף, אני אצביע לך במשאבים רשמיים עכשיו.
docs.python.org/3-- זהיר שזה 3 ולא 2--
יש אזכור שימושי.
ההדרכה תיקח אתכם דרך הרבה מאותם הדברים
שאני עושה עכשיו, אלא בצורת טקסט.
ההתייחסות היא שימושית כ התייחסות לשפה,
והספרייה רגילה נותנת אתה חלק מההרחבות
עם פונקציונליות נוספת.
>> אז תכנית פייתון הראשונה.
בצד השמאל יש לנו C סטנדרטי, בצד הימין, יש לנו פייתון.
ייתכן שהוכרת בעיה זו, זה
אחד מהבעיה הראשונה סטים בCS50, ואלה
לפתור אותה באמצעות אותו הפתרון.
עכשיו, הסיבה שאנחנו מסתכל על הצד אלה על ידי צד
הוא כל כך שאנחנו יכולים להסתכל ב הבדלים תחביריים.
אחד הפילים בחדר שאולי שמת לב תקין
את הבת, הוא שאין פייתון עטיפת פונקציה העיקרית סביב הקוד.
אז ב- C, אתה כותב חבורה של קבצים, אתה מקשר אותם יחד,
והתכנית מתחילה ביצוע בדבר הזה שנקרא עיקרי int.
>> בפייתון, אתה כותב להגיש לך, להפעיל את הקובץ,
התכנית מתחילה ביצוע בחלק העליון של הקובץ.
אז זה הולך להתחיל בחלק העליון של קובץ
לרדת עד שימצא משהו אחר.
אם הוא מוצא הגדרת תפקיד, זה לא ממש לבצע קוד ש,
זה יהיה פשוט להגדיר את הפונקציה.
אבל כאן, כאשר הראשון תכנית היא n שווה 10,
הדבר הראשון שתכנית זו יעשה הוא לקחת ערך זה של 10
ולהגדיר אותו לתוך משתנה בשם n.
>> אם כבר מדברים על קו ש, אחד מ אחר things-- sorry-- זה
משמעות הדבר היא שתוכניות C, אתה כותב אותם,
תוכל לעשות אותם, שיהיה להפעיל פקודות מסוימות צלצול,
ואז אתה רץ וכתוצאה מכך הפעלה.
תוכניות פייתון, אתה מפעיל את אולי טקסט file-- mario.py זה
להיות בקובץ זה כי אני פשוט הראיתי אתם-- תוכל לרוץ קובץ ש
ואתה לבצע, ואת התוכן שלו
יבוצע על ידי מתורגמן פייתון.
אתה יכול לעשות את זה בIDE שלך.
>> אז אם יש לי קובץ שלום, שפשוט יש את זה תוכן.
זהו למעשה פייתון 2, לא פייתון 3, ולכן לא
לדאוג תחביר לעת עתה.
אבל אני ארוץ פייתון, ב hello.py, והיא פועלת.
>> דרך נוספת שאני יכול להשתמש בפייתון ש אני לא אעסוק בכל כך הרבה בדיבורים,
הוא אם אני פשוט להקליד פייתון, זה טיפות לסביבה שבה לי
אני יכול להאכיל אותו קו פייתון על ידי קו.
אז הנה, אם אני מקליד ב שטח הדפסה "שלום, עולם".
הקלד להיכנס.
זה לירוק לי שיגבה את התוצאות כי קו בודד באופן מיידי.
>> זה עשוי להיות שימושי.
בהרצאה זו אני אעשה דברים בשקופיות.
וכך תוכל לעקוב לאורך או לכאן, או על ידי כתיבה
קבצים ולאחר מכן ביצוע בפועל.
>> אבל, חוזר לזה קוד, עוד דבר
שאולי יש לך noticed-- גם, יש
שני דברים שאתה עלול הודעה על בלוקים אלה.
הראשון, ולא יותר ארצי, הוא ש יש פייתון לא פסיק נגרר.
>> פסיק הם אופציונליים בכל מקום ובלתי מזיק בכל מקום.
אתה יכול להוסיף אותם.
זה עלול לגרום לאנשים שכותבים Python לגיחוך חיים בך
מאחורי הגב שלך, בגלל ש הם לא הכרחיים.
הם לעתים קרובות סימן למוחזק על מג המעצבים של השפה
מרגיש שזה יותר ברור בדרך זו ושזה לא הכרחי להצהיר
כל פעם שאתה בסופו של קו.
>> עוד דבר מוזר בn זה הוא שאין לה סוג מצורף.
אחת יצירות הקסם של Python-- ואני הולך לקרוא לזה קסם,
אבל יש מאוד מסיבות טכניות למה זה
works-- אחד חתיכות קסם של פייתון
הוא שמשתנים יכולים להרחיב או לכווץ להכיל כל הנתונים
סוגים שהייתם רוצים שהם.
>> אז זה 10.
אם מאוחר יותר למטה אני הוקצה לכך n 0.5, שזה ייקח ש0.5.
לא משנה שזה int כאן ו לצוף שם, כל דבר שמשתמש n זה
יהיה, פחות או יותר, תוכל לטרטר לאורך אם זה נעשה באחת מאלה.
אלא אם כן יש כמה אמיתי מאוד סיבה למה זה לא יכול להשתמש בנתונים
הקלד שn כיום, ובשלב זה יקבל
תקוע ולזרוק שגיאה, ואלה מיני דברים.
>> אבל כאן, Python לא ממש אכפת לי מה
זה שאני הולך לתקוע בזה משפט, כמו, אתה רוצה את הדבר הזה?
דבר זה בזה?
כן, זה סוג של דבר.
אני לתקוע אותו בסופו של הדבר.
זה יהיה בעיה בהמשך, אם מישהו שרוצה להשתמש הסוף ש
לא יכול להתמודד עם זה.
זהו אחד הגדול הבדלים בין פייתון ו- C
זה עושה את זה קל לכתוב תוכניות C גדולות מאוד
והופך אותו קל יותר לכתוב תכנית פייתון קטנה מאוד.
>> לתחביר הוא לא מאוד שונה במה שהוא עושה.
זה קצת שונה באיך זה בא לידי ביטוי.
אז זה מאוד, מה שנקרא נחש ארסי, דרך של כתיבתו.
לשורה בטווח (n), זה הוא טווח מספרים בין 0 ל n,
כולל בתחתית ובלעדי בחלק העליון.
אז זה בין 0 ל n-1, אשר הוא בדיוק מה קוד C עושה,
מלבד זה הרבה יותר קל להסתכל על אולי.
>> הבלוק הרלוונטי הוא לא יצא ידי פלטה,
במקום שזה יצא על ידי כניסה זו.
אז כל קווים אלה ארבעה חללים מעל לימין,
או כמו על רוחב פיל.
ואלה הם אלה ש הולך להיות מוצא להורג בזה ל.
אם אני לבלגן כניסה על זה ואני
לדחוף הדפסה שתחזור ל הכניסה המקורית,
ההדפסה שתשאיר ללולאה.
בניגוד ל- C, שבו אני ממש כאן צריך להעביר שסד סגור מסביב.
>> זה אומר שאתה לא מקבל שגיאות כי לקפוץ החוצה אליך, כי אתה
לשים סד במקום הלא נכון.
זה אומר שאתה מקבל שגיאות כי לקפוץ החוצה אליך, כי אתה
מסוכסך שגוי קו.
אז זה עושה חריצים סופר זהירים.
אני מקווה שאתה היה להיות סופר זהיר עם כניסתך בכל מקרה,
ואז זה לא ש הרבה יותר של נטל.
>> אבל כלל בסיסי לפייתון, ויהיה לנו כמה כאלה
שנלך דרך דרך במהלך השיחה,
הוא מנסה תחביר טבעי לפני מחפש את דבר.
אז תחביר זה, ל מספר זה בטווח,
הוא מאוד ייחודי במונחים של סגנון.
הרבה דברים בפייתון אנחנו תראו לקחת טופס זה.
>> ולכן אם אתה בא עם אובייקט חדש ש
חושב שאתה צריך להיות מסוגל לחזר על זה, במתכונת זו,
מתברר שזה כנראה תומך בפורמט זה.
אנחנו לא הולכים סופר עמוק ב מסיבות הטכניות מדוע זה נכון.
>> אבל זה אינטואיציה שימושית יש כאשר אתה מתקרב תוכניות פייתון,
שהדבר הזה הוא רק הולך לעבודה.
נסה זאת.
לאתחל את שורת הפקודה מתורגמן, לראות אם זה עובד,
הלאה עם דברים, לפני ש אפילו צריך לפתוח את גוגל ואומר,
מה התחביר ל דבר המסוים הזה?
המון פייתון אתה יכול לגלות רק על ידי מנסה.
>> זה אם הוא אפילו יותר דומה ל- C אז fors הם.
שים לב שאין סוגריים.
הסוגריים, שוב, לא מזיק אבל מיותר.
יש מעי גס בסוף בדיוק כמו ללולאות,
ושוב, בלוקים היחסי הם מפורץ ולא יצא ידי פלטה.
אחר זה הוא במקור רמת הזחה,
ומסוכסך הבלוק הרלוונטי שלה שוב.
עבודה אלה בדיוק כפי שהם עושים בג
>> זהו למעשה מאוד דומה.
שוב, הדפסה מאבדת תו אחד הנחה של printf אתה עובר בחוטים.
מתברר מחרוזות גם יכול להיות מסומן מ
על ידי ציטוטים בודדים או מרכאות כפולות.
אין הבדל, מלבד בתוך ש
ציטוטים שאתה יכול להשתמש מרכאות כפולות עם לנטוש,
ולא שיש ל לברוח כולם.
ובתוך מרכאות כפולות, יכול להשתמש בגרשיים בודדים עם לנטוש
מבלי לברוח מהם.
אם אתה רוצה לערבב שלהם, אתה בהחלט יכול
לחפש באינטרנט איך לעשות את זה.
>> תוכל להבחין כי לכאן, אני כבר עברתי בסופו של דבר = הדבר הזה.
זוהי דוגמא של שמירת טענה, שהוא אחד מאותם דברים
שפייתון תומך ש עושה את זה די שימושי.
אז הדפסה בפועל יש הרבה טענות, שהם בדרך כלל
מוגדר כברירת המחדל שלהם ערך, אבל כאן יש לי
החליט לעקוף את אחד נקרא הסוף.
הסיבה שיש לי ל לעקוף אותו עם מחרוזת ריקה
היא הדפסה שבפייתון, על ידי ברירת מחדל, מדפיסה קו חדש
לאחר שהדבר שאמרת לה יותר מדי.
>> אז חשיש זה באמת הולך להדפיס את חשיש בשורה חדשה.
ואם אני לא רוצה חשיש להדפיס קו חדש לאחר ש, אז אני חייב לומר
לא להדפיס אחד.
אבל עדיין, כל כך, הדבר האחרון ש תכנית זו היא חסרה כי יש היא
כוללים בראש.
הדפסה אפויה לפייתון אז בעצם שאין כותרת או מודול
שאתה צריך כולל, אבל אם רציתי
לכלול דברים אחרים בסקריפט פייתון,
אני הייתי עושה את זה בformat-- דומה מאוד המילים הן רק מעט שונות.
>> שהזכרתי לנו ש לא צריך עיקרי כאן,
כי פייתון מתחיל ביצוע בחלק העליון.
אם אני רוצה לעטוף זה בפונקציה, אני
אעשה את זה כמו שאני זה-- הייתי אומר def שם פונקציה,
טיעונים יכולים ללכת לכאן ואנחנו לראות כמה מאותם מאוחר יותר, מעי גס,
ואז שוב, זה בלוק יצא כל
מה הוא מבצעי לחסום לפונקציה ש.
אז זו ההגדרה של הפונקציה.
ויש הצהרה, ואז למטה כאן, אני יכול רק לקרוא את הפונקציה.
ושוב, את התכנית מתורגמן, מתחיל בראש,
יראה את זה הוא ההגדרה.
זה לא לבצע את זה עד ש להגיע לכאן, ואז זה כמו, הו
עכשיו אתה כבר קראת לזה, אני מניח שאני צריך לבצע אותה.
>> דבר שמאוד נפוץ לראות בקבצי פייתון,
במיוחד קבצי פייתון ש הם שוחררו לציבור
ופתחתי by-- ופיתח שמר, הוא משהו מסוג זה.
זה כל כך כי basically-- פייטון, אתה מתחיל בראש
ואז אתה לבצע עד לתחתית, אני אם רק היה לי מריו קראתי כאן,
אז כל פעם שאני כלול בקובץ זה ב קובץ אחר, כי רציתי להשתמש ב
היא פונקצית מריו, שהיית קובץ אחר גם קריאה זו למריו בזה.
וכשרצתי קובץ ש, זה הייתי קורא מריו.
>> אז זה אפשרי שאני רק רוצה להפעיל את זה אם יש לי בעצם
להורג קובץ מסוים זה.
ואז אני יכול לעטוף את זה ב ניב כזה, שבו אני אומר,
אם שמו של ביצוע זה הסביבה היא עיקרי,
אז אני רוצה לעשות את הדברים האלה.
אחרת מישהו אחר יכול use-- כולל function--
הקובץ שלי, ורק כדי לקבל גישה לפונקציות אלה
מבלי להפעיל את הדברים שאני רוצה לבצע בקובץ זה.
שוב זה,, אופציונאלי אבל נפוץ מאוד.
>> דברים אלה הם entirely-- הם בדיוק אותו הדבר בין C ופייתון,
בהחלט ב 3.
אני חושב ב2, מפעיל האגף לפעמים נותן לך בחזרה צף כש
אתה מופעל על ints, וגם אתה רוצה את זה או שאתה לא.
אבל בתוספת, מינוס, ופעמים עובד בדיוק כמו שהיית מצפה,
חוץ מאשר על מעט יותר סוגים.
אז אתה יכול להכפיל צף על ידי ints, ואלה מיני דברים.
>> סט עובד בדיוק אותו הדבר.
אתה יכול להשתמש בשני שלטים שווים.
inequals-- גדול יותר, פחות מ, מיני things-- אלה
יש משמעויות ש אתה מכיר אותם.
>> איפה C משתמשת מפעילים אלה, פייתון משתמש מעט יותר אנגלית
קריאים אלה.
אז במקום שני, סימן חיבור, פשוטו כמשמעו, הקלד את המילה "ו"," או, "
או לא."
כמו בif-- בך הצהרות מותנות,
שראינו קודם שתחביר זה ב- C מתאים לתחביר זה בפייתון.
ואין הרבה שונה שם, פרט לקצת
פיסוק סביב הצדדים.
שוב, כאשר C אחר היית אם, Python משתמש אליף,
אבל אלה הם בעיקר שינויים ברמת שטח.
>> איטרציה כזה היא לעתים קרובות נכתב בניב זה בפייתון.
אתה יכול לייצר סוג כזה של דבר עם לולאה בזמן שבחוץ
אם אתה רוצה, אבל אתה בהחלט לא צריך.
ושוב, אם אתה רוצה להדפיס את האלמנטים במערך של
אתה יכול לעשות את זה ככה.
אחד הדברים מהנים על אף Python,
הוא שאתה לא צריך להשתמש פרדיגמה זו,
ואתה יכול להשתמש מעט יותר אלגנטי אחד.
אתה אומר בהאר"י.
>> אז לא הולך כאן ופועל על המדדים,
ולאחר מכן מוציא את אלמנטים בודדים,
אתה אומר לבעצם רק לדרוס את האלמנטים עצמם.
ואז כל מה שאתה עושה בתוך יכול לפעול ישירות
על האלמנטים, שהוא די כיף.
ואנחנו תראה-- אנו נשתמש ניב ששוב ושוב
כפי שאנו הולכים בקוד.
>> שוב זה,, דוגמא של משהו שאני
קורא קסם פייתון, אם כי יש סיבות טכניות מאוד למה זה עובד.
ויש דברים טכניים ש צריך להיות נכון לגבי מערך כדי
לזה לעבוד מאחורי הקלעים.
העניין הוא שרוב הסוגים שבו אתה מצפה שזה יעבוד
יש לי זו מיושמת ל שלך בשפה מובנית.
>> דבר נוסף שזה יהיה נחמד אם זה עבד בכל שפה,
אבל יש כמה סיבות למה זה לא יכול, להדפיס פעמים במחרוזת זו מספר זה.
מתברר בפייתון, זה עושה בדיוק מה אתה רוצה, שהוא פשוט כיף,
והמשמעות הוא שאנחנו באמת יכולים להפחית תכנית זו, שוב mario.c.
במקום iterating הרבה, אנחנו יכולים רק אומרים, אני רוצה קצת מספר החללים,
אני רוצה את המספר של Hash, וכמה גיבובים בסוף.
ושוב, אנו משתמשים בפורמט זה.
>> הנה, אנחנו עוברים ב משתנה בדרך זו.
שוב, אנחנו לא צריכים לומר איזה סוג של משתנה זה,
והפעם היחידה שנציע ב מקבל שגיאות הוא בזמן הריצה.
כאשר מישהו מנסה להעביר משהו ב,
יבוא לתפקודו בסדר גמור.
אם טריז כאן כי זה לא דבר שאתה יכול ליצור טווחים מעל,
אני אקבל את שגיאת זמן ריצה יש, ואני אצטרך לאתר באגים את זה ככה.
אבל בינתיים, אין לי להיות מאוד זהיר לגבי מה ש
מקבל עבר ב, כל עוד בבפועל ביצוע כל זה עובד בצורה נקיה מאוד.
>> אני יכול אפילו להפוך את זה מנקה קצת
באמצעות פונקציה מובנית בפרט על מיתרים, שיישר לימין.
זה רק פונקציה שימושית זרוק הספרייה.
זה בתיעוד אם אתה רוצה ללכת ולחפש אותו.
ואני אומר, גם אני הולך יש לי מחרוזת זו, חלק מספר של Hash,
ואני רוצה להצדיק את כרית it-- תקין את זה עם רווחים להיות אורך זה.
>> שוב, זה ב תיעוד, אשר מביא us--
אני באמת יהיה לחץ באמצעות these-- מה שמביא אותנו לכלל השני שלנו
לספרייה סטנדרטית Python-- שיטות פונקציה הן החברים שלך.
וזה לעתים קרובות תשתלם לך ללכת לחפש אני תוהה
אם יש דבר שפשוט עושה את זה.
יש כנראה הוא.
אם ברצונך כרית את מחרוזת, אם היית
רוצה לקחת בחזרה מחצית ממחרוזת, אם היית
רוצה לחפש במחרוזת, אם אתה רוצה לנפץ כמה דברים
יחד עם מחרוזת עם פסיקים ביניהם,
יש בספרייה רגילה פונקציות לעושים את זה.
>> וזה עושה את החיים שלך יותר קל אם אתה משתמש בם
במקום מתגלגל החוצה הכל בעצמך
בחמש שורות של קוד כאן, חמש שורות של קוד כאן.
זה באמת מתחיל ב להוסיף עד זמן אמת.
>> אחד הדברים המעניינים על איך זה נקרא.
תוכל להבחין כי יש דבר נקודה.
יש לי כמה אובייקט בצד השמאל, ולאחר מכן התקשרתי לנקודה פונקציה.
זהו אחד מפרדיגמות שפייתון משתמש לחיבור שיטות לאובייקטים.
נדבר על מה זה הוא לזמן קצר מאוד בסוף,
אבל יודע ששנינו יכול לפעול ב דברים על ידי לקיחת שנקודה אומרת דבר
מה, או על ידי התקשרות פונקציה שלוקחת
שאובייקט וכמה טיעונים אחרים.
>> אז אלה הם שני הדרכים ש דברים להספיק בפייתון.
והאם בפרט פונקציונלי מיושם
בסגנון זה או זה סגנון הוא משהו שאתה
צריך להסתכל למעלה עד שאתה מקבל להיתקע שאחד סביר להניח ליפול לתוכו.
יש פחות או יותר מגובש פילוסופיה מאחורי פייתון
שאתה סופג בעיקר על ידי כתיבה הרבה בזה.
בשלב מסוים, שאחד מהם משהו ייושם כ
הופך להיות טבעי.
לעת עתה, זה רק משהו ללומדך כמו שאתה להבין
כל דבר פרט.
>> ספרייה אז סטנדרטית פונקציות הן החברים שלך,
והם מאפשרים לך לכתוב דברים ש תופס שטח רב זה באמת זמן קצר,
באמת באלגנטיות.
וזה בעצם כנראה יותר קריא, הייתי אומר, מאשר תכנית C
שם.
שלא לדבר על העובדה שהיא כל כך קצר אתה יכול להתאים כל פיל
בחלל ששמרנו.
>> דבר נוסף, זה יישום של מריו זה הנקודה C, שאני חושב ש
הוא הקצר ביותר שאתה יכול לקבל את זה.
זה לא חייב int הגט, אבל זה קודים קשים השווי של 10
באותו אופן שזה עושה.
מתברר שאחד שעונים זה ב 84 תווים, ואילו פייתון הוא 64.
וזה הרבה יותר קריא יותר מהזבל הזה כאן.
אז פייתון הוא יעיל יותר בחלל.
זה מעט פחות יעיל בזמן, אבל לא בהרבה.
>> רשימות הן דבר חשוב בפייתון.
אנחנו לא ראינו אותם, אבל הם פועל כמו מערכים לעשות בג
אז הנה, אתה יכול להכריז עליהם, אתה יכול להעביר אותם למשהו.
עכשיו ריבועים מחזיק מערך של הדברים האלה.
שוב, יש לנו לא הוכרז כ סוג, אבל אם אי פעם אנחנו מנסים להשתמש בו,
כל דבר שאתה מצפה ל לעבוד על מערך של מספרים שלמים
הולך לעבוד ב מערך של מספרים שלמים.
>> זה דבר ש אתה לא יכול בהחלט
לעשות בC, משום ש זיכרון זה כל כך על ידיים,
אבל הוא מאוד קל לעשות בפייתון.
אם אני רוצה המערך שלי להיות גדול יותר, אני יכול לצרף אלמנט אליו וזה בסדר גמור.
>> מה קורה מאחורי הקלעים?
המתורגמן ילך החוצה ולקבל קצת זיכרון,
ואולי זה יקבל קצת זיכרון נוסף,
אז אל כל כך אין לי אני ללהקצות מחדש בכל פעם.
אבל כמה יש לי יותר זיכרון זה צריך?
זה לא החלטות שאתה צריך לעשות,
אלה הם החלטות ש מתורגמן הוא הולך לעשות.
>> כאן אנו רואים יכולים לנוע לקחת שני טיעונים,
אבל זה עדיין הולך להיות כלול של הראש כך אנו מוסיפים 1 שם.
זה ניב, שהוא אפילו יותר דרך חכמה כדי לכתוב דברים כאלה.
זה נקרא הבנת רשימה, וכאן מה שאנחנו אומרים
הוא הייתי רוצה לשים באני בריבוע לכל ערך של i בטווח זה.
דבר זה בצד הימין יכול להיות אחר מערך, והדבר הזה בצד השמאל
להיות כל פונקציה מסוימת שייקח בי כמשתנה
ולתת לי כמה תוצאה.
>> מה שאני הולך לעשות הוא, אני הולך לבנות
מערך זה את כל הדברים האלה לכל ערך בטווח זה.
וזה סופר אלגנטי, סופר קצר, וזה מאוד ברור מה זה אומר.
זהו אחד things-- זה שוב,
אחד ל-- סמלי מאוד של סיבות שאנשים כמו פייתון.
אם אתה אוהב תכנות ככה, אז פייתון
היא שפה שאולי תרצה ללמוד.
>> ושוב, יש טכניים סיבות למה זה עובד.
אבל ככל שאנו מודאגים, לא אכפת פחות או יותר.
>> אז אם אתם רוצים להדפיס את הרשימות, חלק מאותם הניבים שימושיים.
כי אני בטווח זה, אנחנו יכולים מדד דרך כל הדברים
ואז להדפיס את כולם.
ותראו לן כאן.
אם אי פעם רציתי להגיע אורכו של המערך, זה
קל מאוד בפייתון, זה מאוד קשה בג
זה היה להדפיס את בדיוק מה שהיית מצפה שזה.
כמו כן, אנו יכולים, כפי שראינו בעבר, לחזר על האלמנטים במערך
ישירות, ואז פשוט לדבר על שלהם, ולא שיש המדד
בחזרה למערך בכל פעם.
>> וזה דבר שאתה יכול לעשות.
אז ב- C, אם אתה מבקש משהו ככה, הדפסה הייתי אומרת,
זה מערך של מספרים שלמים.
זה בהחלט לא מחרוזת, אני לא יכול להדפיס אותו.
פייתון פחות או יותר לא אכפת.
זה כמו, האם יש דרך שאני יכול להפוך בזה למחרוזת?
כן, אני אעשה את זה.
ואז אני רק להדפיס את זה.
זה אומר שאתה יכול לעשות דברים like-- אלה
הם רוב החלקים קשים משחק חמש עשר, נכתב
לזמן קצר מאוד בפייתון.
>> אתה תראה שיש קצת ל-- כאן
אני מטיל מספר שלם למחרוזת, ואני צריך לעשות את זה באופן ידני.
ואני הולך להוסיף זה למחרוזת אחרת,
או בדרך אחרת פייתון מתבלבל.
אבל אם כשאתה הוספת מחרוזת למספר שלם,
אני מניח שכדי לקבל integer גב או מחרוזת בחזרה?
אבל שוב, אם אתה רק קורא str על דבר,
וזה יכול בכל אפשרי להיות העולם יומר למחרוזת,
זה יהיה כנראה יומר למחרוזת.
>> כאן, אנו רואים שימוש ב הבנת רשימה מקוננת
בצד השמאל, כמה אינדקס, ש בדיוק כפי שאתה רוצה להיות רגיל לזה,
וכמה הדפסה מתוך דברים.
שוב, אנו הגדרנו כמה פונקציות ואנחנו נתקשר אותם
בעיקרי כאשר אנחנו באמת לקבל את הקובץ.
תמורה עובדת בדיוק כמו שהיית מצפה לעבוד עם ג מצא,
אנו יכולים להגדיר את הדברים כמו זה-- הנה הבנת רשימה
יש משימה למשתנה, ואנחנו באמת יכולים לעשות את זה אפילו יותר קלים.
אנחנו לא צריכים לכתוב חיפוש, בגלל מובנה לשפה
הוא אם הדבר הזה הוא במערך זה.
חזור אמיתי, אחר לחזור שווא.
אז זה השלמות של ממצא.
>> השלמות מסוג כרוך קוראים סוג,
שהוא-- יש מימושים זה מובנה בתוך ספריות C מסוימות.
אם ברצונך זה סוג של אחורה, אתה
יכול לעקוף זו שמירת טיעון בכיוון הפוך עם אמיתי.
ואם אתה רוצה למיין על מחרוזות, שהוא מובנה וכן.
>> אז זה לא אומר שאלו הם דברים שאתה צריך לעשות בכל יום,
אבל הרעיון הוא שזה היא הפילוסופיה של פייתון,
שכל הדברים האלה שהיית סוג של רוצה לעשות הם מובנים.
ורוב פונקציות סטנדרטיים, כך סוג, אורך, מה,
לתמוך קלט ביותר הגיוני מהבחינה הלוגית.
אתה קורא לן במערך זהה דרך בה אתה קורא לן על חוט.
אתה multiply-- למיין את המחרוזות באותו אופן שלמיין מערכים.
>> רוב פונקציות סטנדרטי שאנשים לבנות,
והצד השלישי ביותר ספריות שאנשים
לבנות, בגלל שהם חיקוי העיצוב של הספרייה סטנדרטית,
יכול להיקרא על כל מה שאתה כמו, למה לא זה פשוט עובד,
בג פחות או יותר, זה יעבוד בפייתון
כי אנשים עובדים מאחורי דמות ל מה הוא דבר ולאחר מכן לפעול
כראוי על זה.
אז שוב, רקע טכני, אבל זה הופך את חיינו לקלים יותר כמתכנתים.
>> אז הנה אני קובץ / O. קובץ I / O יש המון דברים קטנים שעושים את זה מסובך,
וכך יש משאבים באינטרנט, אבל על קצה מזלג,
אתה קורא פתוח על קובץ שם עם סוג מסוים.
אז זה לקרוא, לקרוא ו לכתוב, לכתוב או לצרף.
אתה קורא מספר מסוים של דמויות החוצה ואתה מדפיס אותם,
תקבל שלום!
אני מתכוון, כמו שקובץ זה שלום!
בזה, קורא לקרוא, ומה שתקבל בחזרה
היא מחרוזת שבה יש את כל של שאר המערך,
או כל שאר הקבצים.
אם אתה קורא לקרוא שוב, אתה בסופו של הקובץ,
ואז אתה לא מקבל כל דבר וכך תוכל לסגור.
שוב, זה לא .close קרוב קובץ, כמו שזה יהיה בג
זהו פחות או יותר, כי f היא דבר, ואתה רוצה לF לסגירה.
אבל קלט / פלט קובץ הבסיסי הוא לא מסובך במיוחד.
שוב, אם אתה רוצה לפתוח קובץ, אם אתה רוצה לקרוא קו מסוים,
אתה יכול לצאת מבפרט line-- יש נבנו תוספות של.
אם ברצונך לכתוב דבר, אתה יכול לכתוב את זה.
אם ברצונך לכתוב את פרט עקיצות, אתה יכול לכתוב אותם.
ואם אתה רוצה לחזר על הקווים של קובץ
בנפרד, כפי שעשינו בחתיכה מ לפני כמה שבועות, אתה יכול לעשות את זה ל.
שוב, רוב החפצים שהייתם רוצה להיות מסוגל לחזר על
iterating תמיכה עליהם.
בPythons, קובץ הוא אולי דבר ש אני רוצה לחזר על שורה אחרת שורה.
אם זה היה מילון של מילות ואני היה
מנסה להשיג בודד אלה מילות, ואז, בתוך לולאה זו,
קו זה הולך להיות כל מילה בתורו וזה
הוא הולך להיות מוצא להורג על כל קו בקובץ עד סוף הקובץ.
ושוב, אם אני הדפסתי כל קו, הקווים מגיעים עם קווים חדשים,
אז אני קביעת הסוף חזרה לדבר כזה.
ואז הייתי מקבל את התוכן של הקובץ שלי.
>> הדבר השני שפועל ב מבחינות מסוימות כמו רשימות, ובמובנים מסוימים
כמשהו משמעותי חזק יותר,
מילונים הם, שהם באמת מגניב לשימוש, אבל בעצם חשיש
שולחנות בתחפושת.
אתה יוצר אחד באמצעות בדיוק שתי דמויות, וזה מדהים
אם אתה ניסית ליישם שולחן חשיש לסט הבעיה שלך,
אתה יודע הרבה כאב שיכול להיות.
אבל אנשים שעשו זה, ועשה את זה כל כך טוב,
שאין לך ל לדאוג על זה יותר.
>> אז אתה יכול להכניס דברים אישיים.
tables-- או מילוני חשיש לא במיוחד
אכפת לי מה אתה אחסון בהם.
אז אם חלק מהרשומות מספרים, וכמה ערכי רשימות,
אם חלק מרשומות הן מילונים אחרים, וכמה ערכים הם מחרוזות,
פייתון לא אכפת.
>> שוב, אם אתה נכנסת לזה ציפה מחרוזת ומה שאתה מקבל בחזרה
הוא מערך, זאת הבעיה שלך.
ואולי זה באשמתו של מי ש חשב שזה היה לשים דברים
במילון, אולי זה היה לך.
אם זה היה מישהו אחר, אני מקווה שהם היו
התנהג יפה על מה ש היה הולך במילון
ולא להשאיר שום חסרונות בשבילך ליפול לתוכו.
>> אבל הפונקציות סטנדרטי תהיה אתן לך בחזרה דברים מחונכים.
אז הם אומרים זה חוזר לגבות מילון של מחרוזות,
אז כל מה שאתה הולך לצאת מהוא מחרוזת.
אם אתה עושה קצת מזה וזה טיולים אותך, גם, שעשוי להיות לך.
פייתון בהחלט נותן לך מספיק חבל לתלות את עצמך, אם תרצה.
עכשיו אנחנו יכולים להדפיס את הפרט אלמנטים של זה וזה חוזר
בדיוק מה שהיית מצפה.
בדיוק מה שהיית מצפה, אני מניח, הוא ביטוי שאני משתמש הרבה,
אבל זה יותר או פחות איך פייתון עובד.
אם אתה שואל על דבר שאינו זה, Python יהיה לזרוק את השגיאה
וזה יהיה להפסיק אותך מ מה בתכנית שהיית ב.
זה באמת יהיה להדפיס יותר מידע מזה,
זה יהיה לכוון אותו ימצא אתם-- להוסיף שורה, וכל כך.
>> ושוב, אולי אנחנו רוצים ללחזר על מילונים
ולמצוא את כל הדברים בזה.
כאן אנחנו iterating על שני דברים באותו הזמן.
וכך אנחנו נעשה את זה עם מפתח, ערך, אבל אז להדפיס את כל אלה.
>> ואם אנחנו רוצים cast-- אם אנחנו באמת רצנו זה,
הייתה לנו כמה בעיות, כי on-- כשנכנסנו עם דוד,
זה לא יכול add-- אם אנחנו לא להפיל אותו למחרוזת ראשונה,
אנו לא יכולים להוסיף מערך ש של מחרוזות על מחרוזת.
אבל אם אנחנו מטילים אותו ל מחרוזת, אנחנו מקבלים משהו
כמו זו, שהיא אולי מה שהיינו רוצה לקרוא.
>> וזה איות.
אנחנו פשוט לקרוא בדברים.
אז אנחנו יכולים לקרוא ב מילות בודדות כקווים.
אנו לכרות את שעבר דבר, כך מעי גס מינוס 1
לועס את הדבר האחרון שwe-- התו האחרון של מחרוזת.
אנחנו נגיד.
אישור, כל אחד מאותם מקבל מוכנס לתוך מילון זה,
מיפוי לערך של 1.
אנחנו לא במיוחד אכפת כי אחד,
אבל זה רק שם כדי לומר, נו טוב, הדבר הזה אני אשים במילון.
כי אחר מה אנחנו הולך לעשות הוא אנחנו
הולך להגיד, טוב, אם זה במילון בכלל.
>> שוב, סימון זו ל החברות היא עד הפעלה
באמצעות אחר לגמרי אלגוריתם מאשר שזה יהיה ברשימה,
אבל אנחנו קוראים לזה באותה הדרך, ש זה חלק מעניין ציפוי סוכר פייתון
את הדברים כך שהם קלים יותר לשימוש.
ושוב, שראינו דברים כמו זה לפני.
זה בעצם למצוא, או זה בדיוק אותו דבר התחביר
כלמצוא, אבל פועל על מבנה שונה לחלוטין.
ולא אכפת לנו במיוחד.
אז אלה הם הדברים שאתה התבקשו ליישם לאיות.
בקצב הזה, אנחנו הולכים לקבל פחות או יותר כל psets עשה.
>> קהל: אז ש בעצם רק חוזר
כשגוי כוסמין אם זה לא להתאים משהו במילון?
ROSS RHEINGANS-YOO: כן, כן.
וכך, זה הוא הסתגלות של בעיה להגדיר
שמבקש ממך לעשות בדיוק את זה.
>> קהל: למה הוא הקו מינוס 1 שם?
ROSS RHEINGANS-YOO: אז כאשר אתה iterating
על קובץ מבקש על ידי קווים, הקווים
מגיע עם אופי קו חדש בסוף it-- 1 מינוס
רק כדי לקנות אותם משם.
וזה במיוחד גמיש דרך של אינדקסים לדברים.
אז אם יש לך מחרוזת, ואתה רוצה, גם אני
הולך להתחיל בדמות שלוש ואני מתכוון ללכת עד הסוף.
3 מעי גס יעשה את זה בשבילך.
אם אתם כמו, אני רוצה להתחיל ב מתחיל וללכת למינוס 1 האחרון
אופי, מעי גס מינוס 1.
ואם אתה רוצה ללכת מ השלישי למינוס הראשון,
אז אתה הייתי אומר 3 מינוס 1.
>> בנוסף, אם אתה רוצה מדד לדברים ספירה מאחור,
אתה רק מדד בעם מספרי מינוס.
וכי, כאשר C יתפוצץ או אולי
להאכיל אותך זיכרון אחר לא היה לך גישה ל, לשמוע שאתה יכול להגיד מינוס 1
הפירוש האחרון אבל 1 דמות במחרוזת.
>> מודולים version-- הם תחליפים לספריות בC
ושימושיים להרבה דברים.
דברים הרבה שהיית רוצה לעשות בפייתון,
חוץ מזה פשוט מניפולציה של משתנים,
אתה רוצה להתחבר ל ספריות גדולות עם גדול יותר
ממשקים ועוד יכולות לאינטראקציה
עם חלקים אחרים של העולם.
sys הוא אחד מאותם עם חבורה של כלים
כי הם שימושיים לאינטראקציה עם המערכת עצמה
ולייבא אותו כמו sys יבוא.
>> יש יותר מתיעוד ש, שבו אתה יכול ללכת לכאן,
או שאתה יכול למצוא בגוגל על ידי googling sys פייתון.
אתה מקליד בזן.
הקישור הראשון הולך להיות התיעוד בפייתון 2,
הקישור השני הולך להיות פייתון התיעוד 3.
>> ואם כתבנו את קובץ שנראו כמו זה-- אם בפרט, אנחנו
מסתכל על ההפעלה ב שורת פקודת טיעונים,
כמו שלמדנו לעשות מאוד בשלב מוקדם במעמד הזה.
זה לא קשה. אתה יכול לצאת argv,
שהוא אחד מאותם דברים אשר מיושם על ידי SYS.
זה לא מובנה ל חבילת בסיס, אבל שוב, אתה
יכול להאריך אותו על ידי יבוא פונקציונלי שמsys.
אתה קורא לזה sys.
מה שתגיד.
כאן יש argv.
יש למעשה אין argc בsys, כי אתה
יכול לקבל את זה כל כך בקלות על ידי קורא לן.
לאחר מכן, אנו הדפסנו את זה, אז אנחנו רץ על echo-args.py המסוף שלנו.
אנחנו מקבלים בחזרה מערך, ש הטיעון הראשון.
שוב, זה argv 0, שהוא שמו של הדבר שיש בשם.
אם קראנו לו עם נוסף טיעונים, היינו מקבלים אותם בחזרה.
זוהי דרך אחת להגיע ל שורת פקודת טיעונים.
אם אתה רוצה דגלים שבו אתה פונה דברים מסוימים באו לעקוף
ברירת מחדל מסוים, argparse הוא חבר שלך.
ושוב אתה מוצא באינטרנט ש בפיתון argparse בגוגל.
>> יש כמה שירות מודולים שאתה מוצא את עצמך באמצעות
ושוב, אם אתה מבלה כל זמן של שפה זה יבוא jsons
לקריאה ובמתוך JSON קבצים, לא כל כך מסובך.
אתה פותח את קובץ, אתה נקרא json.load בקובץ שאתה מקבל בחזרה דבר.
מה זה הדבר הזה?
זה אובייקט JSON.
איפה JSON שיש מערך, יש פייתון מערכים.
איפה יש JSON ש מערכים אסוציאטיביים, פייתון של
מילונים, מחרוזות, ומספרים, וכן הלאה.
אתה רוצה לזרוק את זה, אתה לפתוח את הקובץ חדש, אתה קורא מזבלה,
והמון ומשליכה ל להיכנס ולצאת של מחרוזות.
>> באופן דומה, חמוץ מקבל נקרא ביסודו של דבר באותו הממשק.
זה קצת יותר שימושי אם אתה השלכת חפצי פייתון.
אז אם אי פעם רציתי להציל גרסה של המצב הנוכחי
של משתנה לעתיד לרוץ של התכנית שלך,
חמוץ הוא פייתון של ספרייה לעושה את זה.
>> אם יש לך כל סוג של משתנה שיכול להיות כתוב החוצה
במילים כמו ותווים ו bytes-- כמו מילון זה,
אנחנו יכולים לרשום, אנחנו יכול לכתוב את זה כ
כמו אובייקט JSON, שהיה פשוטו כמשמעו בתווים אלה.
ואז זה יהיה קל מאוד ל אדם כדי לפתוח אותו up-- להיפתח
ולקרוא אותו.
אם אנחנו לא עשינו במיוחד אכפת בני אדם לקרוא אותו,
אנחנו יכולים לארוז אפילו בצורה יעילה יותר לצורות שמאוחר יותר יכול להיות לא ארוזים
או שיכול להיות מאוחר יותר מנופח.
וזה חוסך 80% מ חלל שאולי האובייקטים שלך
לקחת אם אתה כתב אותם כתב היד.
>> אתה קורא חמוץ מאוד אותו way-- מזבלה, העומס,
ואז אתה מקבל בחזרה את הדברים שלך.
אז אם אתה כותב מאוד תוכניות פייתון קצרות ש
רוצה לחסוך מדינה, ולאחר מכן לקרוא שלהם שוב מאוחר יותר, דברים כאלה
הם החברים שלך.
כי אתה יכול מאוד בקלות לזרוק אותם כJSON.
רוב אובייקטי פייתון יכול לזרוק את JSON
אם יש תקווה כלשהי שמבנית הם יכולים להיות מיוצגים בדרך זו.
>> אלה הם רק קצה קרחון על מודולים שהם שימושיים.
אז sys, מערכת הפעלה, ריבוי, הן סוג של סוסי עבודה בסיסיות לדברים
אנחנו צריכים אינטראקציה עם מערכת ההפעלה מערכת קבצים.,
כמו os.isfile, os.isdirectory, os.makefile, אלה הם החברים שלך.
אם אתה רוצה אינטראקציה עם סוג קובץ מסוים,
JSON, מלפפון חמוץ, CSV.
אם אתה רוצה אינטראקציה עם אינטרנט דפים, urllib להשגת http
דפים. bs4-- BeautifulSoup-- זה מנתח נפלא לHTML.
אתה מפעיל את זה ב- HTML ואתה לקבל אובייקט מערך מקונן זה עכשיו,
שבו אתה יכול לעבור על Lookin, עם סתם מחפש
אם, הוא, ב, שהוא פנטסטי.
>> יש חבורה של חבילות לrunning--
לעושה בעיקר הדברים mathy.
אז אם אתה רוצה להכפיל, להפוך, להפוך מטריצות,
numpy משמש אנשים בכל רחבי העולם בשביל זה.
scipy הוא אפילו יותר שימושי כלים בכיוון זה.
למידת מכונה sklearn--, עיבוד שפה טבעי,
סופר דברים שימושיים, מקבלים מיושם בפייתון כל הזמן.
>> ושוב, לוקח מעט עוד לwrite-- מצטער,
לוקח מעט יותר זמן לרוץ, אבל הסיבה שמהנדסים אמיתיים נוטים
השימוש פייתון בגלל שאתה נוטה להיות נחסם עליך לכתוב את הקוד, ולא
מהמחשב שלך מפעיל את הקוד.
אז אם אתה הולך לכתוב תכנית, שהרבה אנשים אחרים
הולכים להשתמש לנצח, כמו לינוקס,
אולי לכתוב את זה בג אם היית הולך לכתוב מנוע חישוב,
אולי אתה כותב בפייתון אם אתה זקוק ל כדי לשנות אותו כל כמה חודשים.
יש אנשים שהיו כותבים את זה ב C בגלל שהם כאלה.
>> אז ראינו sys יבוא כדרכו של מקבל דברים
של מקבל מודול לתכנית שלך.
גם אתה יכול לייבא אותו כ כינוי, אם תרצה.
שוב ריבוי הוא כאב ל הקלד את כל זמן, אז לייבא כmp
ולאחר מכן בכל עת ש להשתמש בו בתכנית,
אתה תגיד mp.process, או מה שיש לך.
אם ברצונך יבוא רק דבר אחד,
כך יש urllib דבר שנקרא בקשה, כך שאתה יכול פשוט לייבא את זה.
מאוחר יותר, אתה לא להפעיל אותו כ urllib.request, אבל בדיוק כמו בקשה
בעצמו.
>> ואתה יכול לייבא כל דבר ממודול אם תרצה.
זה לעתים לא idea-- טוב בדרך כלל לא רעיון טוב זה, בעצם.
מכיוון שאתה מאוד-- כי אם כל דבר במודול שיש לו שם ש
רציתי להשתמש במקום אחר בתכנית שלך, אתה לא יכול.
>> וזה לא תמיד ברור שזה המקרה.
על מנת לוודא ש מה אתה היית עושה היה בטוח,
אתה צריך לפתוח את ויראה את כל מודול
מהשמות שסופו של הדבר ב כל הפונקציות יניהם--,
כל המשתנים שגר במודול ש,
כי אתה מביא את כל אותם למרחב המקומי שלך.
>> אז אנשים עושים את זה.
באופן כללי מומלץ שאתה לא עושה את זה.
אבל אנשים עושים את זה כל הזמן בגלל שהם
עצלן ולא רוצה להקליד את חבר הפרלמנט.
שום דבר, אי פעם.
>> כל הדיבורים האלה על מודולים תביא לי סביב לשיחה קצרה
על איך אתה לעצב תוכניות בפייתון.
הצעד הראשון הוא לבדוק אם מישהו אחר כבר עשה את הדבר,
או לעשות 90% מהדבר.
רוב הסיכויים הם כנראה שיש להם, ואתה צריך ללכת לקבל את הדבר שלהם ולהפעיל את זה.
או לכתוב מעטפת סביבו כדי להתאים אותה למטרה שלך.
זה רק אחרי שיש לי נכשל כי היית אז
ללכת על וwrite-- להתחיל לחשוב על איך היית לשים את הדבר הזה ביחד.
יש המון דברים בחוץ, וזה
אחד שימושי ביותר דברים על פייתון.
כמו השפה היא אלגנטית, השפה
קל לשימוש, אלא גם משום ש זה כל כך אלגנטי וקל לשימוש,
אנשים כבר משתמשים בו ל זמן רב ויש הרבה דברים
שם בחוץ, כי אתה יכול לרתום לשימוש שלך.
>> אז שלטון פייתון האחרון הוא, מישהו אחר כנראה כבר נכתב
מודול של, מישהו אחר כבר
כנראה נכתב ספרייה בשביל זה.
לפני שאתה מנסה לעשות דבר, נראה כדי לראות אם זה יושם.
זה לא כל כך קשה.
כל המודולים ששמתי את לפני, אולי עם חריג אחד,
מגיע מותקן מראש בכל התקנת פייתון סטנדרטית.
וכך, עם קריאה ל לייבא מה, אתה
יש כל הפונקציונליות ש בקץ אצבעותיך.
>> מתחיל לעטוף את זה דיבורים, יש כמה דברים
כי אני כבר עזבתי כקופסות שחורות ולא הקדיש זמן לסוג של,
ויש כמה שקרים לבנים שיש לי אמר שלמען היושר,
אני יהיה לפחות נקודה ב כאן, גם אם לא יהיה אני
ללכת סופר עמוק לתוך כולם וההסברים הטכניים שלהם.
>> הרבה דברים כי אני כבר בשם קסם
זה מה שאנשים אחרים היינו קוראים ל תכנות מונחה עצמים.
אז יש הרבה things-- כך משתנה לעתים קרובות מאוד לא
בתים פשוטים יושבים ב, הזיכרון, אבל הם מאוד מסובכים
אובייקטים שיש לי פנימי מדינה על פונקציות והרבה
משתנים של נסתרים, המון פונקציונלי נסתר, ש
מאפשר לך להפוך אותם למחרוזות, המאפשר לך לחזר עליהם.
ואם אתה writing-- והסיבה שהם
יש כל פונקציונליות עשירה זה סיבה לכך הוא אנשים--
האדריכלים של language-- הלכו
דרך ועל כל סטנדרטי אובייקט, לשים בפונקציונליות
להגיד את זה הוא איך זה איך זה הולך לפעול
אם מישהו רוצה לחזר על זה.
>> אז כל מה שאולי מישהו אולי רוצה לחזר על,
יש היגיון נכתב ב באופן ידני על איך אתה
אמור לחזר על אובייקט ש.
כל מה שאתה יכול אולי רוצה זרקנו למחרוזת יש היגיון בכתב.
זוהי הפונקציה שאתה קורא אם אתה רוצה לזרוק את זה למחרוזת.
זו הסיבה שאתה יכול קורא len על דברים, זה
לכן אתה יכול להתקשר ב, זה הוא לכן אתה יכול להתקשר אם בכל מה ש
שהיית רוצה, משום ש אלה כולם נושאים עימם,
הידע הטכני לעשות את זה.
>> זה משהו שאני הסופר לא הולך להיכנס.
אבל על הדבר ברשימה הוא בעדינות שונה מסגנון C ללולאות,
ואתה יכול לקרוא על כל שעל האינטרנט אם אתה מעוניין.
יש גם צד אפל לכל זה, שהזכרתי,
כך שיש שני דברים.
הראשון הוא שאובייקט זה מכוון תכנות מוסיף הרבה מעל
לדברים אקראיים, כך שאתה בסופו של דבר באמצעות הרבה יותר זיכרון;
אתה בסופו של דבר באמצעות יותר קטן זמן מאשר היית אחר.
Other-- אבל יותר צד אפל חתרנית לזה
כלומר, אם דברים פשוט לפעול כמו שאתה רוצה שהם
מבלי שתצטרך לחשוב סופר קשה לגבי שאלה אם זה צריך להיות int
או האם צריכה להיות לצוף, זה יכול להיות שמעל כאן
אתה לייצר int אבל כאן אתה חושב אבל הם תמיד-- מצטערים,
זה יכול להיות שכאן אתה לייצר לצוף,
אבל כשאתה מגיע לחלק השני התכנית שלך, אתה חושב,
נו טוב, אבל הם תמיד עובר לי int.
ואם לא תעשו כן, זה אפשרי כי אתה תקוע איפשהו,
אם אתה מנסה להשתמש בזה למדד למערך, או מה שיש לך.
>> אז אחת מהאמיתי דברים שימושיים על C הוא
זה מכריח אותך לחשוב באמת קשה לפני שתבצע any--
לפני שאתה מביא כל משתנה לקיום, כמו מה ש
הוא הסוג של משתנה זה.
וזה הולך להיות סוג שלכל הזמן.
>> זה לא נכון פייתון, ולמעשה, אתה
can-- אם אתה רק סוג של הולך על ידי אוזן,
ואתה לקבל כמה החלטות דרך אחת במקום אחד,
וכמה החלטות אחד דרך במקום האחר
בלי לשים מספיק דברים מאחורי הסצנות במקום האחר
לתפוס דברים כמו שצריך, אתה יכול לקבל כמה טעויות מוזרות מאוד.
והתכנית יכולה להמשיך לרוץ במשך זמן רב מאוד, כי זה
עושה הרבה עבודה כדי לומר, גם דבר זה יכול לפעול בדרך זו,
אז אני הולך לרוץ ככה.
>> ואכן, העובדה שהוא דוחף קדימה דרך הרבה שגיאות קטנות
משמעות הדבר היא כי, לעתים קרובות כאשר שגיאה היא בעצם רעה
ואתה באמת רוצה לתקן את זה, זה בסופו של קילומטרים away-- התכנית
בסופו של עצירה במרחק של קילומטרים מכאשר היה לך השגיאה שלך.
וכך אנו רוצים דבר אחד תוכניות לעשות, פעמים-- דבר אחד
כי אנחנו רוצים תוכניות לעשות כאשר אנחנו באגים
הוא להיכשל בקול רם ולא מצליח מאוד במהירות כאשר משהו משתבש.
>> פייתון היא רעה מאוד שב.
פייתון היא טובה מאוד בלא כושל ומתגלגל קדימה
דרך דברים בלתי צפויים.
אז זה שימושי כאשר אתה כותב תוכניות קטנות.
כאשר אתה מקבל מסובך באגים לפעמים
לוקח הרבה זמן כדי להקניט אותם.
>> אז יש צד אפל לכל זה, כמו שזה פשוט עובד.
זה פשוט עובד כמו שהיית מצפה שזה.
אלא שכאשר זה לא, אתה בסופו במקום אחר לגמרי
ומנסה להבין איפה זה היה שהשתבש.
>> איסוף אשפה הוא-- כך דבר אחד שתבחין
הוא שכל הדברים האלה ש אני כבר הבאתי לexistence--
מערכים אלה, מילונים אלה, אלה חפצים, אלה files-- אף פעם לא שוחררו.
לא הייתה קריאה ל חופשי בכל הדיבורים האלה.
וזה היה על C-הצד, כי אנחנו אף פעם לא נכנסנו לדברים האלה.
>> אבל בפייתון בצד, אין בחינם.
דברים מקבלים באופן אוטומטי שוחרר כאשר פייתון
חושב שאתה לא מסתכל עליהם.
זה ממש טוב לא לשחרר דברים ש ייתכן שעדיין אולי להיות מסתכלים,
אבל זה אומר שאם היית הולך להקצות הדבר הגדול הזה,
ואתה כמו, הו אני גמרתי עם זה עכשיו,
זה קשה להגיד פייתון שתסיים עם זה עכשיו.
>> לפעמים יכול להגדיר אותך משתנה שלהיות אף אחד,
ולאחר מכן מקווה שהסוף של דבר אספן האשפה
מגיע דרך ומנקה אותו.
אבל שוב, אתה לא יש שליטה על זה.
ואחת הסיבות שאנשים משתמשים C לתוצאות פעילות באמת דברים קריטיים,
היכולת הזו באמת יודע מתי זיכרון מוקצה
וכאשר הוא משוחרר, ויש לי הרבה שליטה על אומר,
אני משתמש לא יותר מאשר זיכרון שאני צריך.
וזה משהו ש פייתון היא לא כל כך גדולה ב.
קהל: האם אני יכול לשאול אותך שאלה?
מה אתה מתכוון בקול רם להיכשל?
>> ROSS RHEINGANS-YOO: אז אם משהו השתבש
ואתה בניפוי מצב, שהיית לעתים קרובות מאוד
רוצה התכנית שלך להגיד לך איפה בדיוק זה השתבש,
ולא רק בשקט להפסיק לרוץ.
אבל אתה בעצם אספת אותו להדפסה מתוך כל מיני פרטים על
כמו, כאן היה זה.
דבר זה קרה אם אתה מדפיס wen-- אם אתה מפעיל server-- אינטרנט
>> קהל: [לא ברור]
>> ROSS RHEINGANS-YOO: כן, אם אתה מפעיל שרת אינטרנט,
זה לפעמים רע אם אתה תמיד השלכת שגיאות,
ואתה אומר, גם זה לא עבד.
אני הולך להפסיק.
אני רק הולך להתעלם זה ולהמשיך הלאה.
כי אז אתה יכול לקבל במאות של טעויות אלה ולא רואה אותם.
>> זה בהחלט יהיה שימושי למטרות ניפוי
אם בכל פעם ששרת האינטרנט שלך עשתה שגיאה, היה לך רשומות עמידה של ש.
אולי אתה אפילו רוצה את התכנית להפסיק, כך שרשומות אלה
לא מקבל נקבר תחת דברים.
אבל שוב, זה במצב ניפוי שגיאות.
>> לעתים קרובות במצב ייצור, העולם הוא קצת שונה.
ובתסריטים זעירים שאני מפעיל, שבו הדבר שאמרתי לעשות
יכול להיות רק קצת מ ממה שאני רוצה לעשות את זה,
אז סוג של דוחף דרך טעויות היא משהו שאולי תרצה.
ובמקרים אלה, בהחלט פייתון באמת מרוויח התחלותיה.
>> הדבר האחרון שאני לא דיברתי בזה-- שלא לדבר על
אבל יכול להיות באמת מקומם הראשון זמן יש לך אחד של טעויות אלה,
ושנייה ושלישית והרביעי זמן יש לך אחד טעויות אלה.
פייטון, שציינתי כי היא משתמשת בחלל לבן
להגיד לך מה רמת הזחה ומה פונקציונלי בלוק אתה ב,
היא מתייחסת לכרטיסיות וחללים שונות.
אז אם אתה כרטיסייה על ארבעה, ולאחר מכן יש השורה הבאה ארבעה חללים,
גם אם הם מופיעים כ אותה כמות בעורך שלך,
פייתון לא להתייחס אליהם אותו הדבר.
>> למעשה, Python מתייחס כרטיסיות וחללים כמו שמן ומים.
הם דברים פשוט שונים.
אין מסוים אורך שכרטיסייה היא,
אז זה לא כמו כרטיסייה שווה 8 מרחבים, וכך היית מקבלים סביבו
בצורה זו.
כמו, כאשר הוא אומר, מה רמת השטח לבן אני ב,
זה בעצם מחפש דפוס של חללים וכרטיסיות.
וכך, הדרך הטובה ביותר להתמודד עם זה תמיד להשתמש ברווחים כל הזמן.
>> ואכן, בCloud9 IDE וIDE CS50,
מוסיף מקש Tab שלך ארבעה חללים במקום
של כרטיסייה, שהוא סופר שימושי.
למרות ששוב, אם אתה כתב פייתון תכנית עם כרטיסיות שיהיו בסדר,
זה רק אם מישהו נכנסתי וניסה להוסיף
שורה אחת לתכנית שלך ש היו לכל כרטיסייה ארבעה חללים,
זה יהיה לשבור.
וזה יהיה לשבור בדרך זה באמת לא נראה לעין.
למרות השגיאה בפועל מסר שהיא זורקת
יש לעשות עם חדש לשנן לא צפוי כאן,
or-- אם הוא מדבר על כניסות וזה נראה כאילו שזה לא בסדר,
זה כנראה בגלל ש יש בעיה כרטיסייה-החלל.
הם עדיין מקוממים לניפוי שגיאות.
כל הגדול ביותר ב שיחה זו, שאני לא
להגיע לכי זה באמת נושא מסובך, עדין,
ולא היה צורך לעשות כל הדברים שעשינו עד כה,
הם מושג שנקרא tuples.
הם נמצאים שם הרבה כמו מערכים שאתה לא יכול לשנות.
הם מתרגלים בכל המקום, כי הם שימושיים להרבה דברים
שמערכים לא שימושיים ל.
>> אבל אם אתה רוצה לעשות מערך, ו לאחר מכן מבטיח המתורגמן ש
אף פעם לא הולכים רוצה לשנות ש thing-- למעשה, אם אתה רוצה לשנות,
תוכל לעשות אחד חדש עם החדש ערכים בit-- אלה tuples.
במקום לייצר שלהם עם סוגריים מרובעים,
אתה מייצר אותם עם תליונים עגולים.
למה אתה משתמש בדברים האלה, הוא קצת שאלה. .
הדבר היחיד שאני אומר על זה אתה
ניתן להשתמש tuples כ מדדים למילונים.
אתה לא יכול להשתמש במערכים כ מדדים למילונים.
ולמה הוא, שוב, וטכני אני לא הולך לרוץ לתוך זה.
>> Pset שלא נגעתי בהרצאה זו היא pset6.
אז הנה איך אתה 'd ליישם זה-- הנה
איך היית ליישם pset6 בפייתון.
תוך התחשבות בפייתון מחזור תכנון, הדבר הראשון
שאתה עושה כשאתה תוכניות כתיבה היא בדיקה
כדי לראות אם מישהו עשה את זה כבר.
>> למעשה, אם אתה רוצה לserve-- אפאצ'י 50
עושה כ זה, מלבד זה לא בא
סטנדרטי מותקן במכונות לינוקס.
פייתון עושה, ופייתון שרת HTTP פשוט עושה גם כן.
אם אתה אי פעם במכונת לינוקס, או מחוץ Cloud9 IDE של CS50
ואתה רוצה לשרת הנוכחי ספרייה ליציאה מסוימת,
פיתון-מ 'SimpleHTTPServer נמל משמש ש.
ניתן גם לייבא שרת HTTP פשוט
ויש לו הרבה פונקציונלי אם אתה רוצה להתאים אותו, או לשנות אותו,
או מנוהלים it-- לרתום אותה ל להפעיל שירותי שרת משלך.
>> אז זה פייתון על קצה מזלג.
וזה כבר CS50.
תודה.