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

2
00:00:05,426 --> 00:00:06,800
ROSS Rheingans-YOO: Oi, eu sou Ross.

3
00:00:06,800 --> 00:00:08,570
E este é um seminário CS50.

4
00:00:08,570 --> 00:00:12,100
Ele irá levá-lo de programação
em C para programação em Python.

5
00:00:12,100 --> 00:00:15,120
>> Python é uma linguagem de script.

6
00:00:15,120 --> 00:00:17,870
É em grande parte como C
na sintaxe, embora alguns

7
00:00:17,870 --> 00:00:20,390
dos detalhes técnicos de
como que a sintaxe é executado

8
00:00:20,390 --> 00:00:22,240
são ligeiramente diferentes.

9
00:00:22,240 --> 00:00:24,780
É menos poderoso do que C em alguns aspectos.

10
00:00:24,780 --> 00:00:28,130
É menos expressivo para
onde exatamente em seu computador

11
00:00:28,130 --> 00:00:30,030
memória é colocado para fora,
como ele é colocado para fora,

12
00:00:30,030 --> 00:00:32,030
quando fica liberdade, e
esses tipos de coisas.

13
00:00:32,030 --> 00:00:36,150
>> É mais útil do que C em alguns aspectos,
porque é mais fácil programar em.

14
00:00:36,150 --> 00:00:39,920
O idioma é, até certo
pessoas, mais intuitiva.

15
00:00:39,920 --> 00:00:44,820
E realmente, o objetivo é que
que seja mais rápido para programar

16
00:00:44,820 --> 00:00:46,490
e potencialmente mais lento para executar.

17
00:00:46,490 --> 00:00:48,198
>> Agora, se você pensar sobre
a quantidade de tempo

18
00:00:48,198 --> 00:00:50,514
você gastou em seu último
conjunto de problemas de escrita

19
00:00:50,514 --> 00:00:52,430
seu código contra a
quantidade de tempo que você gasta

20
00:00:52,430 --> 00:00:55,310
em seu último problema
definir a execução de seu código,

21
00:00:55,310 --> 00:00:58,300
você imaginaria que a linguagem
que foi duas vezes mais rápido para escrever,

22
00:00:58,300 --> 00:01:02,170
e duas vezes mais lento para executar, pode
ser uma melhoria sobre C em alguns aspectos.

23
00:01:02,170 --> 00:01:05,730
Certamente, quando você está tentando escrever
pequenos programas para fazer coisas pequenas,

24
00:01:05,730 --> 00:01:08,520
Python é uma linguagem útil de escolha.

25
00:01:08,520 --> 00:01:10,620
>> E no final da presente
seminário, eu espero que você

26
00:01:10,620 --> 00:01:12,950
ser capaz de fazer o
escolha em projetos futuros

27
00:01:12,950 --> 00:01:17,710
sobre qual a linguagem é
correta de usar, não a idéia

28
00:01:17,710 --> 00:01:21,405
uma língua que é mais
corrigir o tempo todo.

29
00:01:21,405 --> 00:01:23,030
Algumas coisas sobre o que o seminário é.

30
00:01:23,030 --> 00:01:25,910
Este seminário não se destina a
ensinar-lhe Python a partir do zero.

31
00:01:25,910 --> 00:01:28,310
Python é muito semelhante
a C, e eu estou supondo

32
00:01:28,310 --> 00:01:34,056
que você é um estudante CS50, ou alguém
com uma familiaridade semelhante com C.

33
00:01:34,056 --> 00:01:36,700
>> Se você é estudante CS50
em torno de problema ajuste 6,

34
00:01:36,700 --> 00:01:38,866
Então você vê um monte de
coisas em C, eu vou te dar

35
00:01:38,866 --> 00:01:40,740
as principais diferenças,
e algumas das coisas

36
00:01:40,740 --> 00:01:42,840
que fazem Python diferente
e especial e útil,

37
00:01:42,840 --> 00:01:45,256
mas eu não estou indo para ir para
o que é uma linguagem de programação

38
00:01:45,256 --> 00:01:46,920
e como escrever programas.

39
00:01:46,920 --> 00:01:49,820
No entanto, este seminário vai ensinar
você a escrever uma programas em Python

40
00:01:49,820 --> 00:01:52,310
se você é um daqueles poucos grupos.

41
00:01:52,310 --> 00:01:54,820
Mais uma vez vamos ver como
você poderia implementar psets--

42
00:01:54,820 --> 00:01:57,550
que deve ser em 1-6
Python-- e fornecer ponteiros

43
00:01:57,550 --> 00:02:00,322
a documentação oficial
para referência futura.

44
00:02:00,322 --> 00:02:03,030
A outra coisa que é importante
sobre como esta conversa é atribuído,

45
00:02:03,030 --> 00:02:05,360
este vídeo será
on-line, cortesia de CS50,

46
00:02:05,360 --> 00:02:07,550
para que você não deve se sentir como
você precisa para tomar notas.

47
00:02:07,550 --> 00:02:11,180
Você pode sempre ir para trás e olhar
para ele mais tarde como referência.

48
00:02:11,180 --> 00:02:13,340
Além disso, os diapositivos
estão disponíveis no momento

49
00:02:13,340 --> 00:02:16,480
neste local, que deveria
levá-lo fazer um doc Google.

50
00:02:16,480 --> 00:02:21,010
É uma versão ligeiramente abreviada
do que eu estou mostrando na tela.

51
00:02:21,010 --> 00:02:24,850
>> Uma ressalva cuidado antes
nós saltar, Python 3

52
00:02:24,850 --> 00:02:26,700
é uma língua diferente do Python 2.

53
00:02:26,700 --> 00:02:30,020
Eles parecem muito a mesma; existem
diferenças técnicas muito ligeiras

54
00:02:30,020 --> 00:02:32,530
que vai fazer com que programas
escrito em Python 2

55
00:02:32,530 --> 00:02:37,140
não ser capaz de ser executado
no ambiente Python 3.

56
00:02:37,140 --> 00:02:41,969
>> O aparelho vem com CS50
Python, por padrão ele usa Python 2.

57
00:02:41,969 --> 00:02:44,010
Você pode verificar isso
digitação em sua linha de comando

58
00:02:44,010 --> 00:02:51,310
--version python, que deve saída
2.7.6 no aparelho actual.

59
00:02:51,310 --> 00:02:53,580
Tente Python 3, que faz
funcionar no aparelho,

60
00:02:53,580 --> 00:02:58,500
se padrões Python para 2.X.Y, quer por
o aparelho ou em suas próprias máquinas.

61
00:02:58,500 --> 00:03:03,730
Você deve substituir Python 3 a qualquer momento
nesta conversa que escrevo Python.

62
00:03:03,730 --> 00:03:05,760
Se a sua máquina é
executando 2 por padrão, tipo

63
00:03:05,760 --> 00:03:09,770
Python 3, a fim de ser capaz de efectivamente
acompanhar e executar essas coisas.

64
00:03:09,770 --> 00:03:12,280
>> Além disso, eu vou apontá-lo
em recursos oficiais agora.

65
00:03:12,280 --> 00:03:16,082
docs.python.org/3--~~V cuidado
que isso é um 3 e não um 2--

66
00:03:16,082 --> 00:03:17,030
tem referências úteis.

67
00:03:17,030 --> 00:03:19,280
Tutorial irá levá-lo através
muito das mesmas coisas

68
00:03:19,280 --> 00:03:21,460
que eu estou fazendo agora, a não ser em forma de texto.

69
00:03:21,460 --> 00:03:23,725
Referência é útil como um
referência para a linguagem,

70
00:03:23,725 --> 00:03:26,100
ea Biblioteca Padrão dá
você algumas das extensões

71
00:03:26,100 --> 00:03:27,770
com uma funcionalidade adicional.

72
00:03:27,770 --> 00:03:31,300
>> Assim, um primeiro programa Python.

73
00:03:31,300 --> 00:03:34,410
À esquerda temos C padrão,
à direita, temos Python.

74
00:03:34,410 --> 00:03:36,780
Você pode ter reconhecido
este problema, que é

75
00:03:36,780 --> 00:03:40,760
um dos primeiro problema
CS50 em conjuntos, e estes

76
00:03:40,760 --> 00:03:42,677
resolvê-lo com a mesma solução.

77
00:03:42,677 --> 00:03:45,010
Agora, a razão que nós somos
olhando para estes lado a lado

78
00:03:45,010 --> 00:03:46,830
é assim que nós podemos olhar para
diferenças sintáticas.

79
00:03:46,830 --> 00:03:49,580
Um dos elefantes no quarto
que você pode ter notado direita

80
00:03:49,580 --> 00:03:56,350
fora do bastão, é que Python não tem
principal função embrulho em torno do código.

81
00:03:56,350 --> 00:03:59,170
Assim, em C, você escrever um monte de
arquivos, você ligá-los juntos,

82
00:03:59,170 --> 00:04:02,590
eo programa começa a executar
a essa coisa chamada int main.

83
00:04:02,590 --> 00:04:04,930
>> Em Python, você escreve um
arquivo que você, executar o arquivo,

84
00:04:04,930 --> 00:04:07,882
o programa inicia a execução
no topo do ficheiro.

85
00:04:07,882 --> 00:04:09,590
Por isso, vai começar
na parte superior do arquivo

86
00:04:09,590 --> 00:04:11,280
ir para baixo até encontrar outra coisa.

87
00:04:11,280 --> 00:04:14,440
Se ele encontrar uma definição de função,
ele não vai realmente executar esse código,

88
00:04:14,440 --> 00:04:15,940
ele simplesmente irá definir a função.

89
00:04:15,940 --> 00:04:18,459
Mas aqui, quando o primeiro
programa é n igual a 10,

90
00:04:18,459 --> 00:04:21,273
a primeira coisa que este programa
vai fazer é levar esse valor de 10

91
00:04:21,273 --> 00:04:24,120
e configurá-lo em uma variável chamada n.

92
00:04:24,120 --> 00:04:27,690
>> Falando dessa linha, um dos
outra coisas- sorry-- este

93
00:04:27,690 --> 00:04:31,040
significa que programas em C,
você vai escrevê-los,

94
00:04:31,040 --> 00:04:34,899
você vai fazê-los, que será
invocar alguns comandos clang,

95
00:04:34,899 --> 00:04:36,690
e então você vai executar um
resultando executável.

96
00:04:36,690 --> 00:04:41,030
Programas em Python, você corre o
texto file-- este pode mario.py

97
00:04:41,030 --> 00:04:44,900
ser este arquivo que eu mostrei
você-- você executar esse arquivo

98
00:04:44,900 --> 00:04:47,450
e você vai executar,
e o conteúdo do mesmo

99
00:04:47,450 --> 00:04:50,390
vai ser executado por
o interpretador Python.

100
00:04:50,390 --> 00:04:52,470
Você pode fazer isso em seu IDE.

101
00:04:52,470 --> 00:05:02,260
>> Então, se eu tenho um arquivo Olá,
que simplesmente tem este conteúdo.

102
00:05:02,260 --> 00:05:04,840
Este é na verdade o Python
2, não Python 3, por isso não

103
00:05:04,840 --> 00:05:06,600
se preocupar com a sintaxe para agora.

104
00:05:06,600 --> 00:05:14,230
Mas eu vou correr Python, em
hello.py, e ele é executado.

105
00:05:14,230 --> 00:05:18,890
>> Outra maneira que eu possa usar Python que
Eu não vou lidar com tanta coisa nesta conversa,

106
00:05:18,890 --> 00:05:21,840
é se eu apenas digitar Python, ele
me cai em um ambiente onde

107
00:05:21,840 --> 00:05:24,370
Eu posso alimentá-lo linha por linha Python.

108
00:05:24,370 --> 00:05:31,260
Então, aqui, se eu digitar
espaço de impressão 'Olá, mundo ".

109
00:05:31,260 --> 00:05:32,360
Escreva entrar.

110
00:05:32,360 --> 00:05:37,430
Ele vai me cuspir isso de volta os resultados
aquela linha indivíduo imediatamente.

111
00:05:37,430 --> 00:05:38,470
>> Isto é pode ser útil.

112
00:05:38,470 --> 00:05:40,700
Nesta palestra vou fazer as coisas em slides.

113
00:05:40,700 --> 00:05:43,940
E então você vai ser capaz de seguir
ao longo de ambos aqui, ou por escrito

114
00:05:43,940 --> 00:05:45,725
arquivos reais e, em seguida, executá-los.

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

116
00:05:48,340 --> 00:05:50,995
>> Mas, voltando ao presente
código, outra coisa

117
00:05:50,995 --> 00:05:53,230
que você pode ter
noticed-- bem, há

118
00:05:53,230 --> 00:05:55,980
duas coisas que você pode
aviso sobre esses blocos.

