1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:03,227
[સંગીત વગાડવાનો]

3
00:00:03,227 --> 00:00:04,705

4
00:00:04,705 --> 00:00:05,830
એઝરા Zigmond: હાય, દરેકને.

5
00:00:05,830 --> 00:00:08,020
આજે બહાર આવતા માટે આભાર.

6
00:00:08,020 --> 00:00:10,660
આ સેમિનાર "પાયથોન છે
વેબ બાટલી સાથે એપ્લિકેશન્સ. "

7
00:00:10,660 --> 00:00:14,510
>> તેથી, હું વાત કરવા જઈ રહ્યો છું
શા માટે વિશે થોડુંક

8
00:00:14,510 --> 00:00:17,400
તમે બનાવવા માટે બાટલી ઉપયોગ કરવા માંગો છો શકે છે
Python સાથે વેબ એપ્લિકેશન્સ, વિરોધ

9
00:00:17,400 --> 00:00:21,556
ત્યાં ત્યાં બહાર કેટલાક અન્ય માળખા ગમે
સૌથી વધુ સારી રીતે ઓળખાય છે જે જેંગો.

10
00:00:21,556 --> 00:00:24,330
આ પેટાશીર્ષક છે "અને
કંઈક છે જે peewee, "

11
00:00:24,330 --> 00:00:27,250
અમે કેવી રીતે વિશે વાત કરવા જઈ રહ્યાં છો
એસક્યુએલ ડેટાબેઝ સાથે ક્રિયાપ્રતિક્રિયા કરે છે.

12
00:00:27,250 --> 00:00:29,610
તે ખરેખર સરસ બનાવે છે.

13
00:00:29,610 --> 00:00:32,390
>> તેથી, અહીં માત્ર એક ઝડપી rundown છે
હું પર જાઓ કરવા માંગો છો.

14
00:00:32,390 --> 00:00:35,520
તેથી, પ્રથમ, માત્ર એક સ્લાઇડ
કે, ક્વિકસ્ટાર્ટ હશે

15
00:00:35,520 --> 00:00:38,530
જે બધું મેળવવા માટે કેવી રીતે છે
તમારા કમ્પ્યુટર પર સુયોજિત કરો.

16
00:00:38,530 --> 00:00:41,760
હું દર્શાવીને કરી જાઉં છું
મારા સ્થાનિક મેક મશીન પર આ

17
00:00:41,760 --> 00:00:45,220
તે માત્ર કારણ કે હું આ કર્યું છે જ્યાં
પહેલાં, હું તેની સાથે સૌથી વધુ આરામદાયક છું

18
00:00:45,220 --> 00:00:48,510
પરંતુ આ ચોક્કસપણે છે
આ CD50 IDE પર શક્ય છે.

19
00:00:48,510 --> 00:00:52,050
>> તેથી, તે પછી, હું કરવા માંગો છો
, બાટલી શું દાખલ

20
00:00:52,050 --> 00:00:55,089
અને તમે સહમત તમે શા માટે જોઇએ
પ્રથમ સ્થાને ઉપયોગ કરે છે.

21
00:00:55,089 --> 00:00:56,880
પછી, હું એક ઝડપી આપવા પડશે
તમે શું ઉદાહરણ

22
00:00:56,880 --> 00:01:00,550
બાટલી, ઝડપી ઉદાહરણ માં કરી શકો છો
તમે peewee માં શું કરી શકો,

23
00:01:00,550 --> 00:01:05,010
અને પછી હું તમને એક વધુ દેખાશે
સંપૂર્ણ ઉદાહરણ એપ્લિકેશન

24
00:01:05,010 --> 00:01:07,520
હું અમે તે સાથે મૂકવામાં છે કે
એકસાથે લઈ જવામાં કરી શકો છો.

25
00:01:07,520 --> 00:01:10,040
>> અને પછી છેલ્લે,
છેલ્લી સ્લાઇડ, હું

26
00:01:10,040 --> 00:01:12,730
તમે જુઓ કે કેટલાક સ્રોતો
વધુ માહિતી માટે ઓનલાઇન છે.

27
00:01:12,730 --> 00:01:15,560
આ એક સંપૂર્ણ નથી
બાટલી કેવી રીતે વાપરવા માટે ટ્યુટોરીયલ.

28
00:01:15,560 --> 00:01:18,140
અને હું છોડી આશા પડશે
પ્રશ્નો માટે કેટલાક સમય.

29
00:01:18,140 --> 00:01:21,050
કોઈપણ ફક્ત સ્થાનિક જોવાનું
જેમ કે, મધ્યમાં પોકાર

30
00:01:21,050 --> 00:01:22,340
જો તમે કોઇ પ્રશ્નો હોય તો.

31
00:01:22,340 --> 00:01:27,150
>> તેથી ઝડપી સ્થાપન સામગ્રી,
તમે સાથે પાલન કરવા માંગો છો,

32
00:01:27,150 --> 00:01:29,240
અથવા તમે આ વિચાર કરવા માંગો છો, તો
તમારા પોતાના મશીન પર,

33
00:01:29,240 --> 00:01:32,440
હું Python 2.7.10 ઉપયોગ કરી જાઉં છું.

34
00:01:32,440 --> 00:01:35,860
બાટલી સાથે કામ કરે છે
3 પાયથોન, પરંતુ હું ગમે

35
00:01:35,860 --> 00:01:38,660
કારણ કે ત્યાં, પાયથોન 2 મદદથી
કેટલાક પાયથોન પેકેજો કે

36
00:01:38,660 --> 00:01:40,910
હજુ સુધી 3 સાથે કામ કરતુ નથી.

37
00:01:40,910 --> 00:01:44,800
તમે ફળનું નાનું બીજ સ્થાપિત કરેલ હોય, જે
એ Python પેકેજ વ્યવસ્થાપક છે,

38
00:01:44,800 --> 00:01:48,190
તમારા પાયથોન છે તો મને લાગે છે
એક કરતાં વધારે અથવા 2.7.9 સમાન,

39
00:01:48,190 --> 00:01:52,220
તમે તે પહેલાથી જ સ્થાપિત છે, તે છે
આ પેકેજો સ્થાપિત કરવા માટે સુપર સરળ છે.

40
00:01:52,220 --> 00:01:54,990
>> તમે ફળનું નાનું બીજ સ્થાપિત કરી શકો છો
બાટલી, peewee સ્થાપિત ફળનું નાનું બીજ,

41
00:01:54,990 --> 00:01:58,600
સામાન્ય રીતે તમે માત્ર sudo ચલાવવા માટે છે
જેથી પરવાનગીઓ બહાર કામ કરે છે.

42
00:01:58,600 --> 00:02:01,080
અને, તમે ઉપયોગ કરી રહ્યા છો તો એક
સુપર Python ની જૂની આવૃત્તિ,

43
00:02:01,080 --> 00:02:05,100
હું તમારી પાયથોન અપડેટ કરવાની ભલામણ
અથવા EasyInstall ઉપયોગ ફળનું નાનું બીજ સ્થાપિત કરવા માટે.

44
00:02:05,100 --> 00:02:09,180

45
00:02:09,180 --> 00:02:11,120
તેથી, આગામી પ્રશ્ન છે, બાટલી શું છે?

46
00:02:11,120 --> 00:02:13,280
અને હું પ્રથમ ધારી
વાજબી પ્રશ્ન હું આશ્ચર્ય

47
00:02:13,280 --> 00:02:15,585
લાંબા સમય છે, એક વેબ એપ્લિકેશન શું છે?

48
00:02:15,585 --> 00:02:17,960
એક શબ્દ છે જે છે કારણ કે હું
ઘણો આસપાસ ફેંકવામાં લાગે છે

49
00:02:17,960 --> 00:02:19,240
હું ખરેખર ખબર ન હતી કે.

50
00:02:19,240 --> 00:02:22,340
અને હું શ્રેષ્ઠ લાગે છે કે
વેબ એપ્લિકેશન શું છે, ઉદાહરણ તરીકે,

51
00:02:22,340 --> 00:02:26,960
ખરેખર CS50 ફાયનાન્સ, જ્યાં છે
તે ખરેખર માત્ર એક વેબસાઇટ નથી

52
00:02:26,960 --> 00:02:29,320
પરંતુ તે કંઈક કે જે તમે
સૉર્ટ સાથે વાર્તાલાપ કરી શકે છે.

53
00:02:29,320 --> 00:02:31,736
વપરાશકર્તા એકાઉન્ટ્સ છે અને
વિવિધ વસ્તુઓ તમામ પ્રકારના.

54
00:02:31,736 --> 00:02:35,010
તેથી, બરાબર તમે જ્યાં ડ્રો
એક વેબસાઇટ છે શું વચ્ચે લીટી,

55
00:02:35,010 --> 00:02:38,780
અને વેબ એપ્લિકેશન, શું પ્રકારની છે
મનસ્વી છે, પરંતુ હું વિચાર ધારી,

56
00:02:38,780 --> 00:02:42,110
તે એક વેબસાઇટ કરતાં વધુ કંઈક છે
અને તે એક ઉપયોગી એપ્લિકેશન છે.

57
00:02:42,110 --> 00:02:46,081
>> તેથી, બાટલી એક માળખું છે
Python ઉપયોગ કરીને વેબ એપ્લિકેશન્સ બનાવી રહ્યા છે.

58
00:02:46,081 --> 00:02:48,330
અને આસ્થાપૂર્વક, અંત સુધીમાં
આ કારણે, હું તમને સહમત થશે

59
00:02:48,330 --> 00:02:52,210
તમે ખરેખર કંઈક લખી શકે છે
CS50 ફાયનાન્સ જેવા પાયથોન ઉપયોગ જે હું

60
00:02:52,210 --> 00:02:53,950
વ્યક્તિગત, PHP, કરતાં ઘણો વધુ સારી રીતે ગમે.

61
00:02:53,950 --> 00:02:57,320
>> તેથી, બાટલી છે, તેઓ કૉલ
microframework, જેના દ્વારા,

62
00:02:57,320 --> 00:02:59,800
તેઓ તેને ખૂબ જ અર્થ
સરળ છે, પરંતુ એક્સ્ટેન્સિબલ.

63
00:02:59,800 --> 00:03:02,980
તેથી, તે તમને જરૂર છે તે માત્ર છે
પરંતુ જો તમે વધુ સુવિધાઓ માંગો છો, તો

64
00:03:02,980 --> 00:03:04,522
તે તેમને લાવવા માટે સરળ છે.

65
00:03:04,522 --> 00:03:06,480
પરંતુ તે માત્ર કારણ કે
microframework, નથી

66
00:03:06,480 --> 00:03:08,960
તે નાના પ્રોજેક્ટ માટે માત્ર છે કે થાય છે.

67
00:03:08,960 --> 00:03:12,590
હું કહે છે કે અહીં એક લિંક છે
ઓબામા 2012 માં બાટલી વપરાય છે કે જે

68
00:03:12,590 --> 00:03:14,410
તેમના પ્રચાર માટે
વેબસાઇટ છે, જે આસ્થાપૂર્વક,

69
00:03:14,410 --> 00:03:16,937
એક સમર્થન કંઈક છે.

70
00:03:16,937 --> 00:03:18,770
પરંતુ વસ્તુ કે હું
ખરેખર બાટલી વિશે ગમે

71
00:03:18,770 --> 00:03:22,401
, તે ખરેખર નથી કે છે
તમે માટે નિર્ણયો કોઇ પણ પ્રકારની.

72
00:03:22,401 --> 00:03:24,150
જસ્ટ અમે છો કારણ કે
વેબ એપ્લિકેશન્સ વિશે વાત કરે છે,

73
00:03:24,150 --> 00:03:26,940
હું રૂબી સરખાવવા માટે છે
ટ્રેનની અને જેંગો, જે બંને

74
00:03:26,940 --> 00:03:30,450
મહાન માળખા છે, પરંતુ
તેઓ બંને ધારણાઓને

75
00:03:30,450 --> 00:03:33,600
વિશે તમે કેવી રીતે કરવા માંગો છો
ડેટાબેઝો સાથે સંચાર કરે છે,

76
00:03:33,600 --> 00:03:36,900
તમે કેવી રીતે તમારા પ્રસ્તુત કરવા માંગો છો
વિચારો, અને તેઓ ચોક્કસપણે છો

77
00:03:36,900 --> 00:03:38,850
કે સારા પાસાઓ.

78
00:03:38,850 --> 00:03:41,490
>> ઉદાહરણ તરીકે, રૂબી પર રેલ્સ માટે
આ સક્રિય રેકોર્ડ સિસ્ટમ છે,

79
00:03:41,490 --> 00:03:43,100
જે ખરેખર સરસ છે
માહિતી સાથે સંપર્કવ્યવહાર કરવા માટે માર્ગ છે,

80
00:03:43,100 --> 00:03:45,960
પરંતુ તમે પર રૂબી ઉપયોગ કરવા માંગો છો, તો
રેલ્સ, તમે પ્રકારના કે માં બંધાયેલ કરી રહ્યાં છો.

81
00:03:45,960 --> 00:03:47,835
પરંતુ બાટલી સાથે, હું પડશે
peewee સાથે તમને બતાવે છે,

82
00:03:47,835 --> 00:03:49,830
તમે ગમે સૉર્ટ ઉપયોગ કરી શકો છો
Wego ના ડેટાબેઝ તપાસવામાં તમે કરવા માંગો છો,

83
00:03:49,830 --> 00:03:53,980
અને તમે માત્ર તે ખેંચી શકે છે
બાટલી માં એક એક્સ્ટેન્શન તરીકે.

84
00:03:53,980 --> 00:03:56,350
>> તેથી કે શા માટે હું ખરેખર છે
બાટલી, જેમ કે તે છે

85
00:03:56,350 --> 00:04:01,170
તમારા માટે ધારણાઓને નથી
વસ્તુઓ પર આધારિત તમે ખરેખર જરૂર નથી.

86
00:04:01,170 --> 00:04:04,440
>> તેથી, શા માટે તમે બાટલી ઉપયોગ કરવો જોઇએ?

87
00:04:04,440 --> 00:04:08,230
લાભ તે માત્ર છે
ખરેખર કોર લક્ષણો ધરાવે છે

88
00:04:08,230 --> 00:04:09,420
તે માં સમાયેલ તમને જરૂર છે.

89
00:04:09,420 --> 00:04:11,980
તેથી, જો તમે વિશે ચિંતા કરવાની જરૂર નથી
વસ્તુઓ સંપૂર્ણ ટોળું સમજવામાં

90
00:04:11,980 --> 00:04:13,175
તમે ખરેખર જરૂર નથી.

91
00:04:13,175 --> 00:04:15,060
તમે ચિંતા કરવાની જરૂર ન હોય
લક્ષણો બંધ કરી દેવાનો વિશે

92
00:04:15,060 --> 00:04:16,620
તમે ખરેખર જરૂર નથી.

93
00:04:16,620 --> 00:04:21,082
>> હું ઉલ્લેખ કર્યો છે, તે સુપર છે
વસ્તુઓ એક્સ્ટેન્શન્સ માં ઉમેરવા માટે સરળ

94
00:04:21,082 --> 00:04:21,790
તમને જરૂર નથી.

95
00:04:21,790 --> 00:04:24,700
તેમને કેટલાક બાટલી છે
તે માટે પોતાના આધાર.

96
00:04:24,700 --> 00:04:28,230
તેથી બાટલી કહેવાય કંઈક છે
કે જે સંચાલન મિરર જે સંચાલક,

97
00:04:28,230 --> 00:04:32,060
જેંગો પૂરી પાડે છે કે પેનલ,
કે જે તમને એક સરસ દ્રશ્ય આપે છે

98
00:04:32,060 --> 00:04:33,405
તમારી વેબસાઇટ સંચાલિત.

99
00:04:33,405 --> 00:04:35,280
પરંતુ ફરીથી, તમે છો, તો
કંઈક સરળ બનાવે છે,

100
00:04:35,280 --> 00:04:39,550
તમે કદાચ એક મોટી સંચાલક જરૂર નથી
પેનલ, તેથી હું તે સુપર સરસ લાગે છે.

101
00:04:39,550 --> 00:04:45,940
અને ગેરફાયદા છે, કે જે હોય છે
તમે આ બોક્સની બહાર ઓછી શક્તિ હોય છે.

102
00:04:45,940 --> 00:04:49,660
તેથી, જો તમે પ્રથમ બાટલી ઉપર ખોલો છો ત્યારે,
અને તમારા Python કાર્યક્રમ માં,

103
00:04:49,660 --> 00:04:53,150
તમે માત્ર બાટલી થી લખો
આયાત *, અથવા ગમે,

104
00:04:53,150 --> 00:04:55,957
તમે બરાબર બધા વિચાર નથી
લક્ષણો તમે ઇચ્છો શકે છે.

105
00:04:55,957 --> 00:04:58,540
અને તેથી તમે વધુ સ્પષ્ટપણે છે
તમે કરવા માંગો છો સુવિધાઓ યાદી આપે છે.

106
00:04:58,540 --> 00:05:01,990
જેથી એક ગેરલાભ છે, પરંતુ હું
નાની વેબ માટે મકાન લાગે છે કે

107
00:05:01,990 --> 00:05:04,782
હું જેમ એપ્લિકેશન્સ દર્શાવે કરવા જાઉં છું
તમે તે ખરેખર એક સમસ્યા નથી.

108
00:05:04,782 --> 00:05:07,281
અને છેલ્લા વસ્તુ શું છે
લખતી વખતની ભૂલો છે, કે જે કહે છે માનવામાં આવે છે,

109
00:05:07,281 --> 00:05:10,240
ઓછી એકવિધતા હોય છે
બાટલી વાપરવા માટે કેવી રીતે સંમેલનો,

110
00:05:10,240 --> 00:05:12,400
ત્યાં જ ઘણા નથી કારણ કે
વ્યવસાયિક ઉપયોગ કરે છે લોકો

111
00:05:12,400 --> 00:05:13,191
જેંગો સરખામણીમાં.

112
00:05:13,191 --> 00:05:16,380
તેથી, જો તમે કંઈક જોવા હોય તો,
જેંગો માં "કેવી રીતે હું એક્સ કરવું",

113
00:05:16,380 --> 00:05:18,190
તમે કદાચ તે મળશે.

114
00:05:18,190 --> 00:05:20,260
>> સારી ડિઝાઇન છે
તમે ઉપયોગ કરી શકો પેટર્ન,

115
00:05:20,260 --> 00:05:22,660
પરંતુ બાટલી સાથે, તે છે
સૉર્ટ તમારા પોતાના માર્ગ જાય છે,

116
00:05:22,660 --> 00:05:24,850
ફક્ત તે છે, કારણ કે
ખૂબ નાના પુસ્તકાલય.

117
00:05:24,850 --> 00:05:27,100
તેથી તે છે
ગેરફાયદા છે, પરંતુ મને લાગે છે

118
00:05:27,100 --> 00:05:29,370
તે હજુ પણ ઉપયોગ કરવા માટે એક સારું પુસ્તકાલય છે.

119
00:05:29,370 --> 00:05:31,909
>> તેથી આપણે માત્ર અધિકાર બાટલી માં બાંધી દો.

120
00:05:31,909 --> 00:05:34,200
આ ચોક્કસપણે જતાં નથી
સંપૂર્ણ ટ્યુટોરીયલ હોઇ શકે છે,

121
00:05:34,200 --> 00:05:37,480
પરંતુ તે તમને એક વિચાર આપે છે
વસ્તુઓ માળખું કેવી રીતે,

122
00:05:37,480 --> 00:05:40,790
અને તેથી તમે જઈને આરામદાયક લાગે છે
બંધ અને દસ્તાવેજીકરણ જોઈ

123
00:05:40,790 --> 00:05:42,570
અને વધુ શોધવા.

124
00:05:42,570 --> 00:05:48,500
>> તેથી, મને ખરેખર ખોલો દો
પ્રથમ સરળ ઉદાહરણ તરીકે,

125
00:05:48,500 --> 00:05:50,737
અને તમે શું દર્શાવે છે કે
જેવી લાગે છે, અને પછી અમે પડશે

