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でプログラミングのCインチ

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
これは、いくつかの点でCより少ない強力です。

10
00:00:24,780 --> 00:00:28,130
これは、にはあまり表現力であります
場所を正​​確にあなたのコンピュータで

11
00:00:28,130 --> 00:00:30,030
メモリは、レイアウトされます
どのようにそれがレイアウトされます、

12
00:00:30,030 --> 00:00:32,030
それは、自由を取得したときと
物事のこれらの種類。

13
00:00:32,030 --> 00:00:36,150
>> これは、いくつかの点でCよりも有用です
なぜなら、それはでプログラムする方が簡単です。

14
00:00:36,150 --> 00:00:39,920
言語は、いくつかに、あります
人々、より直感的に。

15
00:00:39,920 --> 00:00:44,820
そして実際に、目標は、のためのものです
それはプログラムに高速にします

16
00:00:44,820 --> 00:00:46,490
そして潜在的に遅い実行します。

17
00:00:46,490 --> 00:00:48,198
>> 今、あなたが考える場合
時間の量

18
00:00:48,198 --> 00:00:50,514
あなたが最後に費やさ
問題設定書き込み

19
00:00:50,514 --> 00:00:52,430
あなたのコード
あなたが費やす時間の量

20
00:00:52,430 --> 00:00:55,310
あなたの最後の問題に
あなたのコードを実行し、

21
00:00:55,310 --> 00:00:58,300
あなたは、言語ことを想像します
書くことが二倍の速さでした、

22
00:00:58,300 --> 00:01:02,170
二回実行するようにゆっくりと、かもしれません
いくつかの点でCに比べて、パフォーマンスが向上し。

23
00:01:02,170 --> 00:01:05,730
確かにあなたが書くしようとしているとき
ささいなことを行うための小さなプログラム、

24
00:01:05,730 --> 00:01:08,520
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は非常に似ています
Cに、私は仮定しています

32
00:01:28,310 --> 00:01:34,056
あなたはCS50の学生だということ、または誰か
Cと同じような親しみやすさと

33
00:01:34,056 --> 00:01:36,700
>> あなたはCS50の学生であれば
問題を回避、6を設定

34
00:01:36,700 --> 00:01:38,866
あなたは多くのを見てきました
C言語でのもの、私はあなたを与えるだろう

35
00:01:38,866 --> 00:01:40,740
主な違い、
物事の一部

36
00:01:40,740 --> 00:01:42,840
それは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
>> 一つ慎重に警告する前に
我々は、Python 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
実行することができるようにするためではありません
Pythonの3環境インチ

56
00:02:37,140 --> 00:02:41,969
>> CS50アプライアンスが付属しています
Pythonは、デフォルトでは、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
してみPythonの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
Pythonの3実際にできるようにするために、
一緒に従うと、これらのことを実行します。

64
00:03:09,770 --> 00:03:12,280
>> また、私はあなたを指します
今公式リソースで。

65
00:03:12,280 --> 00:03:16,082
慎重docs.python.org/3--~~V
それは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を持っています
右側に、我々は、Pythonを持っています。

74
00:03:34,410 --> 00:03:36,780
あなたは認識している可能性があります
この問題は、それはです

75
00:03:36,780 --> 00:03:40,760
最初の問題の1
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
バット、Pythonは何を持っていることではありません
コー​​ドの周りの主な機能の折り返し。

81
00:03:56,350 --> 00:03:59,170
だからCに、あなたはの束を書きます
ファイルは、あなたがそれらを一緒にリンクし、

82
00:03:59,170 --> 00:04:02,590
、プログラムの実行を開始
この事で、int型の主と呼ばれます。

83
00:04:02,590 --> 00:04:04,930
>> 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
しかし、ここで、第1
プログラムは、nが10に等しくあります

90
00:04:18,459 --> 00:04:21,273
このプログラムは、その最初のもの
行います10のこの値を取ることです

91
00:04:21,273 --> 00:04:24,120
nという変数に設定します。

92
00:04:24,120 --> 00:04:27,690
>> 、その行のの一つといえば
このsorry-- things--その他

93
00:04:27,690 --> 00:04:31,040
そのCプログラムを意味し、
あなたはそれらを書きます、

94
00:04:31,040 --> 00:04:34,899
あなたは、意志、それらを作りますよ
いくつかの打ち鳴らすのコマンドを呼び出します、

95
00:04:34,899 --> 00:04:36,690
そしてあなたが実行されます
結果の実行可能ファイル。

96
00:04:36,690 --> 00:04:41,030
あなたが実行するPythonプログラム、
このmario.py file--テキストはかもしれません

97
00:04:41,030 --> 00:04:44,900
私は示した。このファイルで
あなたは、そのファイルを実行しますyou--

98
00:04:44,900 --> 00:04:47,450
あなたは、実行します
それのと内容

99
00:04:47,450 --> 00:04:50,390
によって実行されます
Pythonインタプリタ。

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
これは実際にはPythonで
2、ではないのPython 3、そうではありません

103
00:05:04,840 --> 00:05:06,600
今の構文について心配。

104
00:05:06,600 --> 00:05:14,230
しかし、私は上に、Pythonを実行します
hello.py、それが実行されます。

105
00:05:14,230 --> 00:05:18,890
>> 私はPythonを使用することができます別の方法
私は、この話にはあまり対処しません

106
00:05:18,890 --> 00:05:21,840
私はPythonを入力する場合には、あります
ここで、環境に私をドロップ

107
00:05:21,840 --> 00:05:24,370
私は線でPythonのラインを供給することができます。

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
むしろ、より世俗的な、最初は、ということです
Pythonは末尾のセミコロンがありません。

120
00:05:59,280 --> 00:06:02,630
>> セミコロンはどこにでもオプションであります
無害どこでも。

121
00:06:02,630 --> 00:06:03,722
あなたはそれらを追加することができます。

122
00:06:03,722 --> 00:06:06,430
それは書く人になるかもしれません
あなたに生きている冷笑ためのPython

123
00:06:06,430 --> 00:06:08,860
背中の後ろに、理由
彼らは必要はありません。

124
00:06:08,860 --> 00:06:13,497
彼らは頻繁にオーバー開催中の記号です
言語のCからデザイナー

125
00:06:13,497 --> 00:06:16,580
それがこの方法より明確であることを感じます
それが宣言する必要はありませんことを

126
00:06:16,580 --> 00:06:18,700
たびにあなたが行を終了します。