119
00:05:55,980 --> 00:05:59,280
O primeiro, um pouco mais mundano, é que
o Python não tem ponto e vírgula final.

120
00:05:59,280 --> 00:06:02,630
>> Semicolons são opcionais em todos os lugares
e inofensivo em todos os lugares.

121
00:06:02,630 --> 00:06:03,722
Você pode adicioná-los.

122
00:06:03,722 --> 00:06:06,430
Ele pode fazer as pessoas que escrevem
Python para uma risadinha de estar em você

123
00:06:06,430 --> 00:06:08,860
atrás das costas, porque
eles não são necessários.

124
00:06:08,860 --> 00:06:13,497
Eles são frequentemente um sinal de que está sendo realizado durante
de C. Os designers da linguagem

125
00:06:13,497 --> 00:06:16,580
sinto que é mais claro desta forma
e que não é necessário declarar

126
00:06:16,580 --> 00:06:18,700
cada vez que você terminar uma linha.

127
00:06:18,700 --> 00:06:21,799
>> Outra coisa estranha sobre este n
é que ele não tem um tipo de anexo.

128
00:06:21,799 --> 00:06:24,590
Uma das peças mágicas de Python--
e eu vou chamá-lo de mágica,

129
00:06:24,590 --> 00:06:26,381
mas há muito
motivos técnicos para isso

130
00:06:26,381 --> 00:06:28,560
um dos works--
peças mágicas de Python

131
00:06:28,560 --> 00:06:32,700
é que as variáveis ​​podem expandir ou
encolher para conter todos os dados

132
00:06:32,700 --> 00:06:34,530
tipos que você gostaria que eles.

133
00:06:34,530 --> 00:06:35,580
>> Portanto, esta é a 10.

134
00:06:35,580 --> 00:06:40,060
Se mais tarde para baixo Eu atribuído a este
n 0.5, levaria que 0,5.

135
00:06:40,060 --> 00:06:43,770
Não importa o que é um int aqui e
flutuar lá, qualquer coisa que usa este n

136
00:06:43,770 --> 00:06:47,057
vai, mais ou menos, ser capaz de engole
junto se ele fica um desses.

137
00:06:47,057 --> 00:06:49,640
A menos que haja algum muito real
razão pela qual não pode usar os dados

138
00:06:49,640 --> 00:06:52,170
digite que n tem atualmente,
em que ponto ele vai ficar

139
00:06:52,170 --> 00:06:54,490
entalado e lançar um erro,
e esses tipos de coisas.

140
00:06:54,490 --> 00:06:57,050
>> Mas aqui, Python
realmente não se importa com o que

141
00:06:57,050 --> 00:06:59,140
que é que eu vou ficar neste
sentença, como, você quer isso?

142
00:06:59,140 --> 00:06:59,840
Esta coisa em que?

143
00:06:59,840 --> 00:07:00,640
Sim, é um tipo de coisa.

144
00:07:00,640 --> 00:07:01,810
Vou colocá-lo no final.

145
00:07:01,810 --> 00:07:04,740
Vai ser um problema mais tarde, se
alguém que quer usar esse efeito

146
00:07:04,740 --> 00:07:05,710
não pode lidar com isso.

147
00:07:05,710 --> 00:07:08,500
Esta é uma das principais
diferenças entre Python e C

148
00:07:08,500 --> 00:07:10,790
que torna mais fácil para
escrever grandes programas em C

149
00:07:10,790 --> 00:07:15,120
e torna mais fácil para escrever
programa muito pequeno Python.

150
00:07:15,120 --> 00:07:19,564
>> A sintaxe para não é muito
diferente no que faz.

151
00:07:19,564 --> 00:07:21,480
É um pouco diferente
em como ele é expresso.

152
00:07:21,480 --> 00:07:25,370
Portanto, este é um muito, o que é chamado
Pythonic, modo de escrevê-lo.

153
00:07:25,370 --> 00:07:28,969
para linha na gama (N), esta é a
gama de números de 0 a N,

154
00:07:28,969 --> 00:07:31,010
inclusive na parte inferior
e exclusiva no topo.

155
00:07:31,010 --> 00:07:34,790
Portanto, é de 0 a n-1, que é
exatamente o que o código C está fazendo,

156
00:07:34,790 --> 00:07:38,690
exceto que é muito mais fácil
olhar para talvez.

157
00:07:38,690 --> 00:07:42,710
>> O bloco em causa é
não partiu por chaves,

158
00:07:42,710 --> 00:07:44,540
em vez disso ele é definido off
por este recuo.

159
00:07:44,540 --> 00:07:47,580
Então, todas essas linhas são
quatro espaços para a direita,

160
00:07:47,580 --> 00:07:50,410
ou como sobre uma largura de elefante.

161
00:07:50,410 --> 00:07:54,570
E esses são os que são
vai ser executado no presente para.

162
00:07:54,570 --> 00:07:57,020
Se eu estragar a
recuo sobre isso e eu

163
00:07:57,020 --> 00:08:01,420
empurre que volta para impressão
o recuo inicial,

164
00:08:01,420 --> 00:08:04,320
que vai deixar a impressão de loop.

165
00:08:04,320 --> 00:08:08,560
Em contraste com C, onde eu realmente aqui
precisa mover essa cinta fechada ao redor.

166
00:08:08,560 --> 00:08:11,820
>> Isso significa que você não obter erros
que saltam em você porque você

167
00:08:11,820 --> 00:08:13,580
colocar uma cinta no lugar errado.

168
00:08:13,580 --> 00:08:16,460
Isso significa que você obter erros
que saltam em você porque você

169
00:08:16,460 --> 00:08:17,620
recuadas uma linha errada.

170
00:08:17,620 --> 00:08:19,290
Por isso, faz recortes super cuidadosa.

171
00:08:19,290 --> 00:08:22,123
Esperemos que você estava sendo super-
cuidado com o seu recuo de qualquer maneira,

172
00:08:22,123 --> 00:08:25,300
e por isso este não é que
muito mais de um fardo.

173
00:08:25,300 --> 00:08:28,762
>> Mas uma regra básica para Python,
e nós vamos ter um par destes

174
00:08:28,762 --> 00:08:30,970
que nós vamos passar por meio
o curso da conversa,

175
00:08:30,970 --> 00:08:33,840
é tentar sintaxe naturais
antes de olhar qualquer coisa.

176
00:08:33,840 --> 00:08:37,610
Portanto, esta sintaxe, para
este número no intervalo,

177
00:08:37,610 --> 00:08:41,460
é muito distinto em termos de estilo.

178
00:08:41,460 --> 00:08:45,260
Muitas coisas em Python
vamos ver tomar este formulário.

179
00:08:45,260 --> 00:08:47,420
>> E então se você vir para cima
com um novo objeto que você

180
00:08:47,420 --> 00:08:50,870
acho que você deve ser capaz de
iterar sobre isso, neste formato,

181
00:08:50,870 --> 00:08:53,720
Acontece que, provavelmente,
suporta esse formato.

182
00:08:53,720 --> 00:08:56,990
Nós não estamos indo para ir no fundo de super-
os motivos técnicos pelos quais isso é verdade.

183
00:08:56,990 --> 00:09:00,167
>> Mas é uma intuição útil ter
quando você está se aproximando programas Python,

184
00:09:00,167 --> 00:09:01,750
que essa coisa é só ir para o trabalho.

185
00:09:01,750 --> 00:09:03,020
Experimente.

186
00:09:03,020 --> 00:09:06,480
Arrancar a linha de comando
Interpreter, ver se funciona,

187
00:09:06,480 --> 00:09:09,827
seguir em frente com as coisas, antes de
ainda precisa abrir o Google e dizer:

188
00:09:09,827 --> 00:09:11,660
o que é a sintaxe para
esta coisa em particular?

189
00:09:11,660 --> 00:09:14,740
Lotes de Python que você poderia
descobrir apenas tentando.

190
00:09:14,740 --> 00:09:19,005
>> Este caso é ainda mais semelhante
para C, em seguida, as fors são.

191
00:09:19,005 --> 00:09:20,380
Note que não há nenhuma parênteses.

192
00:09:20,380 --> 00:09:23,490
Os parênteses são, novamente,
inofensivo, mas desnecessário.

193
00:09:23,490 --> 00:09:25,750
Há dois pontos na extremidade
assim como o de loops,

194
00:09:25,750 --> 00:09:30,800
e, novamente, os blocos são relativos
recuado em vez de detonar por chaves.

195
00:09:30,800 --> 00:09:33,080
Este resto é para o original
nível de recuo,

196
00:09:33,080 --> 00:09:35,930
e seu bloco em causa recuado novamente.

197
00:09:35,930 --> 00:09:41,720
Aqueles trabalhos exatamente como eles fazem em C.

198
00:09:41,720 --> 00:09:44,520
>> Isso é realmente muito muito mesmo.

199
00:09:44,520 --> 00:09:49,430
Mais uma vez, impressão perde um personagem
fora de printf Você passa algumas cordas.

200
00:09:49,430 --> 00:09:51,520
Acontece cordas
tanto pode ser marcada fora

201
00:09:51,520 --> 00:09:53,562
por aspas simples ou duplas.

202
00:09:53,562 --> 00:09:55,270
Não há nenhuma diferença,
excepto que dentro

203
00:09:55,270 --> 00:09:57,722
de aspas simples você pode usar
aspas duplas com abandono,

204
00:09:57,722 --> 00:09:59,430
em vez de ter de
escapar todos eles.

205
00:09:59,430 --> 00:10:01,480
E dentro de aspas duplas, você
pode usar aspas simples com abandono

206
00:10:01,480 --> 00:10:02,420
sem ter que escapar deles.

207
00:10:02,420 --> 00:10:04,253
Se você queria misturar
-los, você pode certamente

208
00:10:04,253 --> 00:10:06,100
olhar para cima on-line como fazer isso.

209
00:10:06,100 --> 00:10:09,581
>> Você vai notar que aqui,
Eu já passou no final = esta coisa.

210
00:10:09,581 --> 00:10:12,580
Este é um exemplo de um opcional
argumento, que é uma daquelas coisas

211
00:10:12,580 --> 00:10:14,990
que suporta Python que
torna bastante útil.

212
00:10:14,990 --> 00:10:18,240
Assim impressão realmente tem um monte de
argumentos, que são geralmente

213
00:10:18,240 --> 00:10:20,140
definida para o seu padrão
valor, mas aqui eu tenho

214
00:10:20,140 --> 00:10:21,924
decidiu substituir o chamado final.

215
00:10:21,924 --> 00:10:24,340
A razão que eu tenho que
substituí-lo com uma seqüência vazia

216
00:10:24,340 --> 00:10:26,756
é que de impressão em Python, por
padrão, imprime uma nova linha

217
00:10:26,756 --> 00:10:28,630
depois a coisa que você disse isso também.

218
00:10:28,630 --> 00:10:31,462
>> Portanto, este hash é realmente indo para
imprimir um hash em uma nova linha.

219
00:10:31,462 --> 00:10:34,670
E se eu não quiser hash para imprimir
uma nova linha após isso, então eu tenho que dizer

220
00:10:34,670 --> 00:10:35,340
não imprimir um.

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

222
00:10:37,980 --> 00:10:43,690
Mas, ainda assim, a uma última coisa que
este programa está em falta que se tem é

223
00:10:43,690 --> 00:10:44,960
uma inclusão no topo.

224
00:10:44,960 --> 00:10:48,120
Imprimir é cozida em Python então basicamente
que não há nenhum cabeçalho ou módulo

225
00:10:48,120 --> 00:10:49,869
que você precisa
incluem, embora se queria

226
00:10:49,869 --> 00:10:52,029
para incluir outras coisas
em um script Python,

227
00:10:52,029 --> 00:10:55,320
Eu faria isso em um format-- muito semelhante
as palavras são apenas um pouco diferente.

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

229
00:10:58,840 --> 00:11:01,360
>> Eu mencionei que nós
não precisa de um principal aqui,

230
00:11:01,360 --> 00:11:03,372
porque o Python começa
execução no topo.

231
00:11:03,372 --> 00:11:05,080
Se eu queria envolver
isto em função, I

232
00:11:05,080 --> 00:11:07,667
poderia fazê-lo como eu isto--
diria def nome da função,

233
00:11:07,667 --> 00:11:10,500
argumentos pode entrar aqui e nós vamos
ver alguns dos mais tarde, dois pontos,

234
00:11:10,500 --> 00:11:13,040
e depois, novamente,
Toda bloco partiu

235
00:11:13,040 --> 00:11:16,810
é o que é o operacional
bloquear para essa função.

236
00:11:16,810 --> 00:11:18,560
Portanto, esta é a definição
da função.

237
00:11:18,560 --> 00:11:21,587
E há uma declaração, em seguida, para baixo
aqui, eu só posso chamar a função.

