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
તે પ્રોગ્રામિંગ કરવાથી લેશે
Python પ્રોગ્રામિંગ માટે સી.

5
00:00:12,100 --> 00:00:15,120
>> Python સ્ક્રિપ્ટીંગ ભાષા છે.

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
તે કેટલીક રીતે સી કરતાં ઓછા શક્તિશાળી છે.

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
>> તે કેટલીક રીતે સી કરતાં વધુ ઉપયોગી છે
તે કાર્યક્રમ માટે સરળ છે કારણ કે.

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
અને બે વખત ધીમી, શકે ચલાવવા માટે
કેટલીક રીતે સી ઉપર સુધારો છે.

23
00:01:02,170 --> 00:01:05,730
ચોક્કસપણે જ્યારે તમે લખવા માટે પ્રયાસ કરી રહ્યાં છો
નાના કાર્યક્રમો થોડી વસ્તુઓ કરવા માટે,

24
00:01:05,730 --> 00:01:08,520
Python પસંદગીના ઉપયોગી ભાષા છે.

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
આ પરિસંવાદ માટે બનાવાયેલ નથી,
શરૂઆતથી તમે Python શીખવે છે.

31
00:01:25,910 --> 00:01:28,310
Python ખૂબ સમાન છે
સી, અને હું ધારી રહ્યા છીએ છું

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
જેથી તમે ઘણો જુઓ કર્યું
સી વસ્તુઓ, હું તમને આપી શકશો

35
00:01:38,866 --> 00:01:40,740
મુખ્ય તફાવત,
અને કેટલીક બાબતો

36
00:01:40,740 --> 00:01:42,840
એ Python અલગ કરો
અને ખાસ અને ઉપયોગી છે,

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
જો કે, આ પરિસંવાદ શીખવે કરશે
તમે Python કાર્યક્રમો લખવા માટે

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
આ સાઇટ પર છે, કે જે જોઇએ
જો તમે Google ડૉક કરી લે છે.

50
00:02:16,480 --> 00:02:21,010
તે સહેજ સંક્ષિપ્ત આવૃત્તિ છે
હું સ્ક્રીન પર દર્શાવે છું શું છે.

51
00:02:21,010 --> 00:02:24,850
>> કાળજી એક ચેતવણી પહેલાં
અમે આવો, પાયથોન 3

52
00:02:24,850 --> 00:02:26,700
Python 2 અલગ ભાષા છે.

53
00:02:26,700 --> 00:02:30,020
તેઓ ઘણો જ જુઓ; ત્યાં છે
ખૂબ જ થોડી ટેકનિકલ તફાવતો

54
00:02:30,020 --> 00:02:32,530
કાર્યક્રમો કે જે થાય છે
Python માં લખાયેલ 2

55
00:02:32,530 --> 00:02:37,140
નથી ચલાવવામાં આવશે સમક્ષ રજુ કરવાનો પ્રયત્ન કરવા માટે
આ 3 પાયથોન પર્યાવરણ.

56
00:02:37,140 --> 00:02:41,969
>> CS50 સાધન સાથે આવે છે
Python, મૂળભૂત રીતે તે પાયથોન 2 ઉપયોગ કરે છે.

57
00:02:41,969 --> 00:02:44,010
તમે આ ચકાસી શકો છો
તમારા આદેશ વાક્ય લખીને

58
00:02:44,010 --> 00:02:51,310
Python --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 માટે Python મૂળભૂતો ક્યાં
આ સાધન અથવા તમારા પોતાના મશીનો પર.

61
00:02:58,500 --> 00:03:03,730
તમે Python 3 ગમે ત્યારે બદલવા જોઇએ
કે આ ચર્ચા માં હું Python લખો.

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
>> તેથી એક ખૂબ જ પ્રથમ Python કાર્યક્રમ.

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
સી તેથી, જો તમે એક ટોળું લખવા
ફાઇલો, તમે તેમને એકસાથે લિંક

82
00:03:59,170 --> 00:04:02,590
અને કાર્યક્રમ ચલાવવા શરૂ થાય છે
આ વસ્તુ પૂર્ણાંક મુખ્ય કહેવાય છે.

