1
00:00:00,000 --> 00:00:05,426

2
00:00:05,426 --> 00:00:06,800
ROSS RHEINGANS-YOO: היי, אני רוס.

3
00:00:06,800 --> 00:00:08,570
וזה סמינר CS50.

4
00:00:08,570 --> 00:00:12,100
זה ייקח לך מתכנות
ב- C לתכנות בפייתון.

5
00:00:12,100 --> 00:00:15,120
>> פייתון היא שפת scripting.

6
00:00:15,120 --> 00:00:17,870
זה במידה רבה כמו C
בתחביר, למרות שחלקם

7
00:00:17,870 --> 00:00:20,390
של הפרטים הטכניים של
איך תחביר שמקבל להורג

8
00:00:20,390 --> 00:00:22,240
הם מעט שונים.

9
00:00:22,240 --> 00:00:24,780
זה פחות חזק מאשר C במובנים מסוימים.

10
00:00:24,780 --> 00:00:28,130
זה פחות הבעה ל
איפה בדיוק במחשב שלך

11
00:00:28,130 --> 00:00:30,030
זיכרון מקבל ערוך,
איך זה מקבל ערוך,

12
00:00:30,030 --> 00:00:32,030
כאשר הוא מקבל חופש, ו
אלה מיני דברים.

13
00:00:32,030 --> 00:00:36,150
>> זה שימושי יותר מאשר C במובנים מסוימים,
כי זה יותר קל לתכנת ב.

14
00:00:36,150 --> 00:00:39,920
השפה היא, לכמה
אנשים, אינטואיטיבי יותר.

15
00:00:39,920 --> 00:00:44,820
ובאמת, המטרה היא ל
שזה יהיה מהר יותר לתכנת

16
00:00:44,820 --> 00:00:46,490
ואולי איטי יותר לביצוע.

17
00:00:46,490 --> 00:00:48,198
>> עכשיו, אם אתה חושב על
את משך זמן

18
00:00:48,198 --> 00:00:50,514
אתה בילה על המשפחה שלך
כתיבה להגדיר בעיה

19
00:00:50,514 --> 00:00:52,430
הקוד שלך נגד
כמות הזמן שאתם מבלים

20
00:00:52,430 --> 00:00:55,310
על הבעיה האחרונה שלך
להגדיר ביצוע הקוד שלך,

21
00:00:55,310 --> 00:00:58,300
היית מתאר לעצמי שאת השפה
אשר היה במהירות כפולה כדי לכתוב,

22
00:00:58,300 --> 00:01:02,170
ופעמים כאיטיות לביצוע, אולי
להיות שיפור לעומת C במובנים מסוימים.

23
00:01:02,170 --> 00:01:05,730
בוודאי כשאתה מנסה לכתוב
תוכניות קטנות לעשות דברים קטנים,

24
00:01:05,730 --> 00:01:08,520
פייתון היא שפה שימושית של בחירה.

25
00:01:08,520 --> 00:01:10,620
>> ובסופו של זה
סמינר, אני מקווה שאתה תמצאו

26
00:01:10,620 --> 00:01:12,950
להיות מסוגל לעשות
בחירה בפרויקטים עתידיים

27
00:01:12,950 --> 00:01:17,710
על איזו שפה היא
נכון לשימוש לא הרעיון,

28
00:01:17,710 --> 00:01:21,405
ששפה אחת היא יותר
לתקן כל הזמן.

29
00:01:21,405 --> 00:01:23,030
כמה דברים על מה הוא הסמינר.

30
00:01:23,030 --> 00:01:25,910
סמינר זה אינו מיועד ל
ללמד אותך פייתון מאפס.

31
00:01:25,910 --> 00:01:28,310
פייתון היא דומה מאוד
ל- C, ואני מניח ש

32
00:01:28,310 --> 00:01:34,056
כי אתה סטודנט CS50, או מישהו
עם היכרות דומה עם ג

33
00:01:34,056 --> 00:01:36,700
>> אם אתה סטודנט CS50
סביב בעיה להגדיר 6,

34
00:01:36,700 --> 00:01:38,866
כך שיש לך לראות הרבה
דברים בC, אני אתן לך

35
00:01:38,866 --> 00:01:40,740
ההבדלים העיקריים,
וחלק מהדברים

36
00:01:40,740 --> 00:01:42,840
שהופך את פייתון שונה
ומיוחד ושימושי,

37
00:01:42,840 --> 00:01:45,256
אבל אני לא מתכוון ללכת ל
מה היא שפת תכנות

38
00:01:45,256 --> 00:01:46,920
ואיך לכתוב תוכניות.

39
00:01:46,920 --> 00:01:49,820
עם זאת, סמינר זה ילמד
לך לכתוב תוכניות פייתון

40
00:01:49,820 --> 00:01:52,310
אם אתה אחד מכמה קבוצות אלה.

41
00:01:52,310 --> 00:01:54,820
שוב אנו מסתכלים איך
היית ליישם psets--

42
00:01:54,820 --> 00:01:57,550
שצריך להיות 1-6 ב
Python-- ומצביעים לספק

43
00:01:57,550 --> 00:02:00,322
לתיעוד רשמי
לעיון בעתיד.

44
00:02:00,322 --> 00:02:03,030
הדבר השני שחשוב
על איך לדבר זה מוקצה,

45
00:02:03,030 --> 00:02:05,360
וידאו זה יהיה
באינטרנט, באדיבות CS50,

46
00:02:05,360 --> 00:02:07,550
כך שאתה לא צריך להרגיש כמו
אתה צריך לקחת את הערות.

47
00:02:07,550 --> 00:02:11,180
אתה תמיד יכול לחזור ולהסתכל
על זה מאוחר יותר כנקודת התייחסות.

48
00:02:11,180 --> 00:02:13,340
בנוסף השקופיות
זמינים עכשיו

49
00:02:13,340 --> 00:02:16,480
באתר זה, שאמור
אקח לך לעשות doc גוגל.

50
00:02:16,480 --> 00:02:21,010
זוהי גרסה מעט מקוצרת
ממה שאני מראה על המסך.

51
00:02:21,010 --> 00:02:24,850
>> אזהרה זהירה לפני
אנחנו קופצים ב, Python 3

52
00:02:24,850 --> 00:02:26,700
היא בשפה שונה מפייתון 2.

53
00:02:26,700 --> 00:02:30,020
הם נראים הרבה זהים; יש
הבדלים טכניים קלים מאוד

54
00:02:30,020 --> 00:02:32,530
שיגרום תוכניות
נכתב בפייתון 2

55
00:02:32,530 --> 00:02:37,140
לא להיות מסוגל להיות מוצאים להורג
בסביבת Python 3.

56
00:02:37,140 --> 00:02:41,969
>> המכשיר מגיע עם CS50
פייטון, כברירת מחדל הוא משתמש בפייתון 2.

57
00:02:41,969 --> 00:02:44,010
אתה יכול לבדוק זאת על ידי
הקלדה בשורת הפקודה שלך

58
00:02:44,010 --> 00:02:51,310
--version פיתון, שאמור פלט
2.7.6 על המכשיר הנוכחי.

59
00:02:51,310 --> 00:02:53,580
נסה פייתון 3, אשר עושה
עובד במכשיר,

60
00:02:53,580 --> 00:02:58,500
אם ברירת מחדל של פייתון ל2.X.Y, או על
המכשיר או על המכונות שלך.

61
00:02:58,500 --> 00:03:03,730
אתה צריך להחליף את פייטון 3 בכל עת
בהרצאה זו שאני כותב פייתון.

62
00:03:03,730 --> 00:03:05,760
אם המחשב שלך הוא
ריצת 2 כברירת מחדל, סוג

63
00:03:05,760 --> 00:03:09,770
פייטון 3 כדי להיות מסוגל למעשה
פעל יחד ולבצע את הדברים האלה.

64
00:03:09,770 --> 00:03:12,280
>> בנוסף, אני אצביע לך
במשאבים רשמיים עכשיו.

65
00:03:12,280 --> 00:03:16,082
docs.python.org/3-- זהיר
שזה 3 ולא 2--

66
00:03:16,082 --> 00:03:17,030
יש אזכור שימושי.

67
00:03:17,030 --> 00:03:19,280
ההדרכה תיקח אתכם דרך
הרבה מאותם הדברים

68
00:03:19,280 --> 00:03:21,460
שאני עושה עכשיו, אלא בצורת טקסט.

69
00:03:21,460 --> 00:03:23,725
ההתייחסות היא שימושית כ
התייחסות לשפה,

70
00:03:23,725 --> 00:03:26,100
והספרייה רגילה נותנת
אתה חלק מההרחבות

71
00:03:26,100 --> 00:03:27,770
עם פונקציונליות נוספת.

72
00:03:27,770 --> 00:03:31,300
>> אז תכנית פייתון הראשונה.

73
00:03:31,300 --> 00:03:34,410
בצד השמאל יש לנו C סטנדרטי,
בצד הימין, יש לנו פייתון.

74
00:03:34,410 --> 00:03:36,780
ייתכן שהוכרת
בעיה זו, זה

75
00:03:36,780 --> 00:03:40,760
אחד מהבעיה הראשונה
סטים בCS50, ואלה

76
00:03:40,760 --> 00:03:42,677
לפתור אותה באמצעות אותו הפתרון.

77
00:03:42,677 --> 00:03:45,010
עכשיו, הסיבה שאנחנו
מסתכל על הצד אלה על ידי צד

78
00:03:45,010 --> 00:03:46,830
הוא כל כך שאנחנו יכולים להסתכל ב
הבדלים תחביריים.

79
00:03:46,830 --> 00:03:49,580
אחד הפילים בחדר
שאולי שמת לב תקין

80
00:03:49,580 --> 00:03:56,350
את הבת, הוא שאין פייתון
עטיפת פונקציה העיקרית סביב הקוד.

81
00:03:56,350 --> 00:03:59,170
אז ב- C, אתה כותב חבורה של
קבצים, אתה מקשר אותם יחד,

82
00:03:59,170 --> 00:04:02,590
והתכנית מתחילה ביצוע
בדבר הזה שנקרא עיקרי int.

83
00:04:02,590 --> 00:04:04,930
>> בפייתון, אתה כותב
להגיש לך, להפעיל את הקובץ,

84
00:04:04,930 --> 00:04:07,882
התכנית מתחילה ביצוע
בחלק העליון של הקובץ.

85
00:04:07,882 --> 00:04:09,590
אז זה הולך להתחיל
בחלק העליון של קובץ

86
00:04:09,590 --> 00:04:11,280
לרדת עד שימצא משהו אחר.

87
00:04:11,280 --> 00:04:14,440
אם הוא מוצא הגדרת תפקיד,
זה לא ממש לבצע קוד ש,

88
00:04:14,440 --> 00:04:15,940
זה יהיה פשוט להגדיר את הפונקציה.

89
00:04:15,940 --> 00:04:18,459
אבל כאן, כאשר הראשון
תכנית היא n שווה 10,

90
00:04:18,459 --> 00:04:21,273
הדבר הראשון שתכנית זו
יעשה הוא לקחת ערך זה של 10

91
00:04:21,273 --> 00:04:24,120
ולהגדיר אותו לתוך משתנה בשם n.

92
00:04:24,120 --> 00:04:27,690
>> אם כבר מדברים על קו ש, אחד מ
אחר things-- sorry-- זה

93
00:04:27,690 --> 00:04:31,040
משמעות הדבר היא שתוכניות C,
אתה כותב אותם,

94
00:04:31,040 --> 00:04:34,899
תוכל לעשות אותם, שיהיה
להפעיל פקודות מסוימות צלצול,

95
00:04:34,899 --> 00:04:36,690
ואז אתה רץ
וכתוצאה מכך הפעלה.

96
00:04:36,690 --> 00:04:41,030
תוכניות פייתון, אתה מפעיל את
אולי טקסט file-- mario.py זה

97
00:04:41,030 --> 00:04:44,900
להיות בקובץ זה כי אני פשוט הראיתי
אתם-- תוכל לרוץ קובץ ש

98
00:04:44,900 --> 00:04:47,450
ואתה לבצע,
ואת התוכן שלו

99
00:04:47,450 --> 00:04:50,390
יבוצע על ידי
מתורגמן פייתון.

100
00:04:50,390 --> 00:04:52,470
אתה יכול לעשות את זה בIDE שלך.

101
00:04:52,470 --> 00:05:02,260
>> אז אם יש לי קובץ שלום,
שפשוט יש את זה תוכן.

102
00:05:02,260 --> 00:05:04,840
זהו למעשה פייתון
2, לא פייתון 3, ולכן לא

103
00:05:04,840 --> 00:05:06,600
לדאוג תחביר לעת עתה.

104
00:05:06,600 --> 00:05:14,230
אבל אני ארוץ פייתון, ב
hello.py, והיא פועלת.

105
00:05:14,230 --> 00:05:18,890
>> דרך נוספת שאני יכול להשתמש בפייתון ש
אני לא אעסוק בכל כך הרבה בדיבורים,

106
00:05:18,890 --> 00:05:21,840
הוא אם אני פשוט להקליד פייתון, זה
טיפות לסביבה שבה לי

107
00:05:21,840 --> 00:05:24,370
אני יכול להאכיל אותו קו פייתון על ידי קו.

108
00:05:24,370 --> 00:05:31,260
אז הנה, אם אני מקליד ב
שטח הדפסה "שלום, עולם".

109
00:05:31,260 --> 00:05:32,360
הקלד להיכנס.

110
00:05:32,360 --> 00:05:37,430
זה לירוק לי שיגבה את התוצאות
כי קו בודד באופן מיידי.

111
00:05:37,430 --> 00:05:38,470
>> זה עשוי להיות שימושי.

112
00:05:38,470 --> 00:05:40,700
בהרצאה זו אני אעשה דברים בשקופיות.

113
00:05:40,700 --> 00:05:43,940
וכך תוכל לעקוב
לאורך או לכאן, או על ידי כתיבה

114
00:05:43,940 --> 00:05:45,725
קבצים ולאחר מכן ביצוע בפועל.

115
00:05:45,725 --> 00:05:48,340

116
00:05:48,340 --> 00:05:50,995
>> אבל, חוזר לזה
קוד, עוד דבר

117
00:05:50,995 --> 00:05:53,230
שאולי יש לך
noticed-- גם, יש

118
00:05:53,230 --> 00:05:55,980
שני דברים שאתה עלול
הודעה על בלוקים אלה.