238
00:11:21,587 --> 00:11:23,920
E, novamente, o programa
intérprete, começando no topo,

239
00:11:23,920 --> 00:11:25,280
vai ver isso é a definição.

240
00:11:25,280 --> 00:11:27,960
Ele não será executado até que este
chegar aqui, e então é como, oh

241
00:11:27,960 --> 00:11:30,860
agora você chamou, eu
acho que eu deveria executá-lo.

242
00:11:30,860 --> 00:11:33,850
>> Uma coisa que é muito comum
ver em arquivos Python,

243
00:11:33,850 --> 00:11:36,700
especialmente arquivos Python que
são liberados para o público

244
00:11:36,700 --> 00:11:41,650
e desenvolvido e desenvolvido e por--
mantida, é algo desta forma.

245
00:11:41,650 --> 00:11:44,540
Isto é assim porque basically--
Python, você começar no topo

246
00:11:44,540 --> 00:11:50,310
e então você executar até o fundo,
Eu se eu só tinha Mario chamou aqui,

247
00:11:50,310 --> 00:11:54,190
em seguida, a qualquer momento eu incluído esse arquivo em
outro arquivo, porque eu queria usar

248
00:11:54,190 --> 00:11:58,580
é função de Mario, que seria outro arquivo
também têm esta chamada para Mario nele.

249
00:11:58,580 --> 00:12:01,000
E quando eu corri esse arquivo,
ele chamaria Mario.

250
00:12:01,000 --> 00:12:04,520
>> Portanto, é possível que eu só
deseja executar este se eu realmente

251
00:12:04,520 --> 00:12:07,290
executado este arquivo em particular.

252
00:12:07,290 --> 00:12:11,520
E assim que eu posso quebrar isso em um
idioma como este, onde eu digo,

253
00:12:11,520 --> 00:12:14,820
se o nome desta execução
ambiente é o principal,

254
00:12:14,820 --> 00:12:16,200
então eu quero fazer essas coisas.

255
00:12:16,200 --> 00:12:18,710
Caso contrário, alguém pode
use-- incluir o meu function--

256
00:12:18,710 --> 00:12:22,510
meu arquivo, e apenas para obter
o acesso a essas funções

257
00:12:22,510 --> 00:12:25,552
sem ter que executar as coisas
que eu quero executar neste arquivo.

258
00:12:25,552 --> 00:12:27,260
Isto é, de novo, opcional
mas muito comum.

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

260
00:12:30,450 --> 00:12:33,840
>> Essas coisas são entirely-- são
exatamente o mesmo entre C e Python,

261
00:12:33,840 --> 00:12:35,100
certamente em três.

262
00:12:35,100 --> 00:12:38,610
Eu acho que em 2, o operador de divisão
às vezes dá-lo de volta quando flutua

263
00:12:38,610 --> 00:12:41,450
você operado ints, e quer
você queria que você ou não.

264
00:12:41,450 --> 00:12:44,777
Mas mais, menos, e os tempos
funcionam exatamente como você esperaria,

265
00:12:44,777 --> 00:12:46,110
exceto ao longo de pouco mais tipos.

266
00:12:46,110 --> 00:12:49,740
Então você pode multiplicar por carros alegóricos
ints, e esses tipos de coisas.

267
00:12:49,740 --> 00:12:52,480
>> conjunto funciona exatamente da mesma.

268
00:12:52,480 --> 00:12:54,310
Você pode usar dois sinais de igual.

269
00:12:54,310 --> 00:12:59,000
inequals-- maior que, menor
que, esses tipos de coisas-

270
00:12:59,000 --> 00:13:02,580
têm os significados que
você está familiarizado com eles.

271
00:13:02,580 --> 00:13:05,770
>> Onde C usa esses operadores,
Python usa um pouco mais Inglês

272
00:13:05,770 --> 00:13:06,390
aqueles legível.

273
00:13:06,390 --> 00:13:09,348
Então, ao invés de dois, ampersands, você
literalmente digitar a palavra "e", "ou"

274
00:13:09,348 --> 00:13:10,740
ou não."

275
00:13:10,740 --> 00:13:13,420
Como em seu se-- em sua
instruções condicionais,

276
00:13:13,420 --> 00:13:17,670
Vimos anteriormente que esta sintaxe em C
corresponde a esta sintaxe em Python.

277
00:13:17,670 --> 00:13:21,010
E há não muito diferente
lá, com exceção de um pouco

278
00:13:21,010 --> 00:13:24,780
de pontuação em torno dos lados.

279
00:13:24,780 --> 00:13:28,890
Mais uma vez, em que C seria mais
se, Python usa elif,

280
00:13:28,890 --> 00:13:33,960
mas estes são principalmente
mudanças de nível de superfície.

281
00:13:33,960 --> 00:13:38,450
>> Iteração como este é muitas vezes
escrita neste idioma em Python.

282
00:13:38,450 --> 00:13:42,350
Você pode fabricar este tipo de
coisa com um loop while no exterior

283
00:13:42,350 --> 00:13:46,387
se você quiser, mas você
certamente não tem que.

284
00:13:46,387 --> 00:13:48,970
E, novamente, se você queria o
imprimir elementos de uma matriz

285
00:13:48,970 --> 00:13:50,560
você pode fazê-lo desta maneira.

286
00:13:50,560 --> 00:13:52,927
Uma das coisas divertidas
sobre Python, porém,

287
00:13:52,927 --> 00:13:54,760
é que você não precisa
para usar este paradigma,

288
00:13:54,760 --> 00:13:57,290
e você pode usar um
um pouco mais elegante.

289
00:13:57,290 --> 00:13:59,370
Você diz que para um em ary.

290
00:13:59,370 --> 00:14:02,980
>> Então, ao invés de ir aqui
e correndo ao longo dos índices,

291
00:14:02,980 --> 00:14:05,630
e, em seguida, puxando para fora
elementos individuais,

292
00:14:05,630 --> 00:14:08,644
você dizer a verdade apenas para a
atropelar os próprios elementos.

293
00:14:08,644 --> 00:14:11,060
E então o que você está fazendo
interior pode operar diretamente

294
00:14:11,060 --> 00:14:13,260
sobre os elementos, o que é muito divertido.

295
00:14:13,260 --> 00:14:16,710
E nós vamos see-- usaremos
que idioma novo e de novo

296
00:14:16,710 --> 00:14:18,050
como nós caminhamos através de código.

297
00:14:18,050 --> 00:14:20,091
>> Isto é, de novo, um exemplo
de algo que eu vou

298
00:14:20,091 --> 00:14:23,300
Python chamar mágica, embora existam
razões técnicas muito porque trabalha.

299
00:14:23,300 --> 00:14:26,340
E há coisas que técnicos
precisa ser verdade sobre array em ordem

300
00:14:26,340 --> 00:14:28,340
para este trabalho nos bastidores.

301
00:14:28,340 --> 00:14:31,390
A coisa é que a maioria dos tipos
que você esperaria que isso funcione

302
00:14:31,390 --> 00:14:36,610
ter tido esta implementada para
na língua embutido.

303
00:14:36,610 --> 00:14:40,030
>> Outra coisa que seria bom
se isso funcionou em todas as línguas,

304
00:14:40,030 --> 00:14:45,460
mas existem algumas razões por que não pode,
imprimir esta string vezes este número.

305
00:14:45,460 --> 00:14:48,860
Acontece que em Python, isso faz exatamente
o que você gostaria, que é apenas diversão,

306
00:14:48,860 --> 00:14:52,840
e significa que nós podemos, na verdade,
reduzir este programa, novamente mario.c.

307
00:14:52,840 --> 00:14:57,150
Em vez de iteração muito, nós podemos
apenas dizer, eu quero um pouco número de espaços,

308
00:14:57,150 --> 00:15:01,120
Eu quero o número de hashes,
e alguns hash no final.

309
00:15:01,120 --> 00:15:02,640
E, novamente, nós usamos este formato.

310
00:15:02,640 --> 00:15:05,340
>> Aqui, nós estamos passando em
uma variável dessa maneira.

311
00:15:05,340 --> 00:15:08,050
Mais uma vez, nós não precisamos de dizer
que tipo de variável é,

312
00:15:08,050 --> 00:15:11,322
ea única vez que vai
obter erros é em tempo de execução.

313
00:15:11,322 --> 00:15:13,030
Quando alguém tenta
para passar algo em,

314
00:15:13,030 --> 00:15:14,860
ele vai vir para a função muito bem.

315
00:15:14,860 --> 00:15:18,240
Se calçar aqui, porque este não é o
coisa que você pode criar intervalos mais,

316
00:15:18,240 --> 00:15:22,100
Vou pegar um erro de execução lá,
e eu vou ter de depurá-lo dessa forma.

317
00:15:22,100 --> 00:15:25,050
Mas, entretanto, eu não tenho
de ser muito cuidadosos sobre o que

318
00:15:25,050 --> 00:15:32,800
é passado em, tanto tempo como no real
execução tudo funciona muito limpa.

319
00:15:32,800 --> 00:15:35,080
>> Eu poderia até fazer isso
um pouco mais limpo

320
00:15:35,080 --> 00:15:41,770
usando uma função interna, em particular,
em cordas, o que é justificado à direita.

321
00:15:41,770 --> 00:15:45,250
Esta é apenas uma função útil
mentindo ao redor da biblioteca.

322
00:15:45,250 --> 00:15:47,660
É na documentação
se você ir e olhar para ele.

323
00:15:47,660 --> 00:15:51,650
E eu digo, bem, eu vou ter
essa seqüência, algum número de hashes,

324
00:15:51,650 --> 00:15:56,390
e eu gostaria de justificar direito pad ele--
-lo com espaços para ser esse comprimento.

325
00:15:56,390 --> 00:16:00,584
>> Novamente, isto é na
documentação, que traz US--

326
00:16:00,584 --> 00:16:03,500
Na verdade, eu vou clicar these--
o que nos leva à nossa segunda regra

327
00:16:03,500 --> 00:16:06,990
para a biblioteca padrão Python--
métodos de função são seus amigos.

328
00:16:06,990 --> 00:16:09,880
E é muitas vezes vale o seu tempo
para ir à procura de eu me pergunto

329
00:16:09,880 --> 00:16:12,310
se há uma coisa que só faz isso.

330
00:16:12,310 --> 00:16:13,830
Há provavelmente é.

331
00:16:13,830 --> 00:16:15,990
Se você gostaria de almofada
uma seqüência de caracteres, se você

332
00:16:15,990 --> 00:16:17,470
gostaria de aproveitar a volta
metade de uma corda, se você

333
00:16:17,470 --> 00:16:20,370
gostaria de pesquisar através de uma corda, se
você gostaria de esmagar um par de coisas

334
00:16:20,370 --> 00:16:22,420
com uma corda
com vírgulas entre eles,

335
00:16:22,420 --> 00:16:24,640
existem biblioteca padrão
funções para fazer isso.

336
00:16:24,640 --> 00:16:27,190
>> E isso torna a sua vida
mais fácil se você usá-los

337
00:16:27,190 --> 00:16:29,240
em vez de rolar para fora
tudo por conta própria

338
00:16:29,240 --> 00:16:31,650
em cinco linhas de código aqui,
cinco linhas de código aqui.

339
00:16:31,650 --> 00:16:34,430
Isso realmente começa em
adicionar até tempo real.

340
00:16:34,430 --> 00:16:37,430
>> Uma das coisas interessantes
sobre como este é chamado.

341
00:16:37,430 --> 00:16:39,980
Você vai notar que há uma coisa de ponto.

342
00:16:39,980 --> 00:16:43,490
Eu tenho algum objeto à esquerda,
e, em seguida, liguei para uma função um ponto.

343
00:16:43,490 --> 00:16:49,780
Este é um dos paradigmas que Python
usa métodos para a fixação de objectos.

344
00:16:49,780 --> 00:16:54,410
Vamos falar sobre o que este
é muito brevemente, no final,

345
00:16:54,410 --> 00:16:58,510
mas sabemos que podemos ambos operam em
coisas por tomar essa coisa dizendo dot

346
00:16:58,510 --> 00:17:01,690
o que quer, ou pelo telefone
uma função que leva

347
00:17:01,690 --> 00:17:04,339
esse objeto e alguns outros argumentos.

348
00:17:04,339 --> 00:17:07,450
>> Então, essas são as duas maneiras que
as coisas são feitas em Python.

349
00:17:07,450 --> 00:17:09,780
E se um determinado
funcionalidade é implementada

350
00:17:09,780 --> 00:17:14,230
neste estilo ou este
estilo é algo que você

351
00:17:14,230 --> 00:17:19,990
deve olhar para cima até conseguir um jeito
para os quais um que é provável que se enquadram.

352
00:17:19,990 --> 00:17:22,660
Há um mais ou menos coesa
filosofia por trás Python