83
00:04:02,590 --> 00:04:04,930
>> Python માં, તમે લખી
, તમે ફાઇલ ફાઇલ ચલાવો

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
પરંતુ અહીં, જ્યારે પ્રથમ
કાર્યક્રમ એ 10 બરાબર છે

90
00:04:18,459 --> 00:04:21,273
આ કાર્યક્રમ છે કે પ્રથમ વસ્તુ
કરશે 10 આ કિંમત લે છે

91
00:04:21,273 --> 00:04:24,120
અને એ કહેવાય ચલ માં સુયોજિત કરો.

92
00:04:24,120 --> 00:04:27,690
>> , તે લીટી ની એક બોલતા
આ sorry-- વસ્તુઓ અન્ય

93
00:04:27,690 --> 00:04:31,040
એનો અર્થ એ થાય સી કાર્યક્રમો કે,
તમે તેમને લખવા પડશે,

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
Python કાર્યક્રમો, તમે રન
આ 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
>> મને લાગે છે કે Python ઉપયોગ કરી શકો છો કે અન્ય માર્ગ
હું આ વાત ખૂબ જ સાથે કામ નહીં

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
તે લખવા જે લોકો કરી શકે છે
તમે એક વસવાટ કરો છો snicker માટે 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--
Python ની મેજિક ટુકડાઓ

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
તે અહીં પૂર્ણાંક છે કે કોઈ બાબત અને
ત્યાં આ n વાપરે છે કે જે કંઈપણ ફ્લોટ

136
00:06:43,770 --> 00:06:47,057
વધુ અથવા ઓછા, chug કરવા માટે સક્ષમ હશે
તે ક્યાં મળે તો સાથે.

137
00:06:47,057 --> 00:06:49,640
કેટલાક ખૂબ વાસ્તવિક છે, જ્યાં સુધી
તે માહિતી ઉપયોગ કરી શકતા નથી શા માટે

138
00:06:49,640 --> 00:06:52,170
કે હાલમાં છે એ લખો
જે સમયે તે મળશે

139
00:06:52,170 --> 00:06:54,490
wedged અને ભૂલ ફેંકવું,
અને વસ્તુઓ તે પ્રકારના.

140
00:06:54,490 --> 00:06:57,050
>> પરંતુ અહીં, પાયથોન
શું કાળજી નથી

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
આ મુખ્ય એક છે
Python અને C વચ્ચે તફાવત

148
00:07:08,500 --> 00:07:10,790
કે તે સરળ બનાવે છે
ખૂબ મોટી સી કાર્યક્રમો લખવા

149
00:07:10,790 --> 00:07:15,120
અને તેને સરળ લખવા માટે બનાવે છે
ખૂબ જ નાના Python કાર્યક્રમ.

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
તેથી આ શું કહે છે, એ ખૂબ છે
Pythonic, તે લખવાની રીત.

153
00:07:25,370 --> 00:07:28,969
શ્રેણી (એન) માં પંક્તિ માટે, આ છે
0 થી n નંબરો શ્રેણી

154
00:07:28,969 --> 00:07:31,010
તળિયે વ્યાપક
અને ટોચ પર વિશિષ્ટ.

155
00:07:31,010 --> 00:07:34,790
તેથી તે 0 થી N-1 છે, જે છે
બરાબર સી કોડ શું કરી રહ્યા છે,

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
સી વિપરીત, અહીં જ્યાં હું ખરેખર
આસપાસ કે બંધ તાણવું ખસેડવા જરૂર છે.

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
તેથી તે indentations સુપર સાવચેત બનાવે છે.

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
Python માં વસ્તુઓ ઘણી
અમે આ ફોર્મ લેવા જોશો.

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
>> પરંતુ તે ઉપયોગી અંતઃપ્રેરણા છે
તમે Python કાર્યક્રમો નજીક રહ્યાં છે, ત્યારે

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
Python ની ઘણી બધી તમે કરી શકે
માત્ર પ્રયાસ દ્વારા શોધે છે.