119
00:05:55,980 --> 00:05:59,280
הראשון, ולא יותר ארצי, הוא ש
יש פייתון לא פסיק נגרר.

120
00:05:59,280 --> 00:06:02,630
>> פסיק הם אופציונליים בכל מקום
ובלתי מזיק בכל מקום.

121
00:06:02,630 --> 00:06:03,722
אתה יכול להוסיף אותם.

122
00:06:03,722 --> 00:06:06,430
זה עלול לגרום לאנשים שכותבים
Python לגיחוך חיים בך

123
00:06:06,430 --> 00:06:08,860
מאחורי הגב שלך, בגלל ש
הם לא הכרחיים.

124
00:06:08,860 --> 00:06:13,497
הם לעתים קרובות סימן למוחזק על
מג המעצבים של השפה

125
00:06:13,497 --> 00:06:16,580
מרגיש שזה יותר ברור בדרך זו
ושזה לא הכרחי להצהיר

126
00:06:16,580 --> 00:06:18,700
כל פעם שאתה בסופו של קו.

127
00:06:18,700 --> 00:06:21,799
>> עוד דבר מוזר בn זה
הוא שאין לה סוג מצורף.

128
00:06:21,799 --> 00:06:24,590
אחת יצירות הקסם של Python--
ואני הולך לקרוא לזה קסם,

129
00:06:24,590 --> 00:06:26,381
אבל יש מאוד
מסיבות טכניות למה זה

130
00:06:26,381 --> 00:06:28,560
works-- אחד
חתיכות קסם של פייתון

131
00:06:28,560 --> 00:06:32,700
הוא שמשתנים יכולים להרחיב או
לכווץ להכיל כל הנתונים

132
00:06:32,700 --> 00:06:34,530
סוגים שהייתם רוצים שהם.

133
00:06:34,530 --> 00:06:35,580
>> אז זה 10.

134
00:06:35,580 --> 00:06:40,060
אם מאוחר יותר למטה אני הוקצה לכך
n 0.5, שזה ייקח ש0.5.

135
00:06:40,060 --> 00:06:43,770
לא משנה שזה int כאן ו
לצוף שם, כל דבר שמשתמש n זה

136
00:06:43,770 --> 00:06:47,057
יהיה, פחות או יותר, תוכל לטרטר
לאורך אם זה נעשה באחת מאלה.

137
00:06:47,057 --> 00:06:49,640
אלא אם כן יש כמה אמיתי מאוד
סיבה למה זה לא יכול להשתמש בנתונים

138
00:06:49,640 --> 00:06:52,170
הקלד שn כיום,
ובשלב זה יקבל

139
00:06:52,170 --> 00:06:54,490
תקוע ולזרוק שגיאה,
ואלה מיני דברים.

140
00:06:54,490 --> 00:06:57,050
>> אבל כאן, Python
לא ממש אכפת לי מה

141
00:06:57,050 --> 00:06:59,140
זה שאני הולך לתקוע בזה
משפט, כמו, אתה רוצה את הדבר הזה?

142
00:06:59,140 --> 00:06:59,840
דבר זה בזה?

143
00:06:59,840 --> 00:07:00,640
כן, זה סוג של דבר.

144
00:07:00,640 --> 00:07:01,810
אני לתקוע אותו בסופו של הדבר.

145
00:07:01,810 --> 00:07:04,740
זה יהיה בעיה בהמשך, אם
מישהו שרוצה להשתמש הסוף ש

146
00:07:04,740 --> 00:07:05,710
לא יכול להתמודד עם זה.

147
00:07:05,710 --> 00:07:08,500
זהו אחד הגדול
הבדלים בין פייתון ו- C

148
00:07:08,500 --> 00:07:10,790
זה עושה את זה קל
לכתוב תוכניות C גדולות מאוד

149
00:07:10,790 --> 00:07:15,120
והופך אותו קל יותר לכתוב
תכנית פייתון קטנה מאוד.

150
00:07:15,120 --> 00:07:19,564
>> לתחביר הוא לא מאוד
שונה במה שהוא עושה.

151
00:07:19,564 --> 00:07:21,480
זה קצת שונה
באיך זה בא לידי ביטוי.

152
00:07:21,480 --> 00:07:25,370
אז זה מאוד, מה שנקרא
נחש ארסי, דרך של כתיבתו.

153
00:07:25,370 --> 00:07:28,969
לשורה בטווח (n), זה הוא
טווח מספרים בין 0 ל n,

154
00:07:28,969 --> 00:07:31,010
כולל בתחתית
ובלעדי בחלק העליון.

155
00:07:31,010 --> 00:07:34,790
אז זה בין 0 ל n-1, אשר הוא
בדיוק מה קוד C עושה,

156
00:07:34,790 --> 00:07:38,690
מלבד זה הרבה יותר קל
להסתכל על אולי.

157
00:07:38,690 --> 00:07:42,710
>> הבלוק הרלוונטי הוא
לא יצא ידי פלטה,

158
00:07:42,710 --> 00:07:44,540
במקום שזה יצא
על ידי כניסה זו.

159
00:07:44,540 --> 00:07:47,580
אז כל קווים אלה
ארבעה חללים מעל לימין,

160
00:07:47,580 --> 00:07:50,410
או כמו על רוחב פיל.

161
00:07:50,410 --> 00:07:54,570
ואלה הם אלה ש
הולך להיות מוצא להורג בזה ל.

162
00:07:54,570 --> 00:07:57,020
אם אני לבלגן
כניסה על זה ואני

163
00:07:57,020 --> 00:08:01,420
לדחוף הדפסה שתחזור ל
הכניסה המקורית,

164
00:08:01,420 --> 00:08:04,320
ההדפסה שתשאיר ללולאה.

165
00:08:04,320 --> 00:08:08,560
בניגוד ל- C, שבו אני ממש כאן
צריך להעביר שסד סגור מסביב.

166
00:08:08,560 --> 00:08:11,820
>> זה אומר שאתה לא מקבל שגיאות
כי לקפוץ החוצה אליך, כי אתה

167
00:08:11,820 --> 00:08:13,580
לשים סד במקום הלא נכון.

168
00:08:13,580 --> 00:08:16,460
זה אומר שאתה מקבל שגיאות
כי לקפוץ החוצה אליך, כי אתה

169
00:08:16,460 --> 00:08:17,620
מסוכסך שגוי קו.

170
00:08:17,620 --> 00:08:19,290
אז זה עושה חריצים סופר זהירים.

171
00:08:19,290 --> 00:08:22,123
אני מקווה שאתה היה להיות סופר
זהיר עם כניסתך בכל מקרה,

172
00:08:22,123 --> 00:08:25,300
ואז זה לא ש
הרבה יותר של נטל.

173
00:08:25,300 --> 00:08:28,762
>> אבל כלל בסיסי לפייתון,
ויהיה לנו כמה כאלה

174
00:08:28,762 --> 00:08:30,970
שנלך דרך דרך
במהלך השיחה,

175
00:08:30,970 --> 00:08:33,840
הוא מנסה תחביר טבעי
לפני מחפש את דבר.

176
00:08:33,840 --> 00:08:37,610
אז תחביר זה, ל
מספר זה בטווח,

177
00:08:37,610 --> 00:08:41,460
הוא מאוד ייחודי במונחים של סגנון.

178
00:08:41,460 --> 00:08:45,260
הרבה דברים בפייתון
אנחנו תראו לקחת טופס זה.

179
00:08:45,260 --> 00:08:47,420
>> ולכן אם אתה בא
עם אובייקט חדש ש

180
00:08:47,420 --> 00:08:50,870
חושב שאתה צריך להיות מסוגל
לחזר על זה, במתכונת זו,

181
00:08:50,870 --> 00:08:53,720
מתברר שזה כנראה
תומך בפורמט זה.

182
00:08:53,720 --> 00:08:56,990
אנחנו לא הולכים סופר עמוק ב
מסיבות הטכניות מדוע זה נכון.

183
00:08:56,990 --> 00:09:00,167
>> אבל זה אינטואיציה שימושית יש
כאשר אתה מתקרב תוכניות פייתון,

184
00:09:00,167 --> 00:09:01,750
שהדבר הזה הוא רק הולך לעבודה.

185
00:09:01,750 --> 00:09:03,020
נסה זאת.

186
00:09:03,020 --> 00:09:06,480
לאתחל את שורת הפקודה
מתורגמן, לראות אם זה עובד,

187
00:09:06,480 --> 00:09:09,827
הלאה עם דברים, לפני ש
אפילו צריך לפתוח את גוגל ואומר,

188
00:09:09,827 --> 00:09:11,660
מה התחביר ל
דבר המסוים הזה?

189
00:09:11,660 --> 00:09:14,740
המון פייתון אתה יכול
לגלות רק על ידי מנסה.

190
00:09:14,740 --> 00:09:19,005
>> זה אם הוא אפילו יותר דומה
ל- C אז fors הם.

191
00:09:19,005 --> 00:09:20,380
שים לב שאין סוגריים.

192
00:09:20,380 --> 00:09:23,490
הסוגריים, שוב,
לא מזיק אבל מיותר.

193
00:09:23,490 --> 00:09:25,750
יש מעי גס בסוף
בדיוק כמו ללולאות,

194
00:09:25,750 --> 00:09:30,800
ושוב, בלוקים היחסי הם
מפורץ ולא יצא ידי פלטה.

195
00:09:30,800 --> 00:09:33,080
אחר זה הוא במקור
רמת הזחה,

196
00:09:33,080 --> 00:09:35,930
ומסוכסך הבלוק הרלוונטי שלה שוב.

197
00:09:35,930 --> 00:09:41,720
עבודה אלה בדיוק כפי שהם עושים בג

198
00:09:41,720 --> 00:09:44,520
>> זהו למעשה מאוד דומה.

199
00:09:44,520 --> 00:09:49,430
שוב, הדפסה מאבדת תו אחד
הנחה של printf אתה עובר בחוטים.

200
00:09:49,430 --> 00:09:51,520
מתברר מחרוזות
גם יכול להיות מסומן מ

201
00:09:51,520 --> 00:09:53,562
על ידי ציטוטים בודדים או מרכאות כפולות.

202
00:09:53,562 --> 00:09:55,270
אין הבדל,
מלבד בתוך ש

203
00:09:55,270 --> 00:09:57,722
ציטוטים שאתה יכול להשתמש
מרכאות כפולות עם לנטוש,

204
00:09:57,722 --> 00:09:59,430
ולא שיש ל
לברוח כולם.

205
00:09:59,430 --> 00:10:01,480
ובתוך מרכאות כפולות,
יכול להשתמש בגרשיים בודדים עם לנטוש

206
00:10:01,480 --> 00:10:02,420
מבלי לברוח מהם.

207
00:10:02,420 --> 00:10:04,253
אם אתה רוצה לערבב
שלהם, אתה בהחלט יכול

208
00:10:04,253 --> 00:10:06,100
לחפש באינטרנט איך לעשות את זה.

209
00:10:06,100 --> 00:10:09,581
>> תוכל להבחין כי לכאן,
אני כבר עברתי בסופו של דבר = הדבר הזה.

210
00:10:09,581 --> 00:10:12,580
זוהי דוגמא של שמירת
טענה, שהוא אחד מאותם דברים

211
00:10:12,580 --> 00:10:14,990
שפייתון תומך ש
עושה את זה די שימושי.

212
00:10:14,990 --> 00:10:18,240
אז הדפסה בפועל יש הרבה
טענות, שהם בדרך כלל

213
00:10:18,240 --> 00:10:20,140
מוגדר כברירת המחדל שלהם
ערך, אבל כאן יש לי

214
00:10:20,140 --> 00:10:21,924
החליט לעקוף את אחד נקרא הסוף.

215
00:10:21,924 --> 00:10:24,340
הסיבה שיש לי ל
לעקוף אותו עם מחרוזת ריקה

216
00:10:24,340 --> 00:10:26,756
היא הדפסה שבפייתון, על ידי
ברירת מחדל, מדפיסה קו חדש

217
00:10:26,756 --> 00:10:28,630
לאחר שהדבר שאמרת לה יותר מדי.

218
00:10:28,630 --> 00:10:31,462
>> אז חשיש זה באמת הולך
להדפיס את חשיש בשורה חדשה.

219
00:10:31,462 --> 00:10:34,670
ואם אני לא רוצה חשיש להדפיס
קו חדש לאחר ש, אז אני חייב לומר

220
00:10:34,670 --> 00:10:35,340
לא להדפיס אחד.

221
00:10:35,340 --> 00:10:37,980

222
00:10:37,980 --> 00:10:43,690
אבל עדיין, כל כך, הדבר האחרון ש
תכנית זו היא חסרה כי יש היא

223
00:10:43,690 --> 00:10:44,960
כוללים בראש.

224
00:10:44,960 --> 00:10:48,120
הדפסה אפויה לפייתון אז בעצם
שאין כותרת או מודול

225
00:10:48,120 --> 00:10:49,869
שאתה צריך
כולל, אבל אם רציתי

226
00:10:49,869 --> 00:10:52,029
לכלול דברים אחרים
בסקריפט פייתון,

227
00:10:52,029 --> 00:10:55,320
אני הייתי עושה את זה בformat-- דומה מאוד
המילים הן רק מעט שונות.

228
00:10:55,320 --> 00:10:58,840

229
00:10:58,840 --> 00:11:01,360
>> שהזכרתי לנו ש
לא צריך עיקרי כאן,

230
00:11:01,360 --> 00:11:03,372
כי פייתון מתחיל
ביצוע בחלק העליון.

231
00:11:03,372 --> 00:11:05,080
אם אני רוצה לעטוף
זה בפונקציה, אני

232
00:11:05,080 --> 00:11:07,667
אעשה את זה כמו שאני זה--
הייתי אומר def שם פונקציה,

233
00:11:07,667 --> 00:11:10,500
טיעונים יכולים ללכת לכאן ואנחנו
לראות כמה מאותם מאוחר יותר, מעי גס,

234
00:11:10,500 --> 00:11:13,040
ואז שוב, זה
בלוק יצא כל

235
00:11:13,040 --> 00:11:16,810
מה הוא מבצעי
לחסום לפונקציה ש.

236
00:11:16,810 --> 00:11:18,560
אז זו ההגדרה
של הפונקציה.

237
00:11:18,560 --> 00:11:21,587
ויש הצהרה, ואז למטה
כאן, אני יכול רק לקרוא את הפונקציה.