127
00:06:18,700 --> 00:06:21,799
>> このnは約別の奇妙なこと
それは添付のタイプを持っていないです。

128
00:06:21,799 --> 00:06:24,590
Python--の魔法の作品の一つ
私は、魔法のそれを呼び出すつもりです

129
00:06:24,590 --> 00:06:26,381
しかし、非常にあります
技術的な理由なぜ

130
00:06:26,381 --> 00:06:28,560
のいずれかをworks--
パイソンのマジック枚

131
00:06:28,560 --> 00:06:32,700
変数は展開することができるということですか
どのようなデータが含まれて縮小

132
00:06:32,700 --> 00:06:34,530
あなたがそれらをしたいと思うタイプ。

133
00:06:34,530 --> 00:06:35,580
>> だから、これは10です。

134
00:06:35,580 --> 00:06:40,060
私はこれに割り当てられた後にダウンした場合
nは0.5、それは0.5ということを取るでしょう。

135
00:06:40,060 --> 00:06:43,770
それはここでint型だとどんなにと
、そこにこのn個を使用して何かをフロート

136
00:06:43,770 --> 00:06:47,057
、多かれ少なかれ、一気飲みすることができるようになります
それはそれらのいずれかを取得する場合に沿って。

137
00:06:47,057 --> 00:06:49,640
いくつかの非常に現実的ではありますがない限り
それはデータを使用できない理由

138
00:06:49,640 --> 00:06:52,170
それが現在持っているnを入力、
その時点でそれが得られます

139
00:06:52,170 --> 00:06:54,490
楔形とエラーをスローし、
物事のこれらの種類。

140
00:06:54,490 --> 00:06:57,050
>> しかし、ここでは、Pythonの
本当に何を気にしません

141
00:06:57,050 --> 00:06:59,140
それは私がこれに固執するつもりだということです
文は、のような、あなたがこの事をしたいですか？

142
00:06:59,140 --> 00:06:59,840
その中でこのこと？

143
00:06:59,840 --> 00:07:00,640
ええ、それは事のようなものです。

144
00:07:00,640 --> 00:07:01,810
私は最後にそれを固執するでしょう。

145
00:07:01,810 --> 00:07:04,740
場合は、後で問題になるだろう
そのエンドを使用したい人

146
00:07:04,740 --> 00:07:05,710
それを処理することはできません。

147
00:07:05,710 --> 00:07:08,500
これは、主要なの一つであります
PythonとCの間の違い

148
00:07:08,500 --> 00:07:10,790
それはすることが容易になります
非常に大規模なCプログラムを書きます

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
だから、これは非常に、何と呼ばれています
ニシキヘビ、それを書く方法。

153
00:07:25,370 --> 00:07:28,969
レンジ（N）の行のために、これは
0からnまでの番号の範囲、

154
00:07:28,969 --> 00:07:31,010
底の包括
そして上に排他的。

155
00:07:31,010 --> 00:07:34,790
だから、0からN-1であるにです
正確にCコードが何をしていますか、

156
00:07:34,790 --> 00:07:38,690
それははるかに簡単です除い
おそらく見ています。

157
00:07:38,690 --> 00:07:42,710
>> 関連するブロックです
中括弧ではオフに設定されていません、

158
00:07:42,710 --> 00:07:44,540
代わりに、それはオフに設定しています
このインデントによって。

159
00:07:44,540 --> 00:07:47,580
したがって、これらの行のすべてがあります
右のオーバー4つの空間、

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
その印刷は、forループを残します。

165
00:08:04,320 --> 00:08:08,560
ここで実際に私のCとは対照的に、
周りにその閉じブレースを移動する必要があります。

166
00:08:08,560 --> 00:08:11,820
>> これは、エラーを取得しないことを意味し
あなたので、それはあなたに飛び出します

167
00:08:11,820 --> 00:08:13,580
間違った場所にブレースを置きます。

168
00:08:13,580 --> 00:08:16,460
それはあなたがエラーを取得することを意味しています
あなたので、それはあなたに飛び出します

169
00:08:16,460 --> 00:08:17,620
間違った行をインデント。

170
00:08:17,620 --> 00:08:19,290
だから、くぼみ、超慎重になります。

171
00:08:19,290 --> 00:08:22,123
うまくいけば、スーパーされていました
とにかくあなたのインデントに注意してください、

172
00:08:22,123 --> 00:08:25,300
そしてこれはそれがありません
負担のはるか。

173
00:08:25,300 --> 00:08:28,762
>> しかし、Python用の基本的なルール、
私たちはこれらのカップルを持っています

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
>> この場合は、より似ています
Cに、その後FORSです。

191
00:09:19,005 --> 00:09:20,380
括弧がいないことに注意してください。

192
00:09:20,380 --> 00:09:23,490
括弧は、再び、あります
無害が、不要。

193
00:09:23,490 --> 00:09:25,750
最後にコロンがあります
ただ、ループのような

194
00:09:25,750 --> 00:09:30,800
そして再び、相対的なブロックがあります
インデントではなく、中括弧ではオフに設定してください。

195
00:09:30,800 --> 00:09:33,080
この他には、オリジナルであります
インデントのレベル、

196
00:09:33,080 --> 00:09:35,930
その関連するブロックが再インデント。

197
00:09:35,930 --> 00:09:41,720
彼らはCでそうであるように、これらは正確に動作し

198
00:09:41,720 --> 00:09:44,520
>> これは非常に実際には同じです。

199
00:09:44,520 --> 00:09:49,430
繰り返しますが、印刷は1文字を失います
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
1を出力しません。

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

222
00:10:37,980 --> 00:10:43,690
しかし、まだそのように、最後の一つです
このプログラムは1つがある持っていることを欠落しています

223
00:10:43,690 --> 00:10:44,960
上部にあります。

224
00:10:44,960 --> 00:10:48,120
印刷はとても基本的なPythonに焼かれます
何のヘッダーやモジュールがありませんこと

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
Pythonが開始されるため
上部に実行します。

231
00:11:03,372 --> 00:11:05,080
私はラップしたい場合
機能では、この、私は

232
00:11:05,080 --> 00:11:07,667
this--私のようにそれを行うだろう
defの関数名を言うでしょう、

233
00:11:07,667 --> 00:11:10,500
引数はここに行くかもしれないし、我々はよ
これらの後に、コロンのいくつかを参照してください、

234
00:11:10,500 --> 00:11:13,040
し、再度、この
ブロックをオフに設定全体