190
00:09:14,740 --> 00:09:19,005
>> આ તો હજુ પણ વધુ સમાન છે
સી પછી 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
Python કે આધાર આપે છે કે
તે ખૂબ જ ઉપયોગી છે.

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
Python માં છાપો કે જે દ્વારા, છે
મૂળભૂત, એક નવી લાઇન છાપે

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
અન્ય વસ્તુઓ સમાવેશ થાય છે
એ Python સ્ક્રિપ્ટ માં,

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
છે આ હું જેમ તે શું કરશે
ડેફ વિધેય નામ કહે છે,

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
>> ખૂબ જ સામાન્ય છે કે જે વસ્તુ
Python ફાઇલો જોવા માટે,

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-- છે
Python, તમે ટોચ પર શરૂ

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-- છે
સી અને Python વચ્ચે બરાબર એ જ,

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-- કરતાં વધારે ઓછી
વસ્તુઓ આ પ્રકારના કરતાં

270
00:12:59,000 --> 00:13:02,580
અર્થ છે કે
તમે તેમની સાથે પરિચિત છો.

271
00:13:02,580 --> 00:13:05,770
>> સી આ ઓપરેટર્સની વાપરે છે,
Python થોડી વધારે ઇંગલિશ વાપરે

272
00:13:05,770 --> 00:13:06,390
વાંચી શકાય રાશિઓ.

273
00:13:06,390 --> 00:13:09,348
તેથી તેના બદલે બે ampersands, તમે
શબ્દશઃ ", શબ્દ પ્રકાર" અને "," અથવા

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
અમે અગાઉ જોયું કે સી માં આ વાક્યરચના
Python માં આ વાક્યરચના અનુલક્ષે છે.

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
ફરીથી, જ્યાં સી બીજું કરશે
, પાયથોન Elif વાપરે તો,

280
00:13:28,890 --> 00:13:33,960
પરંતુ આ મોટે ભાગે છે
સપાટી સ્તર બદલાય છે.

281
00:13:33,960 --> 00:13:38,450
>> આ જેમ પુનરાવૃત્તિ ઘણી વાર છે
Python માં આ રૂઢિપ્રયોગ માં લખાયેલ છે.

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
મનોરંજક વસ્તુઓ એક
છતાં પાયથોન વિશે

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
અને અમે ઉપયોગ કરશો see-- પડશે
ફરીથી અને ફરીથી રૂઢિપ્રયોગ

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
આ બરાબર નથી Python માં બહાર ફેંકે છે
તમે માત્ર મજા છે, કે જે શું માંગો છો

306
00:14:48,860 --> 00:14:52,840
અને છે કે અમે ખરેખર કરી શકો છો એનો અર્થ એ થાય
ફરી mario.c, આ કાર્યક્રમ ઘટાડે છે.

307
00:14:52,840 --> 00:14:57,150
તેના બદલે એક ઘણો વારો કરતાં, અમે કરી શકો છો
માત્ર હું જગ્યાઓ કેટલાક નંબર માંગો છો કહે છે,

308
00:14:57,150 --> 00:15:01,120
હું હેશો સંખ્યા માંગો છો,
અને અંતે કેટલાક હેશો.

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
અને હું સારી રીતે મારી પાસે જાઉં છું, કહે
આ શબ્દમાળા હેશો કેટલાક નંબર,

324
00:15:51,650 --> 00:15:56,390
અને હું અધિકાર તેને પેડ સર્મથન કરવા માંગો છો
જગ્યાઓ સાથે બહાર આ લંબાઈ હોય છે.

325
00:15:56,390 --> 00:16:00,584
>> ફરીથી, આ છે
us-- લાવે જે દસ્તાવેજીકરણ,

326
00:16:00,584 --> 00:16:03,500
હું ખરેખર ગયો હતો મારફતે ક્લિક કરો પડશે
જે અમારા માટે બીજા નિયમ માટે લાવે

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
આ કોષ્ટકો એક એ Python છે
વસ્તુઓ માટે પદ્ધતિઓ જોડવા માટે ઉપયોગ કરે છે.

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
>> તેથી આ બંને માર્ગો છે કે
વસ્તુઓ Python માં કરવામાં વિચાર.

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
વધુ કે ઓછા સ્નિગ્ધ છે
Python પાછળ તત્વજ્ઞાન

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
અને આ કદાચ વધુ ખરેખર છે
સુવાચ્ય, હું સી કાર્યક્રમ કરતાં, કહે કરશો

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
>> અન્ય વસ્તુ, આ એક અમલીકરણ છે
મારિયો મને લાગે છે કે જે કોઈ સી, કે