238
00:11:21,587 --> 00:11:23,920
ושוב, את התכנית
מתורגמן, מתחיל בראש,

239
00:11:23,920 --> 00:11:25,280
יראה את זה הוא ההגדרה.

240
00:11:25,280 --> 00:11:27,960
זה לא לבצע את זה עד ש
להגיע לכאן, ואז זה כמו, הו

241
00:11:27,960 --> 00:11:30,860
עכשיו אתה כבר קראת לזה, אני
מניח שאני צריך לבצע אותה.

242
00:11:30,860 --> 00:11:33,850
>> דבר שמאוד נפוץ
לראות בקבצי פייתון,

243
00:11:33,850 --> 00:11:36,700
במיוחד קבצי פייתון ש
הם שוחררו לציבור

244
00:11:36,700 --> 00:11:41,650
ופתחתי by-- ופיתח
שמר, הוא משהו מסוג זה.

245
00:11:41,650 --> 00:11:44,540
זה כל כך כי basically--
פייטון, אתה מתחיל בראש

246
00:11:44,540 --> 00:11:50,310
ואז אתה לבצע עד לתחתית,
אני אם רק היה לי מריו קראתי כאן,

247
00:11:50,310 --> 00:11:54,190
אז כל פעם שאני כלול בקובץ זה ב
קובץ אחר, כי רציתי להשתמש ב

248
00:11:54,190 --> 00:11:58,580
היא פונקצית מריו, שהיית קובץ אחר
גם קריאה זו למריו בזה.

249
00:11:58,580 --> 00:12:01,000
וכשרצתי קובץ ש,
זה הייתי קורא מריו.

250
00:12:01,000 --> 00:12:04,520
>> אז זה אפשרי שאני רק
רוצה להפעיל את זה אם יש לי בעצם

251
00:12:04,520 --> 00:12:07,290
להורג קובץ מסוים זה.

252
00:12:07,290 --> 00:12:11,520
ואז אני יכול לעטוף את זה ב
ניב כזה, שבו אני אומר,

253
00:12:11,520 --> 00:12:14,820
אם שמו של ביצוע זה
הסביבה היא עיקרי,

254
00:12:14,820 --> 00:12:16,200
אז אני רוצה לעשות את הדברים האלה.

255
00:12:16,200 --> 00:12:18,710
אחרת מישהו אחר יכול
use-- כולל function--

256
00:12:18,710 --> 00:12:22,510
הקובץ שלי, ורק כדי לקבל
גישה לפונקציות אלה

257
00:12:22,510 --> 00:12:25,552
מבלי להפעיל את הדברים
שאני רוצה לבצע בקובץ זה.

258
00:12:25,552 --> 00:12:27,260
שוב זה,, אופציונאלי
אבל נפוץ מאוד.

259
00:12:27,260 --> 00:12:30,450

260
00:12:30,450 --> 00:12:33,840
>> דברים אלה הם entirely-- הם
בדיוק אותו הדבר בין C ופייתון,

261
00:12:33,840 --> 00:12:35,100
בהחלט ב 3.

262
00:12:35,100 --> 00:12:38,610
אני חושב ב2, מפעיל האגף
לפעמים נותן לך בחזרה צף כש

263
00:12:38,610 --> 00:12:41,450
אתה מופעל על ints, וגם
אתה רוצה את זה או שאתה לא.

264
00:12:41,450 --> 00:12:44,777
אבל בתוספת, מינוס, ופעמים
עובד בדיוק כמו שהיית מצפה,

265
00:12:44,777 --> 00:12:46,110
חוץ מאשר על מעט יותר סוגים.

266
00:12:46,110 --> 00:12:49,740
אז אתה יכול להכפיל צף על ידי
ints, ואלה מיני דברים.

267
00:12:49,740 --> 00:12:52,480
>> סט עובד בדיוק אותו הדבר.

268
00:12:52,480 --> 00:12:54,310
אתה יכול להשתמש בשני שלטים שווים.

269
00:12:54,310 --> 00:12:59,000
inequals-- גדול יותר, פחות
מ, מיני things-- אלה

270
00:12:59,000 --> 00:13:02,580
יש משמעויות ש
אתה מכיר אותם.

271
00:13:02,580 --> 00:13:05,770
>> איפה C משתמשת מפעילים אלה,
פייתון משתמש מעט יותר אנגלית

272
00:13:05,770 --> 00:13:06,390
קריאים אלה.

273
00:13:06,390 --> 00:13:09,348
אז במקום שני, סימן חיבור,
פשוטו כמשמעו, הקלד את המילה "ו"," או, "

274
00:13:09,348 --> 00:13:10,740
או לא."

275
00:13:10,740 --> 00:13:13,420
כמו בif-- בך
הצהרות מותנות,

276
00:13:13,420 --> 00:13:17,670
שראינו קודם שתחביר זה ב- C
מתאים לתחביר זה בפייתון.

277
00:13:17,670 --> 00:13:21,010
ואין הרבה שונה
שם, פרט לקצת

278
00:13:21,010 --> 00:13:24,780
פיסוק סביב הצדדים.

279
00:13:24,780 --> 00:13:28,890
שוב, כאשר C אחר היית
אם, Python משתמש אליף,

280
00:13:28,890 --> 00:13:33,960
אבל אלה הם בעיקר
שינויים ברמת שטח.

281
00:13:33,960 --> 00:13:38,450
>> איטרציה כזה היא לעתים קרובות
נכתב בניב זה בפייתון.

282
00:13:38,450 --> 00:13:42,350
אתה יכול לייצר סוג כזה של
דבר עם לולאה בזמן שבחוץ

283
00:13:42,350 --> 00:13:46,387
אם אתה רוצה, אבל אתה
בהחלט לא צריך.

284
00:13:46,387 --> 00:13:48,970
ושוב, אם אתה רוצה
להדפיס את האלמנטים במערך של

285
00:13:48,970 --> 00:13:50,560
אתה יכול לעשות את זה ככה.

286
00:13:50,560 --> 00:13:52,927
אחד הדברים מהנים
על אף Python,

287
00:13:52,927 --> 00:13:54,760
הוא שאתה לא צריך
להשתמש פרדיגמה זו,

288
00:13:54,760 --> 00:13:57,290
ואתה יכול להשתמש
מעט יותר אלגנטי אחד.

289
00:13:57,290 --> 00:13:59,370
אתה אומר בהאר"י.

290
00:13:59,370 --> 00:14:02,980
>> אז לא הולך כאן
ופועל על המדדים,

291
00:14:02,980 --> 00:14:05,630
ולאחר מכן מוציא את
אלמנטים בודדים,

292
00:14:05,630 --> 00:14:08,644
אתה אומר לבעצם רק
לדרוס את האלמנטים עצמם.

293
00:14:08,644 --> 00:14:11,060
ואז כל מה שאתה עושה
בתוך יכול לפעול ישירות

294
00:14:11,060 --> 00:14:13,260
על האלמנטים, שהוא די כיף.

295
00:14:13,260 --> 00:14:16,710
ואנחנו תראה-- אנו נשתמש
ניב ששוב ושוב

296
00:14:16,710 --> 00:14:18,050
כפי שאנו הולכים בקוד.

297
00:14:18,050 --> 00:14:20,091
>> שוב זה,, דוגמא
של משהו שאני

298
00:14:20,091 --> 00:14:23,300
קורא קסם פייתון, אם כי יש
סיבות טכניות מאוד למה זה עובד.

299
00:14:23,300 --> 00:14:26,340
ויש דברים טכניים ש
צריך להיות נכון לגבי מערך כדי

300
00:14:26,340 --> 00:14:28,340
לזה לעבוד מאחורי הקלעים.

301
00:14:28,340 --> 00:14:31,390
העניין הוא שרוב הסוגים
שבו אתה מצפה שזה יעבוד

302
00:14:31,390 --> 00:14:36,610
יש לי זו מיושמת ל
שלך בשפה מובנית.

303
00:14:36,610 --> 00:14:40,030
>> דבר נוסף שזה יהיה נחמד
אם זה עבד בכל שפה,

304
00:14:40,030 --> 00:14:45,460
אבל יש כמה סיבות למה זה לא יכול,
להדפיס פעמים במחרוזת זו מספר זה.

305
00:14:45,460 --> 00:14:48,860
מתברר בפייתון, זה עושה בדיוק
מה אתה רוצה, שהוא פשוט כיף,

306
00:14:48,860 --> 00:14:52,840
והמשמעות הוא שאנחנו באמת יכולים
להפחית תכנית זו, שוב mario.c.

307
00:14:52,840 --> 00:14:57,150
במקום iterating הרבה, אנחנו יכולים
רק אומרים, אני רוצה קצת מספר החללים,

308
00:14:57,150 --> 00:15:01,120
אני רוצה את המספר של Hash,
וכמה גיבובים בסוף.

309
00:15:01,120 --> 00:15:02,640
ושוב, אנו משתמשים בפורמט זה.

310
00:15:02,640 --> 00:15:05,340
>> הנה, אנחנו עוברים ב
משתנה בדרך זו.

311
00:15:05,340 --> 00:15:08,050
שוב, אנחנו לא צריכים לומר
איזה סוג של משתנה זה,

312
00:15:08,050 --> 00:15:11,322
והפעם היחידה שנציע ב
מקבל שגיאות הוא בזמן הריצה.

313
00:15:11,322 --> 00:15:13,030
כאשר מישהו מנסה
להעביר משהו ב,

314
00:15:13,030 --> 00:15:14,860
יבוא לתפקודו בסדר גמור.

315
00:15:14,860 --> 00:15:18,240
אם טריז כאן כי זה לא
דבר שאתה יכול ליצור טווחים מעל,

316
00:15:18,240 --> 00:15:22,100
אני אקבל את שגיאת זמן ריצה יש,
ואני אצטרך לאתר באגים את זה ככה.

317
00:15:22,100 --> 00:15:25,050
אבל בינתיים, אין לי
להיות מאוד זהיר לגבי מה ש

318
00:15:25,050 --> 00:15:32,800
מקבל עבר ב, כל עוד בבפועל
ביצוע כל זה עובד בצורה נקיה מאוד.

319
00:15:32,800 --> 00:15:35,080
>> אני יכול אפילו להפוך את זה
מנקה קצת

320
00:15:35,080 --> 00:15:41,770
באמצעות פונקציה מובנית בפרט
על מיתרים, שיישר לימין.

321
00:15:41,770 --> 00:15:45,250
זה רק פונקציה שימושית
זרוק הספרייה.

322
00:15:45,250 --> 00:15:47,660
זה בתיעוד
אם אתה רוצה ללכת ולחפש אותו.

323
00:15:47,660 --> 00:15:51,650
ואני אומר, גם אני הולך יש לי
מחרוזת זו, חלק מספר של Hash,

324
00:15:51,650 --> 00:15:56,390
ואני רוצה להצדיק את כרית it-- תקין
את זה עם רווחים להיות אורך זה.

325
00:15:56,390 --> 00:16:00,584
>> שוב, זה ב
תיעוד, אשר מביא us--

326
00:16:00,584 --> 00:16:03,500
אני באמת יהיה לחץ באמצעות these--
מה שמביא אותנו לכלל השני שלנו

327
00:16:03,500 --> 00:16:06,990
לספרייה סטנדרטית Python--
שיטות פונקציה הן החברים שלך.

328
00:16:06,990 --> 00:16:09,880
וזה לעתים קרובות תשתלם לך
ללכת לחפש אני תוהה

329
00:16:09,880 --> 00:16:12,310
אם יש דבר שפשוט עושה את זה.

330
00:16:12,310 --> 00:16:13,830
יש כנראה הוא.

331
00:16:13,830 --> 00:16:15,990
אם ברצונך כרית
את מחרוזת, אם היית

332
00:16:15,990 --> 00:16:17,470
רוצה לקחת בחזרה
מחצית ממחרוזת, אם היית

333
00:16:17,470 --> 00:16:20,370
רוצה לחפש במחרוזת, אם
אתה רוצה לנפץ כמה דברים

334
00:16:20,370 --> 00:16:22,420
יחד עם מחרוזת
עם פסיקים ביניהם,

335
00:16:22,420 --> 00:16:24,640
יש בספרייה רגילה
פונקציות לעושים את זה.

336
00:16:24,640 --> 00:16:27,190
>> וזה עושה את החיים שלך
יותר קל אם אתה משתמש בם

337
00:16:27,190 --> 00:16:29,240
במקום מתגלגל החוצה
הכל בעצמך

338
00:16:29,240 --> 00:16:31,650
בחמש שורות של קוד כאן,
חמש שורות של קוד כאן.

339
00:16:31,650 --> 00:16:34,430
זה באמת מתחיל ב
להוסיף עד זמן אמת.

340
00:16:34,430 --> 00:16:37,430
>> אחד הדברים המעניינים
על איך זה נקרא.

341
00:16:37,430 --> 00:16:39,980
תוכל להבחין כי יש דבר נקודה.

342
00:16:39,980 --> 00:16:43,490
יש לי כמה אובייקט בצד השמאל,
ולאחר מכן התקשרתי לנקודה פונקציה.

343
00:16:43,490 --> 00:16:49,780
זהו אחד מפרדיגמות שפייתון
משתמש לחיבור שיטות לאובייקטים.

344
00:16:49,780 --> 00:16:54,410
נדבר על מה זה
הוא לזמן קצר מאוד בסוף,

345
00:16:54,410 --> 00:16:58,510
אבל יודע ששנינו יכול לפעול ב
דברים על ידי לקיחת שנקודה אומרת דבר

346
00:16:58,510 --> 00:17:01,690
מה, או על ידי התקשרות
פונקציה שלוקחת

347
00:17:01,690 --> 00:17:04,339
שאובייקט וכמה טיעונים אחרים.

348
00:17:04,339 --> 00:17:07,450
>> אז אלה הם שני הדרכים ש
דברים להספיק בפייתון.

349
00:17:07,450 --> 00:17:09,780
והאם בפרט
פונקציונלי מיושם

350
00:17:09,780 --> 00:17:14,230
בסגנון זה או זה
סגנון הוא משהו שאתה

351
00:17:14,230 --> 00:17:19,990
צריך להסתכל למעלה עד שאתה מקבל להיתקע
שאחד סביר להניח ליפול לתוכו.

352
00:17:19,990 --> 00:17:22,660
יש פחות או יותר מגובש
פילוסופיה מאחורי פייתון