235
00:11:13,040 --> 00:11:16,810
動作しているものです
その関数のブロック。

236
00:11:16,810 --> 00:11:18,560
だから、これは定義であります
関数の。

237
00:11:18,560 --> 00:11:21,587
そしてダウン、宣言あります
ここで、私は関数を呼び出すことができます。

238
00:11:21,587 --> 00:11:23,920
そして再び、プログラム
通訳、先頭から、

239
00:11:23,920 --> 00:11:25,280
これが定義され表示されます。

240
00:11:25,280 --> 00:11:27,960
それまでは、これを実行されません
ここで取得し、それがああ、のようなものです

241
00:11:27,960 --> 00:11:30,860
今では私は、それを呼んでいます
私はそれを実行する必要がありますね。

242
00:11:30,860 --> 00:11:33,850
>> 非常に一般的ですもの
Pythonのファイルで見るために、

243
00:11:33,850 --> 00:11:36,700
特にPythonのファイルその
一般にリリースされています

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
そうでなければ他の誰かのことができ
私function--を含みますuse--

256
00:12:18,710 --> 00:12:22,510
私のファイル、およびだけで取得します
これらの機能へのアクセス

257
00:12:22,510 --> 00:12:25,552
物事を実行することなく、
私は、このファイルに実行すること。

258
00:12:25,552 --> 00:12:27,260
これは、再び、オプションです
しかし、非常に一般的。

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

260
00:12:30,450 --> 00:12:33,840
>> これらのことはentirely--されています
Cと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
あなたはint型で動作し、いずれか
あなたはそれを望んでいたか、あなたはしませんでした。

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
だからによりフロートを掛けることができます
int型、物事のこれらの種類。

267
00:12:49,740 --> 00:12:52,480
>> セットには、まったく同じ動作します。

268
00:12:52,480 --> 00:12:54,310
次の2つの等号を使用することができます。

269
00:12:54,310 --> 00:12:59,000
inequals--より大きい、少なく
things--この種の、より

270
00:12:59,000 --> 00:13:02,580
意味を持っています
あなたはそれらに精通しています。

271
00:13:02,580 --> 00:13:05,770
>> Cは、これらの演算子を使用する場合、
Pythonはもう少し英語を使用しています

272
00:13:05,770 --> 00:13:06,390
読みやすいもの。

273
00:13:06,390 --> 00:13:09,348
だから、代わりに2、アンパサンド、あなた
文字通り "、単語を入力し、「と」、「または

274
00:13:09,348 --> 00:13:10,740
か否か。"

275
00:13:10,740 --> 00:13:13,420
あなたの中のあなたのif--のように
条件文、

276
00:13:13,420 --> 00:13:17,670
我々は前に見たことC言語でこの構文
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
繰り返しますが、ここで、Cは他のだろう
、Pythonは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
あなたはこの種の製造することができます
外側のwhileループとの事

283
00:13:42,350 --> 00:13:46,387
あなたが望んでいた場合、あなた
確かにありま​​せん。

284
00:13:46,387 --> 00:13:48,970
そして再び、あなたが望んでいた場合
配列の中の要素を印刷

285
00:13:48,970 --> 00:13:50,560
あなたは、このようにそれを行う可能性があります。

286
00:13:50,560 --> 00:13:52,927
楽しいことの一つ
しかしPythonの程度、

287
00:13:52,927 --> 00:13:54,760
あなたが必要としないということです
このパラダイムを使用するには、

288
00:13:54,760 --> 00:13:57,290
あなたが使用することができます
もう少しエレガントなもの。

289
00:13:57,290 --> 00:13:59,370
あなたは進でのために言います。

290
00:13:59,370 --> 00:14:02,980
>> そうではなく、ここに行くより
そして、インデックス上で動作します、

291
00:14:02,980 --> 00:14:05,630
して、引き出し
個々の要素、

292
00:14:05,630 --> 00:14:08,644
あなただけの、実際のために教えてくれ
要素の上に自分自身を実行します。

293
00:14:08,644 --> 00:14:11,060
そして、あなたがやっているものは何でも
内部直接操作することができます

294
00:14:11,060 --> 00:14:13,260
かなり楽しいです要素、上。

295
00:14:13,260 --> 00:14:16,710
そして、我々は、我々が使用します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
ありますが、Pythonの魔法を呼び出します
それが動作する理由は非常に技術的な理由。

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
私は右it--パッドを正当化したいのですが
この長さにスペースでそれアウト。

325
00:15:56,390 --> 00:16:00,584
>> 再び、これはです
us--もたらしドキュメント、

326
00:16:00,584 --> 00:16:03,500
私は実際にクリックスルーますthese--
これは私たちの第二のルールに私たちをもたらします

327
00:16:03,500 --> 00:16:06,990
Python--標準ライブラリのための
機能メソッドはあなたの友達です。

328
00:16:06,990 --> 00:16:09,880
そして、それは多くの場合、あなたの中の価値があります
探しに行くために私は疑問に思います

329
00:16:09,880 --> 00:16:12,310
ただ、これを行う事があれば。

330
00:16:12,310 --> 00:16:13,830
おそらくあります。

331
00:16:13,830 --> 00:16:15,990
あなたはパッドしたい場合
文字列アウト、あなたが希望の場合

332
00:16:15,990 --> 00:16:17,470
バックを利用したいです
文字列の半分、あなたが希望の場合

333
00:16:17,470 --> 00:16:20,370
場合、文字列を検索したいです
あなたは物事のカップルを粉砕したいのですが

334
00:16:20,370 --> 00:16:22,420
一緒に文字列を
それらの間のカンマで、

335
00:16:22,420 --> 00:16:24,640
標準ライブラリがあります
これを行うための機能。

336
00:16:24,640 --> 00:16:27,190
>> そして、それはあなたの人生を作ります
あなたがそれらを使用する場合より簡単に

337
00:16:27,190 --> 00:16:29,240
代わりにロールアウトの
自分ですべてのもの

338
00:16:29,240 --> 00:16:31,650
ここでのコードの5行で、
ここでのコードの5行。

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
そして、これはおそらくより実際にあります
Cプログラムよりも、私は言うだろう、読みやすいです

362
00:17:45,670 --> 00:17:46,780
あそこ。

363
00:17:46,780 --> 00:17:49,730
そうであるという事実は言うまでもありません
短いあなたは全体象を収めることができます

364
00:17:49,730 --> 00:17:52,250
その空間に我々が保存されてきました。