126
00:05:50,737 --> 00:05:52,070
થોડી વધુ નીચે તૂટી જાય છે.

127
00:05:52,070 --> 00:05:56,160
>> તેથી આ અહીં, મને તે ચાલી વિચાર કરીએ.

128
00:05:56,160 --> 00:06:06,800

129
00:06:06,800 --> 00:06:09,750
તેથી, હવે હું મારા કાર્યક્રમ ચાલી રહ્યો છે.

130
00:06:09,750 --> 00:06:15,910
હું સફારી અપ ખોલવા માટે જાઉં છું
તે મારા સ્થાનિક યજમાન પર ચાલી રહ્યું છે.

131
00:06:15,910 --> 00:06:19,360
તેથી હું ફક્ત આ મોટી બનાવવા જઈ રહ્યો છું.

132
00:06:19,360 --> 00:06:23,960
પરંતુ સ્થાનિક યજમાન: 5000

133
00:06:23,960 --> 00:06:27,650
>> અને તેથી, હમણાં, આ બધા કરે છે
છે, તમે વેબસાઇટ ની મુલાકાત લો, ત્યારે

134
00:06:27,650 --> 00:06:31,490
તે "હેલો, બાટલી" છાપે
જે સુપર ઉપયોગી નથી

135
00:06:31,490 --> 00:06:34,630
પરંતુ હું તે ઠંડી લાગે છે
અહીં આ થોડું ફાઈલમાં,

136
00:06:34,630 --> 00:06:37,390
અમે વેબ સર્વર ચાલી રહ્યું હોય
કંઈક કે જે બહાર છાપવા છે.

137
00:06:37,390 --> 00:06:40,500
તેથી, ચાલો વાસ્તવમાં જુઓ
એક બીજા માટે કોડ અંતે,

138
00:06:40,500 --> 00:06:43,080
અને થોડી તે તોડી.

139
00:06:43,080 --> 00:06:45,260
માપ અહીં દરેકને માટે સારું છે?

140
00:06:45,260 --> 00:06:51,560
>> તેથી, આસ્થાપૂર્વક, તમે કંઈક છો
પાયથોન ઉપયોગ આરામદાયક.

141
00:06:51,560 --> 00:06:55,820
હું અમે જોઈ શકો છો કે ધારી રહ્યા છીએ છું
પાયથોન અને તે દ્વારા વાંચી શકાય છે.

142
00:06:55,820 --> 00:06:59,290
તમારા વિશે કોઇ પ્રશ્નો હોય તો
કંઈપણ હું પણ છે કે ઉપર જઈ શકે છે.

143
00:06:59,290 --> 00:07:03,974
>> તેથી પ્રથમ વાક્ય બાટલી થી છે,
અમે એક મૂડી સાથે, બાટલી આયાત કરો "એફ"

144
00:07:03,974 --> 00:07:06,140
જે તમામ જેવું છે
તમને જરૂર છે કે કી લક્ષણો.

145
00:07:06,140 --> 00:07:08,890
જ્યારે તમે લખી રહ્યાં
ફાઇલ અને ઉપયોગ કરીને બાટલી,

146
00:07:08,890 --> 00:07:12,120
તમે આયાત કરવા માંગો છો જઈ રહ્યાં છો,
કે બધા મુખ્ય વસ્તુઓ છે માત્ર કારણ કે.

147
00:07:12,120 --> 00:07:15,400
અમે શું આગામી વસ્તુ, અમે છે
માત્ર આ કાર્ય બાટલી કૉલ

148
00:07:15,400 --> 00:07:19,270
એક એપ્લિકેશન પદાર્થ બનાવવા માટે, અને તમે છો માટે
હંમેશા કરવા માંગો છો જઈ રહી છે.

149
00:07:19,270 --> 00:07:25,960
>> અને પછી, નીચે જમ્પિંગ
નીચે ઝડપથી આ ભાગ અહીં છે,

150
00:07:25,960 --> 00:07:28,760
છે જે 'if_name _ == "_ main_"
એ Python સંમેલન જેવું.

151
00:07:28,760 --> 00:07:32,750
તેથી આ માત્ર જો તમે ચલાવવા કરશે
સીધા પાયથોન મદદથી આગળ આ ફાઇલ ચલાવો.

152
00:07:32,750 --> 00:07:36,040
પછી, અમે જે કરશે, app.run કૉલ
ખરેખર જઈને એપ્લિકેશન શરૂ કરો.

153
00:07:36,040 --> 00:07:39,570
>> તેથી, તે મુખ્ય માળખું છે કે
જો તમે કોઇ બાટલી કાર્યક્રમમાં પડશે,

154
00:07:39,570 --> 00:07:48,550
તમે આ પડશે
એપ્લિકેશન = બાટલી (_name_), અને પછી app.run.

155
00:07:48,550 --> 00:07:54,940
>> તેથી, બે વસ્તુઓ હું હોય છે કે
અહીં, અમે વધુ રૂટ કૉલ શું છે.

156
00:07:54,940 --> 00:07:57,150
તેથી, ચાલો વિશે વાત કરો
થોડો વધુ રૂટીંગ.

157
00:07:57,150 --> 00:07:58,430
હું પાછા સ્લાઇડ પર જાઓ પડશે.

158
00:07:58,430 --> 00:08:02,540
>> તેથી સૌથી મૂળભૂત
બાટલી માં કન્સેપ્ટ રૂટીંગ છે.

159
00:08:02,540 --> 00:08:06,750
અને તે વિચાર છે કે તમે
Python માં કાર્યો સોંપી

160
00:08:06,750 --> 00:08:11,280
ખાસ સરનામાં પર
તમારા વેબ પૃષ્ઠ પર.

161
00:08:11,280 --> 00:08:13,930
તેથી, જ્યારે તમે કરવા માંગો છો
એક નવો માર્ગ બનાવવા માટે,

162
00:08:13,930 --> 00:08:16,500
તમે આ @ app.route ઉપયોગ
કાર્ય શોભનકળાનો નિષ્ણાત.

163
00:08:16,500 --> 00:08:19,770
તેથી, જો તમે સાથે પરિચિત નહિં હોય, તો છે
Python માં કાર્ય decorators,

164
00:08:19,770 --> 00:08:24,160
તે આ ખ્યાલ છે કે
તમે એક કાર્ય લેવા દે

165
00:08:24,160 --> 00:08:26,800
અને બીજું કંઈક સાથે ઘેરાયેલા.

166
00:08:26,800 --> 00:08:30,140
>> તેથી ખરેખર, આ શોભનકળાનો નિષ્ણાત શું કરે છે,
, તે નીચે કાર્ય લે છે

167
00:08:30,140 --> 00:08:33,409
અને તે વધુ માહિતી ઉમેરે છે
તે છે, પરંતુ શું બાટલી ખરેખર

168
00:08:33,409 --> 00:08:37,480
તે થાય બનાવવા નથી સુપર નથી
નિર્ણાયક છે, પરંતુ મહત્વનું શું છે,

169
00:08:37,480 --> 00:08:43,640
કે તમે માર્ગ પહેલાં
તો પછી આ @ app.route મૂકી, અને

170
00:08:43,640 --> 00:08:46,480
માર્ગ સરનામું,
જેથી સ્લેશ અમે શું

171
00:08:46,480 --> 00:08:48,360
અમે ફક્ત વેબ પેજ ખોલો ત્યારે જોવા મળી હતી.

172
00:08:48,360 --> 00:08:49,580
તેથી તે હોમપેજ છે.

173
00:08:49,580 --> 00:08:51,037
તે માત્ર સ્લેશ માર્ગ છે.

174
00:08:51,037 --> 00:08:52,370
અને પછી તમે આ કાર્ય છે.

175
00:08:52,370 --> 00:08:54,453
આ કાર્ય નું નામ
તમે ઇચ્છો ગમે હોઈ શકે છે.

176
00:08:54,453 --> 00:08:56,930
તે આવશ્યકપણે નથી
માર્ગ સાથે કરી છે.

177
00:08:56,930 --> 00:08:59,440
અને પછી, ગમે
કાર્ય વળતર,

178
00:08:59,440 --> 00:09:01,730
કાર્ય શબ્દમાળા પાછા જોઈએ.

179
00:09:01,730 --> 00:09:03,740
અને કે જેઓ શબ્દમાળા કરી શકો છો
, એચટીએમએલ અથવા કંઈપણ સમાવે

180
00:09:03,740 --> 00:09:06,920
અને તે શું મળશે ખરેખર છે
HTML તરીકે તમારા વેબ બ્રાઉઝર પરત ફર્યો,

181
00:09:06,920 --> 00:09:08,200
અને તે રેન્ડર કરશે.

182
00:09:08,200 --> 00:09:12,030
>> તેથી આ જ કોડ છે
કે ઉદાહરણ હતો

183
00:09:12,030 --> 00:09:16,430
હું માત્ર ચાલી હતી કે, તેથી અમે સ્લેશ મુલાકાત લો ત્યારે,
તે હેલો વર્લ્ડ કાર્ય, કહે છે, જે

184
00:09:16,430 --> 00:09:20,470
માત્ર એક શબ્દમાળા હેલો, બાટલી આપે છે,
અને તે સ્ક્રીન પર મુદ્રિત નહીં.

185
00:09:20,470 --> 00:09:27,290
>> તેથી અન્ય ઉદાહરણ છે,
છે, કે જે જ્યારે તમે હેલો / મુલાકાત,

186
00:09:27,290 --> 00:09:30,370
તે હેલો વર્ડ, બહાર છાપે છે
ખરેખર, હેલો વર્લ્ડ કહેવું જોઈએ,

187
00:09:30,370 --> 00:09:32,010
પરંતુ કે ઇરાદાપૂર્વક હતી ડોળ દો.

188
00:09:32,010 --> 00:09:35,140
તેથી આપણે વાસ્તવિક ઝડપી સુધી ખેંચી દો.

189
00:09:35,140 --> 00:09:41,290
>> તેથી જો તમે હેલો / localhost પર જાઓ, તો
તે હવે કંઈક બીજું છાપશે.

190
00:09:41,290 --> 00:09:45,680
તેથી કેવી રીતે માત્ર એક ઝડપી ઉદાહરણ છે
તમે બે અલગ માર્ગો બનાવી શકો છો.

191
00:09:45,680 --> 00:09:50,630
>> તેથી, અત્યાર સુધી આ સુપર ઉપયોગી નથી
તમે કરી શકો છો એક સમગ્ર ઘણો નથી,

192
00:09:50,630 --> 00:09:55,360
તમે માત્ર સાથે તમામ કરી શકે
અલગ અલગ HTML પૃષ્ઠો કર્યા,

193
00:09:55,360 --> 00:09:58,000
અને તમે એક ખાસ મુલાકાત લો ત્યારે
પાનું તે માત્ર પાનું લોડ કરે છે.

194
00:09:58,000 --> 00:10:00,864
તેથી આપણે કેટલાક વધુ જોવા દો
તમે કરી શકો છો ઉપયોગી વસ્તુઓ.

195
00:10:00,864 --> 00:10:03,780
તેથી, એક વસ્તુ તમે હોઈ શકે છે કે
હું ખેંચાય કે ઉદાહરણ સૂચન

196
00:10:03,780 --> 00:10:07,160
ઉપર, હું app.run હતું કે છે (ડિબગ = સત્ય) છે.

197
00:10:07,160 --> 00:10:09,580
અને તેથી, આ શું
ડિબગ દલીલ છે, કરે છે

198
00:10:09,580 --> 00:10:14,600
તમે તમારા વેબ સર્વર ચલાવવા ત્યારે,
તમે તમારી અરજી કરશો ત્યારે,

199
00:10:14,600 --> 00:10:18,100
તમે ફાઈલ બદલવા માટે, તે કરશે
આપોઆપ સર્વર ફરીથી લોડ કરો.

200
00:10:18,100 --> 00:10:21,160
>> અને તેથી તમે ખરેખર ન હોય
સુપર ઉપયોગી છે કે જે પુનઃપ્રારંભ પાયથોન.

201
00:10:21,160 --> 00:10:24,020
મને લાગે છે કે બતાવી શકે છે.

202
00:10:24,020 --> 00:10:26,960
મારા કોડ ખેંચી દો
તે ટાઈપો સાથે,

203
00:10:26,960 --> 00:10:30,420
અને તે ટાઈપો ત્યાં મૂકી હતી ડોળ
ઈરાદાપૂર્વક ઉપદેશક હેતુઓ માટે.

204
00:10:30,420 --> 00:10:31,625
તેથી આપણે આ પાછા ઉમેરો.

205
00:10:31,625 --> 00:10:33,140
તેથી હવે તે હેલો વર્લ્ડ કહે છે.

206
00:10:33,140 --> 00:10:34,410
હું તેને બચાવે છે.

207
00:10:34,410 --> 00:10:36,540
અને અમે પાછા ખેંચવાનો અપ તો
ટર્મિનલ, તમે

208
00:10:36,540 --> 00:10:39,520
તે પુનઃશરૂ છે કહે છે કે,
તે થોડા બદલાવ શોધેલ છે, કારણ કે

209
00:10:39,520 --> 00:10:43,620
અને તેથી હવે અમે આ પૃષ્ઠને ફરીથી લોડ જ્યારે
તે યોગ્ય વસ્તુ છાપશે.

210
00:10:43,620 --> 00:10:45,630
>> તેથી ડિબગ કે સુપર ઉપયોગી છે.

211
00:10:45,630 --> 00:10:48,740
પણ, તમે કોઇ હોય તો
ભંગાણ જેવું છે, જેથી

212
00:10:48,740 --> 00:10:54,370
મને આ એપ્લિકેશન ક્રેશ બનાવવા દો
હોવાના તે શબ્દમાળા પાછા નથી.

213
00:10:54,370 --> 00:10:57,540
તેથી, માત્ર તે હોય ચાલો
કેટલાક કારણોસર નહીં આવો.

214
00:10:57,540 --> 00:11:00,810
અને પછી હું આ મુલાકાત લો ત્યારે
પાનું, તે માત્ર ભાંગી જશે,

215
00:11:00,810 --> 00:11:04,465
પરંતુ સર્વરે માત્ર તે તૂટી નથી
ખરેખર તમે એક સુપર ઉપયોગી પાછી આપે છે

216
00:11:04,465 --> 00:11:06,490
બધું ટ્રેસ ખોટું થયું છે.

217
00:11:06,490 --> 00:11:10,050
અને, ખરેખર સરસ શું છે કે જે આવે છે
આ પાછળ ટ્રેસ કોઈપણ પગલું ખાતે,

218
00:11:10,050 --> 00:11:14,260
તમે એક ઇન્ટરેક્ટિવ ખોલો શકે
અહીં શેલ, અને પ્રકારની શું છાપે

219
00:11:14,260 --> 00:11:17,780
ચલો તમે પર એક નજર માંગો છો.

220
00:11:17,780 --> 00:11:21,054
>> અને તેથી ડિબગીંગ ખરેખર છે
બહાર figuring માટે ઉપયોગી

221
00:11:21,054 --> 00:11:23,470
શું સાથે ચાલી રહ્યું છે તમારા
સર્વર, બદલે માત્ર જોયા

222
00:11:23,470 --> 00:11:28,201
500 આંતરિક જેવા PHP કંઈક
સુપર નકામું છે, જે સર્વર ભૂલ.

223
00:11:28,201 --> 00:11:30,700
એક વસ્તુ છે, ચેતો
કે તમે તમારા એપ્લિકેશન મૂકવામાં જો

224
00:11:30,700 --> 00:11:34,260
તેથી તે જાહેર જનતા માટે દૃશ્યમાન છે તમે
ક્યારેય ડિબગ સ્થિતિ પર છોડવા માંગો છો,

225
00:11:34,260 --> 00:11:37,320
લોકો ખરેખર કરી શકો છો કારણ કે
કે કન્સોલ વાપરો કે જે હું

226
00:11:37,320 --> 00:11:39,150
તમે કોડ ચલાવાય દર્શાવ્યું.

227
00:11:39,150 --> 00:11:42,120
>> તેથી તેઓ કોઈપણ જેવા બહાર છાપી શકો છો
તમે ત્યાં છે ગુપ્ત કોડ્સ,

228
00:11:42,120 --> 00:11:44,755
તેઓ બરાબર જોઈ શકો છો
કેવી રીતે તમારી વેબસાઇટ કામ કરે છે.

229
00:11:44,755 --> 00:11:46,630
તેથી તે ખરેખર ઉપયોગી છે
પરીક્ષણ માટે છે, પરંતુ હંમેશા

230
00:11:46,630 --> 00:11:50,090
પહેલાં તેને બહાર લેવા માટે ખાતરી કરો
તમે ઑનલાઇન કંઈપણ પ્રકાશિત.

231
00:11:50,090 --> 00:11:56,640
>> તેથી જ્યારે તમે કંઈક ઉપયોગ કરી રહ્યાં છો
PHP, જેમ, આ વિચાર છે

232
00:11:56,640 --> 00:11:58,920
તમે પસાર કરી શકાય છે
વેબ પાનાંઓ વચ્ચે માહિતી

233
00:11:58,920 --> 00:12:03,620
ખરેખર આ માહિતી મૂકવા દ્વારા
વિચાર વિનંતી છે, જે URL માં,

234
00:12:03,620 --> 00:12:07,490
પરંતુ બાટલી, તમે ખરેખર કરી શકો છો
સૉર્ટ કરો કે કંઈક કરવું,

235
00:12:07,490 --> 00:12:10,590
છે કે માર્ગ હોવાના
તે એક ભાગ તરીકે એક ચલ.

236
00:12:10,590 --> 00:12:14,090
>> તમે આ જુઓ તો તેથી
અહીં સ્ક્રીન પર, ઉદાહરણ તરીકે,

237
00:12:14,090 --> 00:12:19,930
અમે છે કે માર્ગ છે
('હેલો / /'), અને તેથી, તમે મુલાકાત લો છો તો

238
00:12:19,930 --> 00:12:23,790
હેલો / / કંઈક કે જે કંઈક
ખરેખર ભરેલ વિચાર રહ્યું છે

239
00:12:23,790 --> 00:12:25,490
નામ ચલ માં.

240
00:12:25,490 --> 00:12:27,850
અને કાર્ય કે નોટિસ
કે માર્ગ સાથે આવે છે

241
00:12:27,850 --> 00:12:31,302
પરિમાણ માં લેવા માટે છે
નામ તે ખરેખર કરશે કે જેથી

242
00:12:31,302 --> 00:12:32,510
આ કાર્ય માં પસાર કરો.

243
00:12:32,510 --> 00:12:34,190
>> અને પછી, એક વાર તમે છો
કે કાર્ય ની અંદર,

244
00:12:34,190 --> 00:12:36,420
તમે જેમ કે સારવાર કરી શકે છે
સામાન્ય પાયથોન ચલ,

245
00:12:36,420 --> 00:12:39,650
અને તેથી તે પછી, તે
હેલો છાપે છે, અને તે

246
00:12:39,650 --> 00:12:42,000
મદદથી નામને ભરો કરશે
કેટલાક શબ્દમાળા ફોર્મેટિંગ.

247
00:12:42,000 --> 00:12:48,060
>> તેથી રાઉટીંગ ચલ ભાગો ઉમેરવા માટે,
તમે ચિહ્નિત કોણ કૌંસ વાપરો.

248
00:12:48,060 --> 00:12:51,220
અને વૈકલ્પિક રીતે, તમે ઉપયોગ કરી શકો છો
શું પરિવર્તક કહેવાય છે.

249
00:12:51,220 --> 00:12:56,840
અને તેથી, તમે આ મૂકી તો
કોલોન સાથે એનોટેશન,

250
00:12:56,840 --> 00:13:00,015
તમે તે છે સ્પષ્ટ કરી શકો છો
પૂર્ણાંક, અથવા એક ફ્લોટ, અથવા પાથ,

251
00:13:00,015 --> 00:13:01,640
અને તે આપોઆપ કે રૂપાંતરિત કરશે.

252
00:13:01,640 --> 00:13:05,130
પણ તમે રૂપાંતર કરી શકો છો
પાયથોન કાર્ય અંદર,