353
00:17:22,660 --> 00:17:24,930
que absorvem principalmente
escrevendo um monte nele.

354
00:17:24,930 --> 00:17:28,190
Em algum ponto, o que um desses
algo vai ser implementado como

355
00:17:28,190 --> 00:17:29,470
torna-se natural.

356
00:17:29,470 --> 00:17:32,420
Por enquanto, é apenas algo
você aprende como você descobrir

357
00:17:32,420 --> 00:17:34,140
cada coisa individual.

358
00:17:34,140 --> 00:17:36,420
>> Então biblioteca padrão
funções são seus amigos,

359
00:17:36,420 --> 00:17:41,320
e elas permitem que você escreva coisas que
ocupar esse espaço muito em breve,

360
00:17:41,320 --> 00:17:42,040
realmente elegante.

361
00:17:42,040 --> 00:17:45,670
E este é, na verdade, provavelmente mais
legível, eu diria, do que o programa C

362
00:17:45,670 --> 00:17:46,780
bem ali.

363
00:17:46,780 --> 00:17:49,730
Para não mencionar o fato de que é tão
suma, você pode caber um elefante inteiro

364
00:17:49,730 --> 00:17:52,250
no espaço que temos guardado.

365
00:17:52,250 --> 00:17:56,270
>> Outra coisa, esta é uma implementação
de mario que é ponto C, que eu acho que

366
00:17:56,270 --> 00:17:57,890
é o mais curto que você pode obtê-lo.

367
00:17:57,890 --> 00:18:00,757
Ele não tem o get int, mas
ele rígido códigos o valor de 10

368
00:18:00,757 --> 00:18:02,090
da mesma maneira que esta não.

369
00:18:02,090 --> 00:18:06,080
Acontece que este aqui relógios em
84 caracteres, ao passo que Python é de 64.

370
00:18:06,080 --> 00:18:11,490
E isso é infinitamente mais
legível do que esse lixo aqui.

371
00:18:11,490 --> 00:18:14,610
Assim Python é mais eficiente no espaço.

372
00:18:14,610 --> 00:18:17,260
É um pouco menos eficiente
no tempo, mas não por muito.

373
00:18:17,260 --> 00:18:18,890
>> As listas são uma coisa importante em Python.

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

375
00:18:21,540 --> 00:18:24,587
Nós não vimos eles, mas eles
operam como matrizes fazer em C.

376
00:18:24,587 --> 00:18:27,170
Então aqui, você pode declará-los,
você pode passá-los em uma coisa.

377
00:18:27,170 --> 00:18:29,810
Agora quadrados detém um
matriz dessas coisas.

378
00:18:29,810 --> 00:18:33,480
Mais uma vez, nós não declarados como
tipo, mas se sempre tentar usá-lo,

379
00:18:33,480 --> 00:18:36,260
qualquer coisa que você esperaria
trabalhar sobre uma matriz de números inteiros

380
00:18:36,260 --> 00:18:40,130
vai trabalhar em
uma matriz de números inteiros.

381
00:18:40,130 --> 00:18:42,030
>> Isso é uma coisa que
Você absolutamente não pode

382
00:18:42,030 --> 00:18:47,390
fazer em C, porque o
memória é tão mãos,

383
00:18:47,390 --> 00:18:48,950
mas é muito fácil de fazer em Python.

384
00:18:48,950 --> 00:18:55,310
Se eu quero a minha matriz para ser maior, eu posso
anexar um elemento a ele e ele está bem.

385
00:18:55,310 --> 00:18:57,150
>> O que está acontecendo nos bastidores?

386
00:18:57,150 --> 00:18:59,150
O intérprete vai
para fora e obter um pouco de memória,

387
00:18:59,150 --> 00:19:00,860
e talvez ele vai ter um
pouco de memória extra,

388
00:19:00,860 --> 00:19:03,090
então eu não, então eu não tenho
para realloc cada vez.

389
00:19:03,090 --> 00:19:04,897
Mas quanto mais ter
memória que ele precisa?

390
00:19:04,897 --> 00:19:06,730
Isto não são decisões
que você tem que fazer,

391
00:19:06,730 --> 00:19:10,540
estas são decisões que os
intérprete vai fazer.

392
00:19:10,540 --> 00:19:12,270
>> Aqui vemos gama pode
levar dois argumentos,

393
00:19:12,270 --> 00:19:16,430
mas ainda vai ser inclusiva
do topo para que adicionar um lá.

394
00:19:16,430 --> 00:19:21,970
Esta é uma expressão, que é uma ainda mais
maneira inteligente de escrever coisas como esta.

395
00:19:21,970 --> 00:19:25,980
É chamado de lista de compreensão,
e aqui o que estamos dizendo

396
00:19:25,980 --> 00:19:32,560
é que eu gostaria de colocar em i quadrado
para cada valor de i nesta gama.

397
00:19:32,560 --> 00:19:35,770
Essa coisa à direita poderia ser outro
array, e esta coisa do lado esquerdo

398
00:19:35,770 --> 00:19:40,740
ser qualquer função específica
que levaria em i como uma variável

399
00:19:40,740 --> 00:19:42,250
e me dar algum resultado.

400
00:19:42,250 --> 00:19:43,480
>> O que eu vou fazer é,
Eu estou indo para construir

401
00:19:43,480 --> 00:19:46,200
uma matriz que é todas essas coisas
para cada valor nesse intervalo.

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

403
00:19:48,960 --> 00:19:55,670
E isso é super elegante, super curto,
e é muito claro o que isso significa.

404
00:19:55,670 --> 00:19:59,190
Esta é uma das mais
coisas- este é novamente,

405
00:19:59,190 --> 00:20:03,860
um de-- muito emblemático da
razões que pessoas como Python.

406
00:20:03,860 --> 00:20:05,900
Se você gosta de programação
como este, então Python

407
00:20:05,900 --> 00:20:07,830
é uma linguagem que você gostaria de aprender.

408
00:20:07,830 --> 00:20:10,950
>> E, novamente, há técnica
razões por que isso funciona.

409
00:20:10,950 --> 00:20:14,730
Mas, tanto quanto nós estamos preocupados,
nós mais ou menos não me importo.

410
00:20:14,730 --> 00:20:18,500
>> Então, se você quiser imprimir listas,
algumas das mesmas expressões são úteis.

411
00:20:18,500 --> 00:20:20,940
Para i neste intervalo, nós poderíamos
Índice através de todas as coisas

412
00:20:20,940 --> 00:20:23,140
e, em seguida, imprimi-los todos para fora.

413
00:20:23,140 --> 00:20:24,650
E você vai ver len aqui.

414
00:20:24,650 --> 00:20:27,150
Se você já quis começar
o comprimento da matriz, que é

415
00:20:27,150 --> 00:20:31,150
muito fácil em Python,
é muito difícil em C.

416
00:20:31,150 --> 00:20:33,720
Isso imprimir exatamente
o que você esperaria que ele.

417
00:20:33,720 --> 00:20:36,986
Poderíamos também, como vimos antes,
iterar sobre os elementos em array

418
00:20:36,986 --> 00:20:39,860
diretamente, e depois é só falar sobre
eles, ao invés de ter o índice

419
00:20:39,860 --> 00:20:43,190
de volta para a matriz de cada vez.

420
00:20:43,190 --> 00:20:45,990
>> E isso é uma coisa que você pode fazer.

421
00:20:45,990 --> 00:20:49,984
Assim, em C, se você pedir algo
como este, impressão diria,

422
00:20:49,984 --> 00:20:51,150
isso é um array de inteiros.

423
00:20:51,150 --> 00:20:53,456
Isso definitivamente não é um
corda, eu não posso imprimi-lo.

424
00:20:53,456 --> 00:20:54,830
Python mais ou menos não se importa.

425
00:20:54,830 --> 00:20:57,496
É como, se existe uma maneira que eu
poderia transformar isso em um fio?

426
00:20:57,496 --> 00:20:58,500
Sim, eu vou fazer isso.

427
00:20:58,500 --> 00:21:01,600
E então eu vou apenas imprimir isso.

428
00:21:01,600 --> 00:21:03,640
Isto significa que você pode
fazer coisas como-- estes

429
00:21:03,640 --> 00:21:06,530
são a maioria das partes duras
do jogo de quinze anos, por escrito

430
00:21:06,530 --> 00:21:08,930
muito brevemente em Python.

431
00:21:08,930 --> 00:21:11,320
>> Você verá que não há
um pouco de-- aqui

432
00:21:11,320 --> 00:21:14,441
Eu lançou um inteiro para uma cadeia,
e eu tenho que fazer isso manualmente.

433
00:21:14,441 --> 00:21:16,190
E eu estou indo para adicionar
-lo para outra cadeia,

434
00:21:16,190 --> 00:21:17,590
ou de outra forma Python fica confuso.

435
00:21:17,590 --> 00:21:19,840
Mas se quando você está
adicionando uma string para um inteiro,

436
00:21:19,840 --> 00:21:22,630
sou eu supor para obter um
inteiros de volta ou uma seqüência de volta?

437
00:21:22,630 --> 00:21:24,480
Mas, novamente, se você apenas
chamar str em uma coisa,

438
00:21:24,480 --> 00:21:27,240
e poderiam, de qualquer possível
mundo ser convertido em uma seqüência de caracteres,

439
00:21:27,240 --> 00:21:30,390
ele provavelmente será
convertida em uma string.

440
00:21:30,390 --> 00:21:33,120
>> Aqui, vemos o uso de
aninhada compreensão da lista

441
00:21:33,120 --> 00:21:38,690
no lado esquerdo, alguns de indexação, que
é exatamente como você estaria acostumado com isso,

442
00:21:38,690 --> 00:21:40,060
e alguns a impressão de coisas.

443
00:21:40,060 --> 00:21:42,560
Mais uma vez, nós definimos alguns
funções e vamos chamá-los para baixo

444
00:21:42,560 --> 00:21:45,820
na principal quando nós realmente obter o arquivo.

445
00:21:45,820 --> 00:21:52,004
retorno funciona exatamente como você deseja
espera de trabalhar com C. Localizar,

446
00:21:52,004 --> 00:21:54,420
podemos configurar coisas como
isto-- aqui está lista de compreensão

447
00:21:54,420 --> 00:21:59,245
há uma atribuição a uma variável,
e nós podemos realmente fazê-lo ainda mais fácil.

448
00:21:59,245 --> 00:22:01,870
Nós não precisamos de escrever pesquisa,
porque built-in para o idioma

449
00:22:01,870 --> 00:22:04,230
é se essa coisa é nessa matriz.

450
00:22:04,230 --> 00:22:05,680
Retornar true, senão retornar falso.

451
00:22:05,680 --> 00:22:08,830
Então essa é a totalidade do achado.

452
00:22:08,830 --> 00:22:12,230
>> A totalidade da espécie
envolve chamar espécie,

453
00:22:12,230 --> 00:22:15,462
é-- que há implementações
desta construído em certas bibliotecas C.

454
00:22:15,462 --> 00:22:17,170
Se você gostaria deste
espécie de trás, você

455
00:22:17,170 --> 00:22:20,450
pode substituir esse opcional
argumento em sentido inverso com uma verdadeira.

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

457
00:22:23,350 --> 00:22:27,860
E se você gostaria de classificar mais
cordas, que é built-in também.

458
00:22:27,860 --> 00:22:31,950
>> Portanto, este não é para dizer que estes são
coisas que você precisa fazer todos os dias,

459
00:22:31,950 --> 00:22:34,280
mas a idéia é que este
é a filosofia do Python,

460
00:22:34,280 --> 00:22:37,530
que todas essas coisas que você gostaria
tipo de querer fazer são built-in.

461
00:22:37,530 --> 00:22:42,410
E a maioria das funções padrão,
tão tipo, comprimento, qualquer que seja,

462
00:22:42,410 --> 00:22:44,380
suporta a entrada de mais logicamente sensato.

463
00:22:44,380 --> 00:22:49,020
Você chama len em uma disposição a mesma
forma você chama len em uma corda.

464
00:22:49,020 --> 00:22:55,785
Você multiply-- você classificar cordas
Da mesma maneira você classificar matrizes.

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

466
00:22:58,930 --> 00:23:00,740
>> A maioria das funções padrão
que as pessoas constroem,

467
00:23:00,740 --> 00:23:03,000
e mais third-party
bibliotecas que as pessoas

468
00:23:03,000 --> 00:23:06,980
construir, porque eles estão emulando
o desenho da biblioteca padrão,

469
00:23:06,980 --> 00:23:10,190
pode ser chamado em tudo o que você é
como, por que não esta apenas trabalhar,

470
00:23:10,190 --> 00:23:12,800
em C. Mais ou menos,
ele vai trabalhar em Python

471
00:23:12,800 --> 00:23:15,930
porque as pessoas trabalham por trás a figura
o que é uma coisa e depois operar