353
00:17:22,660 --> 00:17:24,930
שאתה סופג בעיקר
על ידי כתיבה הרבה בזה.

354
00:17:24,930 --> 00:17:28,190
בשלב מסוים, שאחד מהם
משהו ייושם כ

355
00:17:28,190 --> 00:17:29,470
הופך להיות טבעי.

356
00:17:29,470 --> 00:17:32,420
לעת עתה, זה רק משהו
ללומדך כמו שאתה להבין

357
00:17:32,420 --> 00:17:34,140
כל דבר פרט.

358
00:17:34,140 --> 00:17:36,420
>> ספרייה אז סטנדרטית
פונקציות הן החברים שלך,

359
00:17:36,420 --> 00:17:41,320
והם מאפשרים לך לכתוב דברים ש
תופס שטח רב זה באמת זמן קצר,

360
00:17:41,320 --> 00:17:42,040
באמת באלגנטיות.

361
00:17:42,040 --> 00:17:45,670
וזה בעצם כנראה יותר
קריא, הייתי אומר, מאשר תכנית C

362
00:17:45,670 --> 00:17:46,780
שם.

363
00:17:46,780 --> 00:17:49,730
שלא לדבר על העובדה שהיא כל כך
קצר אתה יכול להתאים כל פיל

364
00:17:49,730 --> 00:17:52,250
בחלל ששמרנו.

365
00:17:52,250 --> 00:17:56,270
>> דבר נוסף, זה יישום
של מריו זה הנקודה C, שאני חושב ש

366
00:17:56,270 --> 00:17:57,890
הוא הקצר ביותר שאתה יכול לקבל את זה.

367
00:17:57,890 --> 00:18:00,757
זה לא חייב int הגט, אבל
זה קודים קשים השווי של 10

368
00:18:00,757 --> 00:18:02,090
באותו אופן שזה עושה.

369
00:18:02,090 --> 00:18:06,080
מתברר שאחד שעונים זה ב
84 תווים, ואילו פייתון הוא 64.

370
00:18:06,080 --> 00:18:11,490
וזה הרבה יותר
קריא יותר מהזבל הזה כאן.

371
00:18:11,490 --> 00:18:14,610
אז פייתון הוא יעיל יותר בחלל.

372
00:18:14,610 --> 00:18:17,260
זה מעט פחות יעיל
בזמן, אבל לא בהרבה.

373
00:18:17,260 --> 00:18:18,890
>> רשימות הן דבר חשוב בפייתון.

374
00:18:18,890 --> 00:18:21,540

375
00:18:21,540 --> 00:18:24,587
אנחנו לא ראינו אותם, אבל הם
פועל כמו מערכים לעשות בג

376
00:18:24,587 --> 00:18:27,170
אז הנה, אתה יכול להכריז עליהם,
אתה יכול להעביר אותם למשהו.

377
00:18:27,170 --> 00:18:29,810
עכשיו ריבועים מחזיק
מערך של הדברים האלה.

378
00:18:29,810 --> 00:18:33,480
שוב, יש לנו לא הוכרז כ
סוג, אבל אם אי פעם אנחנו מנסים להשתמש בו,

379
00:18:33,480 --> 00:18:36,260
כל דבר שאתה מצפה ל
לעבוד על מערך של מספרים שלמים

380
00:18:36,260 --> 00:18:40,130
הולך לעבוד ב
מערך של מספרים שלמים.

381
00:18:40,130 --> 00:18:42,030
>> זה דבר ש
אתה לא יכול בהחלט

382
00:18:42,030 --> 00:18:47,390
לעשות בC, משום ש
זיכרון זה כל כך על ידיים,

383
00:18:47,390 --> 00:18:48,950
אבל הוא מאוד קל לעשות בפייתון.

384
00:18:48,950 --> 00:18:55,310
אם אני רוצה המערך שלי להיות גדול יותר, אני יכול
לצרף אלמנט אליו וזה בסדר גמור.

385
00:18:55,310 --> 00:18:57,150
>> מה קורה מאחורי הקלעים?

386
00:18:57,150 --> 00:18:59,150
המתורגמן ילך
החוצה ולקבל קצת זיכרון,

387
00:18:59,150 --> 00:19:00,860
ואולי זה יקבל
קצת זיכרון נוסף,

388
00:19:00,860 --> 00:19:03,090
אז אל כל כך אין לי אני
ללהקצות מחדש בכל פעם.

389
00:19:03,090 --> 00:19:04,897
אבל כמה יש לי יותר
זיכרון זה צריך?

390
00:19:04,897 --> 00:19:06,730
זה לא החלטות
שאתה צריך לעשות,

391
00:19:06,730 --> 00:19:10,540
אלה הם החלטות ש
מתורגמן הוא הולך לעשות.

392
00:19:10,540 --> 00:19:12,270
>> כאן אנו רואים יכולים לנוע
לקחת שני טיעונים,

393
00:19:12,270 --> 00:19:16,430
אבל זה עדיין הולך להיות כלול
של הראש כך אנו מוסיפים 1 שם.

394
00:19:16,430 --> 00:19:21,970
זה ניב, שהוא אפילו יותר
דרך חכמה כדי לכתוב דברים כאלה.

395
00:19:21,970 --> 00:19:25,980
זה נקרא הבנת רשימה,
וכאן מה שאנחנו אומרים

396
00:19:25,980 --> 00:19:32,560
הוא הייתי רוצה לשים באני בריבוע
לכל ערך של i בטווח זה.

397
00:19:32,560 --> 00:19:35,770
דבר זה בצד הימין יכול להיות אחר
מערך, והדבר הזה בצד השמאל

398
00:19:35,770 --> 00:19:40,740
להיות כל פונקציה מסוימת
שייקח בי כמשתנה

399
00:19:40,740 --> 00:19:42,250
ולתת לי כמה תוצאה.

400
00:19:42,250 --> 00:19:43,480
>> מה שאני הולך לעשות הוא,
אני הולך לבנות

401
00:19:43,480 --> 00:19:46,200
מערך זה את כל הדברים האלה
לכל ערך בטווח זה.

402
00:19:46,200 --> 00:19:48,960

403
00:19:48,960 --> 00:19:55,670
וזה סופר אלגנטי, סופר קצר,
וזה מאוד ברור מה זה אומר.

404
00:19:55,670 --> 00:19:59,190
זהו אחד
things-- זה שוב,

405
00:19:59,190 --> 00:20:03,860
אחד ל-- סמלי מאוד של
סיבות שאנשים כמו פייתון.

406
00:20:03,860 --> 00:20:05,900
אם אתה אוהב תכנות
ככה, אז פייתון

407
00:20:05,900 --> 00:20:07,830
היא שפה שאולי תרצה ללמוד.

408
00:20:07,830 --> 00:20:10,950
>> ושוב, יש טכניים
סיבות למה זה עובד.

409
00:20:10,950 --> 00:20:14,730
אבל ככל שאנו מודאגים,
לא אכפת פחות או יותר.

410
00:20:14,730 --> 00:20:18,500
>> אז אם אתם רוצים להדפיס את הרשימות,
חלק מאותם הניבים שימושיים.

411
00:20:18,500 --> 00:20:20,940
כי אני בטווח זה, אנחנו יכולים
מדד דרך כל הדברים

412
00:20:20,940 --> 00:20:23,140
ואז להדפיס את כולם.

413
00:20:23,140 --> 00:20:24,650
ותראו לן כאן.

414
00:20:24,650 --> 00:20:27,150
אם אי פעם רציתי להגיע
אורכו של המערך, זה

415
00:20:27,150 --> 00:20:31,150
קל מאוד בפייתון,
זה מאוד קשה בג

416
00:20:31,150 --> 00:20:33,720
זה היה להדפיס את בדיוק
מה שהיית מצפה שזה.

417
00:20:33,720 --> 00:20:36,986
כמו כן, אנו יכולים, כפי שראינו בעבר,
לחזר על האלמנטים במערך

418
00:20:36,986 --> 00:20:39,860
ישירות, ואז פשוט לדבר על
שלהם, ולא שיש המדד

419
00:20:39,860 --> 00:20:43,190
בחזרה למערך בכל פעם.

420
00:20:43,190 --> 00:20:45,990
>> וזה דבר שאתה יכול לעשות.

421
00:20:45,990 --> 00:20:49,984
אז ב- C, אם אתה מבקש משהו
ככה, הדפסה הייתי אומרת,

422
00:20:49,984 --> 00:20:51,150
זה מערך של מספרים שלמים.

423
00:20:51,150 --> 00:20:53,456
זה בהחלט לא
מחרוזת, אני לא יכול להדפיס אותו.

424
00:20:53,456 --> 00:20:54,830
פייתון פחות או יותר לא אכפת.

425
00:20:54,830 --> 00:20:57,496
זה כמו, האם יש דרך שאני
יכול להפוך בזה למחרוזת?

426
00:20:57,496 --> 00:20:58,500
כן, אני אעשה את זה.

427
00:20:58,500 --> 00:21:01,600
ואז אני רק להדפיס את זה.

428
00:21:01,600 --> 00:21:03,640
זה אומר שאתה יכול
לעשות דברים like-- אלה

429
00:21:03,640 --> 00:21:06,530
הם רוב החלקים קשים
משחק חמש עשר, נכתב

430
00:21:06,530 --> 00:21:08,930
לזמן קצר מאוד בפייתון.

431
00:21:08,930 --> 00:21:11,320
>> אתה תראה שיש
קצת ל-- כאן

432
00:21:11,320 --> 00:21:14,441
אני מטיל מספר שלם למחרוזת,
ואני צריך לעשות את זה באופן ידני.

433
00:21:14,441 --> 00:21:16,190
ואני הולך להוסיף
זה למחרוזת אחרת,

434
00:21:16,190 --> 00:21:17,590
או בדרך אחרת פייתון מתבלבל.

435
00:21:17,590 --> 00:21:19,840
אבל אם כשאתה
הוספת מחרוזת למספר שלם,

436
00:21:19,840 --> 00:21:22,630
אני מניח שכדי לקבל
integer גב או מחרוזת בחזרה?

437
00:21:22,630 --> 00:21:24,480
אבל שוב, אם אתה רק
קורא str על דבר,

438
00:21:24,480 --> 00:21:27,240
וזה יכול בכל אפשרי
להיות העולם יומר למחרוזת,

439
00:21:27,240 --> 00:21:30,390
זה יהיה כנראה
יומר למחרוזת.

440
00:21:30,390 --> 00:21:33,120
>> כאן, אנו רואים שימוש ב
הבנת רשימה מקוננת

441
00:21:33,120 --> 00:21:38,690
בצד השמאל, כמה אינדקס, ש
בדיוק כפי שאתה רוצה להיות רגיל לזה,

442
00:21:38,690 --> 00:21:40,060
וכמה הדפסה מתוך דברים.

443
00:21:40,060 --> 00:21:42,560
שוב, אנו הגדרנו כמה
פונקציות ואנחנו נתקשר אותם

444
00:21:42,560 --> 00:21:45,820
בעיקרי כאשר אנחנו באמת לקבל את הקובץ.

445
00:21:45,820 --> 00:21:52,004
תמורה עובדת בדיוק כמו שהיית
מצפה לעבוד עם ג מצא,

446
00:21:52,004 --> 00:21:54,420
אנו יכולים להגדיר את הדברים כמו
זה-- הנה הבנת רשימה

447
00:21:54,420 --> 00:21:59,245
יש משימה למשתנה,
ואנחנו באמת יכולים לעשות את זה אפילו יותר קלים.

448
00:21:59,245 --> 00:22:01,870
אנחנו לא צריכים לכתוב חיפוש,
בגלל מובנה לשפה

449
00:22:01,870 --> 00:22:04,230
הוא אם הדבר הזה הוא במערך זה.

450
00:22:04,230 --> 00:22:05,680
חזור אמיתי, אחר לחזור שווא.

451
00:22:05,680 --> 00:22:08,830
אז זה השלמות של ממצא.

452
00:22:08,830 --> 00:22:12,230
>> השלמות מסוג
כרוך קוראים סוג,

453
00:22:12,230 --> 00:22:15,462
שהוא-- יש מימושים
זה מובנה בתוך ספריות C מסוימות.

454
00:22:15,462 --> 00:22:17,170
אם ברצונך זה
סוג של אחורה, אתה

455
00:22:17,170 --> 00:22:20,450
יכול לעקוף זו שמירת
טיעון בכיוון הפוך עם אמיתי.

456
00:22:20,450 --> 00:22:23,350

457
00:22:23,350 --> 00:22:27,860
ואם אתה רוצה למיין על
מחרוזות, שהוא מובנה וכן.

458
00:22:27,860 --> 00:22:31,950
>> אז זה לא אומר שאלו הם
דברים שאתה צריך לעשות בכל יום,

459
00:22:31,950 --> 00:22:34,280
אבל הרעיון הוא שזה
היא הפילוסופיה של פייתון,

460
00:22:34,280 --> 00:22:37,530
שכל הדברים האלה שהיית
סוג של רוצה לעשות הם מובנים.

461
00:22:37,530 --> 00:22:42,410
ורוב פונקציות סטנדרטיים,
כך סוג, אורך, מה,

462
00:22:42,410 --> 00:22:44,380
לתמוך קלט ביותר הגיוני מהבחינה הלוגית.

463
00:22:44,380 --> 00:22:49,020
אתה קורא לן במערך זהה
דרך בה אתה קורא לן על חוט.

464
00:22:49,020 --> 00:22:55,785
אתה multiply-- למיין את המחרוזות
באותו אופן שלמיין מערכים.

465
00:22:55,785 --> 00:22:58,930

466
00:22:58,930 --> 00:23:00,740
>> רוב פונקציות סטנדרטי
שאנשים לבנות,

467
00:23:00,740 --> 00:23:03,000
והצד השלישי ביותר
ספריות שאנשים

468
00:23:03,000 --> 00:23:06,980
לבנות, בגלל שהם חיקוי
העיצוב של הספרייה סטנדרטית,

469
00:23:06,980 --> 00:23:10,190
יכול להיקרא על כל מה שאתה
כמו, למה לא זה פשוט עובד,

470
00:23:10,190 --> 00:23:12,800
בג פחות או יותר,
זה יעבוד בפייתון

471
00:23:12,800 --> 00:23:15,930
כי אנשים עובדים מאחורי דמות ל
מה הוא דבר ולאחר מכן לפעול

472
00:23:15,930 --> 00:23:17,510
כראוי על זה.