365
00:17:52,250 --> 00:17:56,270
>> もう一つは、これは実装です
マリオのそれは私が考えるドットC、です

366
00:17:56,270 --> 00:17:57,890
あなたはそれを得ることができ、最短です。

367
00:17:57,890 --> 00:18:00,757
これは、get int型を持っていませんが、
それハードコード10の値

368
00:18:00,757 --> 00:18:02,090
この1つはと同じ方法。

369
00:18:02,090 --> 00:18:06,080
判明している時で、この1クロック
84文字、Pythonは64であるのに対し。

370
00:18:06,080 --> 00:18:11,490
そして、これは無限に多いです
ここで、このゴミよりも読みやすいです。

371
00:18:11,490 --> 00:18:14,610
だから、Pythonは空間内でより効率的です。

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
我々は彼らを見て、彼らしていません
配列はCで行うように多くの動作

376
00:18:24,587 --> 00:18:27,170
だからここに、あなたはそれらを宣言することができ、
あなたが事にそれらを渡すことができます。

377
00:18:27,170 --> 00:18:29,810
今四角は保持しています
これらのものの配列。

378
00:18:29,810 --> 00:18:33,480
繰り返しますが、私たちは次のように宣言されていません
タイプが、私たちは今までそれを使用しようとすると、

379
00:18:33,480 --> 00:18:36,260
あなたが期待するもの
整数の配列に取り組みます

380
00:18:36,260 --> 00:18:40,130
上の仕事に行くされています
整数の配列。

381
00:18:40,130 --> 00:18:42,030
>> これは、ものです
あなたは絶対にできません

382
00:18:42,030 --> 00:18:47,390
ので、C言語で行います
それはとても手にあるメモリ、

383
00:18:47,390 --> 00:18:48,950
しかし、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
私が入れしたいです私は乗
この範囲内で、iの値ごと。

397
00:19:32,560 --> 00:19:35,770
右側のこの事は、別の可能性
アレイと、左側にこの事

398
00:19:35,770 --> 00:19:40,740
任意の特定の関数であることが
それが変数として私に取ります

399
00:19:40,740 --> 00:19:42,250
いくつかの結果を私を与えます。

400
00:19:42,250 --> 00:19:43,480
>> 私は何をするつもりだことはあります、
私が構築するつもりです

401
00:19:43,480 --> 00:19:46,200
これらの事のすべてです配列
この範囲内の各値のため。

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

403
00:19:48,960 --> 00:19:55,670
そして、これは、超短、超エレガントです
そしてそれが何を意味するのか非常に明確です。

404
00:19:55,670 --> 00:19:59,190
これは、のいずれかです
これは再びthings--

405
00:19:59,190 --> 00:20:03,860
1 of--の非常に象徴
理由のPythonのような人。

406
00:20:03,860 --> 00:20:05,900
あなたはプログラミングのような場合
このように、その後のPython

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
この範囲のiについて、我々は可能性
すべてのものを通してインデックス

412
00:20:20,940 --> 00:20:23,140
し、それらすべてをプリントアウト。

413
00:20:23,140 --> 00:20:24,650
そして、あなたはここでLEN表示されます。

414
00:20:24,650 --> 00:20:27,150
あなたが取得したいしている場合
配列の長さは、それです

415
00:20:27,150 --> 00:20:31,150
Pythonで非常に簡単に、
それは、C言語では非常に難しいです

416
00:20:31,150 --> 00:20:33,720
これは、正確にプリントアウトするだろう
あなたはそれを期待したいです。

417
00:20:33,720 --> 00:20:36,986
私たちは前に見てきたように、またできました、
配列内の要素を反復処理

418
00:20:36,986 --> 00:20:39,860
直接、その後、ちょうど話
それよりもむしろ率を有します

419
00:20:39,860 --> 00:20:43,190
バック配列するたびに。

420
00:20:43,190 --> 00:20:45,990
>> そして、これはあなたがすることができるものです。

421
00:20:45,990 --> 00:20:49,984
Cではだから、あなたが何かを求める場合
このように、印刷は言うだろう、

422
00:20:49,984 --> 00:20:51,150
それは、整数の配列です。

423
00:20:51,150 --> 00:20:53,456
それは間違いではありません
文字列は、私はそれを印刷することはできません。

424
00:20:53,456 --> 00:20:54,830
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
これは、あなたができることを意味します
これらlike--ことを行います

429
00:21:03,640 --> 00:21:06,530
ハードパーツのほとんどをしています
15のゲームで、書かれました

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
またはそうでなければPythonが混乱します。

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
あなたがしたいようリターンが正確に動作します
検索するCでの作業に期待、

446
00:21:52,004 --> 00:21:54,420
私たちはのようなものを設定することができます
this--ここにリスト内包です

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
falseを返す他に、trueを返します。

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
あなたは、同じアレイ上のlenを呼び出します
あなたは、文字列にlenを呼び出す方法。

464
00:22:49,020 --> 00:22:55,785
あなたは、文字列を並べ替えますmultiply--
あなたは配列をソートするのと同じ方法。

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

466
00:22:58,930 --> 00:23:00,740
>> ほとんどの標準機能
人々が構築していること、

467
00:23:00,740 --> 00:23:03,000
最もサードパーティ
ライブラリ人

468
00:23:03,000 --> 00:23:06,980
彼らがエミュレートしているので、ビルド
標準ライブラリの設計、

469
00:23:06,980 --> 00:23:10,190
あなたがしているすべてのものの上に呼び出すことができます
以下のように、なぜこれだけでは動作しません、

470
00:23:10,190 --> 00:23:12,800
Cで多かれ少なかれ、
それは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があります。ファイルI / Oががたくさんあり​​ます
それは複雑にささいなこと、

475
00:23:26,820 --> 00:23:29,890
そのためのリソースがあります
オンラインが、一言で言えば、

476
00:23:29,890 --> 00:23:33,010
あなたは、ファイルにオープンを呼び出します
特定のタイプと名前を付けます。

477
00:23:33,010 --> 00:23:37,640
それは読んだので、読み、
書き込み、書き込みまたは追加します。

478
00:23:37,640 --> 00:23:41,790
あなたは、特定の数の読み取り
文字が出て、あなたは、それらを印刷

479
00:23:41,790 --> 00:23:42,595
あなたはハローを得るでしょう！

480
00:23:42,595 --> 00:23:43,970
このファイルはこんにちは持っていたように私は、意味します！