253
00:13:05,130 --> 00:13:09,710
માત્ર એક કાસ્ટ ઉપયોગ કરીને, પરંતુ ક્યારેક તો
તમે તેને પૂર્ણાંક છે કે જે ખાતરી કરવા માંગો છો,

254
00:13:09,710 --> 00:13:12,080
તમે તે મૂકી શકો છો
ત્યાં રૂપાંતર નિયમ.

255
00:13:12,080 --> 00:13:15,930
>> તેથી આપણે એક ઉદાહરણ અપ ખેંચવાનો દો
કેટલાક ચલ નિયમો.

256
00:13:15,930 --> 00:13:21,480
અહીં, આ મૂળભૂત જ છે
બાટલી આયાત સાથે માળખું

257
00:13:21,480 --> 00:13:25,030
બાટલી, એપ્લિકેશન = બાટલી (_name_)
અને પછી તે ઓવરને અંતે ચાલી રહ્યું છે.

258
00:13:25,030 --> 00:13:28,050
અમે આ બે અલગ અલગ હોય છે
અહીં ચલ માર્ગ.

259
00:13:28,050 --> 00:13:29,900
અને પ્રથમ એક છે,
હું દર્શાવે છે કે એક

260
00:13:29,900 --> 00:13:34,230
કે હતી, જે સ્લાઇડ માં
તે માત્ર એક શબ્દમાળા નામ લે

261
00:13:34,230 --> 00:13:35,650
અને તે નામ હેલો છાપશે.

262
00:13:35,650 --> 00:13:41,410
>> અને પછી, બીજા
એક રૂપાંતર ઉપયોગ કરે છે.

263
00:13:41,410 --> 00:13:44,690
તેથી આ આપોઆપ કન્વર્ટ થશે
પૂર્ણાંક માટે, અને પછી, પૂર્ણાંક ડબલ

264
00:13:44,690 --> 00:13:46,150
અને તે છાપે.

265
00:13:46,150 --> 00:13:48,220
અને, અમે કોઇ પણ પ્રકારની નથી
તે અંદર રૂપાંતર

266
00:13:48,220 --> 00:13:49,594
બાટલી કે કાળજી લે છે, કારણ કે.

267
00:13:49,594 --> 00:13:53,181
તેથી આપણે આ ચાલી વિચાર કરીએ.

268
00:13:53,181 --> 00:13:54,930
તમે એક બાટલી હોય ત્યારે
અરજી ચાલી,

269
00:13:54,930 --> 00:13:58,440
તમે તેને બહાર સી નિયંત્રિત કરી શકો છો
સર્વર ચાલી રોકવા માટે.

270
00:13:58,440 --> 00:14:02,420
અને પછી હું ચલો ચાલશે.

271
00:14:02,420 --> 00:14:11,740
>> તેથી આપણે localhost / હેલો / એઝરા પર જાઓ અને
આસ્થાપૂર્વક, આ મને હેલો કહો આવશે.

272
00:14:11,740 --> 00:14:14,530

273
00:14:14,530 --> 00:14:20,310
>> તેથી તે ચલ, મારું નામ લીધો
માર્ગ છે, અને તે અહીં તે ભરી.

274
00:14:20,310 --> 00:14:23,950
તેથી હું પણ ઝડપી બતાવીશું
આ ડબલિંગ ઉદાહરણ.

275
00:14:23,950 --> 00:14:28,600
તેથી જો તમે 3 / ડબલ / પર જાઓ, તો
તે 6 છાપશે.

276
00:14:28,600 --> 00:14:31,440
તેથી આ કાળજી લીધી
અમારા માટે રૂપાંતર.

277
00:14:31,440 --> 00:14:34,190
>> તેથી તમે પણ સાથે કરી શકો છો
ફ્લોટ, અને ખાસ કંઈક છે,

278
00:14:34,190 --> 00:14:37,530
તમે કંઈક સ્પષ્ટ કરવાની જરૂર છે, તો
તે સ્લેશ સ્વીકારી શકો છો કે જે પાથ,

279
00:14:37,530 --> 00:14:39,155
પરંતુ તે સામાન્ય રીતે એક મુદ્દો ન હોવી જોઈએ.

280
00:14:39,155 --> 00:14:41,480

281
00:14:41,480 --> 00:14:43,820
અત્યાર સુધી અમે હજુ પણ હોય છે
માત્ર પરત કરવામાં આવી

282
00:14:43,820 --> 00:14:46,320
ખૂબ જ રસપ્રદ નથી કે જે શબ્દમાળાઓ.

283
00:14:46,320 --> 00:14:48,730
>> અમે ખરેખર પરત કરી શકે છે
શાબ્દિક HTML શબ્દમાળા.

284
00:14:48,730 --> 00:14:54,322
તેથી તે કોડ અમે કંઈક દાખલ કરી શકો છો
બી ટેગ તે બોલ્ડ બનાવવા માંગો,

285
00:14:54,322 --> 00:14:56,030
પરંતુ મોટા ભાગના સમય તમે
ખરેખર માંગો છો નથી

286
00:14:56,030 --> 00:14:58,420
HTML કોડ લખી શકાય
તમારા પાયથોન કોડ.

287
00:14:58,420 --> 00:15:01,940
તે ખરેખર અવ્યવસ્થિત નહીં
અને તે એક સારા સમય નથી.

288
00:15:01,940 --> 00:15:06,430
>> બાટલી અમને અલગ કરવા માટે પરવાનગી આપે છે
ઢાંચો કહેવાય છે તે માં HTML,

289
00:15:06,430 --> 00:15:09,467
અને તેથી જો તમે વિચારી રહ્યાં છો
ના MVC મોડેલ દ્રષ્ટિએ

290
00:15:09,467 --> 00:15:11,550
તમે પરિચિત છો કે,
આસ્થાપૂર્વક, કામ

291
00:15:11,550 --> 00:15:15,520
CS50 ફાયનાન્સ સાથે થોડો,
તમે Python ફાઇલો વિચાર કરી શકો છો

292
00:15:15,520 --> 00:15:19,430
નિયંત્રક, જ્યાં વધુ હોવાથી
તેઓ ગમે સાથે સંપર્કમાં આવવાની છે

293
00:15:19,430 --> 00:15:20,970
તમે હોઈ શકે છે માહિતી મોડેલ.

294
00:15:20,970 --> 00:15:24,900
>> અને પછી તેઓ જોવાઈ બહાર ફોન આવે છે
અને તે જુઓ જાણકારી પસાર

295
00:15:24,900 --> 00:15:28,120
માહિતી ભરવા માટે
HTML માં તેને જરૂર છે.

296
00:15:28,120 --> 00:15:30,490
અને અમે તે દૃશ્યો કૉલ શું
વર્ગ નમૂનાઓ છે.

297
00:15:30,490 --> 00:15:35,280
>> તેથી બાટલી અન્ય પાયથોન વાપરે
મોડ્યુલ તે આપમેળે ચાલશે

298
00:15:35,280 --> 00:15:38,620
તમે સ્થાપિત કરવા ફળનું નાનું બીજ જ્યારે સ્થાપિત
બાટલી Jinja કહેવાય છે, જે

299
00:15:38,620 --> 00:15:40,885
તમે આ ઉમેરી શકો છો
એચટીએમએલ એનોટેશંસ

300
00:15:40,885 --> 00:15:45,140
તમે સ્ક્રીન પર જોવા કે, કરી શકો છો
તમે, શરતો જેવી વસ્તુઓ મૂકી

301
00:15:45,140 --> 00:15:47,230
અને HTML માં આંટીઓ.

302
00:15:47,230 --> 00:15:51,140
>> તેથી તે તમે કેવી રીતે જેમ થોડો લાગે છે
એક HTML ફાઇલ અંદર PHP ઉપયોગ કરી શકે છે,

303
00:15:51,140 --> 00:15:57,380
પરંતુ આ માત્ર ત્યારે બાટલી છે
સર્વર, HTML ફાઇલ આપે છે

304
00:15:57,380 --> 00:16:01,610
તે આ templating એન્જિન ચાલશે અને
આ દ્વારા પાર્સ અને વસ્તુઓ ભરો.

305
00:16:01,610 --> 00:16:06,650
તેથી બાટલી એક render_template કાર્ય છે
તમે અહીં નીચે જોઈ શકો છો છે.

306
00:16:06,650 --> 00:16:14,300
અને તેથી તમે તે આ પૃષ્ઠની મુલાકાત લો ત્યારે
આ hello.html નમૂનો રેન્ડર કરશે,

307
00:16:14,300 --> 00:16:16,407
અને પછી આ HTML પાનામાં ભરો.

308
00:16:16,407 --> 00:16:18,990
તેથી આપણે માત્ર આ વાસ્તવિક ચલાવો
ઝડપી, અને તે જેવી લાગે છે તે જોવા માટે,

309
00:16:18,990 --> 00:16:21,198
અને પછી હું પસાર કરશો
વધુ વિગતવાર થોડુંક.

310
00:16:21,198 --> 00:16:25,380

311
00:16:25,380 --> 00:16:30,260
તેથી, તમારા નમૂનાઓ જતા હોય છે
એક નમૂનાઓ ફોલ્ડર માં જાઓ.

312
00:16:30,260 --> 00:16:33,980
તે આપમેળે અંદર જોવા મળશે
નમૂનાઓ કે ઢાંચો માટે ફોલ્ડર.

313
00:16:33,980 --> 00:16:35,615
તેથી આપણે આ ખોલો દો.

314
00:16:35,615 --> 00:16:47,350

315
00:16:47,350 --> 00:16:50,005
તેથી, હું Templating ઉદાહરણ ચલાવવા પડશે.

316
00:16:50,005 --> 00:16:52,820

317
00:16:52,820 --> 00:17:03,660
>> તેથી હું હેલો / / એઝરા પર જાઓ, તો
તે આ ભયાનક છે,

318
00:17:03,660 --> 00:17:05,930
હું મૂકી કે ખરાબ માર્કી ટેગ.

319
00:17:05,930 --> 00:17:08,050
ખૂબ જ સરસ, ખૂબ ગતિશીલ.

320
00:17:08,050 --> 00:17:09,349
હું એક મોટી ચાહક છું.

321
00:17:09,349 --> 00:17:13,900
પરંતુ શું થાય છે જો
હું માત્ર હેલો / પર જાઓ?

322
00:17:13,900 --> 00:17:15,220
તેથી તે માત્ર હેલ્લો વિશ્વ કહે.

323
00:17:15,220 --> 00:17:17,678
હું તે નામ પસાર ન હતી, અને
તે આપમેળે ભરી.

324
00:17:17,678 --> 00:17:22,050
તેથી તે હતી કે કેવી રીતે માતાનો જોવા દો, અને કેવી રીતે
અમે કદાચ કે માર્કી છુટકારો મેળવી શકો છો.

325
00:17:22,050 --> 00:17:26,240
>> તેથી અહીં, આ પ્રકારની છે
એક રસપ્રદ ઉદાહરણ તરીકે,

326
00:17:26,240 --> 00:17:29,101
તમે કેવી રીતે સ્વીચ સાથે પરિચિત હોય છે, તો
નિવેદનો ભાષામાં કામ કરે છે.

327
00:17:29,101 --> 00:17:31,350
આ જેવા પ્રકારની છે કહે છે
દ્વારા પતન કે આનાથી સૉર્ટ કરો,

328
00:17:31,350 --> 00:17:34,266
જ્યાં તમે વાસ્તવમાં બે જોડાયેલ
એ જ કાર્ય માટે વિવિધ માર્ગો.

329
00:17:34,266 --> 00:17:41,190
તેથી અમે હેલો / માર્ગ સાથે જોડે છે અને
હેલો કરવા માટે / હેલો / નામ માર્ગ,

330
00:17:41,190 --> 00:17:45,130
python તમે કરી શકો છો using-- અને અમે સ્પષ્ટ
મૂળભૂત કાર્ય arguments-- સ્પષ્ટ

331
00:17:45,130 --> 00:17:48,300
જેથી કોઈ નામ છે, તેથી જો ત્યાં
અમે પર જાઓ હોય તો માત્ર / હેલો,

332
00:17:48,300 --> 00:17:50,680
તે આપોઆપ ફિલ્ટર કરશે
નામ કંઈ સમાન છે.

333
00:17:50,680 --> 00:17:55,010
>> તેથી, અમે રેન્ડર
નામ = નામ સાથે ઢાંચો,

334
00:17:55,010 --> 00:17:59,510
તેથી તે નામ પરિમાણમાં પસાર કરશે
આ નામ કાર્ય પરિમાણ માટે સમાન,

335
00:17:59,510 --> 00:18:00,730
નમૂના માં.

336
00:18:00,730 --> 00:18:04,040
કેવી રીતે તે હજુ પણ સમજાવતું નથી
હેલો વર્લ્ડ પ્રિન્ટ નક્કી કરો કે શું,

337
00:18:04,040 --> 00:18:05,100
કે મારા નામ છાપો.

338
00:18:05,100 --> 00:18:08,050
તેથી ચાલો વાસ્તવમાં જુઓ
આ નમૂનો પોતે માં,

339
00:18:08,050 --> 00:18:11,610
અને તે આવતા થયેલ છે જુઓ.

340
00:18:11,610 --> 00:18:18,680
>> તેથી, આ નમૂનો અંદર, અમે
વાસ્તવમાં કેટલાક શરતી તર્ક હોય છે,

341
00:18:18,680 --> 00:18:20,580
જે અમુક લોકો કરશે
એવી દલીલ કરે છે, તમે ખરેખર

342
00:18:20,580 --> 00:18:23,730
શરતી ઘણો ન જોઈએ
તમારા નમૂનો પોતે અંદર તર્ક.

343
00:18:23,730 --> 00:18:26,310
તે અંદર વધુ પ્રયત્ન કરીશું
કંટ્રોલર, પરંતુ આ ઉદાહરણ માટે

344
00:18:26,310 --> 00:18:27,476
તે ખૂબ નાના કંઈક છે.

345
00:18:27,476 --> 00:18:31,060
નામ તેથી જો અહીં, અમે આમ, તપાસ,
જો નામ કંઈ બરાબર નથી,

346
00:18:31,060 --> 00:18:33,130
નામ ખરેખર છે, તો
, તો પછી અમે કરશે પસાર

347
00:18:33,130 --> 00:18:36,210
સાથે નામ, હેલો કહો
હેડર અને માર્કી,

348
00:18:36,210 --> 00:18:41,490
આ બધા સામાન્ય એચટીએમએલ, અન્યથા, અમે
હેલો છાપે, વિશ્વમાં માત્ર સામાન્ય રીતે.

349
00:18:41,490 --> 00:18:45,820
તેથી એક દંપતિ વસ્તુઓ અહીં નોટિસ
તમે templating ફોર્મેટ કેવી રીતે વિશે

350
00:18:45,820 --> 00:18:49,110
આમાંથી, કે જે બધા છે
શરતી નિવેદનો,

351
00:18:49,110 --> 00:18:54,475
સૉર્ટ જેવા અમે તેને ત્યારે php કેવી રીતે
તમે કેટલાક PHP દાખલ કરવા માંગો છો,

352
00:18:54,475 --> 00:18:58,380
તમે ઓછા વાપરવા પ્રશ્ન
માર્ક, તે અહીં પ્રકારના સમાન છે