473
00:23:17,510 --> 00:23:22,760
אז שוב, רקע טכני, אבל זה
הופך את חיינו לקלים יותר כמתכנתים.

474
00:23:22,760 --> 00:23:26,820
>> אז הנה אני קובץ / O. קובץ I / O יש המון
דברים קטנים שעושים את זה מסובך,

475
00:23:26,820 --> 00:23:29,890
וכך יש משאבים
באינטרנט, אבל על קצה מזלג,

476
00:23:29,890 --> 00:23:33,010
אתה קורא פתוח על קובץ
שם עם סוג מסוים.

477
00:23:33,010 --> 00:23:37,640
אז זה לקרוא, לקרוא ו
לכתוב, לכתוב או לצרף.

478
00:23:37,640 --> 00:23:41,790
אתה קורא מספר מסוים של
דמויות החוצה ואתה מדפיס אותם,

479
00:23:41,790 --> 00:23:42,595
תקבל שלום!

480
00:23:42,595 --> 00:23:43,970
אני מתכוון, כמו שקובץ זה שלום!

481
00:23:43,970 --> 00:23:46,480
בזה, קורא לקרוא,
ומה שתקבל בחזרה

482
00:23:46,480 --> 00:23:49,520
היא מחרוזת שבה יש את כל
של שאר המערך,

483
00:23:49,520 --> 00:23:50,860
או כל שאר הקבצים.

484
00:23:50,860 --> 00:23:53,805

485
00:23:53,805 --> 00:23:56,055
אם אתה קורא לקרוא שוב,
אתה בסופו של הקובץ,

486
00:23:56,055 --> 00:23:58,138
ואז אתה לא מקבל
כל דבר וכך תוכל לסגור.

487
00:23:58,138 --> 00:24:02,510
שוב, זה לא .close
קרוב קובץ, כמו שזה יהיה בג

488
00:24:02,510 --> 00:24:07,190
זהו פחות או יותר, כי f היא
דבר, ואתה רוצה לF לסגירה.

489
00:24:07,190 --> 00:24:12,092
אבל קלט / פלט קובץ הבסיסי הוא לא
מסובך במיוחד.

490
00:24:12,092 --> 00:24:15,300
שוב, אם אתה רוצה לפתוח קובץ, אם
אתה רוצה לקרוא קו מסוים,

491
00:24:15,300 --> 00:24:17,870
אתה יכול לצאת מבפרט
line-- יש נבנו תוספות של.

492
00:24:17,870 --> 00:24:19,995
אם ברצונך לכתוב
דבר, אתה יכול לכתוב את זה.

493
00:24:19,995 --> 00:24:23,412
אם ברצונך לכתוב את פרט
עקיצות, אתה יכול לכתוב אותם.

494
00:24:23,412 --> 00:24:25,620
ואם אתה רוצה לחזר
על הקווים של קובץ

495
00:24:25,620 --> 00:24:29,557
בנפרד, כפי שעשינו בחתיכה מ
לפני כמה שבועות, אתה יכול לעשות את זה ל.

496
00:24:29,557 --> 00:24:32,140
שוב, רוב החפצים שהייתם
רוצה להיות מסוגל לחזר על

497
00:24:32,140 --> 00:24:33,780
iterating תמיכה עליהם.

498
00:24:33,780 --> 00:24:37,430
בPythons, קובץ הוא אולי דבר ש
אני רוצה לחזר על שורה אחרת שורה.

499
00:24:37,430 --> 00:24:39,138
אם זה היה מילון
של מילות ואני היה

500
00:24:39,138 --> 00:24:42,181
מנסה להשיג בודד אלה
מילות, ואז, בתוך לולאה זו,

501
00:24:42,181 --> 00:24:44,180
קו זה הולך להיות
כל מילה בתורו וזה

502
00:24:44,180 --> 00:24:47,880
הוא הולך להיות מוצא להורג על כל קו
בקובץ עד סוף הקובץ.

503
00:24:47,880 --> 00:24:52,280
ושוב, אם אני הדפסתי כל
קו, הקווים מגיעים עם קווים חדשים,

504
00:24:52,280 --> 00:24:54,740
אז אני קביעת הסוף
חזרה לדבר כזה.

505
00:24:54,740 --> 00:24:56,580
ואז הייתי מקבל את התוכן של הקובץ שלי.

506
00:24:56,580 --> 00:25:03,610

507
00:25:03,610 --> 00:25:07,480
>> הדבר השני שפועל ב
מבחינות מסוימות כמו רשימות, ובמובנים מסוימים

508
00:25:07,480 --> 00:25:11,870
כמשהו משמעותי
חזק יותר,

509
00:25:11,870 --> 00:25:16,170
מילונים הם, שהם באמת
מגניב לשימוש, אבל בעצם חשיש

510
00:25:16,170 --> 00:25:17,670
שולחנות בתחפושת.

511
00:25:17,670 --> 00:25:23,330
אתה יוצר אחד באמצעות בדיוק
שתי דמויות, וזה מדהים

512
00:25:23,330 --> 00:25:25,959
אם אתה ניסית ליישם
שולחן חשיש לסט הבעיה שלך,

513
00:25:25,959 --> 00:25:27,250
אתה יודע הרבה כאב שיכול להיות.

514
00:25:27,250 --> 00:25:29,390
אבל אנשים שעשו
זה, ועשה את זה כל כך טוב,

515
00:25:29,390 --> 00:25:32,260
שאין לך ל
לדאוג על זה יותר.

516
00:25:32,260 --> 00:25:35,180
>> אז אתה יכול להכניס דברים אישיים.

517
00:25:35,180 --> 00:25:38,110
tables-- או מילוני חשיש
לא במיוחד

518
00:25:38,110 --> 00:25:40,240
אכפת לי מה אתה אחסון בהם.

519
00:25:40,240 --> 00:25:44,210
אז אם חלק מהרשומות מספרים,
וכמה ערכי רשימות,

520
00:25:44,210 --> 00:25:47,360
אם חלק מרשומות הן מילונים אחרים,
וכמה ערכים הם מחרוזות,

521
00:25:47,360 --> 00:25:49,930
פייתון לא אכפת.

522
00:25:49,930 --> 00:25:53,460
>> שוב, אם אתה נכנסת לזה ציפה
מחרוזת ומה שאתה מקבל בחזרה

523
00:25:53,460 --> 00:25:56,269
הוא מערך, זאת הבעיה שלך.

524
00:25:56,269 --> 00:25:58,810
ואולי זה באשמתו של מי ש
חשב שזה היה לשים דברים

525
00:25:58,810 --> 00:26:00,476
במילון, אולי זה היה לך.

526
00:26:00,476 --> 00:26:02,350
אם זה היה מישהו
אחר, אני מקווה שהם היו

527
00:26:02,350 --> 00:26:04,520
התנהג יפה על מה ש
היה הולך במילון

528
00:26:04,520 --> 00:26:07,420
ולא להשאיר שום חסרונות
בשבילך ליפול לתוכו.

529
00:26:07,420 --> 00:26:10,890
>> אבל הפונקציות סטנדרטי תהיה
אתן לך בחזרה דברים מחונכים.

530
00:26:10,890 --> 00:26:13,500
אז הם אומרים זה חוזר
לגבות מילון של מחרוזות,

531
00:26:13,500 --> 00:26:15,860
אז כל מה שאתה הולך
לצאת מהוא מחרוזת.

532
00:26:15,860 --> 00:26:20,710
אם אתה עושה קצת מזה וזה טיולים
אותך, גם, שעשוי להיות לך.

533
00:26:20,710 --> 00:26:25,542
פייתון בהחלט נותן לך מספיק
חבל לתלות את עצמך, אם תרצה.

534
00:26:25,542 --> 00:26:28,250
עכשיו אנחנו יכולים להדפיס את הפרט
אלמנטים של זה וזה חוזר

535
00:26:28,250 --> 00:26:29,935
בדיוק מה שהיית מצפה.

536
00:26:29,935 --> 00:26:32,810
בדיוק מה שהיית מצפה, אני מניח,
הוא ביטוי שאני משתמש הרבה,

537
00:26:32,810 --> 00:26:35,070
אבל זה יותר או
פחות איך פייתון עובד.

538
00:26:35,070 --> 00:26:39,880
אם אתה שואל על דבר שאינו
זה, Python יהיה לזרוק את השגיאה

539
00:26:39,880 --> 00:26:43,194
וזה יהיה להפסיק אותך מ
מה בתכנית שהיית ב.

540
00:26:43,194 --> 00:26:45,360
זה באמת יהיה להדפיס
יותר מידע מזה,

541
00:26:45,360 --> 00:26:49,110
זה יהיה לכוון אותו ימצא אתם--
להוסיף שורה, וכל כך.

542
00:26:49,110 --> 00:26:52,190
>> ושוב, אולי אנחנו רוצים
ללחזר על מילונים

543
00:26:52,190 --> 00:26:54,410
ולמצוא את כל הדברים בזה.

544
00:26:54,410 --> 00:26:57,440
כאן אנחנו iterating על
שני דברים באותו הזמן.

545
00:26:57,440 --> 00:27:03,040
וכך אנחנו נעשה את זה עם מפתח, ערך,
אבל אז להדפיס את כל אלה.

546
00:27:03,040 --> 00:27:06,300
>> ואם אנחנו רוצים cast--
אם אנחנו באמת רצנו זה,

547
00:27:06,300 --> 00:27:10,840
הייתה לנו כמה בעיות, כי
on-- כשנכנסנו עם דוד,

548
00:27:10,840 --> 00:27:13,920
זה לא יכול add-- אם אנחנו לא
להפיל אותו למחרוזת ראשונה,

549
00:27:13,920 --> 00:27:17,802
אנו לא יכולים להוסיף מערך ש
של מחרוזות על מחרוזת.

550
00:27:17,802 --> 00:27:19,760
אבל אם אנחנו מטילים אותו ל
מחרוזת, אנחנו מקבלים משהו

551
00:27:19,760 --> 00:27:22,590
כמו זו, שהיא אולי
מה שהיינו רוצה לקרוא.

552
00:27:22,590 --> 00:27:27,000

553
00:27:27,000 --> 00:27:30,500
>> וזה איות.

554
00:27:30,500 --> 00:27:32,460
אנחנו פשוט לקרוא בדברים.

555
00:27:32,460 --> 00:27:35,770
אז אנחנו יכולים לקרוא ב
מילות בודדות כקווים.

556
00:27:35,770 --> 00:27:38,240
אנו לכרות את שעבר
דבר, כך מעי גס מינוס 1

557
00:27:38,240 --> 00:27:41,651
לועס את הדבר האחרון שwe--
התו האחרון של מחרוזת.

558
00:27:41,651 --> 00:27:42,150
אנחנו נגיד.

559
00:27:42,150 --> 00:27:44,730
אישור, כל אחד מאותם מקבל
מוכנס לתוך מילון זה,

560
00:27:44,730 --> 00:27:45,810
מיפוי לערך של 1.

561
00:27:45,810 --> 00:27:48,006
אנחנו לא במיוחד
אכפת כי אחד,

562
00:27:48,006 --> 00:27:51,130
אבל זה רק שם כדי לומר, נו טוב,
הדבר הזה אני אשים במילון.

563
00:27:51,130 --> 00:27:53,182
כי אחר מה אנחנו
הולך לעשות הוא אנחנו

564
00:27:53,182 --> 00:27:55,390
הולך להגיד, טוב, אם זה
במילון בכלל.

565
00:27:55,390 --> 00:27:57,650
>> שוב, סימון זו ל
החברות היא עד הפעלה

566
00:27:57,650 --> 00:28:00,940
באמצעות אחר לגמרי
אלגוריתם מאשר שזה יהיה ברשימה,

567
00:28:00,940 --> 00:28:05,709
אבל אנחנו קוראים לזה באותה הדרך, ש
זה חלק מעניין ציפוי סוכר פייתון

568
00:28:05,709 --> 00:28:07,250
את הדברים כך שהם קלים יותר לשימוש.

569
00:28:07,250 --> 00:28:10,230
ושוב, שראינו
דברים כמו זה לפני.

570
00:28:10,230 --> 00:28:12,940
זה בעצם למצוא, או
זה בדיוק אותו דבר התחביר

571
00:28:12,940 --> 00:28:16,480
כלמצוא, אבל פועל על
מבנה שונה לחלוטין.

572
00:28:16,480 --> 00:28:20,170
ולא אכפת לנו במיוחד.

573
00:28:20,170 --> 00:28:25,540
אז אלה הם הדברים שאתה
התבקשו ליישם לאיות.

574
00:28:25,540 --> 00:28:29,278
בקצב הזה, אנחנו הולכים לקבל
פחות או יותר כל psets עשה.

575
00:28:29,278 --> 00:28:31,474
>> קהל: אז ש
בעצם רק חוזר

576
00:28:31,474 --> 00:28:34,852
כשגוי כוסמין אם זה לא
להתאים משהו במילון?

577
00:28:34,852 --> 00:28:36,060
ROSS RHEINGANS-YOO: כן, כן.

578
00:28:36,060 --> 00:28:38,964

579
00:28:38,964 --> 00:28:40,880
וכך, זה הוא
הסתגלות של בעיה להגדיר

580
00:28:40,880 --> 00:28:43,150
שמבקש ממך לעשות בדיוק את זה.

581
00:28:43,150 --> 00:28:46,357
>> קהל: למה הוא הקו מינוס 1 שם?

582
00:28:46,357 --> 00:28:48,190
ROSS RHEINGANS-YOO: אז
כאשר אתה iterating

583
00:28:48,190 --> 00:28:50,300
על קובץ מבקש
על ידי קווים, הקווים

584
00:28:50,300 --> 00:28:53,900
מגיע עם אופי קו חדש
בסוף it-- 1 מינוס

585
00:28:53,900 --> 00:28:55,260
רק כדי לקנות אותם משם.

586
00:28:55,260 --> 00:28:59,549
וזה במיוחד גמיש
דרך של אינדקסים לדברים.

587
00:28:59,549 --> 00:29:01,590
אז אם יש לך מחרוזת,
ואתה רוצה, גם אני

588
00:29:01,590 --> 00:29:05,340
הולך להתחיל בדמות שלוש
ואני מתכוון ללכת עד הסוף.

589
00:29:05,340 --> 00:29:07,140
3 מעי גס יעשה את זה בשבילך.

590
00:29:07,140 --> 00:29:10,570
אם אתם כמו, אני רוצה להתחיל ב
מתחיל וללכת למינוס 1 האחרון