366
00:17:56,270 --> 00:17:57,890
તમે તે મેળવી શકો છો ટૂંકી છે.

367
00:17:57,890 --> 00:18:00,757
તે પૂર્ણાંક વિચાર હોય છે, પરંતુ નથી
તે હાર્ડ કોડ 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
>> યાદી આપે છે, Python માં એક મહત્વપૂર્ણ વસ્તુ છે.

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
, કારણ કે સી કરવું
મેમરી તે પર જેથી હાથ છે

383
00:18:47,390 --> 00:18:48,950
પરંતુ Python માં કરવા માટે ખૂબ જ સરળ છે.

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
તેથી હું તેથી હું નથી નથી
દર વખતે realloc છે.

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
હું મૂકવા માંગો છો હું સ્ક્વેર્ડ
આ શ્રેણીમાં હું દરેક કિંમત માટે.

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
આ એક છે
આ ફરીથી છે વસ્તુઓ

405
00:19:59,190 --> 00:20:03,860
એક of-- આ ખૂબ સાંકેતિક
કારણો પાયથોન જેવા લોકો છે.

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
Python માં ખૂબ જ સરળ,
તે સી માં ખૂબ જ મુશ્કેલ છે

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
તેથી સી, ​​તમે કંઈક માટે પૂછતા હોય
આ જેમ, પ્રિન્ટ, કહે છે

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
Python વધુ કે ઓછા કાળજી નથી.

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
આ તમે કરી શકો છો કે જે થાય છે
આ જેવા વસ્તુઓ કરી

429
00:21:03,640 --> 00:21:06,530
હાર્ડ ભાગના છે
પંદર રમત, તેવા પરચૂરણ ખર્ચ

430
00:21:06,530 --> 00:21:08,930
Python માં ખૂબ જ સંક્ષિપ્તમાં.

431
00:21:08,930 --> 00:21:11,320
>> તમે ત્યાં છે કે નહીં તે જોવા મળશે
અહીં of-- થોડો

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
હું એક વિચાર ધારવું છું
પાછા પૂર્ણાંક અથવા પાછા શબ્દમાળા?

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
જે અમલીકરણો છે is--
આ ચોક્કસ 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
પરંતુ આ વિચાર, આ છે
Python ની ફિલસૂફી છે,

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
તમે શબ્દમાળાઓ સૉર્ટ ગુણાકાર
તમે એરે સૉર્ટ જ રીતે.

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
સી માં વધુ અથવા ઓછા,
તે Python માં કામ કરશે

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
>> તેથી અહીં ફાઈલ I / O છે. હું ફાઈલ / O ઘણાં બધાં છે
તે જટિલ બનાવે છે થોડી વસ્તુઓ

475
00:23:26,820 --> 00:23:29,890
અને તેથી સ્રોતો હોય છે
ઓનલાઇન, પરંતુ એક nutshell માં,

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
ફરીથી, આ જગ્યાએ .દ્વારા બંધ છે
બંધ કરો ફાઇલ, તે સી માં હશે

488
00:24:02,510 --> 00:24:07,190
એફ છે, કારણ કે આ વધુ કે ઓછી હોય છે
એફ બંધ કરવા માટે વસ્તુ છે, અને તમે ઇચ્છો.

489
00:24:07,190 --> 00:24:12,092
પરંતુ મૂળભૂત ફાઈલ I / O નથી
ખાસ કરીને જટિલ.

490
00:24:12,092 --> 00:24:15,300
ફરીથી, તમે ફાઈલ ખોલવા માંગો છો, તો જો
જો તમે ચોક્કસ વાક્ય વાંચવા કરવા માંગો છો,

491
00:24:15,300 --> 00:24:17,870
તમે ચોક્કસ બહાર મેળવી શકો છો
વાક્ય તે માટે આંતરિક ઇન્સ છે.

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
તેમને ટેકો વારો.

498
00:24:33,780 --> 00:24:37,430
અજગર, એક ફાઈલ વસ્તુ કદાચ છે કે
હું વાક્ય દ્વારા વાક્ય પર ફરી વળવું માંગો છો.

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
Python ખૂબ કાળજી નથી.

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
Python ચોક્કસપણે પર્યાપ્ત આપે
તમે ઇચ્છો તો દોરડું, તમારી જાતને અટકી.

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
પરંતુ તે વધુ કે
Python કેવી રીતે કામ કરે ઓછો હોય છે.