481
00:23:43,970 --> 00:23:46,480
その中で、読むために呼び出し、
あなたが戻って何を得るでしょう

482
00:23:46,480 --> 00:23:49,520
すべて持っている文字列です
配列の残りの部分、

483
00:23:49,520 --> 00:23:50,860
またはファイルの残りのすべて。

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

485
00:23:53,805 --> 00:23:56,055
もう一度読んで呼び出した場合、
あなたは、ファイルの最後にしています

486
00:23:56,055 --> 00:23:58,138
ので、あなたが得ることはありません
何ので、あなたが閉じます。

487
00:23:58,138 --> 00:24:02,510
再び、このことはなく.closeあります
それはCでであるように、ファイルを閉じます

488
00:24:02,510 --> 00:24:07,190
fがあるので、これはより多くのまたは少ないです
fは閉鎖するためのもの、あなたはしたいと思います。

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
あなたは、特定の外に取得することができます
line--そのための組み込み関数があります。

492
00:24:17,870 --> 00:24:19,995
次のように記述したい場合
事は、あなたはこれを書くことができます。

493
00:24:19,995 --> 00:24:23,412
あなたは個人を書き出すしたい場合
刺され、あなたがそれらを書くことができます。

494
00:24:23,412 --> 00:24:25,620
そして、あなたは反復処理したい場合
ファイルの行の上

495
00:24:25,620 --> 00:24:29,557
個別に、私たちはより一枚で行ったように
数週間前に、あなたがにそれを行うことができます。

496
00:24:29,557 --> 00:24:32,140
ここでも、ほとんどのオブジェクトは、あなたがしたいです
反復処理できるようにしたいです

497
00:24:32,140 --> 00:24:33,780
それらを反復処理をサポートします。

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
>> で動作する第2のもの
いくつかのリストのような方法、およびいくつかの点で

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
あなたがないものを求める場合
それは、Pythonはエラーをスローします

539
00:26:39,880 --> 00:26:43,194
それはのあなたを終了します
どのようなプログラムあなたがしていました。

540
00:26:43,194 --> 00:26:45,360
これは、実際にプリントアウトします
それよりも多くの情報、

541
00:26:45,360 --> 00:26:49,110
それはよyou--指します
行を追加し、そう。

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
ここでは、繰り返し処理されています
同時に2つの事。

545
00:26:57,440 --> 00:27:03,040
そして、私たちは、キー、値でそれをやります、
しかし、これらのすべてをプリントアウト。

546
00:27:03,040 --> 00:27:06,300
>> そして、私たちはcast--したい場合
我々は実際にこれを実行した場合、

547
00:27:06,300 --> 00:27:10,840
我々はいくつかの問題のためを持っているでしょう
on--私たちはダビデで行った時、

548
00:27:10,840 --> 00:27:13,920
私たちはしなかった場合にはadd--ことができませんでした
最初の文字列にキャストし、

549
00:27:13,920 --> 00:27:17,802
私たちは、その配列を追加することができませんでした
文字列への文字列の。

550
00:27:17,802 --> 00:27:19,760
しかし、我々はそれをキャストした場合
文字列、我々は何かを得ます

551
00:27:19,760 --> 00:27:22,590
このように、これは多分あります
私たちは読みたいと思います。

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

553
00:27:27,000 --> 00:27:30,500
>> そして、これはスペルチェックです。

554
00:27:30,500 --> 00:27:32,460
私たちは物事を読み込みます。

555
00:27:32,460 --> 00:27:35,770
だから我々はで読むことができます
線として個々の単語。

556
00:27:35,770 --> 00:27:38,240
我々は最後切り落とします
事なので、コロンマイナス1

557
00:27:38,240 --> 00:27:41,651
we--最後をオフchompし
文字列の最後の文字。

558
00:27:41,651 --> 00:27:42,150
私たちは言うでしょう。

559
00:27:42,150 --> 00:27:44,730
[OK]を、それらのそれぞれが取得します
この辞書に挿入し、

560
00:27:44,730 --> 00:27:45,810
1の値にマッピングします。

561
00:27:45,810 --> 00:27:48,006
我々はしない、特に
その1気に、

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
このレートでは、我々は取得するつもりです
行わのpsetのすべて多かれ少なかれ。

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
改行文字が付いています
it--マイナス1の終わりに

585
00:28:53,900 --> 00:28:55,260
それらをオフに買い物をするだけです。

586
00:28:55,260 --> 00:28:59,549
そして、これは特に柔軟性があります
物事にインデックス付けの方法。

587
00:28:59,549 --> 00:29:01,590
ですから、文字列を持っている場合、
あなたはよく私は、たい

588
00:29:01,590 --> 00:29:05,340
文字3で開始する予定
私は最後まで行くつもりです。

589
00:29:05,340 --> 00:29:07,140
3コロンはあなたのためにそれを行います。

590
00:29:07,140 --> 00:29:10,570
あなたが似ている場合、私はで開始したいです
始まり、最後のマイナス1に移動

591
00:29:10,570 --> 00:29:12,400
文字、コロンマイナス1。

592
00:29:12,400 --> 00:29:14,940
そして、あなたはから行きたいと思った場合
最初のマイナスの三番目、

593
00:29:14,940 --> 00:29:16,570
あなたは3マイナス1を言うと思います。

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

595
00:29:19,464 --> 00:29:22,400
>> さらに、インデックスを作成する場合
背面から数えて物事に、

596
00:29:22,400 --> 00:29:24,470
マイナスの数字で、あなただけのインデックスです。

597
00:29:24,470 --> 00:29:26,980
そしてので、ここで、C
爆発または多分う

598
00:29:26,980 --> 00:29:31,090
あなたが持っていなかった他のメモリを養います
あなたが言うことができ、聞くにアクセスマイナス1

599
00:29:31,090 --> 00:29:34,104
最後が、1を意味
文字列内の文字。

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

601
00:29:36,950 --> 00:29:43,590
>> モジュールは、version--されています
C言語のライブラリへの類似体

602
00:29:43,590 --> 00:29:45,119
そして、たくさんのことのために有用です。

603
00:29:45,119 --> 00:29:46,910
たくさんのあなたがしたいです
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をグーグルこともできます。

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
2番目のリンクをしようとしています
ドキュメントのPython 3です。