591
00:29:10,570 --> 00:29:12,400
אופי, מעי גס מינוס 1.

592
00:29:12,400 --> 00:29:14,940
ואם אתה רוצה ללכת מ
השלישי למינוס הראשון,

593
00:29:14,940 --> 00:29:16,570
אז אתה הייתי אומר 3 מינוס 1.

594
00:29:16,570 --> 00:29:19,464

595
00:29:19,464 --> 00:29:22,400
>> בנוסף, אם אתה רוצה מדד
לדברים ספירה מאחור,

596
00:29:22,400 --> 00:29:24,470
אתה רק מדד בעם מספרי מינוס.

597
00:29:24,470 --> 00:29:26,980
וכי, כאשר C
יתפוצץ או אולי

598
00:29:26,980 --> 00:29:31,090
להאכיל אותך זיכרון אחר לא היה לך
גישה ל, לשמוע שאתה יכול להגיד מינוס 1

599
00:29:31,090 --> 00:29:34,104
הפירוש האחרון אבל 1
דמות במחרוזת.

600
00:29:34,104 --> 00:29:36,950

601
00:29:36,950 --> 00:29:43,590
>> מודולים version-- הם
תחליפים לספריות בC

602
00:29:43,590 --> 00:29:45,119
ושימושיים להרבה דברים.

603
00:29:45,119 --> 00:29:46,910
דברים הרבה שהיית
רוצה לעשות בפייתון,

604
00:29:46,910 --> 00:29:50,040
חוץ מזה פשוט
מניפולציה של משתנים,

605
00:29:50,040 --> 00:29:52,290
אתה רוצה להתחבר ל
ספריות גדולות עם גדול יותר

606
00:29:52,290 --> 00:29:55,910
ממשקים ועוד
יכולות לאינטראקציה

607
00:29:55,910 --> 00:29:57,195
עם חלקים אחרים של העולם.

608
00:29:57,195 --> 00:29:58,910
sys הוא אחד מאותם
עם חבורה של כלים

609
00:29:58,910 --> 00:30:01,159
כי הם שימושיים לאינטראקציה
עם המערכת עצמה

610
00:30:01,159 --> 00:30:05,050
ולייבא אותו כמו sys יבוא.

611
00:30:05,050 --> 00:30:07,820
>> יש יותר מתיעוד
ש, שבו אתה יכול ללכת לכאן,

612
00:30:07,820 --> 00:30:11,490
או שאתה יכול למצוא בגוגל
על ידי googling sys פייתון.

613
00:30:11,490 --> 00:30:12,640
אתה מקליד בזן.

614
00:30:12,640 --> 00:30:15,140
הקישור הראשון הולך להיות
התיעוד בפייתון 2,

615
00:30:15,140 --> 00:30:19,260
הקישור השני הולך
להיות פייתון התיעוד 3.

616
00:30:19,260 --> 00:30:24,830
>> ואם כתבנו את קובץ שנראו
כמו זה-- אם בפרט, אנחנו

617
00:30:24,830 --> 00:30:27,910
מסתכל על ההפעלה ב
שורת פקודת טיעונים,

618
00:30:27,910 --> 00:30:30,040
כמו שלמדנו לעשות מאוד
בשלב מוקדם במעמד הזה.

619
00:30:30,040 --> 00:30:32,190
זה לא קשה.
אתה יכול לצאת argv,

620
00:30:32,190 --> 00:30:34,565
שהוא אחד מאותם דברים
אשר מיושם על ידי SYS.

621
00:30:34,565 --> 00:30:37,210
זה לא מובנה ל
חבילת בסיס, אבל שוב, אתה

622
00:30:37,210 --> 00:30:40,080
יכול להאריך אותו על ידי יבוא
פונקציונלי שמsys.

623
00:30:40,080 --> 00:30:41,090
אתה קורא לזה sys.

624
00:30:41,090 --> 00:30:42,611
מה שתגיד.

625
00:30:42,611 --> 00:30:43,360
כאן יש argv.

626
00:30:43,360 --> 00:30:45,193
יש למעשה אין
argc בsys, כי אתה

627
00:30:45,193 --> 00:30:47,880
יכול לקבל את זה כל כך בקלות על ידי קורא לן.

628
00:30:47,880 --> 00:30:55,390
לאחר מכן, אנו הדפסנו את זה, אז אנחנו
רץ על echo-args.py המסוף שלנו.

629
00:30:55,390 --> 00:30:58,360
אנחנו מקבלים בחזרה מערך, ש
הטיעון הראשון.

630
00:30:58,360 --> 00:31:02,240
שוב, זה argv 0, שהוא
שמו של הדבר שיש בשם.

631
00:31:02,240 --> 00:31:04,870
אם קראנו לו עם נוסף
טיעונים, היינו מקבלים אותם בחזרה.

632
00:31:04,870 --> 00:31:07,687

633
00:31:07,687 --> 00:31:09,770
זוהי דרך אחת להגיע ל
שורת פקודת טיעונים.

634
00:31:09,770 --> 00:31:13,440
אם אתה רוצה דגלים שבו אתה פונה
דברים מסוימים באו לעקוף

635
00:31:13,440 --> 00:31:16,050
ברירת מחדל מסוים,
argparse הוא חבר שלך.

636
00:31:16,050 --> 00:31:21,550
ושוב אתה מוצא באינטרנט ש
בפיתון argparse בגוגל.

637
00:31:21,550 --> 00:31:24,300
>> יש כמה שירות
מודולים שאתה מוצא את עצמך באמצעות

638
00:31:24,300 --> 00:31:27,630
ושוב, אם אתה מבלה כל זמן
של שפה זה יבוא jsons

639
00:31:27,630 --> 00:31:33,300
לקריאה ובמתוך JSON
קבצים, לא כל כך מסובך.

640
00:31:33,300 --> 00:31:37,139
אתה פותח את קובץ, אתה נקרא json.load
בקובץ שאתה מקבל בחזרה דבר.

641
00:31:37,139 --> 00:31:37,930
מה זה הדבר הזה?

642
00:31:37,930 --> 00:31:40,329
זה אובייקט JSON.

643
00:31:40,329 --> 00:31:42,370
איפה JSON שיש מערך,
יש פייתון מערכים.

644
00:31:42,370 --> 00:31:44,420
איפה יש JSON ש
מערכים אסוציאטיביים, פייתון של

645
00:31:44,420 --> 00:31:48,810
מילונים, מחרוזות,
ומספרים, וכן הלאה.

646
00:31:48,810 --> 00:31:53,560
אתה רוצה לזרוק את זה, אתה
לפתוח את הקובץ חדש, אתה קורא מזבלה,

647
00:31:53,560 --> 00:31:57,590
והמון ומשליכה ל
להיכנס ולצאת של מחרוזות.

648
00:31:57,590 --> 00:32:02,120
>> באופן דומה, חמוץ מקבל נקרא
ביסודו של דבר באותו הממשק.

649
00:32:02,120 --> 00:32:04,740
זה קצת יותר שימושי אם
אתה השלכת חפצי פייתון.

650
00:32:04,740 --> 00:32:08,370
אז אם אי פעם רציתי להציל
גרסה של המצב הנוכחי

651
00:32:08,370 --> 00:32:11,930
של משתנה לעתיד
לרוץ של התכנית שלך,

652
00:32:11,930 --> 00:32:14,740
חמוץ הוא פייתון של
ספרייה לעושה את זה.

653
00:32:14,740 --> 00:32:19,140
>> אם יש לך כל סוג של
משתנה שיכול להיות כתוב החוצה

654
00:32:19,140 --> 00:32:21,990
במילים כמו ותווים ו
bytes-- כמו מילון זה,

655
00:32:21,990 --> 00:32:24,230
אנחנו יכולים לרשום, אנחנו
יכול לכתוב את זה כ

656
00:32:24,230 --> 00:32:26,670
כמו אובייקט JSON, שהיה
פשוטו כמשמעו בתווים אלה.

657
00:32:26,670 --> 00:32:29,420
ואז זה יהיה קל מאוד ל
אדם כדי לפתוח אותו up-- להיפתח

658
00:32:29,420 --> 00:32:30,889
ולקרוא אותו.

659
00:32:30,889 --> 00:32:33,180
אם אנחנו לא עשינו במיוחד
אכפת בני אדם לקרוא אותו,

660
00:32:33,180 --> 00:32:38,490
אנחנו יכולים לארוז אפילו בצורה יעילה יותר
לצורות שמאוחר יותר יכול להיות לא ארוזים

661
00:32:38,490 --> 00:32:42,860
או שיכול להיות מאוחר יותר מנופח.

662
00:32:42,860 --> 00:32:46,740
וזה חוסך 80% מ
חלל שאולי האובייקטים שלך

663
00:32:46,740 --> 00:32:49,390
לקחת אם אתה כתב אותם כתב היד.

664
00:32:49,390 --> 00:32:52,384
>> אתה קורא חמוץ מאוד
אותו way-- מזבלה, העומס,

665
00:32:52,384 --> 00:32:53,800
ואז אתה מקבל בחזרה את הדברים שלך.

666
00:32:53,800 --> 00:32:56,880
אז אם אתה כותב מאוד
תוכניות פייתון קצרות ש

667
00:32:56,880 --> 00:32:59,952
רוצה לחסוך מדינה, ולאחר מכן לקרוא
שלהם שוב מאוחר יותר, דברים כאלה

668
00:32:59,952 --> 00:33:00,660
הם החברים שלך.

669
00:33:00,660 --> 00:33:02,640
כי אתה יכול מאוד
בקלות לזרוק אותם כJSON.

670
00:33:02,640 --> 00:33:04,550
רוב אובייקטי פייתון
יכול לזרוק את JSON

671
00:33:04,550 --> 00:33:11,310
אם יש תקווה כלשהי שמבנית
הם יכולים להיות מיוצגים בדרך זו.

672
00:33:11,310 --> 00:33:14,410
>> אלה הם רק קצה
קרחון על מודולים שהם שימושיים.

673
00:33:14,410 --> 00:33:19,510
אז sys, מערכת הפעלה, ריבוי, הן
סוג של סוסי עבודה בסיסיות לדברים

674
00:33:19,510 --> 00:33:23,120
אנחנו צריכים אינטראקציה עם
מערכת ההפעלה מערכת קבצים.,

675
00:33:23,120 --> 00:33:28,764
כמו os.isfile, os.isdirectory,
os.makefile, אלה הם החברים שלך.

676
00:33:28,764 --> 00:33:30,930
אם אתה רוצה אינטראקציה
עם סוג קובץ מסוים,

677
00:33:30,930 --> 00:33:32,190
JSON, מלפפון חמוץ, CSV.

678
00:33:32,190 --> 00:33:37,160
אם אתה רוצה אינטראקציה עם אינטרנט
דפים, urllib להשגת http

679
00:33:37,160 --> 00:33:41,370
דפים. bs4-- BeautifulSoup--
זה מנתח נפלא לHTML.

680
00:33:41,370 --> 00:33:47,047
אתה מפעיל את זה ב- HTML ואתה
לקבל אובייקט מערך מקונן זה עכשיו,

681
00:33:47,047 --> 00:33:49,630
שבו אתה יכול לעבור על
Lookin, עם סתם מחפש

682
00:33:49,630 --> 00:33:52,380
אם, הוא, ב, שהוא פנטסטי.

683
00:33:52,380 --> 00:33:55,920
>> יש חבורה של
חבילות לrunning--

684
00:33:55,920 --> 00:33:57,960
לעושה בעיקר הדברים mathy.

685
00:33:57,960 --> 00:34:01,790
אז אם אתה רוצה להכפיל,
להפוך, להפוך מטריצות,

686
00:34:01,790 --> 00:34:05,690
numpy משמש אנשים בכל
רחבי העולם בשביל זה.

687
00:34:05,690 --> 00:34:09,620
scipy הוא אפילו יותר שימושי
כלים בכיוון זה.

688
00:34:09,620 --> 00:34:13,980
למידת מכונה sklearn--,
עיבוד שפה טבעי,

689
00:34:13,980 --> 00:34:17,880
סופר דברים שימושיים, מקבלים
מיושם בפייתון כל הזמן.

690
00:34:17,880 --> 00:34:21,469
>> ושוב, לוקח מעט
עוד לwrite-- מצטער,

691
00:34:21,469 --> 00:34:26,199
לוקח מעט יותר זמן לרוץ, אבל
הסיבה שמהנדסים אמיתיים נוטים

692
00:34:26,199 --> 00:34:29,900
השימוש פייתון בגלל שאתה נוטה להיות
נחסם עליך לכתוב את הקוד, ולא

693
00:34:29,900 --> 00:34:32,699
מהמחשב שלך מפעיל את הקוד.

694
00:34:32,699 --> 00:34:35,860
אז אם אתה הולך לכתוב
תכנית, שהרבה אנשים אחרים

695
00:34:35,860 --> 00:34:37,699
הולכים להשתמש
לנצח, כמו לינוקס,

696
00:34:37,699 --> 00:34:41,900
אולי לכתוב את זה בג אם היית
הולך לכתוב מנוע חישוב,

697
00:34:41,900 --> 00:34:46,124
אולי אתה כותב בפייתון אם אתה זקוק ל
כדי לשנות אותו כל כמה חודשים.

698
00:34:46,124 --> 00:34:48,540
יש אנשים שהיו כותבים את זה ב
C בגלל שהם כאלה.

699
00:34:48,540 --> 00:34:51,100

700
00:34:51,100 --> 00:34:54,050
>> אז ראינו sys יבוא
כדרכו של מקבל דברים

701
00:34:54,050 --> 00:34:57,070
של מקבל מודול לתכנית שלך.

702
00:34:57,070 --> 00:35:00,370
גם אתה יכול לייבא אותו כ
כינוי, אם תרצה.

703
00:35:00,370 --> 00:35:03,660
שוב ריבוי הוא כאב ל
הקלד את כל זמן, אז לייבא כmp

704
00:35:03,660 --> 00:35:05,900
ולאחר מכן בכל עת ש
להשתמש בו בתכנית,

705
00:35:05,900 --> 00:35:09,732
אתה תגיד mp.process, או מה שיש לך.

706
00:35:09,732 --> 00:35:12,670
אם ברצונך יבוא
רק דבר אחד,

707
00:35:12,670 --> 00:35:19,450
כך יש urllib דבר שנקרא
בקשה, כך שאתה יכול פשוט לייבא את זה.