538
00:26:35,070 --> 00:26:39,880
નથી કે જે તમે એક વસ્તુ માટે પૂછતા હોય
તે, પાયથોન એક ભૂલ ફેંકવું કરશે

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
અહીં અમે પર વારો આવે છે
આ જ સમયે બે વસ્તુઓ.

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
અમે કેટલાક મુશ્કેલી કારણ હશે
થઈ અમે ડેવિડ સાથે ગયા ત્યારે,

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-- છેલ્લા વસ્તુ કે બંધ chomps
શબ્દમાળા છેલ્લા પાત્ર.

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
પરંતુ અમે એ જ રીતે, તે કૉલ જે
એ Python ખાંડ કોટિંગ માટે અમુક છે

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: તેથી
જ્યારે તમે વારો કરી રહ્યાં છો

583
00:28:48,190 --> 00:28:50,300
ફાઇલ માટે પૂછતી પર
લાઇન્સ દ્વારા, લાઇન્સ

584
00:28:50,300 --> 00:28:53,900
એક નવી લાઇન પાત્ર સાથે આવે છે
તેને આ બાદ 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
અને જ્યાં સી, કારણ કે
ફૂટવું અથવા કદાચ કરશે

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-- છે
સી લાઈબ્રેરીઓ માટે analogs

602
00:29:43,590 --> 00:29:45,119
અને વસ્તુઓ ઘણો માટે ઉપયોગી છે.

603
00:29:45,119 --> 00:29:46,910
વસ્તુઓ ઘણો તમે કરશો
Python માં કરવા માંગો,

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
અથવા તમે Google પર શોધી શકે
Python sys Googling દ્વારા.

613
00:30:11,490 --> 00:30:12,640
તમે લખો દાખલ કરો.

614
00:30:12,640 --> 00:30:15,140
પ્રથમ કડી હોઈ ચાલે છે
Python 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
અને તમને ફરીથી કે જે ઑનલાઇન શોધી
પાયથોન Google પર 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
જો તે થોડી વધારે ઉપયોગી છે
તમે Python વસ્તુઓ ડમ્પીંગ કરી રહ્યાં છો.

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
અથાણું માતાનો, Python છે
જે માટે પુસ્તકાલય.

653
00:32:14,740 --> 00:32:19,140
>> તમે કોઇ પણ પ્રકારની હોય તો
બહાર લખી શકાય છે કે ચલ

654
00:32:19,140 --> 00:32:21,990
જેવા શબ્દો અને અક્ષરો અને
ચોક્કો બાઇટ્સ આ શબ્દકોશ જેમ,

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
તમે longhand તેમને બહાર લખ્યું તો લે છે.

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, ઓએસ, મલ્ટીપ્રોસેસીંગ છે
વસ્તુઓ માટે મૂળભૂત workhorses જેવું

674
00:33:19,510 --> 00:33:23,120
અમે સાથે વાર્તાલાપ કરવાની જરૂર
ફાઈલ સિસ્ટમ ઓએસ.,

675
00:33:23,120 --> 00:33:28,764
, os.isdirectory, os.isfile જેવા
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
>> એક ટોળું હોય છે
ચાલી માટે પેકેજો

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
સુપર ઉપયોગી સામગ્રી નહીં
Python માં બધા સમય અમલ.

690
00:34:17,880 --> 00:34:21,469
>> અને ફરી, સહેજ લે
લાંબા સમય સુધી માફ કરશો લખવા માટે,

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
તમે જો જરૂરી હોય તો તમે Python માં લખી શકે
દર થોડા મહિના તે બદલવા માટે.

698
00:34:46,124 --> 00:34:48,540
કેટલાક લોકો તેને લખી હશે
સી એવું રહ્યાં છીએ.

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
ફરીથી મલ્ટીપ્રોસેસીંગ પીડા છે
દર વખતે બહાર લખો, જેથી સાંસદ તરીકે આયાત

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
આ ક્યારેક ક્યારેક એક સારી વિચાર છે નથી
આ સામાન્ય રીતે એક સારો વિચાર છે, ખરેખર.