472
00:23:15,930 --> 00:23:17,510
de forma adequada sobre ele.

473
00:23:17,510 --> 00:23:22,760
Então, novamente, a formação técnica, mas
torna a nossa vida mais fácil como programadores.

474
00:23:22,760 --> 00:23:26,820
>> Então aqui está o arquivo I / O. arquivo I / O tem muitos
pequenas coisas que tornam mais complicado,

475
00:23:26,820 --> 00:23:29,890
e por isso há recursos
on-line, mas em poucas palavras,

476
00:23:29,890 --> 00:23:33,010
você chama aberta em um arquivo
nome com um tipo particular.

477
00:23:33,010 --> 00:23:37,640
Assim que é ler, ler e
escrever, escrever ou acrescentar.

478
00:23:37,640 --> 00:23:41,790
Você lê um certo número de
caracteres fora e imprimir esses,

479
00:23:41,790 --> 00:23:42,595
você vai ter Olá!

480
00:23:42,595 --> 00:23:43,970
Quero dizer, como este arquivo teve Olá!

481
00:23:43,970 --> 00:23:46,480
Nele, ligue para ler,
eo que você vai receber de volta

482
00:23:46,480 --> 00:23:49,520
é uma cadeia que tem tudo
do resto da matriz,

483
00:23:49,520 --> 00:23:50,860
ou a totalidade do resto do ficheiro.

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

485
00:23:53,805 --> 00:23:56,055
Se você ligar para ler de novo,
você está no final do arquivo,

486
00:23:56,055 --> 00:23:58,138
e assim você não conseguir
qualquer coisa e assim você vai fechar.

487
00:23:58,138 --> 00:24:02,510
Novamente, isto é, em vez de .close
arquivo de perto, como seria em C.

488
00:24:02,510 --> 00:24:07,190
Isto é mais ou menos porque é um f
coisa, e você gostaria de f para fechar.

489
00:24:07,190 --> 00:24:12,092
Mas arquivo básico E / S não é
particularmente complicada.

490
00:24:12,092 --> 00:24:15,300
Novamente, se você deseja abrir um arquivo, se
você gostaria de ler uma linha particular,

491
00:24:15,300 --> 00:24:17,870
você pode sair de particular
linha-- há built-ins para isso.

492
00:24:17,870 --> 00:24:19,995
Se você gostaria de escrever um
coisa, você pode escrever isso.

493
00:24:19,995 --> 00:24:23,412
Se você gostaria de escrever out individual
mordidas, você pode escrever aqueles.

494
00:24:23,412 --> 00:24:25,620
E se você gostaria de iteração
sobre as linhas de um arquivo

495
00:24:25,620 --> 00:24:29,557
individualmente, como fizemos em um pedaço de
há algumas semanas, você pode fazer isso.

496
00:24:29,557 --> 00:24:32,140
Mais uma vez, a maioria dos objetos que você gostaria
gostaria de ser capaz de interagir sobre

497
00:24:32,140 --> 00:24:33,780
suporte a iteração sobre eles.

498
00:24:33,780 --> 00:24:37,430
Em Pythons, um arquivo é talvez uma coisa que
Eu gostaria de iterar linha por linha.

499
00:24:37,430 --> 00:24:39,138
Se fosse um dicionário
de palavras e eu estava

500
00:24:39,138 --> 00:24:42,181
tentando fazer com que aqueles indivíduo
palavras para fora, em seguida, dentro deste loop,

501
00:24:42,181 --> 00:24:44,180
linha que vai ser
cada palavra de cada vez e este

502
00:24:44,180 --> 00:24:47,880
vai ser executado para cada linha
no arquivo até que o fim do ficheiro.

503
00:24:47,880 --> 00:24:52,280
E, novamente, se eu impresso cada
linha, as linhas vêm com novas linhas,

504
00:24:52,280 --> 00:24:54,740
assim que eu estou definindo a final
de volta para uma coisa como esta.

505
00:24:54,740 --> 00:24:56,580
Então eu ia ficar o conteúdo do meu arquivo.

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

507
00:25:03,610 --> 00:25:07,480
>> A segunda coisa que atua em
algumas maneiras, como listas, e em alguns aspectos

508
00:25:07,480 --> 00:25:11,870
como algo substancialmente
mais poderoso,

509
00:25:11,870 --> 00:25:16,170
são dicionários, que são realmente
legal de usar, mas são basicamente de hash

510
00:25:16,170 --> 00:25:17,670
mesas disfarçado.

511
00:25:17,670 --> 00:25:23,330
Você criar um usando exatamente
dois personagens, o que é impressionante

512
00:25:23,330 --> 00:25:25,959
se você tentou implementar o
tabela de hash para o seu conjunto de problemas,

513
00:25:25,959 --> 00:25:27,250
você sabe muita dor que pode ser.

514
00:25:27,250 --> 00:25:29,390
Mas as pessoas têm feito
, e fez isso tão bem,

515
00:25:29,390 --> 00:25:32,260
que você não tem que
preocupar mais.

516
00:25:32,260 --> 00:25:35,180
>> Em seguida, você pode inserir coisas individuais.

517
00:25:35,180 --> 00:25:38,110
Tables-- Hash ou dicionários
particularmente não

518
00:25:38,110 --> 00:25:40,240
importo com o que você está armazenando em si.

519
00:25:40,240 --> 00:25:44,210
Portanto, se algumas entradas são números,
e algumas entradas são listas,

520
00:25:44,210 --> 00:25:47,360
se algumas entradas são outros dicionários,
e algumas entradas são strings,

521
00:25:47,360 --> 00:25:49,930
Python não faz muito cuidado.

522
00:25:49,930 --> 00:25:53,460
>> Novamente, se você entrar nele esperando
uma corda eo que você recebe de volta

523
00:25:53,460 --> 00:25:56,269
é uma matriz, isso é problema seu.

524
00:25:56,269 --> 00:25:58,810
E talvez a culpa é de quem
Pensei que era colocar as coisas

525
00:25:58,810 --> 00:26:00,476
no dicionário, talvez que era você.

526
00:26:00,476 --> 00:26:02,350
Se isso era alguém
outra coisa, espero que eles eram

527
00:26:02,350 --> 00:26:04,520
bem comportado sobre o que
ia no dicionário

528
00:26:04,520 --> 00:26:07,420
e não deixou qualquer armadilhas
para que você possa cair.

529
00:26:07,420 --> 00:26:10,890
>> Mas as funções padrão será
dar-lhe de volta as coisas bem-comportado.

530
00:26:10,890 --> 00:26:13,500
É o que dizem isso retorna
cópia de um dicionário de cordas,

531
00:26:13,500 --> 00:26:15,860
então tudo o que você está indo
para sair é uma string.

532
00:26:15,860 --> 00:26:20,710
Se você fizer alguma deste e viagens
lo, bem, isso pode estar em você.

533
00:26:20,710 --> 00:26:25,542
Python certamente lhe dá o suficiente
corda para se enforcar, se você gostaria.

534
00:26:25,542 --> 00:26:28,250
Agora podemos imprimir indivíduo
elementos deste e isso retorna

535
00:26:28,250 --> 00:26:29,935
exatamente o que você esperaria.

536
00:26:29,935 --> 00:26:32,810
Exatamente o que você esperaria, eu acho,
é uma frase que eu estou usando um monte,

537
00:26:32,810 --> 00:26:35,070
mas isso é mais ou
menos como Python funciona.

538
00:26:35,070 --> 00:26:39,880
Se você pedir uma coisa que não é
ele, Python vai jogar fora um erro

539
00:26:39,880 --> 00:26:43,194
e ele vai desistir de você para fora de
qualquer programa que você estava.

540
00:26:43,194 --> 00:26:45,360
Ele realmente vai imprimir
mais informações do que isso,

541
00:26:45,360 --> 00:26:49,110
ele vai apontar vocę-- ele vai
adicionar uma linha, e assim.

542
00:26:49,110 --> 00:26:52,190
>> E, novamente, talvez nós queremos
iterar sobre dicionários

543
00:26:52,190 --> 00:26:54,410
e encontrar todas as coisas nele.

544
00:26:54,410 --> 00:26:57,440
Aqui nós estamos interagindo sobre
duas coisas ao mesmo tempo.

545
00:26:57,440 --> 00:27:03,040
E assim nós vamos fazê-lo com uma chave, o valor,
mas, em seguida, imprimir tudo isso.

546
00:27:03,040 --> 00:27:06,300
>> E se quiséssemos cast--
se realmente correu este,

547
00:27:06,300 --> 00:27:10,840
teríamos alguns problemas porque
on-- quando fomos com David,

548
00:27:10,840 --> 00:27:13,920
não poderia add-- se não o fizéssemos
lançá-lo para uma string em primeiro lugar,

549
00:27:13,920 --> 00:27:17,802
nós não poderíamos acrescentar que matriz
de strings em uma string.

550
00:27:17,802 --> 00:27:19,760
Mas se nós expulsá-lo para um
seqüência, temos algo

551
00:27:19,760 --> 00:27:22,590
como este, que é talvez
o que nós gostaríamos de ler.

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

553
00:27:27,000 --> 00:27:30,500
>> E este é o speller.

554
00:27:30,500 --> 00:27:32,460
Acabamos de ler nas coisas.

555
00:27:32,460 --> 00:27:35,770
Assim, podemos ler em
palavras individuais como linhas.

556
00:27:35,770 --> 00:27:38,240
Nós cortar a última
coisa, então cólon menos 1

557
00:27:38,240 --> 00:27:41,651
chomps fora a última coisa que nós--
o último caractere de uma string.

558
00:27:41,651 --> 00:27:42,150
Vamos dizer.

559
00:27:42,150 --> 00:27:44,730
OK, cada um deles recebe
inserida neste dicionário,

560
00:27:44,730 --> 00:27:45,810
mapeamento de um valor de 1.

561
00:27:45,810 --> 00:27:48,006
Nós particularmente não
se preocupam com esse,

562
00:27:48,006 --> 00:27:51,130
mas é só lá para dizer, oh bem,
esta coisa que eu vou colocar no dicionário.

563
00:27:51,130 --> 00:27:53,182
Porque depois que nós somos
vai fazer é que estamos

564
00:27:53,182 --> 00:27:55,390
vai dizer, bem, se é
no dicionário de todo.

565
00:27:55,390 --> 00:27:57,650
>> Mais uma vez, esta verificação para
adesão é até operacional

566
00:27:57,650 --> 00:28:00,940
usando um completamente diferente
algoritmo que ele vai em uma lista,

567
00:28:00,940 --> 00:28:05,709
mas nós chamá-lo da mesma forma, que
é um pouco desse revestimento de açúcar Python

568
00:28:05,709 --> 00:28:07,250
coisas de modo que eles são mais fáceis de usar.

569
00:28:07,250 --> 00:28:10,230
E, novamente, temos visto
coisas assim antes.

570
00:28:10,230 --> 00:28:12,940
Este é basicamente encontrar, ou
é exatamente a mesma sintaxe

571
00:28:12,940 --> 00:28:16,480
como encontrar, mas está operando ao longo de um
estrutura completamente diferente.

572
00:28:16,480 --> 00:28:20,170
E nós particularmente não me importo.

573
00:28:20,170 --> 00:28:25,540
Portanto, estas são as coisas que você
foram convidados a implementar para ortográfico.

574
00:28:25,540 --> 00:28:29,278
A este ritmo, vamos chegar
mais ou menos todos os Série de Exercícios feito.

575
00:28:29,278 --> 00:28:31,474
>> AUDIÊNCIA: Assim que
basicamente só volta

576
00:28:31,474 --> 00:28:34,852
grafado incorretamente como se isso não acontecer
combinar algo no dicionário?

577
00:28:34,852 --> 00:28:36,060
ROSS Rheingans-YOO: Sim, sim.

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

579
00:28:38,964 --> 00:28:40,880
E assim, esta é uma
adaptação de um conjunto de problemas

580
00:28:40,880 --> 00:28:43,150
que lhe pede para fazer exatamente isso.

581
00:28:43,150 --> 00:28:46,357
>> AUDIÊNCIA: Porque é que a linha menos um lá?

582
00:28:46,357 --> 00:28:48,190
ROSS Rheingans-YOO: Então,
quando você está interagindo

583
00:28:48,190 --> 00:28:50,300
sobre um arquivo pedindo
por linhas, as linhas

584
00:28:50,300 --> 00:28:53,900
vêm com um caractere de nova linha
no final de ele-- a menos 1

585
00:28:53,900 --> 00:28:55,260
é apenas para fazer compras aqueles fora.

586
00:28:55,260 --> 00:28:59,549
E isto é particularmente flexível
forma de indexar as coisas.

587
00:28:59,549 --> 00:29:01,590
Então se você tem uma seqüência de caracteres,
e você gostaria, bem, eu sou