616
00:30:19,260 --> 00:30:24,830
>> そして、私たちは見てファイルを書いた場合
特にthis--場合のように、私たちはしています

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
LENを呼び出すことによって、そう簡単にそれを得ることができます。

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
そして再び、あなたはそれをオンラインで見つけます
pythonでグーグルで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は配列を有する場合、
Pythonは配列を持っています。

644
00:31:42,370 --> 00:31:44,420
そのJSONは有する場合
連想配列、Pythonの

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
以下のような言葉と文字とで
、この辞書のようbytes--

655
00:32:21,990 --> 00:32:24,230
我々は、我々を書き留めることができ
それを書くことができます

656
00:32:24,230 --> 00:32:26,670
たJSONオブジェクトなど
文字通りこれらの文字。

657
00:32:26,670 --> 00:32:29,420
そして、それがために非常に簡単だろう
それを開くには、人間が開きますup--

658
00:32:29,420 --> 00:32:30,889
それを読んでください。

659
00:32:30,889 --> 00:32:33,180
我々は特にしなかった場合
それを読んで、人間を気に、

660
00:32:33,180 --> 00:32:38,490
私たちも、より効率的にパッケージ化することができ
後で解凍することができた形に

661
00:32:38,490 --> 00:32:42,860
またはそれは後に膨張させることができました。

662
00:32:42,860 --> 00:32:46,740
これは、80％を節約します
スペースあなたのオブジェクトが可能性があること

663
00:32:46,740 --> 00:32:49,390
あなたが手書きをそれらを書いた場合は取ります。

664
00:32:49,390 --> 00:32:52,384
>> あなたは非常に多くの漬物を呼び出します
同じway--ダンプ、ロード、

665
00:32:52,384 --> 00:32:53,800
そして、あなたはあなたの事を取り戻します。

666
00:32:53,800 --> 00:32:56,880
だから、非常に記述している場合
その短いPythonプログラム

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
ほとんどのPythonオブジェクト
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、OS、マルチプロセッシングで​​あり、
物事の基本的な主力のソート

674
00:33:19,510 --> 00:33:23,120
我々はと対話する必要があります
ファイルシステムのOS、

675
00:33:23,120 --> 00:33:28,764
、os.isfileようos.isdirectory、
os.makefile、これらはあなたの友達です。

676
00:33:28,764 --> 00:33:30,930
あなたが相互に作用する場合
特定のファイルタイプと、

677
00:33:30,930 --> 00:33:32,190
JSON、ピクルス、CSV。

678
00:33:32,190 --> 00:33:37,160
あなたがウェブと対話する場合
ページ、HTTPを取得するためのurllibでも

679
00:33:37,160 --> 00:33:41,370
ページ。 bs4-- BeautifulSoup--
それは、HTMLのための素晴らしいパーサです。

680
00:33:41,370 --> 00:33:47,047
あなたは、HTML上でそれを実行し、
今、このネストされた配列オブジェクトを取得し、

681
00:33:47,047 --> 00:33:49,630
あなたはオーバー横断することができます
ちょうど探しのように、のlookin

682
00:33:49,630 --> 00:33:52,380
幻想的である、で、である、場合。

683
00:33:52,380 --> 00:33:55,920
>> の束があります
running--用のパッケージ

684
00:33:55,920 --> 00:33:57,960
特に数学に強いことをやってます。

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
>> そして再び、少し取り
長くて申し訳ありませんwrite--します、

691
00:34:21,469 --> 00:34:26,199
実行するには少し時間がかかりますが、
実際のエンジニアが傾向があることを理由

692
00:34:26,199 --> 00:34:29,900
あなたがする傾向があるので、使用Pythonがあります
むしろ、コードを書いて、あなたの上にブロックされました

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
使用しようとしています
永遠に、Linuxでは、あなたのような

696
00:34:37,699 --> 00:34:41,900
あなたがいた場合はCでそれを書くかもしれません
計算エンジンを書くつもり、

697
00:34:41,900 --> 00:34:46,124
あなたが必要な場合は、Pythonで記述します
全ての数ヶ月、それを変更します。

698
00:34:46,124 --> 00:34:48,540
一部の人々はそれを書きます
C、彼らはそのようだから。

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

700
00:34:51,100 --> 00:34:54,050
>> だから我々は、インポートsysを見てきました
物事を取得する方法として、

701
00:34:54,050 --> 00:34:57,070
あなたのプログラムにモジュールを取得します。

702
00:34:57,070 --> 00:35:00,370
また、それを次のようにインポートすることができます
ニックネームは、あなたがしたいと思います。

703
00:35:00,370 --> 00:35:03,660
ここでもマルチプロセッシングは、痛みには、
毎回を入力するので、融点としてインポート

704
00:35:03,660 --> 00:35:05,900
そしてその後、いつでも
プログラムで使用し、

705
00:35:05,900 --> 00:35:09,732
あなたはmp.process、または何を持っていると言うでしょう。

706
00:35:09,732 --> 00:35:12,670
あなたは、インポートしたい場合
唯一の事、

707
00:35:12,670 --> 00:35:19,450
そうurllibでもと呼ばれるものがあります
要求は、あなたがちょうどそれをインポートすることができます。

708
00:35:19,450 --> 00:35:22,610
その後、あなたはとしてそれを呼び出しません
urllib.requestが、ちょうど要求として

709
00:35:22,610 --> 00:35:24,590
それ自体で。

710
00:35:24,590 --> 00:35:30,110
>> そして、あなたはすべてをインポートすることができます
あなたが好きな場合は、モジュールから。

711
00:35:30,110 --> 00:35:34,820
これは時折良いidea--ではありません
この通常は良い​​考え、実際に。

712
00:35:34,820 --> 00:35:39,080
どちらかといえば、あなたが原因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
で終わる名前の
there--すべての機能、

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
怠惰とMPを入力する必要はありません。

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
それとも周りのラッパーを書きます
あなたの目的に適合させるために。

732
00:36:28,900 --> 00:36:31,250
それは持っていた後だけです
あなたが失敗しただろうと

733
00:36:31,250 --> 00:36:35,529
上に行くとのことを考え始めますwrite--
どのように一緒にこの事を入れてしまうでしょう。

734
00:36:35,529 --> 00:36:37,320
ものがたくさんがあります
そこに、それはです

735
00:36:37,320 --> 00:36:39,180
最も有用なの一つ
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
私は我慢モジュールのすべて
おそらく1つの例外を除いて、前に、

746
00:37:11,960 --> 00:37:15,220
すべての中にプレインストールされてい
標準のPythonインストール。