712
00:35:34,820 --> 00:35:39,080
તમે કંઈપણ કારણ કે જો very-- કારણ કે
કે મોડ્યુલ માં એક નામ ધરાવે છે કે જે તમે

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
તમે Python કાર્યક્રમો ડિઝાઇન કેવી રીતે.

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
અથવા તે આસપાસ wrapper લખવા
તમારા હેતુ માટે તે સ્વીકારવાનું.

732
00:36:28,900 --> 00:36:31,250
કે ગયા પછી તે માત્ર
પછી તમે છો કે નિષ્ફળ

733
00:36:31,250 --> 00:36:35,529
પર જાઓ અને વિશે વિચારવાનો શરૂ લખવા
તમે કેવી રીતે સાથે મળીને આ વસ્તુ મૂકવામાં આવશે.

734
00:36:35,529 --> 00:36:37,320
સામગ્રી ઘણાં બધાં છે
ત્યાં ત્યાં બહાર છે, અને તે છે

735
00:36:37,320 --> 00:36:39,180
સૌથી વધુ ઉપયોગી એક
Python વિશે વસ્તુઓ.

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
>> તેથી Python ની છેલ્લા નિયમ, કોઈકને છે
બીજું કદાચ પહેલાથી જ લખ્યું છે

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
હું કાળા બોક્સ તરીકે છોડી દીધું છે કે
અને જેવું, પર glossed

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
તેથી વસ્તુઓ ઘણાં બધાં છે
તેથી ચલો ઘણી વાર નથી

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
ના આર્કિટેક્ટ્સ
ભાષા દ્વારા ચાલ્યા ગયા છે

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
આ શા માટે તમે કરી શકો છો છે
વસ્તુઓ પર આ લેન કૉલ

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
પરંતુ યાદી માટે વસ્તુ subtly છે
આંટીઓ માટે સી શૈલી અલગ છે,

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
તમે સુપર હાર્ડ વિચારો કર્યા વગર
આ પૂર્ણાંક પ્રયત્ન કરીશું કે કેમ તે અંગે

789
00:39:27,130 --> 00:39:29,713
અથવા ત્યાં હોવી જોઇએ કે નહીં
ફ્લોટ, તે અહીં ઉપર કે હોઈ શકે છે

790
00:39:29,713 --> 00:39:34,240
તમે અહે પૂર્ણાંક પેદા પરંતુ તમે
લાગે છે, પરંતુ તેઓ માફ કરશો હંમેશની પડશે,

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
ઓહ, પરંતુ તેઓ પડશે
હંમેશા મને પૂર્ણાંક પસાર કરે છે.

794
00:39:41,150 --> 00:39:43,608
તેઓ નથી, તો, તે શક્ય છે
કે તમે ક્યાંક wedged

795
00:39:43,608 --> 00:39:47,600
તમે ઇન્ડેક્સ કે ઉપયોગ કરવાનો પ્રયાસ કરો
એક એરે માં, અથવા તમે શું હોય છે.

796
00:39:47,600 --> 00:39:51,050
>> વાસ્તવિક તેથી એક
સી વિશે ઉપયોગી વસ્તુઓ

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
>> આ સાચું નથી
Python, અને હકીકત એ છે કે તમે

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
અને તેથી એક વસ્તુ અમે માંગો છો કે
કરવા માટે કાર્યક્રમો, એક વસ્તુ sometimes--

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
>> Python કે ખૂબ જ ખરાબ છે.

818
00:40:55,510 --> 00:40:58,820
Python નથી ખૂબ જ સારી છે
નિષ્ફળ અને આગળ રોલિંગ

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
>> કચરો ભેગો કરવો જેથી is--
તમે નોટિસ કરશે કે એક વસ્તુ

828
00:41:25,180 --> 00:41:28,110
આ વસ્તુઓ છે કે જે કોઈપણ છે કે
હું existence-- માં લાવવામાં કર્યું

829
00:41:28,110 --> 00:41:34,114
આ એરે, આ શબ્દકોશ, આ
પદાર્થો, મુક્ત ક્યારેય ફાઈલો છે આ.