708
00:35:19,450 --> 00:35:22,610
מאוחר יותר, אתה לא להפעיל אותו כ
urllib.request, אבל בדיוק כמו בקשה

709
00:35:22,610 --> 00:35:24,590
בעצמו.

710
00:35:24,590 --> 00:35:30,110
>> ואתה יכול לייבא כל דבר
ממודול אם תרצה.

711
00:35:30,110 --> 00:35:34,820
זה לעתים לא idea-- טוב
בדרך כלל לא רעיון טוב זה, בעצם.

712
00:35:34,820 --> 00:35:39,080
מכיוון שאתה מאוד-- כי אם כל דבר
במודול שיש לו שם ש

713
00:35:39,080 --> 00:35:41,640
רציתי להשתמש במקום אחר
בתכנית שלך, אתה לא יכול.

714
00:35:41,640 --> 00:35:44,127
>> וזה לא תמיד ברור
שזה המקרה.

715
00:35:44,127 --> 00:35:46,460
על מנת לוודא ש
מה אתה היית עושה היה בטוח,

716
00:35:46,460 --> 00:35:47,920
אתה צריך לפתוח את
ויראה את כל מודול

717
00:35:47,920 --> 00:35:50,295
מהשמות שסופו של הדבר ב
כל הפונקציות יניהם--,

718
00:35:50,295 --> 00:35:53,010
כל המשתנים
שגר במודול ש,

719
00:35:53,010 --> 00:35:57,040
כי אתה מביא את כל
אותם למרחב המקומי שלך.

720
00:35:57,040 --> 00:35:58,680
>> אז אנשים עושים את זה.

721
00:35:58,680 --> 00:36:01,322
באופן כללי מומלץ
שאתה לא עושה את זה.

722
00:36:01,322 --> 00:36:03,280
אבל אנשים עושים את זה כל
הזמן בגלל שהם

723
00:36:03,280 --> 00:36:05,180
עצלן ולא רוצה להקליד את חבר הפרלמנט.

724
00:36:05,180 --> 00:36:06,310
שום דבר, אי פעם.

725
00:36:06,310 --> 00:36:09,560

726
00:36:09,560 --> 00:36:13,310
>> כל הדיבורים האלה על מודולים
תביא לי סביב לשיחה קצרה

727
00:36:13,310 --> 00:36:15,930
על איך אתה לעצב תוכניות בפייתון.

728
00:36:15,930 --> 00:36:19,860
הצעד הראשון הוא לבדוק אם
מישהו אחר כבר עשה את הדבר,

729
00:36:19,860 --> 00:36:22,160
או לעשות 90% מהדבר.

730
00:36:22,160 --> 00:36:26,010
רוב הסיכויים הם כנראה שיש להם, ואתה
צריך ללכת לקבל את הדבר שלהם ולהפעיל את זה.

731
00:36:26,010 --> 00:36:28,900
או לכתוב מעטפת סביבו
כדי להתאים אותה למטרה שלך.

732
00:36:28,900 --> 00:36:31,250
זה רק אחרי שיש לי
נכשל כי היית אז

733
00:36:31,250 --> 00:36:35,529
ללכת על וwrite-- להתחיל לחשוב על
איך היית לשים את הדבר הזה ביחד.

734
00:36:35,529 --> 00:36:37,320
יש המון דברים
בחוץ, וזה

735
00:36:37,320 --> 00:36:39,180
אחד שימושי ביותר
דברים על פייתון.

736
00:36:39,180 --> 00:36:40,930
כמו השפה היא
אלגנטית, השפה

737
00:36:40,930 --> 00:36:43,800
קל לשימוש, אלא גם משום ש
זה כל כך אלגנטי וקל לשימוש,

738
00:36:43,800 --> 00:36:47,420
אנשים כבר משתמשים בו ל
זמן רב ויש הרבה דברים

739
00:36:47,420 --> 00:36:52,520
שם בחוץ, כי אתה יכול
לרתום לשימוש שלך.

740
00:36:52,520 --> 00:36:58,457
>> אז שלטון פייתון האחרון הוא, מישהו
אחר כנראה כבר נכתב

741
00:36:58,457 --> 00:37:00,290
מודול של,
מישהו אחר כבר

742
00:37:00,290 --> 00:37:02,980
כנראה נכתב ספרייה בשביל זה.

743
00:37:02,980 --> 00:37:06,579
לפני שאתה מנסה לעשות דבר, נראה
כדי לראות אם זה יושם.

744
00:37:06,579 --> 00:37:07,370
זה לא כל כך קשה.

745
00:37:07,370 --> 00:37:11,960
כל המודולים ששמתי את
לפני, אולי עם חריג אחד,

746
00:37:11,960 --> 00:37:15,220
מגיע מותקן מראש בכל
התקנת פייתון סטנדרטית.

747
00:37:15,220 --> 00:37:17,769
וכך, עם קריאה ל
לייבא מה, אתה

748
00:37:17,769 --> 00:37:19,852
יש כל הפונקציונליות ש
בקץ אצבעותיך.

749
00:37:19,852 --> 00:37:24,660

750
00:37:24,660 --> 00:37:28,920
>> מתחיל לעטוף את זה
דיבורים, יש כמה דברים

751
00:37:28,920 --> 00:37:32,770
כי אני כבר עזבתי כקופסות שחורות
ולא הקדיש זמן לסוג של,

752
00:37:32,770 --> 00:37:37,217
ויש כמה שקרים לבנים שיש לי
אמר שלמען היושר,

753
00:37:37,217 --> 00:37:39,050
אני יהיה לפחות נקודה ב
כאן, גם אם לא יהיה אני

754
00:37:39,050 --> 00:37:43,980
ללכת סופר עמוק לתוך כולם
וההסברים הטכניים שלהם.

755
00:37:43,980 --> 00:37:46,010
>> הרבה דברים
כי אני כבר בשם קסם

756
00:37:46,010 --> 00:37:48,980
זה מה שאנשים אחרים היינו קוראים ל
תכנות מונחה עצמים.

757
00:37:48,980 --> 00:37:52,470
אז יש הרבה things--
כך משתנה לעתים קרובות מאוד לא

758
00:37:52,470 --> 00:37:56,540
בתים פשוטים יושבים ב,
הזיכרון, אבל הם מאוד מסובכים

759
00:37:56,540 --> 00:38:01,910
אובייקטים שיש לי פנימי
מדינה על פונקציות והרבה

760
00:38:01,910 --> 00:38:05,570
משתנים של נסתרים, המון
פונקציונלי נסתר, ש

761
00:38:05,570 --> 00:38:09,480
מאפשר לך להפוך אותם למחרוזות,
המאפשר לך לחזר עליהם.

762
00:38:09,480 --> 00:38:12,260
ואם אתה writing--
והסיבה שהם

763
00:38:12,260 --> 00:38:15,710
יש כל פונקציונליות עשירה זה
סיבה לכך הוא אנשים--

764
00:38:15,710 --> 00:38:17,740
האדריכלים של
language-- הלכו

765
00:38:17,740 --> 00:38:22,420
דרך ועל כל סטנדרטי
אובייקט, לשים בפונקציונליות

766
00:38:22,420 --> 00:38:26,970
להגיד את זה הוא איך זה
איך זה הולך לפעול

767
00:38:26,970 --> 00:38:28,470
אם מישהו רוצה לחזר על זה.

768
00:38:28,470 --> 00:38:31,240
>> אז כל מה שאולי מישהו
אולי רוצה לחזר על,

769
00:38:31,240 --> 00:38:34,529
יש היגיון נכתב ב
באופן ידני על איך אתה

770
00:38:34,529 --> 00:38:36,070
אמור לחזר על אובייקט ש.

771
00:38:36,070 --> 00:38:40,274
כל מה שאתה יכול אולי רוצה
זרקנו למחרוזת יש היגיון בכתב.

772
00:38:40,274 --> 00:38:43,440
זוהי הפונקציה שאתה קורא אם
אתה רוצה לזרוק את זה למחרוזת.

773
00:38:43,440 --> 00:38:45,273
זו הסיבה שאתה יכול
קורא len על דברים, זה

774
00:38:45,273 --> 00:38:49,900
לכן אתה יכול להתקשר ב, זה הוא
לכן אתה יכול להתקשר אם בכל מה ש

775
00:38:49,900 --> 00:38:53,490
שהיית רוצה, משום ש
אלה כולם נושאים עימם,

776
00:38:53,490 --> 00:38:55,380
הידע הטכני לעשות את זה.

777
00:38:55,380 --> 00:38:58,170

778
00:38:58,170 --> 00:39:00,432
>> זה משהו שאני
הסופר לא הולך להיכנס.

779
00:39:00,432 --> 00:39:03,140
אבל על הדבר ברשימה הוא בעדינות
שונה מסגנון C ללולאות,

780
00:39:03,140 --> 00:39:06,160
ואתה יכול לקרוא על כל שעל
האינטרנט אם אתה מעוניין.

781
00:39:06,160 --> 00:39:08,930
יש גם צד אפל לכל
זה, שהזכרתי,

782
00:39:08,930 --> 00:39:10,359
כך שיש שני דברים.

783
00:39:10,359 --> 00:39:13,400
הראשון הוא שאובייקט זה מכוון
תכנות מוסיף הרבה מעל

784
00:39:13,400 --> 00:39:16,080
לדברים אקראיים, כך שאתה בסופו של
דבר באמצעות הרבה יותר זיכרון;

785
00:39:16,080 --> 00:39:18,640
אתה בסופו של דבר באמצעות יותר קטן
זמן מאשר היית אחר.

786
00:39:18,640 --> 00:39:21,300
Other-- אבל יותר
צד אפל חתרנית לזה

787
00:39:21,300 --> 00:39:24,047
כלומר, אם דברים פשוט לפעול
כמו שאתה רוצה שהם

788
00:39:24,047 --> 00:39:27,130
מבלי שתצטרך לחשוב סופר קשה
לגבי שאלה אם זה צריך להיות int

789
00:39:27,130 --> 00:39:29,713
או האם צריכה להיות
לצוף, זה יכול להיות שמעל כאן

790
00:39:29,713 --> 00:39:34,240
אתה לייצר int אבל כאן אתה
חושב אבל הם תמיד-- מצטערים,

791
00:39:34,240 --> 00:39:36,555
זה יכול להיות שכאן
אתה לייצר לצוף,

792
00:39:36,555 --> 00:39:39,430
אבל כשאתה מגיע לחלק השני
התכנית שלך, אתה חושב,

793
00:39:39,430 --> 00:39:41,150
נו טוב, אבל הם
תמיד עובר לי int.

794
00:39:41,150 --> 00:39:43,608
ואם לא תעשו כן, זה אפשרי
כי אתה תקוע איפשהו,

795
00:39:43,608 --> 00:39:47,600
אם אתה מנסה להשתמש בזה למדד
למערך, או מה שיש לך.

796
00:39:47,600 --> 00:39:51,050
>> אז אחת מהאמיתי
דברים שימושיים על C הוא

797
00:39:51,050 --> 00:39:54,219
זה מכריח אותך לחשוב באמת
קשה לפני שתבצע any--

798
00:39:54,219 --> 00:39:56,510
לפני שאתה מביא כל משתנה
לקיום, כמו מה ש

799
00:39:56,510 --> 00:39:58,764
הוא הסוג של משתנה זה.

800
00:39:58,764 --> 00:40:00,680
וזה הולך להיות
סוג שלכל הזמן.

801
00:40:00,680 --> 00:40:02,410
>> זה לא נכון
פייתון, ולמעשה, אתה

802
00:40:02,410 --> 00:40:04,740
can-- אם אתה רק
סוג של הולך על ידי אוזן,

803
00:40:04,740 --> 00:40:07,690
ואתה לקבל כמה החלטות
דרך אחת במקום אחד,

804
00:40:07,690 --> 00:40:09,870
וכמה החלטות אחד
דרך במקום האחר

805
00:40:09,870 --> 00:40:12,960
בלי לשים מספיק דברים מאחורי
הסצנות במקום האחר

806
00:40:12,960 --> 00:40:16,170
לתפוס דברים כמו שצריך, אתה
יכול לקבל כמה טעויות מוזרות מאוד.

807
00:40:16,170 --> 00:40:19,200
והתכנית יכולה להמשיך לרוץ
במשך זמן רב מאוד, כי זה

808
00:40:19,200 --> 00:40:23,200
עושה הרבה עבודה כדי לומר, גם
דבר זה יכול לפעול בדרך זו,

809
00:40:23,200 --> 00:40:25,070
אז אני הולך לרוץ ככה.

810
00:40:25,070 --> 00:40:30,300
>> ואכן, העובדה שהוא דוחף
קדימה דרך הרבה שגיאות קטנות

811
00:40:30,300 --> 00:40:33,260
משמעות הדבר היא כי, לעתים קרובות כאשר
שגיאה היא בעצם רעה

812
00:40:33,260 --> 00:40:38,720
ואתה באמת רוצה לתקן את זה,
זה בסופו של קילומטרים away-- התכנית

813
00:40:38,720 --> 00:40:41,780
בסופו של עצירה במרחק של קילומטרים
מכאשר היה לך השגיאה שלך.

814
00:40:41,780 --> 00:40:46,590
וכך אנו רוצים דבר אחד
תוכניות לעשות, פעמים-- דבר אחד

815
00:40:46,590 --> 00:40:48,910
כי אנחנו רוצים תוכניות
לעשות כאשר אנחנו באגים

816
00:40:48,910 --> 00:40:54,160
הוא להיכשל בקול רם ולא מצליח מאוד
במהירות כאשר משהו משתבש.

817
00:40:54,160 --> 00:40:55,510
>> פייתון היא רעה מאוד שב.

818
00:40:55,510 --> 00:40:58,820
פייתון היא טובה מאוד בלא
כושל ומתגלגל קדימה

819
00:40:58,820 --> 00:41:00,320
דרך דברים בלתי צפויים.

820
00:41:00,320 --> 00:41:02,820
אז זה שימושי כאשר
אתה כותב תוכניות קטנות.

821
00:41:02,820 --> 00:41:07,110
כאשר אתה מקבל מסובך
באגים לפעמים

822
00:41:07,110 --> 00:41:09,300
לוקח הרבה זמן כדי להקניט אותם.

823
00:41:09,300 --> 00:41:12,210
>> אז יש צד אפל לכל
זה, כמו שזה פשוט עובד.