747
00:37:15,220 --> 00:37:17,769
だからを呼び出して
、あなたに何をインポート

748
00:37:17,769 --> 00:37:19,852
その機能のすべてを持っています
あなたの指先で。

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

750
00:37:24,660 --> 00:37:28,920
>> これをラップするために開始し
話、いくつかあります

751
00:37:28,920 --> 00:37:32,770
私はブラックボックスとして残してきたこと
ソートの、オーバー練り

752
00:37:32,770 --> 00:37:37,217
私はきたいくつかの白い嘘があります
正直のためにことを告げ、

753
00:37:37,217 --> 00:37:39,050
私は、少なくとも時点でよ
ここでは、場合でも、私はしません

754
00:37:39,050 --> 00:37:43,980
それらのすべてにスーパー深く行きます
その技術的な説明。

755
00:37:43,980 --> 00:37:46,010
>> たくさんの
私は魔法と呼ばれてきたこと

756
00:37:46,010 --> 00:37:48,980
他の人が呼ぶものです
オブジェクト指向プログラミング。

757
00:37:48,980 --> 00:37:52,470
だからthings--がたくさんあり​​ます
そう変数は非常に頻繁ではありません

758
00:37:52,470 --> 00:37:56,540
に座って簡単なバイト、
メモリが、非常に複雑です

759
00:37:56,540 --> 00:38:01,910
内部を持つオブジェクト
機能とたくさんの状態について

760
00:38:01,910 --> 00:38:05,570
隠された変数、たくさんの
隠された機能が、どの

761
00:38:05,570 --> 00:38:09,480
あなたが文字列に変えることができます、
これはあなたがそれらを反復処理することができます。

762
00:38:09,480 --> 00:38:12,260
そして、あなたはwriting--ている場合
彼らその理由

763
00:38:12,260 --> 00:38:15,710
この豊富な機能のすべてを持っています
people--からです

764
00:38:15,710 --> 00:38:17,740
の建築家
language--行っています

765
00:38:17,740 --> 00:38:22,420
通じ、すべての標準のための
オブジェクト、機能に入れ

766
00:38:22,420 --> 00:38:26,970
これはこれがどのようにあると言って
これはどのように動作するように起こっています

767
00:38:26,970 --> 00:38:28,470
誰かがそれを反復処理したい場合。

768
00:38:28,470 --> 00:38:31,240
>> だから、すべて誰かがかもしれません
おそらく、反復処理したいです

769
00:38:31,240 --> 00:38:34,529
ロジックがで書かれています
手動でいる方法について

770
00:38:34,529 --> 00:38:36,070
そのオブジェクトを反復処理することになって。

771
00:38:36,070 --> 00:38:40,274
あなたはおそらくお勧めしますすべて
ロジックが書かれた文字列にダンプ。

772
00:38:40,274 --> 00:38:43,440
これは、場合に呼び出す関数です。
あなたが文字列にこれをダンプします。

773
00:38:43,440 --> 00:38:45,273
これは、なぜあなたができるです
呼び出すものにlenを、この

774
00:38:45,273 --> 00:38:49,900
あなたがのために呼び出すことができますなぜ、これがあります
なぜならば、すべての中で呼び出すことができます

775
00:38:49,900 --> 00:38:53,490
あなたがしたいだろうと、理由
彼らと一緒に運んでいるすべてのものを、

776
00:38:53,490 --> 00:38:55,380
そのための技術ノウハウ。

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

778
00:38:58,170 --> 00:39:00,432
>> これは、私は何かであります
スーパーに行くつもりはありません。

779
00:39:00,432 --> 00:39:03,140
しかし、リストにあるもののために微妙です
ループのC形式とは異なります、

780
00:39:03,140 --> 00:39:06,160
あなたは上のそれについてのすべてを読むことができます
インターネット、あなたは興味があるなら。

781
00:39:06,160 --> 00:39:08,930
すべてのダークサイドがあります
これ、私が述べたことを、

782
00:39:08,930 --> 00:39:10,359
ので、2つのものがあります。

783
00:39:10,359 --> 00:39:13,400
最初は、このオブジェクト指向ということです
プログラミングは、多くのオーバーヘッドを追加します

784
00:39:13,400 --> 00:39:16,080
ランダムなものに、あなたが終了します
より多くのメモリを使用してアップ。

785
00:39:16,080 --> 00:39:18,640
あなたはもう少しを使用して終了します
時間あなたはそれ以外の場合よりも大きくなります。

786
00:39:18,640 --> 00:39:21,300
other--が、より
これに狡猾なダークサイド

787
00:39:21,300 --> 00:39:24,047
物事がちょうど行動する場合、あります
あなたは彼らがしたいように

788
00:39:24,047 --> 00:39:27,130
あなたはスーパーハードと思うしなくても、
これはint型でなければならないかどうかについて

789
00:39:27,130 --> 00:39:29,713
または存在するかどうか
フロートは、それはこっちのことをあるかもしれません

790
00:39:29,713 --> 00:39:34,240
あなたはint型を生産するが、こっちます
思うが、彼らは残念always--よ、

791
00:39:34,240 --> 00:39:36,555
そのここにあるかもしれません
あなたはフロートを生成し、

792
00:39:36,555 --> 00:39:39,430
しかし、あなたは第二部に到達したとき
あなたのプログラムの、あなたが考えています、

793
00:39:39,430 --> 00:39:41,150
まあ、しかし、彼らはよ
いつも私にint型を渡します。

794
00:39:41,150 --> 00:39:43,608
そして、彼らがいない場合は、それが可能です
ことは、どこかに押し込ま

795
00:39:43,608 --> 00:39:47,600
あなたはインデックスにそれを使用しようとした場合
配列に、またはあなたが何を持っています。

796
00:39:47,600 --> 00:39:51,050
>> 本当のだから1
Cに関する有益なものです

797
00:39:51,050 --> 00:39:54,219
それは実際に考えるようにあなたを強制的に
ハードあなたがany--を行う前に

798
00:39:54,219 --> 00:39:56,510
あなたは任意の変数を持って来る前に、
存在するように、好きなもの

799
00:39:56,510 --> 00:39:58,764
この変数の型があります。

800
00:39:58,764 --> 00:40:00,680
そして、それは持っているために起こっています
すべての時間のためにそのタイプ。

801
00:40:00,680 --> 00:40:02,410
>> これは真実ではありません
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
そして、いくつかの決定は、1
他の場所での方法

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
これらの配列は、これらの辞書は、これら
オブジェクト、解放されることはありません飽きないfiles--これら。