588
00:29:01,590 --> 00:29:05,340
vai começar em caráter três
e eu estou indo para ir até o fim.

589
00:29:05,340 --> 00:29:07,140
3 cólon vai fazer isso por você.

590
00:29:07,140 --> 00:29:10,570
Se você é como, eu quero começar pelo
começando e ir para o último menos 1

591
00:29:10,570 --> 00:29:12,400
caráter, dois pontos menos 1.

592
00:29:12,400 --> 00:29:14,940
E se você quisesse ir de
do terceiro para o primeiro negativo,

593
00:29:14,940 --> 00:29:16,570
então você diria 3 menos 1.

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

595
00:29:19,464 --> 00:29:22,400
>> Além disso, se você deseja indexar
em coisas contados a partir da parte traseira,

596
00:29:22,400 --> 00:29:24,470
você apenas no índice com números negativos.

597
00:29:24,470 --> 00:29:26,980
E porque, onde C
explodiria ou talvez

598
00:29:26,980 --> 00:29:31,090
alimentá-lo outra memória que você não tem
acesso, ouvir que você pode dizer menos 1

599
00:29:31,090 --> 00:29:34,104
significa o fim, mas um
caractere em uma seqüência.

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

601
00:29:36,950 --> 00:29:43,590
>> Os módulos são version-- são
análogos de bibliotecas em C

602
00:29:43,590 --> 00:29:45,119
e são úteis para um monte de coisas.

603
00:29:45,119 --> 00:29:46,910
Um monte de coisas que você
gostaria de fazer em Python,

604
00:29:46,910 --> 00:29:50,040
além de simples
manipulação de variáveis,

605
00:29:50,040 --> 00:29:52,290
você quer ligar para o
bibliotecas maiores, com maior

606
00:29:52,290 --> 00:29:55,910
interfaces e mais
capacidades para interagir

607
00:29:55,910 --> 00:29:57,195
com outras partes do mundo.

608
00:29:57,195 --> 00:29:58,910
sys é um daqueles
com um monte de ferramentas

609
00:29:58,910 --> 00:30:01,159
que são úteis para interagir
com o próprio sistema

610
00:30:01,159 --> 00:30:05,050
e importá-lo como sys importação.

611
00:30:05,050 --> 00:30:07,820
>> Há mais de documentação
que, o que você poderia ir aqui,

612
00:30:07,820 --> 00:30:11,490
ou você pode encontrar no Google
por googling sys Python.

613
00:30:11,490 --> 00:30:12,640
Você digita entrar.

614
00:30:12,640 --> 00:30:15,140
O primeiro link vai ser
a documentação em Python 2,

615
00:30:15,140 --> 00:30:19,260
o segundo link vai
ser o Python 3 documentação.

616
00:30:19,260 --> 00:30:24,830
>> E se nós escrevemos para fora um arquivo que olhou
como isto-- Se em particular, estamos

617
00:30:24,830 --> 00:30:27,910
olhando para operar sobre
argumentos de linha de comando,

618
00:30:27,910 --> 00:30:30,040
como nós aprendemos a fazer muito
no início desta classe.

619
00:30:30,040 --> 00:30:32,190
Isto não é difícil.
Você pode sair argv,

620
00:30:32,190 --> 00:30:34,565
que é uma daquelas coisas
que é implementado pela sys.

621
00:30:34,565 --> 00:30:37,210
Não é built-in para o
pacote base, mas, novamente, você

622
00:30:37,210 --> 00:30:40,080
pode estendê-lo por meio da importação
que a funcionalidade de sys.

623
00:30:40,080 --> 00:30:41,090
Você vai chamá-lo de sys.

624
00:30:41,090 --> 00:30:42,611
tanto faz.

625
00:30:42,611 --> 00:30:43,360
Aqui há argv.

626
00:30:43,360 --> 00:30:45,193
Não há realmente nenhuma
argc em sys, porque você

627
00:30:45,193 --> 00:30:47,880
pode obtê-lo tão facilmente chamando len.

628
00:30:47,880 --> 00:30:55,390
Nós, então, impressa que fora, então nós
correu em nosso echo-args.py terminal.

629
00:30:55,390 --> 00:30:58,360
Nós voltar uma matriz, que
é este primeiro argumento.

630
00:30:58,360 --> 00:31:02,240
Mais uma vez, esta é argv 0, que é a
nome da coisa que foi chamado.

631
00:31:02,240 --> 00:31:04,870
Se nós chamamo-lo com adicional
argumentos, teríamos aqueles de volta.

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

633
00:31:07,687 --> 00:31:09,770
Esta é uma maneira de começar
argumentos de linha de comando.

634
00:31:09,770 --> 00:31:13,440
Se você quiser bandeiras Where You Turn
sobre coisas particulares ou substituição

635
00:31:13,440 --> 00:31:16,050
um determinado padrão,
argparse é seu amigo.

636
00:31:16,050 --> 00:31:21,550
E mais uma vez você achar que on-line
em python argparse no Google.

637
00:31:21,550 --> 00:31:24,300
>> Há um par de utilidade
módulos que você está usando

638
00:31:24,300 --> 00:31:27,630
e, novamente, se você gastar algum tempo
desta língua importação jsons

639
00:31:27,630 --> 00:31:33,300
para a leitura de dentro e para fora de JSON
arquivos, não é complicado.

640
00:31:33,300 --> 00:31:37,139
Você abre um arquivo, você chamado json.load
naquele arquivo e você recebe de volta uma coisa.

641
00:31:37,139 --> 00:31:37,930
O que é essa coisa?

642
00:31:37,930 --> 00:31:40,329
É um objeto JSON.

643
00:31:40,329 --> 00:31:42,370
Onde tem que json matriz,
o Python tem arrays.

644
00:31:42,370 --> 00:31:44,420
Onde tem que json
arrays associativos, Python de

645
00:31:44,420 --> 00:31:48,810
dicionários, cordas,
e números, e assim por diante.

646
00:31:48,810 --> 00:31:53,560
Você deseja despejar isso, você
abrir um novo arquivo, você chama de despejo,

647
00:31:53,560 --> 00:31:57,590
e cargas e lixeiras para
entrar e sair das cordas.

648
00:31:57,590 --> 00:32:02,120
>> Da mesma forma, é chamado pickle
basicamente da mesma interface.

649
00:32:02,120 --> 00:32:04,740
É útil se ligeiramente mais
você está despejo objetos Python.

650
00:32:04,740 --> 00:32:08,370
Então, se você sempre quis para salvar
uma versão do status atual

651
00:32:08,370 --> 00:32:11,930
de uma variável para um futuro
executar do seu programa,

652
00:32:11,930 --> 00:32:14,740
pickle é Python de
biblioteca para fazer isso.

653
00:32:14,740 --> 00:32:19,140
>> Se você tem qualquer tipo de
variável que pode ser escrito para fora

654
00:32:19,140 --> 00:32:21,990
em palavras como e personagens e
bytes-- como este dicionário,

655
00:32:21,990 --> 00:32:24,230
poderíamos escrever para baixo, nós
poderia escrevê-lo como

656
00:32:24,230 --> 00:32:26,670
como um objeto JSON, que foi
literalmente esses personagens.

657
00:32:26,670 --> 00:32:29,420
E então seria muito fácil para
um ser humano para abri-lo up-- abrir

658
00:32:29,420 --> 00:32:30,889
e lê-lo.

659
00:32:30,889 --> 00:32:33,180
Se não o fizéssemos particularmente
se preocupam com os seres humanos lê-lo,

660
00:32:33,180 --> 00:32:38,490
poderíamos embalar ainda mais eficiente
em formas que poderia mais tarde ser desembalado

661
00:32:38,490 --> 00:32:42,860
ou que poderia mais tarde ser inflado.

662
00:32:42,860 --> 00:32:46,740
E isso poupa 80% do
espaço que os objetos poderiam

663
00:32:46,740 --> 00:32:49,390
tomar se você escreveu-los longhand.

664
00:32:49,390 --> 00:32:52,384
>> Você chama pickle muito
o mesmo maneira-- despejo, carga,

665
00:32:52,384 --> 00:32:53,800
e então você pegue suas coisas de volta.

666
00:32:53,800 --> 00:32:56,880
Então, se você está escrevendo muito
programas em Python curtas que

667
00:32:56,880 --> 00:32:59,952
deseja salvar estado, e em seguida, ler
los de volta mais tarde, coisas como esta

668
00:32:59,952 --> 00:33:00,660
são seus amigos.

669
00:33:00,660 --> 00:33:02,640
Que você poderia muito
despejá-los facilmente como JSON.

670
00:33:02,640 --> 00:33:04,550
A maioria dos objetos Python
pode despejar o json

671
00:33:04,550 --> 00:33:11,310
se há alguma esperança de que estruturalmente
eles poderiam ser representadas dessa forma.

672
00:33:11,310 --> 00:33:14,410
>> Estes são apenas a ponta do
iceberg em módulos que são úteis.

673
00:33:14,410 --> 00:33:19,510
Então sys, os, multiprocessamento, são
tipo de burros de carga básicas para as coisas

674
00:33:19,510 --> 00:33:23,120
precisamos interagir com
o sistema operacional do sistema de arquivos.,

675
00:33:23,120 --> 00:33:28,764
como os.isfile, os.isdirectory,
os.makefile, estes são seus amigos.

676
00:33:28,764 --> 00:33:30,930
Se você quiser interagir
com um determinado tipo de arquivo,

677
00:33:30,930 --> 00:33:32,190
json, pickle, csv.

678
00:33:32,190 --> 00:33:37,160
Se você quiser interagir com web
páginas, o urllib para obter http

679
00:33:37,160 --> 00:33:41,370
Páginas. bs4-- BeautifulSoup--
é um analisador maravilhoso para html.

680
00:33:41,370 --> 00:33:47,047
Você executá-lo em um html e você
obter esse objeto matriz aninhada agora,

681
00:33:47,047 --> 00:33:49,630
que você pode atravessar mais
lookin, como com apenas procurando

682
00:33:49,630 --> 00:33:52,380
se, é, em, o que é fantástico.

683
00:33:52,380 --> 00:33:55,920
>> Há um monte de
pacotes para running--

684
00:33:55,920 --> 00:33:57,960
para fazer particularmente Mathy coisas.

685
00:33:57,960 --> 00:34:01,790
Então, se você deseja multiplicar,
inverter, transformar matrizes,

686
00:34:01,790 --> 00:34:05,690
numpy é usado por pessoas todos os
o mundo por isso.

687
00:34:05,690 --> 00:34:09,620
scipy é ainda mais útil
ferramentas nessa direção.

688
00:34:09,620 --> 00:34:13,980
aprendizado de máquina sklearn--,
processamento de linguagem natural,

689
00:34:13,980 --> 00:34:17,880
Super material útil, recebe
implementado em Python todo o tempo.

690
00:34:17,880 --> 00:34:21,469
>> E, novamente, leva um pouco
mais tempo para write-- sorry,

691
00:34:21,469 --> 00:34:26,199
demora um pouco mais para ser executado, mas
a razão que os engenheiros reais tendem

692
00:34:26,199 --> 00:34:29,900
uso Python é porque você tende a ser
bloqueada em você escrever o código, em vez

693
00:34:29,900 --> 00:34:32,699
do que o seu computador executar o código.

694
00:34:32,699 --> 00:34:35,860
Então, se você estiver indo para escrever um
programa, que muitas outras pessoas

695
00:34:35,860 --> 00:34:37,699
vai usar
para sempre, como o Linux, você

696
00:34:37,699 --> 00:34:41,900
pode escrevê-lo em C. Se você fosse
vai escrever um motor de computação,

697
00:34:41,900 --> 00:34:46,124
você pode escrever em Python se você precisava
para mudá-lo a cada dois meses.

698
00:34:46,124 --> 00:34:48,540
Algumas pessoas escrevem-no em
C, porque eles são assim.

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

700
00:34:51,100 --> 00:34:54,050
>> Então nós vimos import sys
como uma maneira de fazer as coisas

701
00:34:54,050 --> 00:34:57,070
de obtenção de módulo em seu programa.

702
00:34:57,070 --> 00:35:00,370
Você também pode importá-lo como
um apelido, se você gostaria.

703
00:35:00,370 --> 00:35:03,660
Novamente multiprocessamento é uma dor de
digite a cada vez, de modo que importar como mp

704
00:35:03,660 --> 00:35:05,900
e, em seguida, a qualquer momento você
usá-lo no programa,

705
00:35:05,900 --> 00:35:09,732
você vai dizer mp.process, ou o que você tem.

706
00:35:09,732 --> 00:35:12,670
Se você gostaria de importação
apenas uma única coisa,

707
00:35:12,670 --> 00:35:19,450
assim urllib tem uma coisa chamada
pedido, assim você pode simplesmente importar que.