824
00:41:12,210 --> 00:41:13,860
זה פשוט עובד כמו שהיית מצפה שזה.

825
00:41:13,860 --> 00:41:18,320
אלא שכאשר זה לא, אתה בסופו
במקום אחר לגמרי

826
00:41:18,320 --> 00:41:21,530
ומנסה להבין איפה
זה היה שהשתבש.

827
00:41:21,530 --> 00:41:25,180
>> איסוף אשפה הוא-- כך
דבר אחד שתבחין

828
00:41:25,180 --> 00:41:28,110
הוא שכל הדברים האלה ש
אני כבר הבאתי לexistence--

829
00:41:28,110 --> 00:41:34,114
מערכים אלה, מילונים אלה, אלה
חפצים, אלה files-- אף פעם לא שוחררו.

830
00:41:34,114 --> 00:41:36,030
לא הייתה קריאה ל
חופשי בכל הדיבורים האלה.

831
00:41:36,030 --> 00:41:40,340
וזה היה על C-הצד, כי
אנחנו אף פעם לא נכנסנו לדברים האלה.

832
00:41:40,340 --> 00:41:42,220
>> אבל בפייתון בצד, אין בחינם.

833
00:41:42,220 --> 00:41:43,970
דברים מקבלים באופן אוטומטי
שוחרר כאשר פייתון

834
00:41:43,970 --> 00:41:45,386
חושב שאתה לא מסתכל עליהם.

835
00:41:45,386 --> 00:41:49,640
זה ממש טוב לא לשחרר דברים ש
ייתכן שעדיין אולי להיות מסתכלים,

836
00:41:49,640 --> 00:41:54,262
אבל זה אומר שאם היית
הולך להקצות הדבר הגדול הזה,

837
00:41:54,262 --> 00:41:55,970
ואתה כמו, הו
אני גמרתי עם זה עכשיו,

838
00:41:55,970 --> 00:42:00,360
זה קשה להגיד פייתון
שתסיים עם זה עכשיו.

839
00:42:00,360 --> 00:42:02,986
>> לפעמים יכול להגדיר אותך
משתנה שלהיות אף אחד,

840
00:42:02,986 --> 00:42:05,110
ולאחר מכן מקווה שהסוף של דבר
אספן האשפה

841
00:42:05,110 --> 00:42:06,720
מגיע דרך ומנקה אותו.

842
00:42:06,720 --> 00:42:10,177
אבל שוב, אתה לא
יש שליטה על זה.

843
00:42:10,177 --> 00:42:13,510
ואחת הסיבות שאנשים משתמשים C
לתוצאות פעילות באמת דברים קריטיים,

844
00:42:13,510 --> 00:42:16,570
היכולת הזו באמת
יודע מתי זיכרון מוקצה

845
00:42:16,570 --> 00:42:19,369
וכאשר הוא משוחרר, ויש לי
הרבה שליטה על אומר,

846
00:42:19,369 --> 00:42:20,910
אני משתמש לא יותר מאשר זיכרון שאני צריך.

847
00:42:20,910 --> 00:42:23,632
וזה משהו ש
פייתון היא לא כל כך גדולה ב.

848
00:42:23,632 --> 00:42:25,090
קהל: האם אני יכול לשאול אותך שאלה?

849
00:42:25,090 --> 00:42:29,800
מה אתה מתכוון בקול רם להיכשל?

850
00:42:29,800 --> 00:42:32,070
>> ROSS RHEINGANS-YOO: אז אם
משהו השתבש

851
00:42:32,070 --> 00:42:34,950
ואתה בניפוי
מצב, שהיית לעתים קרובות מאוד

852
00:42:34,950 --> 00:42:38,510
רוצה התכנית שלך להגיד לך
איפה בדיוק זה השתבש,

853
00:42:38,510 --> 00:42:42,360
ולא רק בשקט להפסיק לרוץ.

854
00:42:42,360 --> 00:42:45,085
אבל אתה בעצם אספת אותו להדפסה
מתוך כל מיני פרטים על

855
00:42:45,085 --> 00:42:46,972
כמו, כאן היה זה.

856
00:42:46,972 --> 00:42:53,957
דבר זה קרה אם אתה מדפיס
wen-- אם אתה מפעיל server-- אינטרנט

857
00:42:53,957 --> 00:42:55,390
>> קהל: [לא ברור]

858
00:42:55,390 --> 00:42:59,800
>> ROSS RHEINGANS-YOO: כן, אם
אתה מפעיל שרת אינטרנט,

859
00:42:59,800 --> 00:43:02,680
זה לפעמים רע אם אתה
תמיד השלכת שגיאות,

860
00:43:02,680 --> 00:43:04,530
ואתה אומר,
גם זה לא עבד.

861
00:43:04,530 --> 00:43:05,300
אני הולך להפסיק.

862
00:43:05,300 --> 00:43:07,680
אני רק הולך להתעלם
זה ולהמשיך הלאה.

863
00:43:07,680 --> 00:43:11,260
כי אז אתה יכול לקבל במאות
של טעויות אלה ולא רואה אותם.

864
00:43:11,260 --> 00:43:13,910
>> זה בהחלט יהיה שימושי
למטרות ניפוי

865
00:43:13,910 --> 00:43:20,327
אם בכל פעם ששרת האינטרנט שלך עשתה
שגיאה, היה לך רשומות עמידה של ש.

866
00:43:20,327 --> 00:43:22,910
אולי אתה אפילו רוצה את התכנית
להפסיק, כך שרשומות אלה

867
00:43:22,910 --> 00:43:25,471
לא מקבל נקבר תחת דברים.

868
00:43:25,471 --> 00:43:26,970
אבל שוב, זה במצב ניפוי שגיאות.

869
00:43:26,970 --> 00:43:31,280
>> לעתים קרובות במצב ייצור,
העולם הוא קצת שונה.

870
00:43:31,280 --> 00:43:36,380
ובתסריטים זעירים שאני מפעיל,
שבו הדבר שאמרתי לעשות

871
00:43:36,380 --> 00:43:40,680
יכול להיות רק קצת מ
ממה שאני רוצה לעשות את זה,

872
00:43:40,680 --> 00:43:44,010
אז סוג של דוחף דרך
טעויות היא משהו שאולי תרצה.

873
00:43:44,010 --> 00:43:49,410
ובמקרים אלה, בהחלט
פייתון באמת מרוויח התחלותיה.

874
00:43:49,410 --> 00:43:54,617
>> הדבר האחרון שאני לא דיברתי
בזה-- שלא לדבר על

875
00:43:54,617 --> 00:43:57,700
אבל יכול להיות באמת מקומם הראשון
זמן יש לך אחד של טעויות אלה,

876
00:43:57,700 --> 00:44:00,491
ושנייה ושלישית והרביעי
זמן יש לך אחד טעויות אלה.

877
00:44:00,491 --> 00:44:03,490
פייטון, שציינתי
כי היא משתמשת בחלל לבן

878
00:44:03,490 --> 00:44:06,700
להגיד לך מה רמת הזחה
ומה פונקציונלי בלוק אתה ב,

879
00:44:06,700 --> 00:44:08,840
היא מתייחסת לכרטיסיות וחללים שונות.

880
00:44:08,840 --> 00:44:12,780
אז אם אתה כרטיסייה על ארבעה, ולאחר מכן
יש השורה הבאה ארבעה חללים,

881
00:44:12,780 --> 00:44:16,910
גם אם הם מופיעים כ
אותה כמות בעורך שלך,

882
00:44:16,910 --> 00:44:20,160
פייתון לא להתייחס אליהם אותו הדבר.

883
00:44:20,160 --> 00:44:23,610
>> למעשה, Python מתייחס כרטיסיות
וחללים כמו שמן ומים.

884
00:44:23,610 --> 00:44:25,050
הם דברים פשוט שונים.

885
00:44:25,050 --> 00:44:27,264
אין מסוים
אורך שכרטיסייה היא,

886
00:44:27,264 --> 00:44:30,180
אז זה לא כמו כרטיסייה שווה 8
מרחבים, וכך היית מקבלים סביבו

887
00:44:30,180 --> 00:44:30,860
בצורה זו.

888
00:44:30,860 --> 00:44:34,110
כמו, כאשר הוא אומר, מה
רמת השטח לבן אני ב,

889
00:44:34,110 --> 00:44:37,240
זה בעצם מחפש
דפוס של חללים וכרטיסיות.

890
00:44:37,240 --> 00:44:43,050
וכך, הדרך הטובה ביותר להתמודד עם זה
תמיד להשתמש ברווחים כל הזמן.

891
00:44:43,050 --> 00:44:47,510
>> ואכן, בCloud9
IDE וIDE CS50,

892
00:44:47,510 --> 00:44:50,610
מוסיף מקש Tab שלך
ארבעה חללים במקום

893
00:44:50,610 --> 00:44:53,800
של כרטיסייה, שהוא סופר שימושי.

894
00:44:53,800 --> 00:44:57,074
למרות ששוב, אם אתה כתב פייתון
תכנית עם כרטיסיות שיהיו בסדר,

895
00:44:57,074 --> 00:44:58,990
זה רק אם מישהו
נכנסתי וניסה להוסיף

896
00:44:58,990 --> 00:45:02,655
שורה אחת לתכנית שלך ש
היו לכל כרטיסייה ארבעה חללים,

897
00:45:02,655 --> 00:45:03,280
זה יהיה לשבור.

898
00:45:03,280 --> 00:45:07,800
וזה יהיה לשבור בדרך
זה באמת לא נראה לעין.

899
00:45:07,800 --> 00:45:12,390
למרות השגיאה בפועל
מסר שהיא זורקת

900
00:45:12,390 --> 00:45:15,610
יש לעשות עם חדש
לשנן לא צפוי כאן,

901
00:45:15,610 --> 00:45:18,700
or-- אם הוא מדבר על כניסות
וזה נראה כאילו שזה לא בסדר,

902
00:45:18,700 --> 00:45:22,090
זה כנראה בגלל ש
יש בעיה כרטיסייה-החלל.

903
00:45:22,090 --> 00:45:24,154
הם עדיין מקוממים לניפוי שגיאות.

904
00:45:24,154 --> 00:45:26,070
כל הגדול ביותר ב
שיחה זו, שאני לא

905
00:45:26,070 --> 00:45:29,740
להגיע לכי זה באמת
נושא מסובך, עדין,

906
00:45:29,740 --> 00:45:34,760
ולא היה צורך לעשות כל
הדברים שעשינו עד כה,

907
00:45:34,760 --> 00:45:37,140
הם מושג שנקרא tuples.

908
00:45:37,140 --> 00:45:41,280
הם נמצאים שם הרבה כמו
מערכים שאתה לא יכול לשנות.

909
00:45:41,280 --> 00:45:44,700
הם מתרגלים בכל המקום, כי
הם שימושיים להרבה דברים

910
00:45:44,700 --> 00:45:46,300
שמערכים לא שימושיים ל.

911
00:45:46,300 --> 00:45:49,890
>> אבל אם אתה רוצה לעשות מערך, ו
לאחר מכן מבטיח המתורגמן ש

912
00:45:49,890 --> 00:45:53,140
אף פעם לא הולכים רוצה לשנות ש
thing-- למעשה, אם אתה רוצה לשנות,

913
00:45:53,140 --> 00:45:56,800
תוכל לעשות אחד חדש עם החדש
ערכים בit-- אלה tuples.

914
00:45:56,800 --> 00:45:58,800
במקום לייצר
שלהם עם סוגריים מרובעים,

915
00:45:58,800 --> 00:46:00,341
אתה מייצר אותם עם תליונים עגולים.

916
00:46:00,341 --> 00:46:05,074
למה אתה משתמש בדברים האלה,
הוא קצת שאלה. .

917
00:46:05,074 --> 00:46:06,990
הדבר היחיד שאני
אומר על זה אתה

918
00:46:06,990 --> 00:46:10,680
ניתן להשתמש tuples כ
מדדים למילונים.

919
00:46:10,680 --> 00:46:15,010
אתה לא יכול להשתמש במערכים כ
מדדים למילונים.

920
00:46:15,010 --> 00:46:18,970
ולמה הוא, שוב, וטכני
אני לא הולך לרוץ לתוך זה.

921
00:46:18,970 --> 00:46:23,140
>> Pset שלא נגעתי
בהרצאה זו היא pset6.

922
00:46:23,140 --> 00:46:25,837
אז הנה איך אתה 'd
ליישם זה-- הנה

923
00:46:25,837 --> 00:46:28,140
איך היית ליישם pset6 בפייתון.

924
00:46:28,140 --> 00:46:32,680
תוך התחשבות בפייתון
מחזור תכנון, הדבר הראשון

925
00:46:32,680 --> 00:46:34,760
שאתה עושה כשאתה
תוכניות כתיבה היא בדיקה

926
00:46:34,760 --> 00:46:38,030
כדי לראות אם מישהו עשה את זה כבר.

927
00:46:38,030 --> 00:46:42,152
>> למעשה, אם אתה רוצה
לserve-- אפאצ'י 50

928
00:46:42,152 --> 00:46:44,110
עושה כ זה,
מלבד זה לא בא

929
00:46:44,110 --> 00:46:45,840
סטנדרטי מותקן במכונות לינוקס.

930
00:46:45,840 --> 00:46:50,490
פייתון עושה, ופייתון
שרת HTTP פשוט עושה גם כן.

931
00:46:50,490 --> 00:46:54,717
אם אתה אי פעם במכונת לינוקס,
או מחוץ Cloud9 IDE של CS50

932
00:46:54,717 --> 00:46:57,550
ואתה רוצה לשרת הנוכחי
ספרייה ליציאה מסוימת,

933
00:46:57,550 --> 00:47:04,610
פיתון-מ 'SimpleHTTPServer
נמל משמש ש.

934
00:47:04,610 --> 00:47:07,190
ניתן גם לייבא
שרת HTTP פשוט

935
00:47:07,190 --> 00:47:11,240
ויש לו הרבה פונקציונלי אם
אתה רוצה להתאים אותו, או לשנות אותו,

936
00:47:11,240 --> 00:47:15,860
או מנוהלים it-- לרתום אותה ל
להפעיל שירותי שרת משלך.

937
00:47:15,860 --> 00:47:18,032
>> אז זה פייתון על קצה מזלג.

938
00:47:18,032 --> 00:47:20,280
וזה כבר CS50.

939
00:47:20,280 --> 00:47:21,980
תודה.

940
00:47:21,980 --> 00:47:23,468