830
00:41:34,114 --> 00:41:36,030
કોઈ કોલ આવી હતી
આ ચર્ચા કોઈ પણ મફત છે.

831
00:41:36,030 --> 00:41:40,340
અને તે છે, કારણ કે સી-બાજુ પર હતું
અમે તે વસ્તુઓ માં મળી નથી.

832
00:41:40,340 --> 00:41:42,220
>> પરંતુ python-બાજુ માં, એક મફત નથી.

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
અને કારણો એક લોકો સી ઉપયોગ કરે છે
માટે ખરેખર જટિલ વસ્તુઓ પ્રભાવમાં

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
જે કંઈક છે કે
Python ખાતે મહાન નથી.

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--

857
00:42:53,957 --> 00:42:55,390
>> AUDIENCE: [અશ્રાવ્ય]

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
અને તે કિસ્સામાં, ચોક્કસપણે
Python ખરેખર તેના શરૂ થાય કમાય છે.

874
00:43:49,410 --> 00:43:54,617
>> હું વાત કરી ન હતી કે છેલ્લા વસ્તુ
છે આ કે હું વિશે વાત કરી ન હતી

875
00:43:54,617 --> 00:43:57,700
પરંતુ ખરેખર પ્રથમ infuriating હોઈ શકે છે
સમય તમે આ ભૂલો એક છે,

876
00:43:57,700 --> 00:44:00,491
અને બીજા અને ત્રીજા અને ચોથા
સમય તમે એક આ ભૂલો છે.

877
00:44:00,491 --> 00:44:03,490
Python, હું ઉલ્લેખ કર્યો છે
તે સફેદ જગ્યા વાપરે છે કે જે

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
Python તેમને તે જ સારવાર નથી.

883
00:44:20,160 --> 00:44:23,610
>> હકીકતમાં, પાયથોન ટેબો વર્તે છે
અને તેલ અને પાણી જેવા જગ્યાઓ.

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 અને આ CS50 IDE,

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
ફરીથી છતાં, તમે Python લખ્યું તો
દંડ હશે કે ટેબો સાથે કાર્યક્રમ

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-- તે indents વિશે વાત છે, તો
તે ખોટું છે એવું લાગે છે,

902
00:45:18,700 --> 00:45:22,090
તે કદાચ કારણ
એક ટેબ જગ્યા સમસ્યા છે.

903
00:45:22,090 --> 00:45:24,154
તેઓ હજુ પણ ડિબગ infuriating કરી રહ્યાં છો.

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
ક્યારેય કે સુધારવા માટે માંગો છો જવું છે
હકીકતમાં વસ્તુ, તમે સુધારવા માંગતા હોય તો,

913
00:45:53,140 --> 00:45:56,800
તમે નવા સાથે એક નવું બનાવવા પડશે
તેને તે કિંમતો 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
તેથી અહીં તમે ડી 'કેવી રીતે
અહીં a-- અમલ

923
00:46:25,837 --> 00:46:28,140
તમે કેવી રીતે Python માં 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
>> હકીકતમાં, જો તમે ઇચ્છો તો
અપાચે 50 serve-- માટે

928
00:46:42,152 --> 00:46:44,110
લગભગ આ કરે છે
તે ન કરવામાં આવે તો સિવાય

929
00:46:44,110 --> 00:46:45,840
પ્રમાણભૂત Linux મશીન પર સ્થાપિત થયેલ છે.

930
00:46:45,840 --> 00:46:50,490
Python કરે છે, અને Python
સરળ HTTP સર્વર તરીકે સારી રીતે કરે છે.

931
00:46:50,490 --> 00:46:54,717
તમે Linux મશીન પર ક્યારેય હોવ તો,
અથવા CS50 ના CLOUD9 IDE બહાર

932
00:46:54,717 --> 00:46:57,550
અને તમે આ ચાલુ સેવા કરવા માંગો છો
ચોક્કસ પોર્ટ ડિરેક્ટરી

933
00:46:57,550 --> 00:47:04,610
Python એમ 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
અથવા તેને તે ઉપયોગ ચલાવવામાં આવે છે
તમારા પોતાના સર્વર સેવાઓ ચલાવે છે.

937
00:47:15,860 --> 00:47:18,032
>> તેથી એ Python એક nutshell માં છે.

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