830
00:41:34,114 --> 00:41:36,030
への呼び出しはありませんでした
この話のいずれかで無料。

831
00:41:36,030 --> 00:41:40,340
そして、それはので、C側にありました
私たちは、それらのものになったことはありません。

832
00:41:40,340 --> 00:41:42,220
>> しかし、Pythonの側に、自由がありません。

833
00:41:42,220 --> 00:41:43,970
物事は自動的に取得します
解放されたときのPython

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
それはPythonを伝えることは困難です
ことをあなたは今それを行っています。

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
そして、その理由の1人は、Cを使用すること
本当に重要なものをパフォーマンスのために、

844
00:42:13,510 --> 00:42:16,570
本当にこの能力であります
メモリが割り当てられているときに知っています

845
00:42:16,570 --> 00:42:19,369
それが解放されて、持っていたとき
言うのコントロールの多くは、

846
00:42:19,369 --> 00:42:20,910
私は私が必要とするよりも多くのメモリを使用していませんよ。

847
00:42:20,910 --> 00:42:23,632
どのものです
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
あなたが印刷している場合は、このことが起こりました
あなたがウェブserver--を実行している場合wen--

857
00:42:53,957 --> 00:42:55,390
>> 聴衆：[聞こえません]

858
00:42:55,390 --> 00:42:59,800
>> ROSS RHEINGANS-YOO：うん、あれば
あなたは、Webサーバーを実行しています

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
Webサーバーたびに行われた場合
エラー、あなたはその耐久性のある記録を持っていました。

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
>> 私は話をしなかった最後のもの
this--ことに私は約話をしませんでした

875
00:43:54,617 --> 00:43:57,700
本当に最初に腹立たしいことができます
時間は、あなたがこれらのエラーのいずれかが、

876
00:43:57,700 --> 00:44:00,491
第2および第3および第四
時間はあなたが1これらのエラーを持っています。

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
あなたタブ4を超えるのであれば、その後、
次の行は4つのスペースを持っています、

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
>> 実際には、Pythonはタブを扱います
石油や水のようなスペース。

884
00:44:23,610 --> 00:44:25,050
彼らはただ異なるものです。

885
00:44:25,050 --> 00:44:27,264
特にはありません
タブがある長さ、

886
00:44:27,264 --> 00:44:30,180
タブは8に等しいようなので、そうではありません
スペース、およびので、あなたがそれを回避するだろう

887
00:44:30,180 --> 00:44:30,860
そのように。

888
00:44:30,860 --> 00:44:34,110
、それが言うときに、好きなもの
私がよ空白のレベル、

889
00:44:34,110 --> 00:44:37,240
それは実際に探しています
スペースとタブのパターン。

890
00:44:37,240 --> 00:44:43,050
だから、最良の方法は、これに対処するには
常にスペースのすべての時間を使用することです。

891
00:44:43,050 --> 00:44:47,510
>> そして実際に、Cloud9で
IDEとCS50のIDE、

892
00:44:47,510 --> 00:44:50,610
あなたのTabキーを挿入
代わりに4つのスペース

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
あなたのプログラムと一行
すべてのタブの4つのスペースを持っていました、

897
00:45:02,655 --> 00:45:03,280
それが壊れます。

898
00:45:03,280 --> 00:45:07,800
そして、それが邪魔に破ります
それは実際には表示されません。

899
00:45:07,800 --> 00:45:12,390
実際のエラーものの
それはスローメッセージ

900
00:45:12,390 --> 00:45:15,610
新しいに関係しています
インデントここでは予想されません、

901
00:45:15,610 --> 00:45:18,700
or--それはインデントについて話している場合
それは間違っているように、それが見えます、

902
00:45:18,700 --> 00:45:22,090
それはおそらくです
タブスペースの問題があります。

903
00:45:22,090 --> 00:45:24,154
彼らはまだデバッグに腹立たしいしています。

904
00:45:24,154 --> 00:45:26,070
最大の全体
私はしませんでした。この話、

905
00:45:26,070 --> 00:45:29,740
それは本当にだからに着きます
複雑な、微妙な話題、

906
00:45:29,740 --> 00:45:34,760
そして、は、いずれかの操作を実行する必要はありませんでした
我々はこれまでにやったことの、

907
00:45:34,760 --> 00:45:37,140
タプルと呼ばれる概念です。

908
00:45:37,140 --> 00:45:41,280
彼らは多くのようがあります
あなたが変更することはできません配列。

909
00:45:41,280 --> 00:45:44,700
彼らはので、あらゆる場所に慣れます
彼らは物事の多くのために有用です

910
00:45:44,700 --> 00:45:46,300
アレイは、のために有用ではないこと。

911
00:45:46,300 --> 00:45:49,890
>> しかし、あなたは配列を作るしたい場合、および
あなた通訳を約束

912
00:45:49,890 --> 00:45:53,140
それを変更するつもりされることはありません
実際にthing--、変更したい場合は、

913
00:45:53,140 --> 00:45:56,800
あなたは新しいと新しいものを作ってあげます
it--それらの値はタプルです。

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
タプルを使用することができます
辞書の指標。

919
00:46:10,680 --> 00:46:15,010
あなたはとして配列を使用することはできません
辞書の指標。

920
00:46:15,010 --> 00:46:18,970
そして、なぜである、再び、技術的、
私はそれに実行するつもりはありません。

921
00:46:18,970 --> 00:46:23,140
>> 私は触れていないのpset
この講演で上pset6です。

922
00:46:23,140 --> 00:46:25,837
だからここにあなたがD '方法です
ここにA--実装

923
00:46:25,837 --> 00:46:28,140
どのようにPythonでpset6を実装します。

924
00:46:28,140 --> 00:46:32,680
心の中でPythonを維持
設計サイクル、最初のもの

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
>> 実際には、あなたがしたい場合
Apacheの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-M SimpleHTTPServer
ポートはそれを提供しています。

934
00:47:04,610 --> 00:47:07,190
また、インポートすることができます
単純なHTTPサーバ

935
00:47:07,190 --> 00:47:11,240
それがあれば多くの機能を持っています
あなたはそれをカスタマイズしたり、それを変更したいです、

936
00:47:11,240 --> 00:47:15,860
またはit--がそれを活用実行されます
独自のサーバーサービスを実行します。

937
00:47:15,860 --> 00:47:18,032
>> だから、一言で言えばPythonの。

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