708
00:35:19,450 --> 00:35:22,610
Mais tarde, você não vai invocá-la como
urllib.request, mas apenas como pedido

709
00:35:22,610 --> 00:35:24,590
por si próprio.

710
00:35:24,590 --> 00:35:30,110
>> E você pode importar tudo
a partir de um módulo se você gostaria.

711
00:35:30,110 --> 00:35:34,820
Este não é um bom ocasionalmente idea--
Isso geralmente não é uma boa idéia, na verdade.

712
00:35:34,820 --> 00:35:39,080
Porque você very-- porque se alguma coisa
nesse módulo tem um nome que você

713
00:35:39,080 --> 00:35:41,640
queria usar em outro lugar
em seu programa, você não pode.

714
00:35:41,640 --> 00:35:44,127
>> E nem sempre é óbvio
que esse é o caso.

715
00:35:44,127 --> 00:35:46,460
De modo a certificar-se de que
o que estava fazendo era seguro,

716
00:35:46,460 --> 00:35:47,920
você precisa abrir-se
o módulo e ver tudo

717
00:35:47,920 --> 00:35:50,295
dos nomes que acabam em
há-- todas as funções,

718
00:35:50,295 --> 00:35:53,010
todas as variáveis
que vivem nesse módulo,

719
00:35:53,010 --> 00:35:57,040
porque você está trazendo todos
-los em seu namespace local.

720
00:35:57,040 --> 00:35:58,680
>> Então, as pessoas fazem isso.

721
00:35:58,680 --> 00:36:01,322
Recomenda-se geralmente
que você não faça isso.

722
00:36:01,322 --> 00:36:03,280
Mas as pessoas fazem isso todos
o tempo, porque eles são

723
00:36:03,280 --> 00:36:05,180
preguiçoso e não quer digitar mp.

724
00:36:05,180 --> 00:36:06,310
nada, nunca.

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

726
00:36:09,560 --> 00:36:13,310
>> Toda essa conversa sobre módulos
traga-me em torno de uma pequena palestra

727
00:36:13,310 --> 00:36:15,930
de como você projetar programas em Python.

728
00:36:15,930 --> 00:36:19,860
O primeiro passo é verificar para ver se
qualquer outra pessoa já tenha feito a coisa,

729
00:36:19,860 --> 00:36:22,160
ou feito 90% da coisa.

730
00:36:22,160 --> 00:36:26,010
Provavelmente, eles provavelmente têm, e você
devem ir buscar as suas coisas e executar esse.

731
00:36:26,010 --> 00:36:28,900
Ou escrever um wrapper em torno dele
para adaptá-lo à sua finalidade.

732
00:36:28,900 --> 00:36:31,250
É só depois que tem
não que você gostaria, em seguida,

733
00:36:31,250 --> 00:36:35,529
vá em frente e começar a pensar sobre write--
como você iria colocar essa coisa juntos.

734
00:36:35,529 --> 00:36:37,320
Há um monte de coisas
lá fora, e isso é

735
00:36:37,320 --> 00:36:39,180
um dos mais útil
coisas sobre Python.

736
00:36:39,180 --> 00:36:40,930
Tal como a linguagem é
elegante, o idioma

737
00:36:40,930 --> 00:36:43,800
é fácil de usar, mas também porque
é tão elegante e fácil de usar,

738
00:36:43,800 --> 00:36:47,420
as pessoas têm usado para uma
muito tempo e não há um monte de coisas

739
00:36:47,420 --> 00:36:52,520
lá fora, que você pode
aproveitar para o seu próprio uso.

740
00:36:52,520 --> 00:36:58,457
>> Assim última regra de Python é, alguém
pessoa já foi provavelmente escrito

741
00:36:58,457 --> 00:37:00,290
um módulo para que,
alguém já tem

742
00:37:00,290 --> 00:37:02,980
provavelmente escrito uma biblioteca para isso.

743
00:37:02,980 --> 00:37:06,579
Antes de tentar fazer uma coisa, olhar
para ver se ele já foi implementado.

744
00:37:06,579 --> 00:37:07,370
Não é tão difícil.

745
00:37:07,370 --> 00:37:11,960
Todos os módulos que eu coloquei para cima
antes, talvez com uma única excepção,

746
00:37:11,960 --> 00:37:15,220
vem pré-instalado em todos os
instalação padrão do Python.

747
00:37:15,220 --> 00:37:17,769
E assim, com uma chamada para
importar o que quer, você

748
00:37:17,769 --> 00:37:19,852
tem todas as funcionalidades
Na ponta dos seus dedos.

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

750
00:37:24,660 --> 00:37:28,920
>> Começando a encerrar este
conversa, há algumas coisas

751
00:37:28,920 --> 00:37:32,770
que eu deixei como caixas pretas
e tipo de encoberto,

752
00:37:32,770 --> 00:37:37,217
e há algumas mentiras brancas que eu tenho
disse que por uma questão de honestidade,

753
00:37:37,217 --> 00:37:39,050
Eu vou pelo menos no ponto
aqui, mesmo se eu não vou

754
00:37:39,050 --> 00:37:43,980
Super ir profundamente em todos eles
e suas explicações técnicas.

755
00:37:43,980 --> 00:37:46,010
>> Um monte de coisas
que eu tenho chamado de magia

756
00:37:46,010 --> 00:37:48,980
é o que as outras pessoas chamariam
programação orientada a objeto.

757
00:37:48,980 --> 00:37:52,470
Então há muitas coisas-
portanto as variáveis ​​não são muito frequentemente

758
00:37:52,470 --> 00:37:56,540
bytes simples sentado,
memória, mas são muito complicadas

759
00:37:56,540 --> 00:38:01,910
objetos que têm interno
Estado sobre as funções e os lotes

760
00:38:01,910 --> 00:38:05,570
variáveis ​​ocultas, de lotes de
funcionalidade oculta, que

761
00:38:05,570 --> 00:38:09,480
permite que você transformá-los em cordas,
que lhe permite interagir sobre eles.

762
00:38:09,480 --> 00:38:12,260
E se você está writing--
ea razão que eles

763
00:38:12,260 --> 00:38:15,710
tem toda essa funcionalidade rica
é porque os pessoas--

764
00:38:15,710 --> 00:38:17,740
os arquitetos da
language-- ter ido

765
00:38:17,740 --> 00:38:22,420
através e para cada padrão
objeto, colocar na funcionalidade

766
00:38:22,420 --> 00:38:26,970
Dizer isto é como este é
como isso vai funcionar

767
00:38:26,970 --> 00:38:28,470
se alguém quiser iterar sobre ele.

768
00:38:28,470 --> 00:38:31,240
>> Então, tudo o que alguém poderia
possivelmente querer para repetir,

769
00:38:31,240 --> 00:38:34,529
foi escrito em lógica
manualmente sobre a forma como você é

770
00:38:34,529 --> 00:38:36,070
deveria interagir sobre esse objeto.

771
00:38:36,070 --> 00:38:40,274
Tudo o que você poderia possivelmente querer
despejado em uma seqüência lógica tem escrito.

772
00:38:40,274 --> 00:38:43,440
Esta é a função que você chama se
você deseja despejar isso para uma string.

773
00:38:43,440 --> 00:38:45,273
É por isso que você pode
chamar len sobre as coisas, este

774
00:38:45,273 --> 00:38:49,900
É por isso que você pode chamar para dentro, este é
por que você pode chamar se a par de tudo

775
00:38:49,900 --> 00:38:53,490
que você iria querer, porque
aqueles todos estão carregando com eles,

776
00:38:53,490 --> 00:38:55,380
o know-how técnico para fazer isso.

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

778
00:38:58,170 --> 00:39:00,432
>> Isso é algo que eu sou
Super não vai entrar.

779
00:39:00,432 --> 00:39:03,140
Mas para a coisa na lista é sutilmente
diferente do estilo C para loops,

780
00:39:03,140 --> 00:39:06,160
e você pode ler tudo sobre isso em
internet, se você estiver interessado.

781
00:39:06,160 --> 00:39:08,930
Há um lado escuro para todos
a isso, que eu mencionei,

782
00:39:08,930 --> 00:39:10,359
então há duas coisas.

783
00:39:10,359 --> 00:39:13,400
A primeira é que orientou este objeto
programação adiciona muita sobrecarga

784
00:39:13,400 --> 00:39:16,080
para coisas aleatórias, assim você acaba
utilizando-se muito mais memória;

785
00:39:16,080 --> 00:39:18,640
você acaba usando um pouco mais
tempo do que você faria de outra forma.

786
00:39:18,640 --> 00:39:21,300
O outro-- mas o mais
insidiosa lado escuro a esta

787
00:39:21,300 --> 00:39:24,047
é que, se as coisas simplesmente agir
como você quer que eles

788
00:39:24,047 --> 00:39:27,130
sem você ter que pensar super difícil
sobre se este deve ser um int

789
00:39:27,130 --> 00:39:29,713
ou se deveria haver um
flutuador, pode ser que até aqui

790
00:39:29,713 --> 00:39:34,240
você produz um int, mas aqui você
pensar, mas eles vão always-- sorry,

791
00:39:34,240 --> 00:39:36,555
pode ser que aqui
você produz um flutuador,

792
00:39:36,555 --> 00:39:39,430
mas quando você começa a segunda parte
de seu programa, você está pensando,

793
00:39:39,430 --> 00:39:41,150
oh bem, mas eles
passe-me sempre um int.

794
00:39:41,150 --> 00:39:43,608
E se não o fizerem, é possível
que você entalado em algum lugar,

795
00:39:43,608 --> 00:39:47,600
se você tentar usar isso para índice
em uma matriz, ou o que você tem.

796
00:39:47,600 --> 00:39:51,050
>> Então, um do real
coisas úteis sobre C é

797
00:39:51,050 --> 00:39:54,219
força-o a pensar realmente
rígido antes de fazer any--

798
00:39:54,219 --> 00:39:56,510
antes que você traga qualquer variável
à existência, como o que

799
00:39:56,510 --> 00:39:58,764
é o tipo desta variável.

800
00:39:58,764 --> 00:40:00,680
E vai ter
que tipo para todos os tempos.

801
00:40:00,680 --> 00:40:02,410
>> Isso não é verdade
Python, e na verdade, você

802
00:40:02,410 --> 00:40:04,740
can-- se você é apenas
tipo de vai de ouvido,

803
00:40:04,740 --> 00:40:07,690
e você tomar algumas decisões
uma forma em um lugar,

804
00:40:07,690 --> 00:40:09,870
e algumas decisões um
maneira no outro lugar

805
00:40:09,870 --> 00:40:12,960
sem colocar material suficiente atrás
as cenas em outro lugar

806
00:40:12,960 --> 00:40:16,170
para pegar as coisas corretamente, você
pode obter alguns erros muito estranhos.

807
00:40:16,170 --> 00:40:19,200
E o programa pode continuar a correr
para um tempo muito longo, porque é

808
00:40:19,200 --> 00:40:23,200
fazendo um monte de trabalho para dizer, bem
esta coisa poderia funcionar dessa maneira,

809
00:40:23,200 --> 00:40:25,070
então eu vou correr dessa maneira.

810
00:40:25,070 --> 00:40:30,300
>> E, na verdade, o facto de ele empurra
transmitir através de um monte de pequenos erros

811
00:40:30,300 --> 00:40:33,260
significa que, muitas vezes, quando
na verdade, um erro é má

812
00:40:33,260 --> 00:40:38,720
e você realmente deseja corrigi-lo,
ele acaba milhas away-- o programa

813
00:40:38,720 --> 00:40:41,780
acaba parando milhas de distância
a partir de quando você tinha o seu erro.

814
00:40:41,780 --> 00:40:46,590
E assim uma coisa que gostaríamos
programas para fazer, uma coisa sometimes--

815
00:40:46,590 --> 00:40:48,910
que gostaríamos programas
que fazer quando estamos depurando

816
00:40:48,910 --> 00:40:54,160
é falhar e falham muito alto
rapidamente quando algo dá errado.

817
00:40:54,160 --> 00:40:55,510
>> Python é muito ruim nisso.

818
00:40:55,510 --> 00:40:58,820
Python é muito bom em não
falhando e rolando para a frente

819
00:40:58,820 --> 00:41:00,320
através de coisas inesperadas.

820
00:41:00,320 --> 00:41:02,820
Portanto, este é útil para quando
você está escrevendo pequenos programas.

821
00:41:02,820 --> 00:41:07,110
Quando você ficar complicado
erros que às vezes

822
00:41:07,110 --> 00:41:09,300
Demora muito tempo para provocá-los.

823
00:41:09,300 --> 00:41:12,210
>> Portanto, há um lado escuro para todos
deste, como ele simplesmente funciona.

824
00:41:12,210 --> 00:41:13,860
Ele simplesmente funciona como você esperaria que ele.