353
00:18:58,380 --> 00:19:00,140
આ {% છે.

354
00:19:00,140 --> 00:19:02,130
>> તેથી અહીં, અમે અમારી શરતી કોડ છે.

355
00:19:02,130 --> 00:19:05,920
અને પછી, તમે ખરેખર કરવા માંગો ત્યારે
શાબ્દિક કંઈક મૂલ્યાંકન, અને પ્રિન્ટ

356
00:19:05,920 --> 00:19:08,710
સ્ક્રીન પર બહાર, તમે
ડબલ કૌંસ વાપરો.

357
00:19:08,710 --> 00:19:12,310
તેથી અહીં ડબલ કૌંસ છે,
અને પછી અમે નામ સ્પષ્ટ કરે છે,

358
00:19:12,310 --> 00:19:15,500
કે અંદર તેથી, તે મૂલ્યાંકન કરશે
ચલ નામ, જે

359
00:19:15,500 --> 00:19:18,860
માંથી માં પસાર કરવામાં આવ્યો
, નમૂનો કાર્ય રેન્ડર

360
00:19:18,860 --> 00:19:21,484
તેના બદલે માત્ર પ્રિન્ટીંગ કરતાં
બહાર, અમે આ છુટકારો મેળવ્યો, તો

361
00:19:21,484 --> 00:19:23,150
તે માત્ર શબ્દ છાપે કરશે "નામ."

362
00:19:23,150 --> 00:19:26,340
તેથી, તે માટે જુઓ કંઈક છે.

363
00:19:26,340 --> 00:19:29,792
>> તેથી અન્ય વસ્તુ
નોટિસ છે ત્યારે અમે તે

364
00:19:29,792 --> 00:19:31,500
ઉપયોગ કરવા માંગો છો
render_template કાર્ય,

365
00:19:31,500 --> 00:19:34,490
અમે ખરેખર આયાત કરવા માટે હોય છે
તે સ્પષ્ટ બાટલી છે.

366
00:19:34,490 --> 00:19:36,915
અને આ એક ઉદાહરણ છે
બાટલી ના મોડ્યુલારીટી,

367
00:19:36,915 --> 00:19:39,290
તમે આયાત કરવા નથી કે
તમે જરૂર નથી કે વસ્તુઓ.

368
00:19:39,290 --> 00:19:41,290
તમે માત્ર લાવી શકે છે
કાર્યો ખરેખર તમે

369
00:19:41,290 --> 00:19:43,450
ક્યારેક, કે જે જરૂર નથી
સરસ, જેથી તમે નથી

370
00:19:43,450 --> 00:19:46,560
આ બધા કાર્યો હોય છે
તમે ઉપયોગ કરી રહ્યાં છો કે આસપાસ બેઠક,

371
00:19:46,560 --> 00:19:49,730
પણ તમે તે ભૂલી જો
render_template આયાત કરવા માટે જરૂર છે,

372
00:19:49,730 --> 00:19:52,660
તમે કદાચ એક ચેતવણી મળશે
કે જે તમને વિશે જણાવીશું.

373
00:19:52,660 --> 00:19:56,700
તેથી, તે templating છે.

374
00:19:56,700 --> 00:20:01,680
>> તેથી, અમે કેવી રીતે બતાવ્યા પ્રમાણે કર્યું
સરળ વેબ પાનાંઓ બનાવવા

375
00:20:01,680 --> 00:20:04,947
અને થોડો વધુ તર્કશાસ્ત્ર ઉમેરો
તે ચલ રાઉટીંગ દ્રષ્ટિએ.

376
00:20:04,947 --> 00:20:08,280
તે તમારા પર આધારિત અલગ અલગ વસ્તુઓ કરી શકો છો
શું પછી તમે પણ જાઓ, અને URL આપે છે

377
00:20:08,280 --> 00:20:11,950
માં HTML થોડો વધુ અર્થમાં
તમે વસ્તુઓ રેન્ડર કરવા માંગો છો કેવી રીતે દ્રષ્ટિએ.

378
00:20:11,950 --> 00:20:14,210
તમે બધા મૂકી નથી
તમારા Python માં તમારા HTML,

379
00:20:14,210 --> 00:20:16,640
પરંતુ ખૂબ ખૂબ માટે
દરેક વેબ એપ્લિકેશન,

380
00:20:16,640 --> 00:20:21,480
તમે અમુક પ્રકારના માંગો છો જઈ રહ્યાં છો
માહિતી મોડેલ તેની સાથે સંકળાયેલ હોય છે.

381
00:20:21,480 --> 00:20:25,560
>> અને તેથી પરંપરાગત રીતે, આ કરશે
એક એસક્યુએલ ડેટાબેઝ કંઈક છે.

382
00:20:25,560 --> 00:20:30,280
અને તમે માત્ર સંપર્ક કરી શકો છો
સીધા SQL સાથે.

383
00:20:30,280 --> 00:20:32,190
પાયથોન છે હું તે કહે છે એવું લાગે છે.

384
00:20:32,190 --> 00:20:33,040
SQLite 3.

385
00:20:33,040 --> 00:20:38,454
તમે માત્ર SQLite 3 આયાત કરી શકો છો અને
સીધા SQL પ્રશ્નો ચલાવો

386
00:20:38,454 --> 00:20:40,870
પરંતુ હું તમને વિશે ખબર નથી,
પરંતુ હું ખરેખર માત્ર ગમતું નથી

387
00:20:40,870 --> 00:20:42,750
એસક્યુએલ ક્વેરીઝ લખવાથી.

388
00:20:42,750 --> 00:20:45,350
તે ખરેખર વિચાર કરે છે
લાંબી અને જટિલ.

389
00:20:45,350 --> 00:20:49,180
>> અને તેથી, કંઈક કે
હું ઉપયોગ કરવા જેવું છે શું

390
00:20:49,180 --> 00:20:53,610
એક છે, જે એક ORM, તરીકે પણ ઓળખાય છે
પદાર્થ સંબંધ મેપિંગ.

391
00:20:53,610 --> 00:20:56,890
અને એક બિંદુ
પદાર્થ સંબંધ મેપિંગ,

392
00:20:56,890 --> 00:21:00,100
બે અલગ અલગ હોય છે
રીતે તમે ડેટાબેઝ વિશે વિચાર કરી શકો છો.

393
00:21:00,100 --> 00:21:03,240
>> ઉદાહરણ કે જેથી
પ્રોફેસર માલણ સામાન્ય

394
00:21:03,240 --> 00:21:07,660
વર્ગ વાપરે છે, આ એક્સેલ ટેબલ, જ્યાં છે
તમે આ પંક્તિઓ અને આ કૉલમ છે,

395
00:21:07,660 --> 00:21:10,210
અને તે માટે ખરેખર ઉપયોગી છે
તે એસક્યુએલ રજૂ થાય છે કેવી રીતે

396
00:21:10,210 --> 00:21:13,170
અને તમે તેની સાથે કેવી રીતે સંચાર, પરંતુ
તે ખરેખર છે કે બીજી રીતે

397
00:21:13,170 --> 00:21:16,390
ક્યારેક તે વિશે વિચારો ઉપયોગી
વર્ગો અને ઓબ્જેક્ટો શરતો છે.

398
00:21:16,390 --> 00:21:20,420
>> તેથી તેના બદલે વિચાર
દરેક ટેબલ હોવા તરીકે

399
00:21:20,420 --> 00:21:23,040
ચોક્કસ છે કે આ પંક્તિ
માહિતી, તમે ખરેખર કરી શકો છો

400
00:21:23,040 --> 00:21:26,100
તરીકે તેને લાગે
દરેક કોષ્ટક એક વર્ગ છે,

401
00:21:26,100 --> 00:21:29,810
ના અને પછી દરેક ઉદાહરણ
વર્ગ ચોક્કસ ગુણધર્મો ધરાવે છે.

402
00:21:29,810 --> 00:21:35,110
તેથી, આ ઉદાહરણ માં, ઉદાહરણો
વર્ગ કોષ્ટકમાં પંક્તિઓ છે,

403
00:21:35,110 --> 00:21:37,490
અને પછી દરેક મિલકત કરશે
કોષ્ટકમાં એક સ્તંભ છે.

404
00:21:37,490 --> 00:21:40,840
>> તેથી, હું ગમે છે કે ORM
peewee કહેવામાં આવે છે ઉપયોગ કરે છે.

405
00:21:40,840 --> 00:21:43,520
તે પ્રકારના બાટલી જેવા ખરેખર નાની છે.

406
00:21:43,520 --> 00:21:46,760
હું તેઓ સાથે મળીને જાઓ લાગે છે કે,
પરંતુ અન્ય ORMs ઘણો છે

407
00:21:46,760 --> 00:21:47,730
તમે ઉપયોગ કરી શકો છો.

408
00:21:47,730 --> 00:21:52,180
વધુ લોકપ્રિય છે
SQLAlchemy તરીકે ઓળખાય છે,

409
00:21:52,180 --> 00:21:56,050
અને હું શા માટે હું મૂળ યાદ રાખી શકો નહિં
, SQLAlchemy પર peewee પસંદ

410
00:21:56,050 --> 00:21:58,311
કે હું તમને શા માટે હું કહી કરશે
તે શ્રેષ્ઠ એક છે લાગે છે,

411
00:21:58,311 --> 00:22:01,060
પરંતુ અમે ફક્ત આ ઉપયોગ જઈ રહ્યાં છો
એક હું તેનો ઉપયોગ કેવી રીતે ખબર છે કારણ કે.

412
00:22:01,060 --> 00:22:04,760
>> તેથી, એક પ્રશ્ન છે, શા માટે છે
તમે એક ORM મદદથી સંતાપ જોઈએ,

413
00:22:04,760 --> 00:22:07,552
તેના બદલે માત્ર સીધા ના
એસક્યુએલ ક્વેરીઝ લખી?

414
00:22:07,552 --> 00:22:09,760
અને હું શ્રેષ્ઠ કેસ લાગે છે,
તમે ખરેખર નથી

415
00:22:09,760 --> 00:22:11,356
એસક્યુએલ ક્વેરીઝ લખવા માટે હોય છે.

416
00:22:11,356 --> 00:22:14,480
હું તમને બતાવીશું તરીકે, ખૂબ સરળ છે
પસંદગી જેવી વસ્તુઓ કરી, નિવેશ,

417
00:22:14,480 --> 00:22:16,157
કાઢી નાંખવાનું, ખાસ કરીને કોષ્ટકો બનાવવા.

418
00:22:16,157 --> 00:22:17,990
તે ખૂબ સરળ છે
એક વર્ગ માળખું લખી

419
00:22:17,990 --> 00:22:22,250
તે માળખું કરતાં બનાવો
કોષ્ટક નિવેદન, પરંતુ એક વસ્તુ

420
00:22:22,250 --> 00:22:25,710
, ચેતો છે
આ ORM તેના શ્રેષ્ઠ પ્રયાસ કરશે

421
00:22:25,710 --> 00:22:28,640
બહાર આકૃતિ શું સૌથી
કાર્યક્ષમ એસક્યુએલ ક્વેરી હશે

422
00:22:28,640 --> 00:22:30,110
પરંતુ ક્યારેક તે ખોટું નહીં.

423
00:22:30,110 --> 00:22:32,660
>> અને તમે છો, ખાસ કરીને જો
એક મોટી ડેટાબેઝ સાથે કામ કરે છે,

424
00:22:32,660 --> 00:22:35,557
તમે ક્વેરી નોંધ્યું છે કે કરી શકો છો
કે, ઝડપી ચાલતું હોવું જોઈએ

425
00:22:35,557 --> 00:22:36,640
ખરેખર સમય લે છે.

426
00:22:36,640 --> 00:22:40,164
અને તમે કેવી રીતે હૂડ હેઠળ જુઓ તો
આ ORM, એસક્યુએલ માં કે ઈન્ટરપ્રીટ છે

427
00:22:40,164 --> 00:22:42,080
તે કંઈક કરવાથી થઈ શકે છે
ખરેખર હાસ્યાસ્પદ છે,

428
00:22:42,080 --> 00:22:44,371
માત્ર પ્રકારના કારણ કે તે
તમારા ઇરાદા ખોટું gestured.

429
00:22:44,371 --> 00:22:48,080
અને, સમય ત્યાં કરવામાં આવી છે
હું તેને ફરીથી લખી હતી, અને માત્ર કર્યું

430
00:22:48,080 --> 00:22:52,429
માત્ર મારા પોતાના એસક્યુએલ ક્વેરીઝ ચલાવો
તે એક વિચિત્ર રીતે પદચ્છેદન હતી.

431
00:22:52,429 --> 00:22:54,220
તેથી, ત્યાં કેટલાક
માત્ર માર્ગ માં, ઓવરહેડ

432
00:22:54,220 --> 00:22:58,680
તે કમ્પાઇલ કે જે તમારા
એસક્યુએલ ફેરવાઇ નિવેદનો.

433
00:22:58,680 --> 00:23:06,200
>> તેથી, ચાલો ઝડપથી સુપર જોવા દો
એક ડેટા મોડેલ એક સરળ ઉદાહરણ

434
00:23:06,200 --> 00:23:07,350
તમે ઉપયોગ કરી શકે છે છે.

435
00:23:07,350 --> 00:23:11,880
તેથી, આ જેથી Python કોડ છે, અને
તમે કરવા માંગો છો પ્રથમ વસ્તુ છે

436
00:23:11,880 --> 00:23:12,950
peewee આયાત *.

437
00:23:12,950 --> 00:23:15,850
તેથી, બાટલી, વિપરીત તમે હોય છે
આ બધા વ્યક્તિગત મોડ્યુલો,

438
00:23:15,850 --> 00:23:18,125
અને તમે બાટલી આયાત કરવા માંગો છો, અને
એક નમૂનો, અને કેટલાક અન્ય લોકો લખવા

439
00:23:18,125 --> 00:23:20,690
અમે પાછળથી જોશો કે, peewee થી,
તમે હમણાં બધું આયાત કરી શકો છો

440
00:23:20,690 --> 00:23:22,290
કારણ કે તે એક સુંદર નાની લાઇબ્રેરી છે.

441
00:23:22,290 --> 00:23:26,490
>> તેથી, તમે શું કરવા માંગો છો પ્રથમ વસ્તુ છે,
ખરેખર આ ડેટાબેઝ ઓબ્જેક્ટ બનાવો.

442
00:23:26,490 --> 00:23:31,212
તેથી, જો તમે હોય ડીબી = SqliteDatabase,
અને પછી તમારા ડેટાબેઝ નામ.

443
00:23:31,212 --> 00:23:33,170
અને આ ખરેખર કરશે
ડેટાબેઝ પદાર્થ બનાવવા

444
00:23:33,170 --> 00:23:36,230
તમે peewee સાથે સંપર્ક કરી શકો છો.

445
00:23:36,230 --> 00:23:40,570
>> અને પછી, અમે વાસ્તવિક છે
અમે બનાવવા માંગો છો કે મોડેલ.

446
00:23:40,570 --> 00:23:42,470
જેથી ટેબલ અમે બનાવવા માંગો છો.

447
00:23:42,470 --> 00:23:47,270
તેથી, peewee અંદર દરેક વર્ગ છે
તમારા ડેટાબેઝ અંદર તેના પોતાના ટેબલ.

448
00:23:47,270 --> 00:23:52,800
તેથી, વર્ગો તમામ
બેઝ મોડેલ માંથી બોલાવે,

449
00:23:52,800 --> 00:23:55,960
અને મૂડી એમ મોડેલ છે
peewee વ્યાખ્યાયિત છે કે જે કંઈક.

450
00:23:55,960 --> 00:24:02,162
>> તેથી, તમારા મોડલ તમામ જોઈએ
તેમના સૌથી વધુ સુપરક્લાસ તરીકે બોલાવે,

451
00:24:02,162 --> 00:24:04,620
તેઓ પાસેથી જોઈએ બોલાવે
મોડેલ છે, પરંતુ ખરેખર ઠંડી છે શું

452
00:24:04,620 --> 00:24:07,610
તમે ખરેખર તમારા હોઈ શકે છે
મોડેલ દરેક અન્ય બોલાવે છે.

453
00:24:07,610 --> 00:24:10,530
અને સમય ઘણો, તમારા
માહિતી મોડેલો જરૂરી નથી

454
00:24:10,530 --> 00:24:13,754
એક સરસ વારસો વંશવેલો કરે છે, પરંતુ
તેઓ જ્યાં વખત, તે ખરેખર સરસ છે

455
00:24:13,754 --> 00:24:15,920
તમે મોડેલ છે, કારણ કે
દરેક અન્ય સહજ.

456
00:24:15,920 --> 00:24:19,710
>> તેથી, અમે આ વર્ગ વ્યાખ્યાયિત
એક મોડેલ બોલાવે જે 'વિદ્યાર્થી'

457
00:24:19,710 --> 00:24:21,170
અને તે ત્રણ ગુણધર્મો ધરાવે છે.

458
00:24:21,170 --> 00:24:24,080
તે છે, કે જે એક ID છે
એક PrimaryKeyField, જે

459
00:24:24,080 --> 00:24:26,920
પૂરી પાડવામાં આવેલ છે કે જે કંઈક છે
peewee દ્વારા, નામ એક CharField છે,

460
00:24:26,920 --> 00:24:28,490
અને એક ગ્રેડ એક IntegerField છે.

461
00:24:28,490 --> 00:24:32,260
તેથી આ કે ન હોઈ શકે
કેવી રીતે CS50 ખરેખર બધા સંગ્રહ

462
00:24:32,260 --> 00:24:33,650
'વિદ્યાર્થીઓ ગ્રેડ.

463
00:24:33,650 --> 00:24:36,060
તે નથી, પરંતુ આ હું તે કરી શકે છે કેવી રીતે છે.

464
00:24:36,060 --> 00:24:37,920
>> અને પછી તે અંદર છે,
આ વર્ગ છે, અને આ

465
00:24:37,920 --> 00:24:41,620
તમે સાથે કરી શકો છો કંઈક છે
Python, તમે પુનરાવર્તિત વર્ગો હોઈ શકે છે.

466
00:24:41,620 --> 00:24:43,920
અને આ કંઈક છે
કે peewee દ્વારા જરૂરી છે.

467
00:24:43,920 --> 00:24:47,250
તેથી, આ વર્ગ મેટા, તમારી પાસે
ડેટાબેઝ છે કે સ્પષ્ટ કરવા માટે

468
00:24:47,250 --> 00:24:49,830
પદાર્થ સમાન
અમે ઉપર બનાવવામાં છે.

469
00:24:49,830 --> 00:24:54,339
અને આ ફાઈલની આ ટેબલ શું છે કહે છે
ખરેખર માં સમાયેલ હશે.

470
00:24:54,339 --> 00:24:57,130
તેથી આ કે તમારી પાસે કંઈક છે
તમારા મોડલ બધા અંદર કરવું.

471
00:24:57,130 --> 00:24:59,380
તમે માત્ર સ્પષ્ટ કરવા માટે છે
આ મેટા વર્ગ અંદર

472
00:24:59,380 --> 00:25:01,400
તે ડેટાબેઝ ડીબી સમાન છે.

473
00:25:01,400 --> 00:25:03,940
હું હોય તો હું સામાન્ય રીતે શું
વિવિધ મોડેલો એક ટોળું,

474
00:25:03,940 --> 00:25:05,910
હું એક આધાર હોય છે
મોડેલ, હું સામાન્ય રીતે

475
00:25:05,910 --> 00:25:08,839
ફક્ત "બેઝ મોડેલ" કૉલ
કે મેટા વર્ગ છે,

476
00:25:08,839 --> 00:25:10,380
અને તે ડીબી સમાન ડેટાબેઝ સુયોજિત કરે છે.

477
00:25:10,380 --> 00:25:13,710
અને મારા અનુગામી મોડેલો પછી બધા
તે આધાર વર્ગ વારસો પામશે.

478
00:25:13,710 --> 00:25:16,760
અને પછી હું ચિંતા કરવાની જરૂર નથી
મેટા વર્ગ સુયોજિત વિશે.

479
00:25:16,760 --> 00:25:21,490
>> તેથી, આ ખરેખર નહીં ત્યારે
એક એસક્યુએલ નિવેદન ફેરવાઇ સંકલિત

480
00:25:21,490 --> 00:25:24,875
તે નીચે આ બીભત્સ વસ્તુ જેવી લાગે છે
અહીં, "ટેબલ વિદ્યાર્થી ID પૂર્ણાંક બનાવો

481
00:25:24,875 --> 00:25:26,020
" ગમે તે.

482
00:25:26,020 --> 00:25:30,002
>> અને, હું તે ટૂંકા લાગે છે કે,
અહીં આ એસક્યુએલ ક્વેરી,

483
00:25:30,002 --> 00:25:32,960
પરંતુ તમે અહીં આ વર્ગ જોવા હોય તો
તમે પર રહ્યું છે બરાબર શું જોઈ શકો છો.

484
00:25:32,960 --> 00:25:36,116
તમે ક્ષેત્રો કેવા પ્રકારના જોઈ શકો છો
તેઓ કહે છે શું કરી રહ્યાં છો, ત્યાં છે,

485
00:25:36,116 --> 00:25:38,115
અને તેથી, મને લાગે છે કે
આ પાયથોન કોડ પર જોઈ

486
00:25:38,115 --> 00:25:43,340
કરતાં ઘણો વધુ વાંચનીય છે
આ એસક્યુએલ ક્વેરી લખવા પ્રયાસ કરે છે.

487
00:25:43,340 --> 00:25:45,990
>> તેથી, માટે ક્રમમાં ખરેખર
ડેટાબેઝ વાપરવા માટે,

488
00:25:45,990 --> 00:25:48,470
અમે પાયથોન અંદર તેની સાથે જોડાઈ હોય છે.

489
00:25:48,470 --> 00:25:52,770
તેથી, હું સામાન્ય રીતે કહેવાય કાર્ય લખવા
બે વસ્તુઓ કરે છે initialize_db.

490
00:25:52,770 --> 00:25:54,880
તે ડેટાબેઝમાં લે
પદાર્થ ડીબી અને તે

491
00:25:54,880 --> 00:25:58,360
માત્ર ખોલે છે જે, તે જોડાય છે
ડેટાબેઝ વિભાગ છે.

492
00:25:58,360 --> 00:26:00,860
તમે માત્ર છતાં ચાલી રહ્યાં છો, તો
તમારા સ્થાનિક મશીન પર વેબસાઇટ,

493
00:26:00,860 --> 00:26:04,320
તે ચિંતા કરવાની એક સુપર મોટો સોદો નથી
જોડાઈ અને જોડાણ વિશે,

494
00:26:04,320 --> 00:26:06,885
પરંતુ તમે ચલાવી રહ્યા હોય તો
એક વેબસાઇટ પર તે તમને

495
00:26:06,885 --> 00:26:10,010
ખાતરી કરો કે જ્યારે વપરાશકર્તા, કે બનાવવા માંગો છો
તેઓ બહાર બંધ હોય ત્યારે, તે સાથે જોડાય

496
00:26:10,010 --> 00:26:12,270
આ વેબસાઇટ, તેઓ છે કે જેથી ડિસ્કનેક્ટ તમે
જોડાયેલ લોકો એક ટોળું નથી

497
00:26:12,270 --> 00:26:14,480
તમારા ડેટાબેઝ માટે બધા એક જ સમયે.

498
00:26:14,480 --> 00:26:16,370
>> અને પછી, જ્યારે તમે
ડેટાબેઝ સાથે જોડાવા માટે,

499
00:26:16,370 --> 00:26:20,832
તમે db.create_tables કૉલ કરવા માંગો છો
અને તમે શું કરવા માંગો છો મોડેલો યાદી

500
00:26:20,832 --> 00:26:21,540
કોષ્ટકો બનાવવા માટે.

501
00:26:21,540 --> 00:26:23,950
તેથી અહીં, હું હમણાં જ કરવા માંગો છો
આ વિદ્યાર્થી માટે તે બનાવો.

502
00:26:23,950 --> 00:26:28,070
અને પછી, શું મહત્વનું છે માટે છે
સલામત = સાચું મોટા ભાગના વખતે સ્પષ્ટ કરો.

503
00:26:28,070 --> 00:26:30,380
તેથી શું આ નિવેદન
શું કરશે, તે છે

504
00:26:30,380 --> 00:26:33,580
આ માટે કોષ્ટકો બનાવે છે
વિદ્યાર્થી મોડેલ છે, પરંતુ માત્ર

505
00:26:33,580 --> 00:26:36,109
તે ટેબલ નથી, તો
પહેલાથી જ બનાવવામાં આવી છે.

506
00:26:36,109 --> 00:26:37,400
કે શું સુરક્ષિત તે સ્પષ્ટ કરે છે.

507
00:26:37,400 --> 00:26:39,150
તેથી તે પર ફરીથી લખી નહીં
તમારી હાલની ટેબલ,

508
00:26:39,150 --> 00:26:41,525
તે માત્ર એક નવી બનાવશે
ટેબલ નથી એક હોય તો.

509
00:26:41,525 --> 00:26:45,090
તેથી, તમે માત્ર બનાવી શકે છે
કોષ્ટકો એક વખત એસક્યુએલ મદદથી.

510
00:26:45,090 --> 00:26:49,410
અને પછી તે ડેટાબેઝ બેસવું છે
ત્યાં છે, અને પછી દરેક વખતે સાથે જોડાવા માટે,

511
00:26:49,410 --> 00:26:52,450
પરંતુ તે માત્ર સામાન્ય રીતે સારું છે
આ create_tables કોલ મૂકી,

512
00:26:52,450 --> 00:26:55,550
તેથી, તે તમે ક્યારેય કાઢી તો તમારા
ડેટાબેઝ જ્યારે તમે તમારા વેબ ચલાવવા

513
00:26:55,550 --> 00:26:57,960
એપ્લિકેશન ફરી, તે ફરીથી કરશે.

514
00:26:57,960 --> 00:27:00,730
>> તેથી, માત્ર સલામત છે તેની ખાતરી કરવા
વાત સાચી છે સ્પષ્ટ કરેલ છે,

515
00:27:00,730 --> 00:27:03,580
અથવા તમે માત્ર તમારી માહિતી મળશે
દર વખતે clobbered રહ્યું.

516
00:27:03,580 --> 00:27:06,380
અને પછી, તમે માત્ર કૉલ કરી શકો છો
સ્થાપિત કરવા માટે initialize_db

517
00:27:06,380 --> 00:27:09,820
જોડાણ, અને બનાવવા
કોષ્ટકો જો જરૂરી હોય તો.

518
00:27:09,820 --> 00:27:13,150
>> તેથી, સૌથી સામાન્ય વસ્તુ
તમે કરવા માંગો છો કરશે,

519
00:27:13,150 --> 00:27:15,920
અથવા સૌથી સામાન્ય વસ્તુઓ એક,
ખરેખર વસ્તુઓ કરવા માટે છે

520
00:27:15,920 --> 00:27:17,170
તમારા ડેટાબેઝ માં.

521
00:27:17,170 --> 00:27:19,430
અને તેથી, બદલે કર્યા
માં એક insert લખવા માટે

522
00:27:19,430 --> 00:27:21,990
બધા સાથે નિવેદન
કિંમતો સ્પષ્ટ,

523
00:27:21,990 --> 00:27:24,650
તમે ખરેખર કહી શકો છો
વિદ્યાર્થી વર્ગ પર કાર્ય કરે છે.

524
00:27:24,650 --> 00:27:28,200
તેથી, જો તમે એક વર્ગ છે જ્યારે બનાવવા
કે, મોડેલ માંથી બોલાવે

525
00:27:28,200 --> 00:27:30,200
તે આ પદ્ધતિ બનાવવા છે.

526
00:27:30,200 --> 00:27:33,870
>> તેથી, જો તમે વર્ગ name.create કરવું,
અને તમે પરિમાણો સ્પષ્ટ

527
00:27:33,870 --> 00:27:35,260
તમે પસાર કરવા માંગો છો છે.

528
00:27:35,260 --> 00:27:39,200
તેથી, હું કેટલાક વિદ્યાર્થીઓ ઍડ કરવા માંગો છો, તો
અમારા CS50 ગ્રેડ પુસ્તક ઉદાહરણ માટે,

529
00:27:39,200 --> 00:27:41,820
હું કોણ ધરાવે છે, ડેવિડ મૂકીશું
ખૂબ જ સારી ગ્રેડ, તેમણે 95 છે.

530
00:27:41,820 --> 00:27:45,100
અને મારી જાતને, જે કરી નથી
એટલી સારી રીતે CS50 માં, હું એક 50 છે.

531
00:27:45,100 --> 00:27:47,600
અને તેથી, સરસ વસ્તુ વિશે
આ બનાવવા કાર્ય શું કરે છે,

532
00:27:47,600 --> 00:27:53,040
તે ઉદાહરણ આપે છે, અથવા તે છે
પંક્તિ, તે કોષ્ટકમાં બનાવનાર કે,

533
00:27:53,040 --> 00:27:55,750
અને તેથી તે પછી તમે તે સ્ટોર
ચલ, અને પછી તેની સાથે કામ કરે છે.

534
00:27:55,750 --> 00:27:58,830
તમે આસપાસ બદલી શકો છો, જે
હું એક ઉદાહરણ બતાવવા પડશે.

535
00:27:58,830 --> 00:28:03,050
>> હું ન હતી કે નોટિસ
ને સ્પષ્ટ કરવા માટે હોય છે,

536
00:28:03,050 --> 00:28:09,340
તે છે, કારણ કે કારણ કે
PrimaryKeyField, તે આપમેળે ચાલશે

537
00:28:09,340 --> 00:28:10,930
તમે તેને ઉલ્લેખ નથી, તો તેને વધારતી.

538
00:28:10,930 --> 00:28:12,250
અને, હકીકતમાં, તો તમે કદાચ
તે સ્પષ્ટ ન જોઈએ,

539
00:28:12,250 --> 00:28:14,810
જો તમે આકસ્મિક શકે છે કારણ કે
કોઈના આઈડી clobber.

540
00:28:14,810 --> 00:28:16,830
અને તમે બનાવવા માંગો છો
તે અનન્ય છે તેની ખાતરી કરો.

541
00:28:16,830 --> 00:28:20,662
>> તેથી, ખરેખર, સૌથી
તમે કરવા માંગો છો સામાન્ય વસ્તુ છે,

542
00:28:20,662 --> 00:28:22,620
કદાચ બહાર પસંદ છે
તમે એક વાર ડેટાબેઝ

543
00:28:22,620 --> 00:28:24,078
ત્યાં ઘણી માહિતી છે.

544
00:28:24,078 --> 00:28:27,360
અને તેથી, તમે બધું વિચાર કરવા માંગો છો, તો
જેથી પસંદ કરો તારો સમકક્ષ

545
00:28:27,360 --> 00:28:30,940
વિદ્યાર્થીઓ નિવેદન, તે
માત્ર student.select હશે.

546
00:28:30,940 --> 00:28:34,380
અને તે એક એરે તમે પાછા આપશે
વિદ્યાર્થી તમામ તે વસ્તુઓ સાથે

547
00:28:34,380 --> 00:28:35,770
તમે ઉપર ફરી વળવું કે તમે કરવા માંગો છો.

548
00:28:35,770 --> 00:28:37,019
તમે તેને બહાર વસ્તુઓ મેળવી શકો છો.

549
00:28:37,019 --> 00:28:39,310
અને મોટા ભાગના વખતે, તમે
માત્ર પસંદ કરવા માંગો છો નથી,

550
00:28:39,310 --> 00:28:40,935
તમે ખરેખર કંઈક સ્પષ્ટ કરવા માંગો છો.

551
00:28:40,935 --> 00:28:44,580
અને તેથી, તમે સાંકળ કરી શકો છો
સાથે મળીને આ કાર્ય કોલ્સ,

552
00:28:44,580 --> 00:28:48,830
તમે કેવી રીતે સાંકળ જેમ
એસક્યુએલ એકસાથે નિવેદનો.

553
00:28:48,830 --> 00:28:53,002
તેથી જો તમે) (student.select કરી શકો છો. જ્યાં
આ ઉદાહરણમાં.

554
00:28:53,002 --> 00:28:54,710
અને પછી, તમે કરી શકો છો
, શરતો સ્પષ્ટ

555
00:28:54,710 --> 00:28:57,880
માત્ર સામાન્ય પાયથોન ઉપયોગ
બુલિયનો વસ્તુઓ તપાસો.

556
00:28:57,880 --> 00:29:02,110
>> તેથી, આ કિસ્સામાં, તમે કરવા માંગો છો
તમને પસંદ કરી રહ્યાં છે તે મર્યાદિત

557
00:29:02,110 --> 00:29:06,790
student.grade 50 બરાબર છે,
અને student.name, એઝરા સમાન છે

558
00:29:06,790 --> 00:29:09,130
તેથી તે ફક્ત તેને બહાર મને મળશે.

559
00:29:09,130 --> 00:29:11,340
અને ખરેખર, એક નોટિસ
સૂક્ષ્મ વસ્તુ અહીં છે

560
00:29:11,340 --> 00:29:15,570
તમે સ્પષ્ટ કરવા માંગો છો, તો તે
એક અને / અથવા એક અથવા / અથવા,

561
00:29:15,570 --> 00:29:19,840
Python માં, તમે સામાન્ય રીતે ઉપયોગ કરશે,
હું શબ્દ "અને" ખરેખર લાગે

562
00:29:19,840 --> 00:29:23,351
પરંતુ અહીં તમે એક ચિન્હ વાપરવા માટે,
જે સામાન્ય રીતે એક bitwise ઓપરેટર છે,

563
00:29:23,351 --> 00:29:25,600
પરંતુ આ ખાસ કિસ્સામાં,
માત્ર માર્ગ peewee તે કરે છે,

564
00:29:25,600 --> 00:29:27,660
તમે એક ઉપયોગ
નું ચિહ્ન સ્પષ્ટ "અને છે."

565
00:29:27,660 --> 00:29:29,451
કે કંઈક છે કે
હું ઘણો મિશ્ર કરો,

566
00:29:29,451 --> 00:29:32,530
પરંતુ તે ન કરવામાં આવે તો
વ્યવહારમાં કે ખૂબ.

567
00:29:32,530 --> 00:29:36,350
>> અને પછી, એક વાર તમે બધી
ડેટાબેઝ બહાર વિદ્યાર્થીઓ,

568
00:29:36,350 --> 00:29:39,420
તમે પૂર્ણ કરી છે એકવાર તમે પસંદ કરો છો
અને તમારા વસ્ત્રો અથવા ગમે,

569
00:29:39,420 --> 00:29:42,334
તમે foreach લૂપ ઉપયોગ કરી શકો છો
માત્ર Python માં સામાન્ય જેમ

570
00:29:42,334 --> 00:29:44,500
iterator કોઇ પણ પ્રકારની સાથે
અથવા એરે કોઇ પણ પ્રકારની છે.

571
00:29:44,500 --> 00:29:46,333
તેથી જો તમે ઓ માટે કરી શકો છો
student.select માં (). જ્યાં તે માંગે

572
00:29:46,333 --> 00:29:52,930
(Student.grade <75), અને તેથી આ ફરી
કોષ્ટકમાં દરેક વિદ્યાર્થી પર ફરી વળવું

573
00:29:52,930 --> 00:29:56,260
જેની ગ્રેડ કરતાં ઓછી 75 છે, જે
આ કિસ્સામાં, હજુ હમણાં જ મને છે.

574
00:29:56,260 --> 00:29:59,218
અને પછી તમે અંદર કંઈક કરી શકે
કે લૂપ, જેમ મને એક ઇમેઇલ મોકલો

575
00:29:59,218 --> 00:30:01,680
અને મને ખરેખર કહી
મારી સમસ્યા સેટમાં કરો.

576
00:30:01,680 --> 00:30:04,550
>> તેથી, અન્ય વસ્તુ તમે કરી શકો છો
આમ કરવા માટે, તે ખરેખર સરળ છે છે

577
00:30:04,550 --> 00:30:06,460
ટેબલ અંદર પંક્તિઓ અપડેટ કરવા માટે.

578
00:30:06,460 --> 00:30:08,720
તેથી, અહીં પાછા યાદ રાખો,
તમારા હું દાખલ ત્યારે,

579
00:30:08,720 --> 00:30:11,440
હું હતો કે કિંમત લીધો
student.create દ્વારા પરત,

580
00:30:11,440 --> 00:30:14,920
અને હું એઝરા કહેવાય નામ માટે આઈડી.

581
00:30:14,920 --> 00:30:18,995
અને તેથી હવે, તમે બદલી શકો છો
કે હમણાં અંદર કિંમતો

582
00:30:18,995 --> 00:30:20,870
જેમ તમે એક
Python માં સામાન્ય વર્ગ.

583
00:30:20,870 --> 00:30:25,060
>> તેથી જો તમે સુયોજિત કરી શકો છો ezra.grade = 95 અને
કે સ્થાનિક નકલ અપડેટ કરશે,

584
00:30:25,060 --> 00:30:28,380
પરંતુ જો તમે ખરેખર કરવા માંગો છો જો
ડેટાબેઝ કે પરિવર્તન મોકલવું,

585
00:30:28,380 --> 00:30:31,410
તમે ezra.save કૉલ કરવા માટે હોય છે
જેથી તમે સેવ પદ્ધતિ કહેવાય

586
00:30:31,410 --> 00:30:32,650
આ નમૂના પર.

587
00:30:32,650 --> 00:30:38,085
>> અને તેથી હવે, હું સફળતાપૂર્વક બદલાઈ ગયેલ છે
ડેટાબેઝ અંદર મારા પોતાના ગ્રેડ.

588
00:30:38,085 --> 00:30:41,210
તેથી, પછી હું કેચ કહે છે કે દો
ડેટાબેઝ અંદર મારા ગ્રેડ બદલાતી રહે છે.

589
00:30:41,210 --> 00:30:44,126
પ્રોફેસર માલણ કદાચ રહ્યું છે
વર્ગ માંથી મને કાઢી નાખવા માંગો છો કરવા માટે,

590
00:30:44,126 --> 00:30:48,630
અને તેથી તમે કાઢી નાખો કૉલ કરી શકો છો
કે જે હમણાં જ વસ્તુ પર ઉદાહરણ પદ્ધતિ.

591
00:30:48,630 --> 00:30:51,674
>> જો તમે ઇચ્છતા તેથી, જવા માટે
પાછા આ લૂપ અહીં,

592
00:30:51,674 --> 00:30:53,465
અને ખરેખર, તેના બદલે
ઇમેઇલ્સ તમામ મોકલવાની

593
00:30:53,465 --> 00:30:56,577
વિદ્યાર્થીઓ જેની ગ્રેડ ઓછી છે
75 કરતાં, તમે તેમને કાઢી કરવા માગતા હતા,

594
00:30:56,577 --> 00:30:58,660
આ લૂપ અંદર તમે કરી શકે
s.delete ઉદાહરણ કૉલ કરો.

595
00:30:58,660 --> 00:31:04,180

596
00:31:04,180 --> 00:31:07,780
અને તમે શું કરવા માંગો છો ખૂબ જ છેલ્લા વસ્તુ,
તમે જોડાણ અધિષ્ઠાપિત જ્યારે છે,

597
00:31:07,780 --> 00:31:10,350
અને તમે તમારા કામ સાથે પૂર્ણ કરી રહ્યાં છો
તમે db.close કૉલ કરવા માંગો છો

598
00:31:10,350 --> 00:31:13,190
જ્યાં ડીબી કે ડેટાબેઝ છે
અમે પહેલાં હતી કે પદાર્થ.

599
00:31:13,190 --> 00:31:18,290
અને તમે ખાતરી કરો કે કરવા માંગો છો
બધું બહાર બંધ નહીં.

600
00:31:18,290 --> 00:31:18,790
>> કૂલ.

601
00:31:18,790 --> 00:31:22,410
તેથી હવે, હું એક ઉદાહરણ એપ્લિકેશન ધરાવે છે.

602
00:31:22,410 --> 00:31:26,880
હું પ્રકારના માત્ર બધું પૂર્વ કર્યા
કે જેથી કોઇ પણ જીવંત કોડિંગ ત્યાં હશે નહિં

603
00:31:26,880 --> 00:31:30,220
ભૂલો છે, પરંતુ અમે લઈ જવામાં કરી શકો છો
તે અને તમે બાટલી મૂકવામાં આવશે જુઓ કે કેવી રીતે

604
00:31:30,220 --> 00:31:33,685
અને સાથે મળીને peewee,
અને એક સરળ એપ્લિકેશન બનાવે છે.

605
00:31:33,685 --> 00:31:38,680
હું CS50 મોટા મોટા શબ્દો વાપરવા તે કહી, અને તે છે
એક સરળ બ્લોગ પ્લેટફોર્મ જેવું.

606
00:31:38,680 --> 00:31:41,150
>> તેથી, પ્રથમ, હું તેને ચલાવવા પડશે અને
તે જેવી લાગે છે તે બતાવવા

607
00:31:41,150 --> 00:31:42,890
અને પછી અમે કોડમાં વધુ દેખાય છે.

608
00:31:42,890 --> 00:32:00,470

609
00:32:00,470 --> 00:32:02,830
ઠીક છે, તેથી આપણે માત્ર આ ચલાવો.

610
00:32:02,830 --> 00:32:14,040

611
00:32:14,040 --> 00:32:17,250
હું આ ઠંડી બનાવવા પડશે
થોડી થોડી નાની.

612
00:32:17,250 --> 00:32:20,000
તે માત્ર છે, કારણ કે ખૂબ જ સુંદર છે
હું CSS ઘણો કરી નથી

613
00:32:20,000 --> 00:32:23,255
પરંતુ તે શું કરે છે તે છે, છે
બ્લોગ પોસ્ટ્સ આ ડેટાબેઝ,

614
00:32:23,255 --> 00:32:25,630
અને તે તમામ મારફતે જાય છે
તેમને, અને તે તેમને પ્રદર્શિત કરશે

615
00:32:25,630 --> 00:32:28,170
સૌથી વધુ તાજેતરના ક્રમમાં પાનાં પર.

616
00:32:28,170 --> 00:32:30,920
અને તેથી આ માત્ર કેટલાક પોસ્ટ્સ છે
હું ડેટાબેઝમાં સાચવવામાં હતા.

617
00:32:30,920 --> 00:32:35,680
>> અમે નવા બનાવવા માંગો છો, તો
પોસ્ટ, અમે એક નવી પોસ્ટ ઉમેરો પર જઈ શકો છો

618
00:32:35,680 --> 00:32:42,720
અને અમે શીર્ષક દાખલ કરી શકો છો
પોસ્ટ, જેથી કંઈક, CS50 પરિસંવાદ.

619
00:32:42,720 --> 00:32:45,360

620
00:32:45,360 --> 00:32:46,735
વાહ, ખરેખર આ પરિસંવાદ માણી.

621
00:32:46,735 --> 00:32:51,070

622
00:32:51,070 --> 00:32:52,270
>> કૂલ.

623
00:32:52,270 --> 00:32:56,060
પછી તમે પોસ્ટ દબાવો, અને તે કરશે
હોમ પેજ પર તમે પાછા પુનઃદિશામાન થયેલ છે,

624
00:32:56,060 --> 00:33:00,039
અને પછી તમે જોશો કે
તાજેતરની પોસ્ટ ઉમેરાઈ હતી.

625
00:33:00,039 --> 00:33:01,580
અને અમે હજુ પણ ત્યાં તમામ મુદ્દાઓ છે.

626
00:33:01,580 --> 00:33:08,080
તેથી હવે, ચાલો બધા મારફતે પગલું દો
કોડ અને આ અમલમાં મૂકાયેલ છે કેવી રીતે જુઓ.

627
00:33:08,080 --> 00:33:11,995
>> તેથી, હું દો કે પ્રથમ વસ્તુ લાગે છે
વાસ્તવમાં મોડલ છે પર એક નજર.

628
00:33:11,995 --> 00:33:14,120
આ સમય ઘણો, જ્યારે
તમે કંઈક ડિઝાઇન કરી રહ્યાં છીએ,

629
00:33:14,120 --> 00:33:17,036
તમે કેવી રીતે વિશે પ્રથમ વિચાર કરવા માંગો છો
તમે તમારા માહિતી રજૂ કરવા માટે જઈ રહ્યાં છો

630
00:33:17,036 --> 00:33:22,915
અને પછી તે આસપાસ વસ્તુઓ ડિઝાઇન,
જેથી બધું અર્થમાં બનાવે છે.

631
00:33:22,915 --> 00:33:25,290
અને તે હું કેવી રીતે ખરેખર છે
હું આ કરી હતી, તે હતી

632
00:33:25,290 --> 00:33:28,030
હું નીચે બેઠા અને વિચાર્યું
હું એક પોસ્ટ માં શું કરવા માંગો છો નથી.

633
00:33:28,030 --> 00:33:32,130
>> તેથી, અહીં, અમે એ જ માળખું ધરાવે છે
હું અગાઉ ઉલ્લેખ કરવામાં આવ્યો હતો કે,

634
00:33:32,130 --> 00:33:33,755
અમે ડીબી = Sqldatabase ('posts.db') કરવું છે.

635
00:33:33,755 --> 00:33:37,840

636
00:33:37,840 --> 00:33:40,980
વાસ્તવમાં, તમે કદાચ નથી માંગતા
તમારું નામ ડેટાબેઝ હાર્ડ કોડ.

637
00:33:40,980 --> 00:33:43,730
તે કદાચ એક પરિમાણ પ્રયત્ન કરીશું
કે કદાચ ક્યાંક સંગ્રહિત છે

638
00:33:43,730 --> 00:33:45,940
રૂપરેખાંકન ફાઈલમાં, પરંતુ
આ જેમ એક નાના ઉદાહરણ તરીકે,

639
00:33:45,940 --> 00:33:48,310
તે હાર્ડ કોડ ઠીક છે.

640
00:33:48,310 --> 00:33:53,510
>> તેથી હવે, આપણે આ જગ્યા વર્ગ હોય છે,
જે આધાર મોડલ બોલાવે છે.

641
00:33:53,510 --> 00:33:56,930
અને તે ફરીથી છે,
ID = PrimaryKeyField.

642
00:33:56,930 --> 00:34:02,250
ખરેખર, તમે સ્પષ્ટ ન હોય તો,
હું ખરેખર આ છુટકારો મેળવ્યો, તો

643
00:34:02,250 --> 00:34:07,152
પછી અમે કાળજી લેશે peewee
આપોઆપ કે ID ને ક્ષેત્ર બનાવવા માટે,

644
00:34:07,152 --> 00:34:09,360
અને તે આપોઆપ કરશે
તે PrimaryKey, બનાવવા જે

645
00:34:09,360 --> 00:34:12,485
હું કારણ કે સામાન્ય રીતે, ખરેખર સરસ લાગે છે
કે, તમે કરવા માંગો છો કંઈક છે

646
00:34:12,485 --> 00:34:16,239
પરંતુ હું ખાસ તે મૂકવા માંગો,
માત્ર જેથી હું તે ત્યાં છે કે યાદ કરે છે.

647
00:34:16,239 --> 00:34:19,480
પરંતુ તમે તે સ્પષ્ટ ન હોય તો,
આપોઆપ થશે.

648
00:34:19,480 --> 00:34:22,198
>> તેથી, હું એક તારીખ હોય છે, જે
એક DateTimeField છે, અને બધા

649
00:34:22,198 --> 00:34:24,864
આ વિવિધ ક્ષેત્રો, જો તમે
આ peewee દસ્તાવેજીકરણ જુઓ,

650
00:34:24,864 --> 00:34:28,920
તે તમને વિવિધ યાદી આપી શકશો
તમે ઉપયોગ કરી શકો છો કે ક્ષેત્રો પ્રકારો.

651
00:34:28,920 --> 00:34:34,440
સૌથી મોટા ભાગ માટે, તે સરખું છે
તમે SQL જુઓ તો શું છે.

652
00:34:34,440 --> 00:34:37,699
તેથી CharField એક છે,
VarCharFields, textfields,

653
00:34:37,699 --> 00:34:40,550
ખૂબ લાંબા સમય માટે જે છે
એક બ્લોગ પોસ્ટ જેવા ગ્રંથો,

654
00:34:40,550 --> 00:34:44,460
સંભવિત DateTimeFields,
DoubleFields, FloatFields,

655
00:34:44,460 --> 00:34:46,100
કે જેમ તમામ બાબતો.

656
00:34:46,100 --> 00:34:51,570
>> અને તમે અન્ય દલીલો પાસ કરી શકો છો
તે માટે, હું અહીં સ્પષ્ટ કરેલ નથી છે.

657
00:34:51,570 --> 00:34:55,719
કહો, ઉદાહરણ માટે, તમે કરવા માંગો છો ન હતી
બે પોસ્ટ્સ એ જ શીર્ષક હોય પરવાનગી આપે છે,

658
00:34:55,719 --> 00:34:59,672
તમે સ્પષ્ટ કરી શકે છે
સાચું અનન્ય કંઈક =

659
00:34:59,672 --> 00:35:02,880
અને તે માત્ર એક વધારાનું પરિમાણ છે
તે નીચે કમ્પાઇલ ત્યારે તે ક્ષેત્ર

660
00:35:02,880 --> 00:35:06,865
એસક્યુએલ માં, તે સ્પષ્ટ થશે
તે છે કે જે અનન્ય હોય છે.

661
00:35:06,865 --> 00:35:09,740
તમે પણ કંઈક સ્પષ્ટ કરી શકો છો
નલ અને અન્ય તમામ વસ્તુઓ

662
00:35:09,740 --> 00:35:11,750
તમે સામાન્ય રીતે એસક્યુએલ નથી.

663
00:35:11,750 --> 00:35:16,020
તેથી, આ એક ખૂબ સરળ છે
તારીખ છે કે મોડેલ.

664
00:35:16,020 --> 00:35:19,460
આ DateTimeField અંદર, અહીં નોટિસ,
હું મૂળભૂત શું સ્પષ્ટ કરેલ છે.

665
00:35:19,460 --> 00:35:22,560
હું તે સ્પષ્ટ
, datetime.datetime.now

666
00:35:22,560 --> 00:35:24,920
કારણ કે જે રીતે તે
આ મૂલ્યાંકન નહીં,

667
00:35:24,920 --> 00:35:28,750
તે ખરેખર મૂલ્યાંકન
આ datetime.now જ્યારે

668
00:35:28,750 --> 00:35:32,110
તે ડેટાબેઝ દાખલ નહીં.

669
00:35:32,110 --> 00:35:34,760
>> હું હોય તો લાગે છે કે
આ ડબલ ચેક માટે,

670
00:35:34,760 --> 00:35:38,222
પરંતુ પછી તમે આ કંઈક ન હોય તો
તે ખરેખર એક વખત મૂલ્યાંકન કરશે

671
00:35:38,222 --> 00:35:40,180
અને પછી તારીખ સમય
હંમેશા એ જ રહેશે.

672
00:35:40,180 --> 00:35:44,240
તેથી, જો તમે કંઈક કરી રહ્યા છીએ માત્ર જો
datetimes સાથે ડબલ ચેક

673
00:35:44,240 --> 00:35:47,080
તે જ્યારે મૂલ્યાંકન છે કે
ખરેખર બીજું દાખલ કરો, અથવા નહીં

674
00:35:47,080 --> 00:35:48,780
તમે ગેરસમજ થઈ શકે છે.

675
00:35:48,780 --> 00:35:51,221
>> આ શીર્ષક માત્ર એક છે
CharField, ત્યાં જે

676
00:35:51,221 --> 00:35:53,970
તમે પસાર કરી શકે છે વધુ દલીલો છે
સ્પષ્ટ બરાબર લાંબા કેવી રીતે તમે

677
00:35:53,970 --> 00:35:56,170
તેને કરવા માંગો છો, પરંતુ અહીં,
તે ખરેખર તો કોઈ વાંધો ન હતો.

678
00:35:56,170 --> 00:35:58,687
અને ટેક્સ્ટ હોવા રહ્યું છે
સમગ્ર પોસ્ટ લખાણ

679
00:35:58,687 --> 00:36:01,020
અને તે એક જ હશે
તમે કરવા માંગો છો, માત્ર કારણ કે textfield

680
00:36:01,020 --> 00:36:03,370
તે એક સુંદર લાંબા શબ્દમાળા કરવા માટે પરવાનગી આપવા.

681
00:36:03,370 --> 00:36:05,970
>> પછી અમે આ મેટા છે
પેટાવર્ગ કે જે હમણાં જ

682
00:36:05,970 --> 00:36:11,250
અમે ડેટાબેઝ માંગો છો કે સ્પષ્ટ
આ ખરેખર માં ખોલવામાં આવે છે જ્યાં

683
00:36:11,250 --> 00:36:14,267
અમે અહીં છે કે ડીબી પદાર્થ હોય છે.

684
00:36:14,267 --> 00:36:16,350
અને છેલ્લા વસ્તુ અમે છે
અહીં, ફક્ત આ કાર્ય છે

685
00:36:16,350 --> 00:36:18,120
અમે જઈ રહ્યાં છો કે
અમારી મુખ્ય એપ્લિકેશન ઉપયોગ

686
00:36:18,120 --> 00:36:23,970
જોડાવા માટે ડેટાબેઝ પ્રારંભ કરવા માટે
તે છે, અને તે પછી પોસ્ટ ટેબલ બનાવવા માટે.

687
00:36:23,970 --> 00:36:26,880
>> હવે, ચાલો મુખ્ય એપ્લિકેશન પોતે જોવા દો.

688
00:36:26,880 --> 00:36:30,800
તેથી આ એક તદ્દન એક
રાશિઓ કરતાં લાંબા સમય સુધી બીટ

689
00:36:30,800 --> 00:36:34,840
અમે પહેલાં જોઇ છે,
પરંતુ આસ્થાપૂર્વક ખૂબ ખરાબ નથી.

690
00:36:34,840 --> 00:36:37,140
તેથી, મને આ બહાર વિસ્તારવા દો.

691
00:36:37,140 --> 00:36:38,370
બરાબર.

692
00:36:38,370 --> 00:36:42,070
>> તેથી, નોટિસ અને ટોચ હું આયાત
અન્ય વસ્તુઓ સંપૂર્ણ સમૂહ

693
00:36:42,070 --> 00:36:44,129
બાટલી થી અમે હોય છે
ખરેખર પહેલાં જોવામાં આવે છે.

694
00:36:44,129 --> 00:36:46,670
અને આસ્થાપૂર્વક, અમે મારફતે જઇ શકો છો
આ એક પછી એક દરેક એક

695
00:36:46,670 --> 00:36:49,420
અને વિશે થોડું વધુ વાત
તેમને ઉદાહરણ દ્વારા સોર્ટ થાય છે.

696
00:36:49,420 --> 00:36:51,380
તેથી, અમે બાટલી છે
અને render_template,

697
00:36:51,380 --> 00:36:54,370
જે અમે પહેલા જોયેલા
આ વિનંતી પદાર્થ,

698
00:36:54,370 --> 00:37:00,400
અમે કેવી રીતે જોવા જ્યારે આવશે, જે
હું ખરેખર રહ્યું હતું કે ફોર્મ

699
00:37:00,400 --> 00:37:01,170
કામ કરે છે.

700
00:37:01,170 --> 00:37:04,850
તમે પુનઃદિશામાન કરી શકો છો, કે જે પુનઃદિશામાન
પાછા Create New પોસ્ટ

701
00:37:04,850 --> 00:37:11,710
મૂળ હોમપેજ પર બેક, અને પછી
તમે કરી શકો છો કે જે કંઈક છે URL ને,

702
00:37:11,710 --> 00:37:15,550
પર બહાર આકૃતિ જ્યાં
વેબસાઇટ ચોક્કસ પાનું છે.

703
00:37:15,550 --> 00:37:17,810
>> તેથી, આગામી
હું શું વાત છે, હું આયાત છે

704
00:37:17,810 --> 00:37:21,550
મોડેલો બધી માહિતી
અમે હમણાં જ જોઈ હતી કે ફાઈલો.

705
00:37:21,550 --> 00:37:23,140
અને, હા.

706
00:37:23,140 --> 00:37:28,720
>> તેથી, નવા કંઈક બીજું આવે છે કે
તમારી સાથે વ્યવહાર કરી રહ્યા છો ત્યારે,

707
00:37:28,720 --> 00:37:31,850
ખાસ કરીને ડેટાબેઝો,
તમે સ્પષ્ટ કરી શકે છે

708
00:37:31,850 --> 00:37:35,110
પહેલાં કહેવાય નહીં એક કાર્ય છે કે
નહીં કે દરેક વિનંતી છે, અને કાર્ય

709
00:37:35,110 --> 00:37:39,690
આ મદદથી દરેક વિનંતી પછી કહેવાય
કાર્ય શોભનકળાનો નિષ્ણાત app.before વિનંતી.

710
00:37:39,690 --> 00:37:42,324
>> અને તેથી આ ચલાવવામાં આવશે
ત્યાં આ કાર્ય છે.

711
00:37:42,324 --> 00:37:44,240
આ એટલા માટે થઈ નથી
વિનંતી પહેલાં કહેવાય છે,

712
00:37:44,240 --> 00:37:46,281
પરંતુ સામાન્ય રીતે કે કંઈક છે
તેને કૉલ કરવા યોગ્ય.

713
00:37:46,281 --> 00:37:48,580

714
00:37:48,580 --> 00:37:51,650
તમે ગમે કાર્ય સ્પષ્ટ કરી શકો છો
જો તમને ત્યાં કહેવાય મેળવવા માંગો છો

715
00:37:51,650 --> 00:37:56,330
તેથી હું આ initialize_db સ્પષ્ટ
અમે મોડેલો પાછા હતું કે કાર્ય

716
00:37:56,330 --> 00:38:02,390
ફાઇલ, જેથી દરેક વિનંતી પહેલાં, તમે
ડેટાબેઝ સાથે જોડાવા માંગો છો.

717
00:38:02,390 --> 00:38:04,560
>> બે અલગ અલગ હોય છે
રીતે તમે આ કરી શકો છો.

718
00:38:04,560 --> 00:38:10,830
તમેapp કરી શકો છો., હું
તે after_request છે માને છે.

719
00:38:10,830 --> 00:38:13,800
અને વચ્ચે તફાવત
after_request અને teardown_request,

720
00:38:13,800 --> 00:38:17,590
after_request જ થશે છે
વિનંતી ખરેખર માન્ય તો.

721
00:38:17,590 --> 00:38:20,440
અને તેથી, તો જ
વિનંતી સફળ હતી,

722
00:38:20,440 --> 00:38:22,490
, કંઇ ખોટું થયું હોય તો
પરંતુ teardown_request

723
00:38:22,490 --> 00:38:26,300
સફળ કિસ્સામાં થાય છે
વિનંતી, અથવા એક ભૂલ કિસ્સામાં.

724
00:38:26,300 --> 00:38:28,252
>> તેથી, સામાન્ય રીતે, તમે કરવા માંગો છો
teardown_request વાપરવા માટે,

725
00:38:28,252 --> 00:38:30,460
તમે કરવા માંગો છો જ્યાં સુધી
ખાસ કરીને કંઇક અલગ,

726
00:38:30,460 --> 00:38:31,470
ભૂલ કિસ્સામાં.

727
00:38:31,470 --> 00:38:35,122
પરંતુ માત્ર ડેટાબેઝ બંધ કરવા માટે,
તે સફળ થાય છે અથવા તે નિષ્ફળ જાય તો કે શું

728
00:38:35,122 --> 00:38:37,080
અમે તમને ડિસ્કનેક્ટ કરવા માંગો છો
ડેટાબેઝ માંથી.

729
00:38:37,080 --> 00:38:41,240
તેથી તે db.close, કહેવાય છે
આ ડીબી પદાર્થ પર.

730
00:38:41,240 --> 00:38:43,740
>> આ teardown_request નોંધ કરો કે
એક અપવાદ માં લઈ જાય છે.

731
00:38:43,740 --> 00:38:46,781
ખરેખર ત્યાં તો ઘણા તમે ચકાસી શકો છો
એક ભૂલ તે બંધ કરવામાં આવી હતી જ્યારે

732
00:38:46,781 --> 00:38:49,390
પરંતુ અહીં, આસ્થાપૂર્વક, ત્યાં
ભૂલો સંપૂર્ણ ઘણો નથી,

733
00:38:49,390 --> 00:38:52,720
તેથી અમે ફક્ત પ્રકારની છે કે અવગણીને કરી રહ્યાં છો.

734
00:38:52,720 --> 00:38:55,990
>> ઠીક છે, અને તે બાકીના ખૂબ ખરાબ નથી.

735
00:38:55,990 --> 00:39:02,240
તેથી, અમે ઘર પાનાં પર જવા માટે છે, ત્યારે
અમે આ home.html ઢાંચો પ્રસ્તુત

736
00:39:02,240 --> 00:39:03,490
કે ખોલશે.

737
00:39:03,490 --> 00:39:06,240
આ પાસ પોસ્ટ છે
અને આ શું બરાબર

738
00:39:06,240 --> 00:39:10,260
, અમે આ પોસ્ટ છે યાદ છે કરે છે
મોડેલ, તેથી અમે બધા પોસ્ટ્સ પસંદ

739
00:39:10,260 --> 00:39:13,890
અને પછી તમે શું કરી શકો છો અન્ય વસ્તુ,
તમે જ્યાં કલમ સ્પષ્ટ કરી શકો છો

740
00:39:13,890 --> 00:39:16,910
તમે એક સ્પષ્ટ કરી શકો છો
દ્વારા ઓર્ડર છે, અને તેથી અમે લેવા

741
00:39:16,910 --> 00:39:18,820
પોસ્ટ્સ કે જે બધી
પછી પસંદ કરો, અને

742
00:39:18,820 --> 00:39:22,590
અમે તેમને ઓર્ડર
post.date.descending.

743
00:39:22,590 --> 00:39:25,030
અને તે સ્પષ્ટ થશે, જ્યારે
તેઓ ખરેખર બહાર આવે

744
00:39:25,030 --> 00:39:29,250
સૌથી વધુ તાજેતરના એક
ખૂબ પ્રથમ હશે.

745
00:39:29,250 --> 00:39:31,420
>> અને પછી, અમે માં કે પાસ
આ home.html નમૂનો,

746
00:39:31,420 --> 00:39:34,240
તેથી આપણે ખરેખર ખોલો દો
ખરેખર ઝડપી છે કે ઢાંચો,

747
00:39:34,240 --> 00:39:36,760
અને તે કામ કરી રહ્યા છે કેવી રીતે પર એક નજર.

748
00:39:36,760 --> 00:39:42,130
અને આ મહાન HTML નથી પરંતુ
આસ્થાપૂર્વક, અમે પાયથોન પર ધ્યાન કેન્દ્રિત કરી શકે છે.

749
00:39:42,130 --> 00:39:46,960
>> તેથી નવું ઉમેરો પર એક લિંક છે
પોસ્ટ, અને તેથી આ માર્ગ સ્પષ્ટ

750
00:39:46,960 --> 00:39:51,580
બાટલી અંદર કે અમે
અહીં છે, કે જે વ્યાખ્યાયિત કરે છે.

751
00:39:51,580 --> 00:39:56,310
આ નવી પોસ્ટ માર્ગ છે,
અને અમે અહીં ઉપર સ્પષ્ટ કરો.

752
00:39:56,310 --> 00:40:00,450
અને તેથી તે પછી જાય છે કે કડી છે
બાટલી સર્વર અંદર કે માર્ગ છે.

753
00:40:00,450 --> 00:40:03,820
>> વધુ રસપ્રદ વાત
અહીં લૂપ માટે આ છે.

754
00:40:03,820 --> 00:40:07,685
તેથી અમે આ સ્પષ્ટ છે કે
પોસ્ટ પરિમાણ જે

755
00:40:07,685 --> 00:40:09,560
આ માં પસાર કરવામાં આવ્યો હતો
render_template કાર્ય,

756
00:40:09,560 --> 00:40:13,550
પોસ્ટ માં દરેક પોસ્ટ માટે
માં પસાર નહીં કે પદાર્થ.

757
00:40:13,550 --> 00:40:16,600
અમે પ્રિન્ટ માંગો છો
પોસ્ટ શીર્ષક, H1 માં,

758
00:40:16,600 --> 00:40:21,930
અને પછી નીચે, અમે પ્રિન્ટ માંગો છો
એક ફકરો અંદર પોસ્ટ લખાણ.

759
00:40:21,930 --> 00:40:25,710
>> અને અહીં, અમે ખરેખર કરી શકો છો
એ Python કાર્ય કૉલ,

760
00:40:25,710 --> 00:40:35,130
તેથી અમે strftime કૉલ કરી શકો છો સેન્ટ RF સમય,
અને તમે ફોર્મેટ સ્ટ્રિંગ પાસ કરી શકો છો

761
00:40:35,130 --> 00:40:37,064
તમે બહાર ડેટા પ્રિન્ટ કરવા માંગો છો છે.

762
00:40:37,064 --> 00:40:39,980
તેથી તે તમે કરી શકો છો કે જે ખૂબ સરસ છે છે
ખરેખર આ પાયથોન કાર્ય કૉલ

763
00:40:39,980 --> 00:40:41,090
અહીં અંદર.

764
00:40:41,090 --> 00:40:44,370
તમે પર સ્વરૂપણ શું છે નથી
આ નિયંત્રક બાજુ, ખરેખર, કારણ કે

765
00:40:44,370 --> 00:40:47,770
આ તારીખ ફોર્મેટિંગ કંઈક છે કે
તમે જુઓ અંદર કામ કરવા માંગો છો.

766
00:40:47,770 --> 00:40:51,480
>> અને આ ટકા બધા
વસ્તુઓ સુપર મહત્વનું નથી.

767
00:40:51,480 --> 00:40:55,270
તમારી પાસે આ દસ્તાવેજ ઉપર જુઓ તો
Python માં strftime કાર્ય માટે,

768
00:40:55,270 --> 00:40:57,040
તે આ બધા સ્પષ્ટ
વસ્તુઓ, પરંતુ કે

769
00:40:57,040 --> 00:40:59,190
કેવી રીતે, ક્યારે અમે શોધી રહ્યા હતા
અહીં ઘર પાનું,

770
00:40:59,190 --> 00:41:04,440
તે એક સરસ સાથે આ બંધારણો
તારીખ, અને તે સ્પષ્ટ છું અથવા PM પર પોસ્ટેડ,

771
00:41:04,440 --> 00:41:09,410
પરંતુ સામાન્ય રીતે, અમે તો
અહીં આ ન હતી,

772
00:41:09,410 --> 00:41:14,024
તમે કદાચ કેટલાક કચરો મળશે
ખૂબ જ સારી જોવા ન હતી કે તારીખ.

773
00:41:14,024 --> 00:41:15,940
અને પછી અમે સ્પષ્ટ
post.text, હું કરી શકે

774
00:41:15,940 --> 00:41:19,460
એક દંપતિ મૂકી છે
વાક્ય માત્ર અહીં તોડે

775
00:41:19,460 --> 00:41:21,820
દરેક પોસ્ટ વચ્ચે અમુક જગ્યાઓ મૂકો.

776
00:41:21,820 --> 00:41:26,270
>> તેથી, હું સૌથી મહત્વપૂર્ણ છે
આ ઉદાહરણમાં વસ્તુ,

777
00:41:26,270 --> 00:41:28,697
તમે લૂપ માટે આ ઉપયોગ કરી શકે છે.

778
00:41:28,697 --> 00:41:30,780
અને આ માટે સરખું હોય છે
વસ્તુઓ તમે PHP માં કરી શકો છો.

779
00:41:30,780 --> 00:41:32,905
તમે મારફતે ફરી વળવું કરી શકો છો
બધું પસાર નહીં

780
00:41:32,905 --> 00:41:36,719
અને તેથી, તેના બદલે કર્યા કરવા માટે
નકલ / પેસ્ટ, નકલ /, બધા HTML પેસ્ટ

781
00:41:36,719 --> 00:41:40,010
તમે માત્ર પછી એક વખત તે લખવા માટે હોય છે, અને
તમે પોસ્ટ્સ બધા પર ફરી વળવું કરી શકો છો.

782
00:41:40,010 --> 00:41:41,510
>> અને આ કંઈક છે
તમે કરવા માંગો છો કે જે સામાન્ય

783
00:41:41,510 --> 00:41:44,510
તમે માહિતી ઘણો હોય છે, કરવા માટે,
, કે જે તમારી માહિતી બધું માટે છે

784
00:41:44,510 --> 00:41:48,370
તમે એક જ વસ્તુ કરવા માંગો છો.

785
00:41:48,370 --> 00:41:51,690
અને પછી, ફક્ત યાદ રાખો કે જ્યારે તમે તે
બાહ્ય કંઈક પ્રિન્ટ કરવા માંગો છો

786
00:41:51,690 --> 00:41:54,780
HTML માં, તમે ઉપયોગ
અહીં ડબલ કૌંસ,

787
00:41:54,780 --> 00:41:57,820
પરંતુ તે પછી તમે સ્પષ્ટ કરવા માંગો છો જ્યારે
એક શરત વિશે કેટલીક માહિતી

788
00:41:57,820 --> 00:42:02,430
અથવા લૂપ માટે, તમે
ટકા કૌંસ વાપરો.

789
00:42:02,430 --> 00:42:08,730
>> તેથી, પાયથોન પર પાછા જવાનું
કોડ છે, તેથી કે જે સમજાવે છે

790
00:42:08,730 --> 00:42:12,242
શું મુખ્ય ચાલી રહ્યું છે
માર્ગ, આપણે ત્યાં જાય છે,

791
00:42:12,242 --> 00:42:14,450
તે માત્ર ડિસ્પ્લે તમામ
પોસ્ટ્સ, પરંતુ પછી પ્રશ્ન

792
00:42:14,450 --> 00:42:17,440
, અમે કેવી રીતે વાસ્તવમાં મેળવી શકું છે
ડેટાબેઝ માં પોસ્ટ્સ કે જે

793
00:42:17,440 --> 00:42:18,970
થોડી વધુ રસપ્રદ છે.

794
00:42:18,970 --> 00:42:23,960
>> તેથી, જ્યારે તમે નવા પર ક્લિક કરો
અમે અહીં જે જોયું પોસ્ટ લિંક,

795
00:42:23,960 --> 00:42:26,000
તે આ ફોર્મ તમે પુનઃદિશામાન કરે છે.

796
00:42:26,000 --> 00:42:29,580
અને તે માત્ર એક સરળ કોલ છે
render_template કાર્ય છે, કે જે પછી

797
00:42:29,580 --> 00:42:32,110
HTML ફોર્મ માં નવી પોસ્ટ પસાર કરે છે.

798
00:42:32,110 --> 00:42:36,212
તેથી આપણે તે પર એક નજર કરીએ.

799
00:42:36,212 --> 00:42:37,420
તેથી આ એક ખૂબ જ સરળ છે.

800
00:42:37,420 --> 00:42:45,110
તે એક સરળ HTML ફોર્મ છે, જે
થોડો પરિચિત જોવા મળશે,

801
00:42:45,110 --> 00:42:47,380
CS50 ફાયનાન્સ માં સ્વરૂપો પર આધારિત છે.

802
00:42:47,380 --> 00:42:49,940
અને તેથી, અમે અહીં ક્રિયા સ્પષ્ટ કરો.

803
00:42:49,940 --> 00:42:52,435
અને અહીં તમે કામ કરી રહ્યાં છો
PHP, સાથે, સામાન્ય રીતે, તે

804
00:42:52,435 --> 00:42:55,930
કંઈક હશે,
create.PHP, પરંતુ અહીં

805
00:42:55,930 --> 00:42:59,960
અમે ખરેખર એક માર્ગ સ્પષ્ટ
બાટલી સર્વર અંદર.

806
00:42:59,960 --> 00:43:02,520
અને તેથી, આ માર્ગ અનુલક્ષે
બનાવો માર્ગ

807
00:43:02,520 --> 00:43:05,680
અમે અહીં છે કે જે
અમે એક બીજા માં જઈશ.

808
00:43:05,680 --> 00:43:07,630
>> અને તેથી, અમે તે સ્પષ્ટ
તે એક પોસ્ટ પદ્ધતિ છે

809
00:43:07,630 --> 00:43:09,820
અમે મોકલવા માંગો છો કારણ કે
આ ફોર્મ માહિતી, અને સામાન્ય રીતે

810
00:43:09,820 --> 00:43:12,945
તમે ફોર્મ માંથી માહિતી મોકલી રહ્યાં છો, ત્યારે
તમે પોસ્ટ વિનંતી ઉપયોગ કરવા માંગો છો શકે છે,

811
00:43:12,945 --> 00:43:15,760
તમે અંત નથી માત્ર જેથી
આ મોટી, અતિભારે URL સાથે.

812
00:43:15,760 --> 00:43:18,970
પરંતુ તમે પણ એક વિચાર વિનંતી ઉપયોગ કરી શકે છે,
અને, ચલ રાઉટીંગ સાથે તે પસાર

813
00:43:18,970 --> 00:43:21,170
પરંતુ સ્વરૂપો માટે, તે સારું છે
અહીં એક પોસ્ટ વિનંતી છે.

814
00:43:21,170 --> 00:43:24,620
અને તેથી તે પછી, ફક્ત તમને ગમે
HTML અને PHP, સાથે કરી શકે છે,

815
00:43:24,620 --> 00:43:28,420
તમે આ લખાણ ઇનપુટ્સ સ્પષ્ટ કરી શકો છો,
અને તમે તેમને નામ સ્પષ્ટ કરી શકો છો,

816
00:43:28,420 --> 00:43:33,490
અને તે પસાર મળશે કે નામ છે
બાટલી અંદર વિનંતી પદાર્થ માં.

817
00:43:33,490 --> 00:43:36,960
>> અને પછી અમે સબમિટ હોય છે
બટન પોસ્ટ કહે છે.

818
00:43:36,960 --> 00:43:40,760
અને અહીં, પોસ્ટ નામ છે
બટન, તે એક બ્લોગ પોસ્ટ છે, કારણ કે

819
00:43:40,760 --> 00:43:42,700
પરંતુ અહીં, પોસ્ટ વિનંતી પદ્ધતિ છે.

820
00:43:42,700 --> 00:43:47,060
તેથી તે જ શબ્દ છે
પરંતુ વાસ્તવમાં બિનસંબંધિત.

821
00:43:47,060 --> 00:43:48,460
અરે વાહ

822
00:43:48,460 --> 00:43:54,800
>> પાયથોન કોડ પાછા જવું,
અમે પદ્ધતિ બનાવવા કહેવાય,

823
00:43:54,800 --> 00:43:57,702
અહીં નોંધ્યું છે કે તમે કરી શકો છો
ખરેખર માર્ગ અંદર સ્પષ્ટ

824
00:43:57,702 --> 00:44:00,650
વિનંતી પદ્ધતિઓ
તમે સ્વીકારી કરવા માંગો છો કે,

825
00:44:00,650 --> 00:44:04,770
અને તેથી અહીં, હું કે હું સ્પષ્ટ
માત્ર એક પોસ્ટ પદ્ધતિ સ્વીકારી કરવા માંગો છો.

826
00:44:04,770 --> 00:44:09,800
તેથી, હું ખરેખર પૃષ્ઠની મુલાકાત કરવાનો પ્રયાસ કરો તો
સીધા વિચાર વિનંતી ઉપયોગ કરી રહ્યા છે, જે

827
00:44:09,800 --> 00:44:11,700
તે "પદ્ધતિ મંજૂરી નથી." મને કહેશે

828
00:44:11,700 --> 00:44:15,840
>> અને તેથી, તમે પ્રકારની જેવા પાનાંઓ છે
હું માત્ર છું કે જે આ બનાવવા પાનું,

829
00:44:15,840 --> 00:44:20,192
ખરેખર એક માર્ગ તરીકે ઉપયોગ
ફોર્મ રજૂ કરવા માટે,

830
00:44:20,192 --> 00:44:22,900
તમે નથી કે સ્પષ્ટ કરી શકો છો
લોકો ત્યાં જવા માટે કરવાનો પ્રયત્ન કરવા માંગો

831
00:44:22,900 --> 00:44:25,650
સીધા વિચાર વિનંતી દ્વારા,
અથવા તમે નહિં માંગો હતી, તો

832
00:44:25,650 --> 00:44:28,580
કેટલાક કારણોસર, એક પોસ્ટ વિનંતી,
તમે માત્ર અહીં વિચાર સ્પષ્ટ કરી શકે છે

833
00:44:28,580 --> 00:44:32,720
પરંતુ આ ઉદાહરણમાં, અમે ફક્ત
આ પોસ્ટ વિનંતી બહાર જવા માંગો છો.

834
00:44:32,720 --> 00:44:38,700
>> તેથી, create_post કહેવામાં આવે છે, ત્યારે ત્યારે
અમે પોસ્ટ વિનંતી મારફતે મુલાકાત લો

835
00:44:38,700 --> 00:44:43,600
જો તમે ચોક્કસ તું જાય ત્યારે
માર્ગ, આ વિનંતી પદાર્થ છે,

836
00:44:43,600 --> 00:44:46,640
અને અમે આયાત કરવા માટે હતી
ખૂબ જ ટોચ પર વિનંતીઓ,

837
00:44:46,640 --> 00:44:49,640
પરંતુ આ વિનંતી છે
માં પસાર નહીં કે પદાર્થ,

838
00:44:49,640 --> 00:44:53,210
અને તમે માહિતી ઍક્સેસ કરી શકો છો,
જે આપોઆપ ભરવામાં આવશે

839
00:44:53,210 --> 00:44:55,070
તમે ફોર્મ વિનંતી મોકલી છે.

840
00:44:55,070 --> 00:44:56,990
>> અને પછી, હું શું વિચારો
ખરેખર ઠંડી છે

841
00:44:56,990 --> 00:45:02,840
ફોર્મ પદાર્થ પસાર કરો કે
માત્ર એક પાયથોન શબ્દકોશ છે કે

842
00:45:02,840 --> 00:45:10,560
તમે તેથી અહીં access-- તો, દો સમાવે
મને હમણાં જ તે આગામી HTML ખેંચવાનો અપ

843
00:45:10,560 --> 00:45:17,670
તેથી જો તમે તે કરી શકો છો
સંદર્ભ, હા, જેથી

844
00:45:17,670 --> 00:45:21,060
અમે અહીં સ્પષ્ટ છે કે નામો
વિવિધ ક્ષેત્રો માટે છે, તેથી

845
00:45:21,060 --> 00:45:23,900
શીર્ષક અને લખાણ, અમે
પછી માત્ર અહીં તે ઉપયોગ

846
00:45:23,900 --> 00:45:27,110
ફોર્મ માહિતી માં સૂચકાંક છે.

847
00:45:27,110 --> 00:45:28,950
તેથી તે સુપર અનુકૂળ છે.

848
00:45:28,950 --> 00:45:33,320
>> તેથી પછી અમે post.create કૉલ જે
બનાવવા અને આપોઆપ દાખલ કરશે

849
00:45:33,320 --> 00:45:36,850
ડેટાબેઝ માં આ નવી પોસ્ટ પદાર્થ.

850
00:45:36,850 --> 00:45:40,690
અને હું આ કાર્ય બનાવવા લાગે છે
અહીં કેવી રીતે એક ખરેખર ઠંડી ઉદાહરણ છે

851
00:45:40,690 --> 00:45:44,900
શક્તિશાળી બાટલી અને, આ સાથે કામ કરે છે
તમે કંઈક કરી રહ્યા હતા કારણ કે જો

852
00:45:44,900 --> 00:45:48,660
PHP, માં, તમે હોય શકે છે
માન્યતા ઘણો કરવા માટે,

853
00:45:48,660 --> 00:45:51,730
પછી તમે હશે
ડેટાબેઝ જોડાણ અધિષ્ઠાપિત,

854
00:45:51,730 --> 00:45:55,210
પછી તમે હશે
એસક્યુએલ ક્વેરી ચલાવો

855
00:45:55,210 --> 00:45:59,550
પરંતુ, અહીં આપણે ફક્ત આ સરસ છે
post.create, જે અમે પછી કરી શકો છો ફક્ત

856
00:45:59,550 --> 00:46:01,520
માહિતી બહાર વિચાર
વિનંતી પદાર્થ,

857
00:46:01,520 --> 00:46:05,370
અને પછી એક નવી તેને પસાર
અમે બનાવી રહ્યા છો કે પોસ્ટ કરો.

858
00:46:05,370 --> 00:46:07,850
>> અને, ખૂબ જ છેલ્લા પછી
અમે કરવા માંગો છો વસ્તુ,

859
00:46:07,850 --> 00:46:09,630
પુનઃદિશામાન કરવા માટે છે
ઘરમાં વપરાશકર્તા પાછા.

860
00:46:09,630 --> 00:46:13,020
અને તેથી અમે આ ઉપયોગ
બાટલી કાર્ય પુનઃદિશામાન કરે છે.

861
00:46:13,020 --> 00:46:17,770
અને કંઈક આપણે જોયું હતું કે
પહેલાં, આ URL કાર્ય હતું.

862
00:46:17,770 --> 00:46:21,970
તેથી કાર્ય માટે URL દે
તમે ખરેખર નામ પાસ

863
00:46:21,970 --> 00:46:26,090
તમારા પાયથોન કોડ એક કાર્ય છે,
તેના બદલે ચોક્કસ માર્ગ કરતાં

864
00:46:26,090 --> 00:46:26,720
કે તે છે.

865
00:46:26,720 --> 00:46:32,107
>> તેથી હું જ સરળતાથી કરી શકે છે
સ્લેશ વપરાશકર્તા રીડાયરેક્ટ

866
00:46:32,107 --> 00:46:37,050
જે તેને ઘરે પાછી મોકલી છે, પરંતુ
કાર્ય સરસ છે માટે URL નો ઉપયોગ કરીને,

867
00:46:37,050 --> 00:46:39,990
તમે ફેરફાર, કારણ કે જો
વસ્તુઓ છે જ્યાં સ્થાન,

868
00:46:39,990 --> 00:46:44,080
તેથી આપણે હું ફેરફાર કહે છે કે દો
ઘર, તેના બદલે / home પર હોવું

869
00:46:44,080 --> 00:46:47,040
આ હજુ પણ પછી પાછો આવશે / home,
ખરેખર જાય છે અને જુએ છે કારણ કે

870
00:46:47,040 --> 00:46:50,770
આ કાર્ય નામ, અને તે
તમે તે માટે URL પાછા આપશે.

871
00:46:50,770 --> 00:46:52,490
>> તેથી, પ્રકારની પર
તમે છો કે ધારણા

872
00:46:52,490 --> 00:46:55,489
જ્યાં વસ્તુઓ બદલવા માટે વધુ શક્યતા
કાર્યો નામો કરતાં હોય છે.

873
00:46:55,489 --> 00:46:58,840
તમે ખરેખર આ ઉપયોગ કરી શકો છો
કાર્ય માટે સરસ URL.

874
00:46:58,840 --> 00:47:02,470
અને એક વસ્તુ છે ચેતો
કે થોડો મુશ્કેલ છે

875
00:47:02,470 --> 00:47:05,750
તમે માત્ર લાગે શકે છે કે છે
માટે URL પર પુનઃદિશામાન કૉલ,

876
00:47:05,750 --> 00:47:10,600
પરંતુ વાસ્તવમાં આ માર્ગો બધા છે
લખાણ અને એચટીએમએલ અમુક પ્રકારના પાછા ફરવા માટે,

877
00:47:10,600 --> 00:47:14,360
તેથી જો તમે ખરેખર કરવા માટે હોય છે
પુનઃદિશામાન કોલ આવો.

878
00:47:14,360 --> 00:47:18,379
નહિંતર, તમે કંઈક મળશે
અમાન્ય શબ્દમાળા પાછા ન વિશે

879
00:47:18,379 --> 00:47:21,420
આ બધા પાછા છે કારણ કે
એચટીએમએલ તમે ખરેખર રેન્ડર કરવા માંગો છો.

880
00:47:21,420 --> 00:47:26,980
>> અને તેથી, તમે પુનઃદિશામાન કૉલ કરો ત્યારે,
તે પૃષ્ઠ પર પુનઃદિશામાન

881
00:47:26,980 --> 00:47:30,270
પરંતુ વાસ્તવમાં તે HTML આપે
તમે તે પુનઃદિશામાન ચલાવવા માટે જરૂર છે.

882
00:47:30,270 --> 00:47:34,430

883
00:47:34,430 --> 00:47:37,110
પાછા ઘર પાનાં પર જવા.

884
00:47:37,110 --> 00:47:39,200
તેથી અમે આ બે અલગ મંતવ્યો ધરાવે છે.

885
00:47:39,200 --> 00:47:40,132
અમે ઘર દૃશ્ય છે.

886
00:47:40,132 --> 00:47:41,590
અથવા, હું નમૂનાઓ કહેવું જોઈએ ધારી.

887
00:47:41,590 --> 00:47:44,190
અમે આ બે નમૂનાઓ હોય છે,
ઘર નમૂનો કે જે

888
00:47:44,190 --> 00:47:48,500
અમારા પોસ્ટ્સ તમામ દર્શાવે છે, અને
પછી અમે આ જાહેરાત વસ્તુ છે,

889
00:47:48,500 --> 00:47:52,970
તમે પોસ્ટ પર ક્લિક કરો ત્યારે, તે જાય
બાટલી અંદર એક નવા માર્ગ માટે,

890
00:47:52,970 --> 00:47:55,920
પરંતુ તે માર્ગ જરૂરી નથી
અનુલક્ષી નમૂનો છે.

891
00:47:55,920 --> 00:47:59,290

892
00:47:59,290 --> 00:48:01,560
તમે જુઓ કરવાની જરૂર નથી
કંઈપણ છે, પરંતુ તમે હજુ પણ કરી શકો છો

893
00:48:01,560 --> 00:48:04,090
આ કામ ચાલી રહ્યું છે
પડદા પાછળ છે.

894
00:48:04,090 --> 00:48:07,450
અને પછી તમે રીડાયરેક્ટ કરી
હોમ પેજ પાછા.

895
00:48:07,450 --> 00:48:12,230
અને ચોક્કસપણે, તે કામ કરવા માટે સરળ છે
નમૂના કેટલાક માટે NICER સીએસએસ

896
00:48:12,230 --> 00:48:15,580
અને આ ઘણો NICER દેખાવ બનાવવા,
પરંતુ મુખ્ય તર્ક તમામ

897
00:48:15,580 --> 00:48:18,590
આ Python માં છે.

898
00:48:18,590 --> 00:48:20,020
>> કે ઉદાહરણ વિશે કોઇ પ્રશ્નો?

899
00:48:20,020 --> 00:48:22,760
હું ઘણો ત્યાં છે ખબર
વિવિધ વસ્તુઓ ત્યાં રહ્યું

900
00:48:22,760 --> 00:48:25,341
અમે જોઇ ન હતી વસ્તુઓ ઘણો
પહેલાં, પરંતુ કંઇ ગમે છે.

901
00:48:25,341 --> 00:48:25,840
યાહ.

902
00:48:25,840 --> 00:48:28,346
>> પ્રેક્ષક 1: તમે કંઈ પણ કરવા માટે હોય છે
છે કે માહિતી ઝાડી માટે ખાસ

903
00:48:28,346 --> 00:48:29,600
ફોર્મ આવતા?

904
00:48:29,600 --> 00:48:31,109
હું "બનાવો" તમે હમણાં જ કહ્યું હતું જણાયું

905
00:48:31,109 --> 00:48:33,900
એઝરા Zigmond: અરે વાહ, કે જેથી છે
ખરેખર, કે જે ખરેખર સારા બિંદુ છે.

906
00:48:33,900 --> 00:48:36,350
પ્રશ્ન હતો તેથી, તમે શું
તપાસો અને ખાતરી કરવા માટે જરૂર

907
00:48:36,350 --> 00:48:39,190
માહિતી, માન્ય છે અને
સ્ક્રબિંગ કોઇ પણ પ્રકારની કરવું

908
00:48:39,190 --> 00:48:41,840
તે માન્ય છે કે નહીં તેની ખાતરી કરવા માટે,
તમે અહીં જોઈ શકો છો, કારણ કે,

909
00:48:41,840 --> 00:48:42,660
હું જે કરી રહ્યો છું.

910
00:48:42,660 --> 00:48:48,140
તેથી શું થાય છે તે જોવા દો
હું ખાલી કંઈક પોસ્ટ તો.

911
00:48:48,140 --> 00:48:51,190
તેથી, તે ખરેખર માત્ર એક બનાવવા પડશે
ખાલી પોસ્ટ અને તારીખ સમય ભરો.

912
00:48:51,190 --> 00:48:55,990
>> તેથી વાસ્તવમાં, તમે કદાચ કરશે
કંઈક કરવા માંગો છો,

913
00:48:55,990 --> 00:49:04,749
શીર્ષક સમાન છે, કદાચ સ્પષ્ટ
ખાલી શબ્દમાળા, તો પછી આ નથી.

914
00:49:04,749 --> 00:49:07,290
શીર્ષક છે અથવા, જો માત્ર તે શું
ખાલી શબ્દમાળા બરાબર નથી.

915
00:49:07,290 --> 00:49:10,330
તેથી તે ખરેખર આપોઆપ નથી
કે સ્ક્રબિંગ કાળજી લેવા

916
00:49:10,330 --> 00:49:12,820
તમે માટે છે, તેથી તમે હજુ પણ તે કરવા માટે જરૂર છે.

917
00:49:12,820 --> 00:49:14,330
અરે વાહ, સારો પ્રશ્ન.

918
00:49:14,330 --> 00:49:18,497
>> પ્રેક્ષક 2: તે ઝાડી કરે
સિક્વલ ઈન્જેક્શન માટે?

919
00:49:18,497 --> 00:49:19,890
તમે જાણો છો?

920
00:49:19,890 --> 00:49:22,830
>> એઝરા Zigmond: આસ્થાપૂર્વક,
peewee જે કરે છે.

921
00:49:22,830 --> 00:49:25,830
હું તે ચોક્કસપણે એક સુંદર હશે એવું લાગે છે
ખરાબ પુસ્તકાલય તે ન કર્યું હોય.

922
00:49:25,830 --> 00:49:29,511

923
00:49:29,511 --> 00:49:32,690
હું બરાબર ખબર નથી.

924
00:49:32,690 --> 00:49:34,820
હું જોવા માટે હોય તો
તે પેદા કરી તે શોધો.

925
00:49:34,820 --> 00:49:38,980
હું એક માં ટાઇપ, તો લાગે છે કે
પ્રકારની જોવામાં કે બ્લૉગ પોસ્ટ

926
00:49:38,980 --> 00:49:46,370
એક એસક્યુએલ ઇન્જેક્શન હુમલો જેમ,
આ કંઈક, આ તો

927
00:49:46,370 --> 00:49:49,370
પાસવર્ડ ક્ષેત્ર અથવા કંઈક જેવું છે,
તમે આ કંઈક કરી શકે છે.

928
00:49:49,370 --> 00:49:53,410
>> મને લાગે છે કે હજુ પણ ચાલશે લાગે
શાબ્દિક પોસ્ટ મેળવવા માટે,

929
00:49:53,410 --> 00:49:59,200
પરંતુ હું peewee કરે છે લાગે છે કે
માહિતી સ્ક્રબિંગ અમુક પ્રકારના

930
00:49:59,200 --> 00:50:01,680
તે ખરેખર ચલાવે તે પહેલાં.

931
00:50:01,680 --> 00:50:04,510
>> પ્રેક્ષક 1 કે લખાણ ક્ષેત્ર છે
અધિકાર, સાદા ટેક્સ્ટ લેવા માટે રચાયેલ?

932
00:50:04,510 --> 00:50:05,710
>> એઝરા Zigmond: અરે વાહ, તે છે.

933
00:50:05,710 --> 00:50:06,465
યાહ.

934
00:50:06,465 --> 00:50:09,590
તેથી હું તમામ લાગે છે, જેથી આ છે
યોગ્ય વર્તન, કે શું કરશે,

935
00:50:09,590 --> 00:50:12,170
પરંતુ મને લાગે છે કે peewee લાગે
આસ્થાપૂર્વક કરતું નથી

936
00:50:12,170 --> 00:50:13,780
તેમના ઓવરને પર રક્ષણ અમુક પ્રકારના.

937
00:50:13,780 --> 00:50:16,090
અને તમે ઇચ્છતા હોય તો
ડબલ ચેક, કે ત્યાં

938
00:50:16,090 --> 00:50:19,530
તમે ક્વેરી પેદા જ્યારે માર્ગો છે.

939
00:50:19,530 --> 00:50:22,622
જેથી તમે નથી
સીધા જ ચલાવો.

940
00:50:22,622 --> 00:50:24,330
હું લેવા હોય તો
દસ્તાવેજીકરણ જુઓ,

941
00:50:24,330 --> 00:50:27,930
પરંતુ તમે ખરેખર જોઈ શકો છો
તે પેદા થાય છે કે એસક્યુએલ,

942
00:50:27,930 --> 00:50:30,840
અને તે પર એક નજર, અને બનાવવા
તે વસ્તુઓ નીકળતો છે તેની ખાતરી કરો.

943
00:50:30,840 --> 00:50:33,700
>> અન્ય કારણ શા માટે તમે કદાચ
એસક્યુએલ જોવા માંગો છો

944
00:50:33,700 --> 00:50:37,920
કે peewee તો છે, outputting છે
વસ્તુઓ ખરેખર ધીમે ધીમે જતા હોય તેમ જણાય છે

945
00:50:37,920 --> 00:50:41,090
તમે એક નજર અને તે શું જોઈ શકો છો
તે ક્યારેક કારણ ખરેખર કરી

946
00:50:41,090 --> 00:50:44,670
આકસ્મિક ઉમેરવા માટે સરળ
, જે રીતે તમે તેને લખી,

947
00:50:44,670 --> 00:50:47,880
જો તમે આકસ્મિક તે હોઈ શકે છે
પ્રથમ સમગ્ર ડેટાબેઝ પસંદ કરો,

948
00:50:47,880 --> 00:50:50,230
અને પછી કેટલાક સૉર્ટ કામગીરી
તે પર, જ્યારે તમે ખરેખર

949
00:50:50,230 --> 00:50:51,320
ઉપગણ પસંદ કરવા માટે અર્થ થાય છે.

950
00:50:51,320 --> 00:50:53,560
>> અને તેથી, વસ્તુઓ તો નથી
તદ્દન અધિકાર રહ્યું

951
00:50:53,560 --> 00:50:57,300
તે વિનંતી પર એક નજર સારી છે
કે ખરેખર પેદા રહ્યું છે.

952
00:50:57,300 --> 00:50:57,800
યાહ.

953
00:50:57,800 --> 00:51:02,100
>> પ્રેક્ષક 2: તમે પ્રથમ શરૂ જ્યારે,
તમે 5000 તરીકે પોર્ટ મૂકો.

954
00:51:02,100 --> 00:51:02,904
>> એઝરા Zigmond: યાહ.

955
00:51:02,904 --> 00:51:06,070
પ્રેક્ષક 2: peewee સાથે મૂળભૂત છે
અથવા તમે બદલી શકો છો કંઈક છે?

956
00:51:06,070 --> 00:51:10,870
એઝરા Zigmond: હા, તેથી
પોર્ટ બાટલી સાથે મૂળભૂત છે.

957
00:51:10,870 --> 00:51:13,061
તમે વિના તે ચલાવો, તો
કંઈપણ સ્પષ્ટ,

958
00:51:13,061 --> 00:51:14,310
તે આપોઆપ કે શું કરશે.

959
00:51:14,310 --> 00:51:16,060
હું હોય તો માને છે
આ ડબલ ચેક માટે,

960
00:51:16,060 --> 00:51:19,130
પરંતુ તમે app.run કે સ્પષ્ટ કરી શકો છો
હું તમને કંઈક કરી શકે છે

961
00:51:19,130 --> 00:51:19,629
પોર્ટ = 8080.

962
00:51:19,629 --> 00:51:22,375

963
00:51:22,375 --> 00:51:23,750
એક વાસ્તવિક ઝડપી પ્રયાસ આપી દો.

964
00:51:23,750 --> 00:51:29,100

965
00:51:29,100 --> 00:51:32,230
અરે વાહ, જેથી તમે માત્ર સ્પષ્ટ કરી શકો છો
પોર્ટ = 8080, અને તે તેને ત્યાં ચાલશે

966
00:51:32,230 --> 00:51:36,130
જો તમે ઇચ્છતા મને લાગે છે, કે જે ચલાવવા માટે
જ્યારે IDE પર, હું આ બહાર પ્રયત્ન કર્યો ન હોય

967
00:51:36,130 --> 00:51:38,527
પરંતુ મને લાગે છે કે જો તમે
પોર્ટ 8080 પર ચાલી હતી

968
00:51:38,527 --> 00:51:40,360
તમે કદાચ સમર્થ હશો
સર્વર ઍક્સેસ કરવા માટે,

969
00:51:40,360 --> 00:51:41,870
તમે માત્ર વેબસાઇટ માટે હતા ગમે છે.

970
00:51:41,870 --> 00:51:44,390
>> અરે વાહ, તે પણ સરળ છે
બદલવા માટે જો તમે

971
00:51:44,390 --> 00:51:48,540
જેવા પોર્ટ આગળ ધપાવવાનું કોઇ પણ પ્રકારની હોય છે
તમે શું કરવાની જરૂર છે કે જે વસ્તુઓ.

972
00:51:48,540 --> 00:51:50,410
>> કોઈપણ અન્ય પ્રશ્નો છે?

973
00:51:50,410 --> 00:51:50,916
અરે વાહ?

974
00:51:50,916 --> 00:51:53,416
પ્રેક્ષક 1: તેથી, હું જોયું તમારા
, તમે ઉલ્લેખ કર્યો છે કે મોડેલો,

975
00:51:53,416 --> 00:51:55,647
તમે સ્પષ્ટ કરવા માટે છે
દરેક પદાર્થ માટે ડેટાબેઝ.

976
00:51:55,647 --> 00:51:58,105
તમને ખબર થાય છે, કરે છે
કે જો તમે તે ખરેખર સરળ બનાવે છે

977
00:51:58,105 --> 00:52:03,210
SQLite ડેટાબેઝ ઘણાં હોય છે કે તમે
એક વેબ એપ્લિકેશન માટે ઉપયોગ કરવા માંગો છો,

978
00:52:03,210 --> 00:52:07,210
તમે માત્ર એક ટોળું સ્પષ્ટ કરી શકો છો કે
તમારા મોડેલ માં વિવિધ રાશિઓ?

979
00:52:07,210 --> 00:52:11,620
>> એઝરા Zigmond: અરે વાહ, મને દો
વાસ્તવિક ઝડપી ખોલો.

980
00:52:11,620 --> 00:52:17,570
તમારી પાસે માંગો છો, તો, તમે કહી રહ્યાં છે
કંઇક અલગ એક ટોળું, કદાચ

981
00:52:17,570 --> 00:52:22,670
કેટલાક માટે, ગમે છે અને વિદ્યાર્થીઓ
કારણ, તે કંઈક?

982
00:52:22,670 --> 00:52:26,870
અરે વાહ, જેથી મને લાગે છે કે
હજુ પણ તમે, દરેક મોડેલ

983
00:52:26,870 --> 00:52:30,652
હજુ હમણાં જ હોય ​​હશે
તેને સોંપેલ એક ડેટાબેઝ,

984
00:52:30,652 --> 00:52:32,610
પરંતુ જો તમે ઇચ્છતા હોય
વિવિધ મોડેલો કે

985
00:52:32,610 --> 00:52:35,818
વિવિધ ડેટાબેઝ પદાર્થો સોંપાયેલ છે
તે માટે, તમે ચોક્કસપણે તે કરી શકે.

986
00:52:35,818 --> 00:52:43,070
તેથી, જો હું એક નવા બનાવવામાં
આ કંઈક,

987
00:52:43,070 --> 00:52:47,000
અને હવે આ એક વિદ્યાર્થી છે કે
વિચિત્ર રીતે એક બ્લોગ પોસ્ટ જેવી લાગે છે

988
00:52:47,000 --> 00:52:49,390
મને લાગે છે કે સ્પષ્ટ કરી શકે છે
ડેટાબેઝ અહીં db_2 સમાન છે.

989
00:52:49,390 --> 00:52:51,390
તેથી, હું કે લાગે છે
તમે તે કરી શકો છો મુખ્ય માર્ગ.

990
00:52:51,390 --> 00:52:54,560

991
00:52:54,560 --> 00:52:56,200
>> કૂલ.

992
00:52:56,200 --> 00:52:58,410
કોઈપણ અન્ય પ્રશ્નો છે?

993
00:52:58,410 --> 00:53:02,170
>> તેથી માત્ર થોડી અપ સમાપ્ત કરવા માટે
બીટ, અહીં કેટલાક સ્રોતો છે,

994
00:53:02,170 --> 00:53:06,030
અને આ સ્લાઇડ્સ ઓનલાઇન પોસ્ટ કરવામાં આવશે
તેથી જો તમે ખરેખર આ કડીઓ મેળવી શકો છો.

995
00:53:06,030 --> 00:53:08,500
શ્રેષ્ઠ સાધનો ખરેખર છે
બાટલી દસ્તાવેજો

996
00:53:08,500 --> 00:53:09,930
અને પોતાને peewee.

997
00:53:09,930 --> 00:53:12,940
તેઓ ખરેખર સારી રીતે લખાયેલ કરી રહ્યાં છો, મને લાગે છે.

998
00:53:12,940 --> 00:53:18,180
તેથી, બાટલી વેબસાઇટ અહીં છે, અને
તેઓ એક ક્વિકસ્ટાર્ટ ટ્યુટોરીયલ છે કે

999
00:53:18,180 --> 00:53:20,710
સમાન લઈ જવામાં આવશે
હું મારફતે લોકો ચાલતા જતા હતા શું વસ્તુઓ

1000
00:53:20,710 --> 00:53:23,560
પરંતુ તમે સમીક્ષા કોઇ પણ પ્રકારની માંગો છો
હું ઉપર ગયા કે વસ્તુઓ,

1001
00:53:23,560 --> 00:53:26,200
અથવા તમે હું સમજાવી વિચાર્યું કે
એક ગૂંચવણમાં રીતે કંઈક,

1002
00:53:26,200 --> 00:53:28,390
તેઓ ત્યાં જ ઉદાહરણો પડશે.

1003
00:53:28,390 --> 00:53:31,570
>> Peewee દસ્તાવેજીકરણ ધરાવે છે, અને
તેઓ એક ક્વિકસ્ટાર્ટ ટ્યુટોરીયલ છે

1004
00:53:31,570 --> 00:53:34,650
કે મુખ્ય પરિમાણો પર જાય છે
તમે ઉપયોગ કરવા માંગો છો કે જે.

1005
00:53:34,650 --> 00:53:38,900
તેથી, મેં સાથે વિશે વાત
અનન્ય, અને સ્પષ્ટ મૂળભૂતો

1006
00:53:38,900 --> 00:53:42,710
ક્ષેત્રોમાં આ વિવિધ પ્રકારની છે કે
તમે તે બધા ત્યાં હશે, વાપરી શકો છો.

1007
00:53:42,710 --> 00:53:44,690
>> પણ, જો તમારી પાસે
peewee વિશે પ્રશ્નો

1008
00:53:44,690 --> 00:53:47,530
અને તમે StackOverflow પર તેમને પોસ્ટ
ખરેખર peewee કરનારા વ્યક્તિ

1009
00:53:47,530 --> 00:53:49,500
પર જાય છે અને ક્યારેક તે જવાબ આપે છે.

1010
00:53:49,500 --> 00:53:53,200
તમે આસ્થાપૂર્વક એક પ્રશ્ન હોય, તો
તેમણે તેને જવાબ આપવા માટે સક્ષમ હશો

1011
00:53:53,200 --> 00:53:54,867
તેમણે સમગ્ર બાબત લખ્યું છે.

1012
00:53:54,867 --> 00:53:56,700
મને લાગે છે કે બધું છે એવું લાગે છે
હું આવરી માગે છે.

1013
00:53:56,700 --> 00:53:58,930
બહાર આવતા માટે આભાર.

1014
00:53:58,930 --> 00:54:02,688