825
00:41:13,860 --> 00:41:18,320
Só que quando isso não acontece, você acaba
em um lugar completamente diferente

826
00:41:18,320 --> 00:41:21,530
e tentando descobrir onde
que foi que você deu errado.

827
00:41:21,530 --> 00:41:25,180
>> A coleta de lixo é-- assim
uma coisa que você vai notar

828
00:41:25,180 --> 00:41:28,110
é que qualquer uma dessas coisas que
Eu trouxe em existence--

829
00:41:28,110 --> 00:41:34,114
essas matrizes, estes dicionários, estes
objetos, estes files-- nunca se libertou.

830
00:41:34,114 --> 00:41:36,030
Não houve chamada para
livre em qualquer um essa conversa.

831
00:41:36,030 --> 00:41:40,340
E isso foi no lado do C o, porque
nós nunca entrou essas coisas.

832
00:41:40,340 --> 00:41:42,220
>> Mas em Python-lado, não é livre.

833
00:41:42,220 --> 00:41:43,970
As coisas ficam automaticamente
liberado quando Python

834
00:41:43,970 --> 00:41:45,386
acha que você não está olhando para eles.

835
00:41:45,386 --> 00:41:49,640
É realmente bom não liberando coisas que
você ainda pode possivelmente estar a olhar para,

836
00:41:49,640 --> 00:41:54,262
mas isso significa que se você fosse
vai alocar este grande coisa,

837
00:41:54,262 --> 00:41:55,970
e você é como, oh
Eu sou feito com ele agora,

838
00:41:55,970 --> 00:42:00,360
é difícil dizer Python
que você é feito com isso agora.

839
00:42:00,360 --> 00:42:02,986
>> Às vezes você pode definir
essa variável a ser nenhum,

840
00:42:02,986 --> 00:42:05,110
e, em seguida, espero que, eventualmente,
o coletor de lixo

841
00:42:05,110 --> 00:42:06,720
vem através de e limpa-lo.

842
00:42:06,720 --> 00:42:10,177
Mas, novamente, você não
tem controle sobre isso.

843
00:42:10,177 --> 00:42:13,510
E uma das razões que as pessoas usam C
para realmente desempenho coisas críticas,

844
00:42:13,510 --> 00:42:16,570
É esta capacidade de realmente
sabe quando a memória é alocada

845
00:42:16,570 --> 00:42:19,369
e quando é libertado, e têm
um monte de controle sobre dizendo:

846
00:42:19,369 --> 00:42:20,910
Eu estou usando não mais memória do que eu preciso.

847
00:42:20,910 --> 00:42:23,632
Que é algo que
Python não é tão grande no.

848
00:42:23,632 --> 00:42:25,090
AUDIÊNCIA: Posso fazer uma pergunta?

849
00:42:25,090 --> 00:42:29,800
O que você entende por falhar em voz alta?

850
00:42:29,800 --> 00:42:32,070
>> ROSS Rheingans-YOO: Então se
algo está acontecendo de errado

851
00:42:32,070 --> 00:42:34,950
e você está na depuração
modo, você faria muito frequentemente

852
00:42:34,950 --> 00:42:38,510
quer que seu programa para lhe dizer
onde exatamente está errado,

853
00:42:38,510 --> 00:42:42,360
e não apenas discretamente parar de correr.

854
00:42:42,360 --> 00:42:45,085
Mas você, na verdade, para imprimir
fora todos os tipos de informações sobre

855
00:42:45,085 --> 00:42:46,972
como, aqui estava presente.

856
00:42:46,972 --> 00:42:53,957
Essa coisa aconteceu Se você estiver imprimindo
um wen-- se você estiver executando um server-- web

857
00:42:53,957 --> 00:42:55,390
>> AUDIÊNCIA: [inaudível]

858
00:42:55,390 --> 00:42:59,800
>> ROSS Rheingans-YOO: Sim, se
você está executando um servidor web,

859
00:42:59,800 --> 00:43:02,680
às vezes é ruim se você estiver
sempre descartar erros,

860
00:43:02,680 --> 00:43:04,530
e você está dizendo,
bem que não funcionou.

861
00:43:04,530 --> 00:43:05,300
Eu vou parar.

862
00:43:05,300 --> 00:43:07,680
Eu só vou ignorar
lo e mantê acontecendo.

863
00:43:07,680 --> 00:43:11,260
Porque então você pode entrar em centenas
desses erros e não vê-los.

864
00:43:11,260 --> 00:43:13,910
>> Seria certamente útil
para fins de depuração

865
00:43:13,910 --> 00:43:20,327
se cada vez que seu servidor web fez uma
erro, você tinha registros duráveis ​​do que isso.

866
00:43:20,327 --> 00:43:22,910
Talvez você ainda deseja que o programa
para parar, para que esses registros

867
00:43:22,910 --> 00:43:25,471
Não fique enterrado sob coisas.

868
00:43:25,471 --> 00:43:26,970
Mas, novamente, isso é no modo de depuração.

869
00:43:26,970 --> 00:43:31,280
>> Muitas vezes, no modo de produção, o
mundo é um pouco diferente.

870
00:43:31,280 --> 00:43:36,380
E em pequenos scripts que eu estou correndo,
onde a única coisa que eu disse para fazer

871
00:43:36,380 --> 00:43:40,680
pode ser apenas um pouco fora
do que eu gostaria que ele faça,

872
00:43:40,680 --> 00:43:44,010
em seguida, tipo de empurrar através de
erros é algo que você pode querer.

873
00:43:44,010 --> 00:43:49,410
E, nesses casos, certamente
Python realmente ganha seus começos.

874
00:43:49,410 --> 00:43:54,617
>> A última coisa que eu não falar
isto-- em que eu não falar sobre

875
00:43:54,617 --> 00:43:57,700
mas pode ser realmente irritante o primeiro
vez que você tem um desses erros,

876
00:43:57,700 --> 00:44:00,491
ea segunda e terceira e quarta
vez que você tem um desses erros.

877
00:44:00,491 --> 00:44:03,490
Python, eu mencionei
que ele usa o espaço em branco

878
00:44:03,490 --> 00:44:06,700
para lhe dizer o nível de recuo
e quais blocos funcional que você está,

879
00:44:06,700 --> 00:44:08,840
trata tabulações e espaços de forma diferente.

880
00:44:08,840 --> 00:44:12,780
Então, se você guia sobre quatro, e, em seguida,
a próxima linha tem quatro espaços,

881
00:44:12,780 --> 00:44:16,910
mesmo se elas aparecem como o
mesma quantidade em seu editor,

882
00:44:16,910 --> 00:44:20,160
Python não tratá-los da mesma.

883
00:44:20,160 --> 00:44:23,610
>> Na verdade, trata Python guias
e espaços como óleo e água.

884
00:44:23,610 --> 00:44:25,050
Eles são apenas coisas diferentes.

885
00:44:25,050 --> 00:44:27,264
Não há especial
comprimento que é um separador,

886
00:44:27,264 --> 00:44:30,180
por isso não é como um guia é igual a 8
espaços, e assim que você iria ficar em torno dela

887
00:44:30,180 --> 00:44:30,860
Aquele caminho.

888
00:44:30,860 --> 00:44:34,110
Como, quando se diz, o que
nível de espaço em branco eu estou,

889
00:44:34,110 --> 00:44:37,240
ele está realmente à procura de um
padrão de espaços e tabulações.

890
00:44:37,240 --> 00:44:43,050
E assim, a melhor maneira de lidar com isso
é a utilização de espaços sempre todo o tempo.

891
00:44:43,050 --> 00:44:47,510
>> E, de fato, no Cloud9
IDE e do CS50 IDE,

892
00:44:47,510 --> 00:44:50,610
a tecla tab inserções
quatro espaços em vez

893
00:44:50,610 --> 00:44:53,800
de um guia, que é super útil.

894
00:44:53,800 --> 00:44:57,074
Embora novamente, se você escreveu um Python
programa com guias que seria bom,

895
00:44:57,074 --> 00:44:58,990
é só se alguém
entrou e tentou adicionar

896
00:44:58,990 --> 00:45:02,655
uma única linha ao seu programa que
tinha quatro espaços para cada guia,

897
00:45:02,655 --> 00:45:03,280
ele iria quebrar.

898
00:45:03,280 --> 00:45:07,800
E ele iria quebrar de uma forma
que realmente não é visível.

899
00:45:07,800 --> 00:45:12,390
Embora o erro real
mensagem que ele lança

900
00:45:12,390 --> 00:45:15,610
tem a ver com o novo
travessão não esperado aqui,

901
00:45:15,610 --> 00:45:18,700
ou-- se ele está falando travessões
e parece que ele está errado,

902
00:45:18,700 --> 00:45:22,090
provavelmente é porque
há um problema tab-espaço.

903
00:45:22,090 --> 00:45:24,154
Eles ainda estão enfurecendo para depurar.

904
00:45:24,154 --> 00:45:26,070
A maior em toda
Nesta palestra, o que eu não fiz

905
00:45:26,070 --> 00:45:29,740
chegar porque é realmente
um complicado, tema sutil,

906
00:45:29,740 --> 00:45:34,760
e não era necessário fazer qualquer
das coisas que fizemos até agora,

907
00:45:34,760 --> 00:45:37,140
são um conceito chamado de tuplas.

908
00:45:37,140 --> 00:45:41,280
Eles estão lá muito parecido com o
matrizes que você não pode modificar.

909
00:45:41,280 --> 00:45:44,700
Eles são utilizados em todo o lugar, porque
eles são úteis para muitas coisas

910
00:45:44,700 --> 00:45:46,300
matrizes que não são úteis para.

911
00:45:46,300 --> 00:45:49,890
>> Mas se você gostaria de fazer uma matriz, e
em seguida, o intérprete prometo que você

912
00:45:49,890 --> 00:45:53,140
nunca vai querer modificar esse
coisa-- na verdade, se você quiser modificar,

913
00:45:53,140 --> 00:45:56,800
você vai fazer um novo com o novo
valores em ele-- esses são tuplas.

914
00:45:56,800 --> 00:45:58,800
Em vez de produzir
los com colchetes,

915
00:45:58,800 --> 00:46:00,341
você produzi-los com parênteses.

916
00:46:00,341 --> 00:46:05,074
Por que você usaria essas coisas,
é um pouco de uma pergunta. .

917
00:46:05,074 --> 00:46:06,990
A única coisa que eu vou
dizer sobre isso é que você

918
00:46:06,990 --> 00:46:10,680
pode usar como tuplos
índices de dicionários.

919
00:46:10,680 --> 00:46:15,010
Você não pode usar matrizes como
índices de dicionários.

920
00:46:15,010 --> 00:46:18,970
E por que é, novamente, técnica e
Eu não vou correr para ele.

921
00:46:18,970 --> 00:46:23,140
>> O pset que eu não toquei
em nesta conversa é pset6.

922
00:46:23,140 --> 00:46:25,837
Então aqui está como você 'd
implementar um-- aqui

923
00:46:25,837 --> 00:46:28,140
Como você poderia implementar pset6 em Python.

924
00:46:28,140 --> 00:46:32,680
Tendo em mente o Python
ciclo de design, a primeira coisa

925
00:46:32,680 --> 00:46:34,760
que você faz quando você está
programas de escrita de verificação é

926
00:46:34,760 --> 00:46:38,030
para ver se alguém tem feito isso já.

927
00:46:38,030 --> 00:46:42,152
>> Na verdade, se você quiser
para serve-- Apache 50

928
00:46:42,152 --> 00:46:44,110
faz isso aproximadamente,
exceto que ele não vem

929
00:46:44,110 --> 00:46:45,840
padrão instalado em máquinas Linux.

930
00:46:45,840 --> 00:46:50,490
Python faz, eo Python
servidor http simples faz tão bem.

931
00:46:50,490 --> 00:46:54,717
Se você está sempre em uma máquina Linux,
ou fora Cloud9 IDE de CS50

932
00:46:54,717 --> 00:46:57,550
e você gostaria de servir a esta corrente
diretório para um porto particular,

933
00:46:57,550 --> 00:47:04,610
python-m SimpleHTTPServer
porto serve isso.

934
00:47:04,610 --> 00:47:07,190
Você também pode importar
o servidor http simples

935
00:47:07,190 --> 00:47:11,240
e ele tem um monte de funcionalidade se
você quiser personalizá-lo, ou alterá-lo,

936
00:47:11,240 --> 00:47:15,860
ou são executados ele-- aproveitá-la para
executar seus próprios serviços de servidor.

937
00:47:15,860 --> 00:47:18,032
>> Então, isso é Python em poucas palavras.

938
00:47:18,032 --> 00:47:20,280
E isso tem sido CS50.

939
00:47:20,280 --> 00:47:21,980
Obrigado.

940
00:47:21,980 --> 00:47:23,468