Diretório de artigos
Prefácio
No estudo anterior, aprendemos a usar a função print() para emitir comandos simples para o computador, começamos a entrar em contato com diferentes tipos de dados em Python e aprendemos a usar declarações de julgamento condicional if para implementar a lógica primária de comunicação com o computador.
Após esses estudos, você está um passo mais perto de entender o Python? Você já começou a sentir que o computador frio do passado parecia ter se tornado amigável por meio da comunicação com você?
No entanto, apenas dominar a codificação Python não é suficiente. Se quisermos ir mais longe, devemos dominar a lógica do código Python, usar [dados] corretos e [lógica] razoável para construir comandos e, finalmente, precisamos [responder] ao computador e [inserir] nossas próprias informações.
E essa ação [de resposta] de transmissão de informações é o nosso foco hoje - a função input(), que completará sua primeira comunicação interativa com Python e produzirá uma magia incrível.
Então, o que você está esperando? Vamos começar a jornada mágica rapidamente!
função de entrada()
No curso de hoje, você receberá uma carta de admissão da Escola de Magia e Bruxaria de Hogwarts, que o levará a usar a função input() para abrir um novo capítulo de "comunicação bidirecional" com o computador.
Agora é hora de você escolher. Por favor, execute o botão [Run] no lado esquerdo do bloco de código abaixo. No [Terminal], primeiro [insira] o número que você selecionou e depois pressione a tecla Enter.
import time
print('亲爱的同学：')
time.sleep(1)
print('我们愉快地通知您，您已获准在霍格沃茨魔法学校就读。')
time.sleep(2)
print('随信附上所需书籍及装备一览。')
time.sleep(1)
print('学期定于九月一日开始。')
time.sleep(1)
print('鉴于您对魔法世界的不熟悉，')
time.sleep(1)
print('我们将指派魔咒学老师——吴枫教授带您购买学习用品。')
time.sleep(2)
print('我们将于七月三十一日前静候您的猫头鹰带来的回信。')
time.sleep(2)
print('校长（女）米勒娃·麦格谨上')
time.sleep(1)
print('那么，您的选择是什么？ 1 接受，还是 2 放弃呢？')
time.sleep(2)
choice=input('请输入您选择的数字：')
if choice =='1':
print('霍格沃茨欢迎您的到来。')
else:
print('您可是被梅林选中的孩子，我们不接受这个选项。')
resultado da operação:
亲爱的同学：
我们愉快地通知您，您已获准在霍格沃茨魔法学校就读。
随信附上所需书籍及装备一览。
学期定于九月一日开始。
鉴于您对魔法世界的不熟悉，
我们将指派魔咒学老师——吴枫教授带您购买学习用品。
我们将于七月三十一日前静候您的猫头鹰带来的回信。
校长（女）米勒娃·麦格谨上
那么，您的选择是什么？ 1 接受，还是 2 放弃呢？
请输入您选择的数字：1
霍格沃茨欢迎您的到来。
Veja, esta é sua primeira comunicação interativa com o computador usando a função input().
A chave para alcançar uma verdadeira comunicação interativa homem-máquina é: vai e vem. Por exemplo, se o diretor perguntar se você quer vir para Hogwarts para aprender magia, você precisará inserir um comando de pergunta no programa: Você quer vir para Hogwarts?
Após o programa receber o pedido, ele exibirá imediatamente a pergunta do diretor, palavra por palavra, na tela do seu computador, perguntando: Você quer ir para Hogwarts?
Em seguida, o processo de o ser humano usar o teclado para fornecer instruções ao computador e, em seguida, usar o computador para exibir as perguntas no monitor e aguardar a resposta do ser humano é implementado por meio da função input().
Então, qual é o uso específico da função input() e a lógica por trás dela? Neste nível, irei derrotar a função input() uma por uma em quatro ângulos.
Uso da função input()
Primeiro, vamos dar uma olhada em como a função input() é usada por meio de um trecho de código:
input('请在以下四个选项【格兰芬多；斯莱特林；拉文克劳；赫奇帕奇】中，输入你想去的学院名字:')
A função input() é a função de entrada. Para o exemplo acima, é necessário que você insira o nome da casa para a qual deseja ir nas quatro opções a seguir [Grifinória; Sonserina; Corvinal; Lufa-Lufa] entre colchetes: resposta de.
Portanto, quando você escreve uma pergunta entre colchetes da função, a função input() exibirá a pergunta como está na tela e aguardará sua resposta a esta pergunta na área do terminal.
Mas por que inserimos a resposta no terminal? Está tudo bem em não entrar?
Na verdade, podemos pensar na função input() como uma porta que conecta o mundo real e o mundo do código.
Quando uma pergunta nos é passada do mundo do código, mas não a respondemos, a porta input() aguardando entrada estará sempre aberta, esperando você enviar sua resposta.
Ao inserirmos as informações, a porta input() será fechada e continuaremos executando os seguintes comandos.
A seguir, vamos resumir como usar a função input():
A seguir, vamos experimentar a magia da função input():
1. Adicione o código
input('请在以下四个选项【格兰芬多；斯莱特林；拉文克劳；赫奇帕奇】中，输入你想去的学院名字:')
Copie-o para sua própria caixa de código local;
2. Após clicar em Executar, digite sua escolha no terminal à direita;
3. Pressione a tecla Enter após inserir a resposta.
Que tal isso? Depois de inserir a resposta e pressionar a tecla Enter, não há mais nada além das informações que você inseriu? Mas o programa não reporta nenhum erro. Por que isso acontece?
Enfatizamos repetidamente que o código executa comandos linha por linha, portanto, mesmo que a função input() passe e a porta seja fechada, uma vez que não há outros comandos na função input(), naturalmente não haverá resultados.
Porém, as respostas que inserimos não são perdidas, elas são armazenadas no programa pelo computador.
Então, e se eu quiser encontrar a resposta que acabei de inserir no oceano de programas e usá-la para produzir um resultado, como expressar que a faculdade me acolhe?
请在以下四个选项【格兰芬多；斯莱特林；拉文克劳；赫奇帕奇】中，输入你想去的学院名字: 拉文克劳
#提出的问题
拉文克劳学院欢迎你，小萌新!
#显示的结果
Não vamos nos apressar na codificação ainda. De acordo com as regras antigas, vamos primeiro resolver a lógica do pensamento. Primeiro, para que as faculdades estejam prontas para recebê-lo, elas precisam saber qual faculdade você escolheu, por isso devem primeiro coletar informações sobre sua faculdade preferida.
Então, o primeiro passo em nosso pensamento é usar a função input() para coletar informações:
input('请在以下四个选项【格兰芬多；斯莱特林；拉文克劳；赫奇帕奇】中，输入你想去的学院名字: ')
#运用input函数搜集信息
Porém, quando quero unir os dados coletados com ['Bem-vindo à faculdade, novato fofo!'] e imprimir os resultados, surge um problema. Embora eu tenha coletado algumas informações usando a função input(), como recupero essas informações do oceano de programas e executo a emenda de dados?
Isso envolve o segundo ponto de conhecimento da função input() – a atribuição dos resultados da função.
Atribuição do resultado da função input()
Em primeiro lugar, podemos atribuir valores às variáveis, de forma que quando quisermos extrair dados, só precisamos imprimir o nome da variável diretamente para despertar a memória dos dados do programa.
Esta lógica de atribuição também funciona na função input(). Também podemos atingir o objetivo de extrair os resultados de entrada a qualquer momento por meio de atribuição. Mas, num nível lógico, precisamos de virar uma esquina.
Por exemplo, tome nossa seguinte sequência de código como exemplo:
name = input('请输入你的名字：')
#函数赋值
Embora pareça atribuir um valor à função input(), na verdade, atribuímos o resultado da execução da função input() (as informações coletadas) ao nome da variável.
Em termos leigos, o que colocamos na caixa de nome não é a pergunta feita na função input(), mas as respostas de outras pessoas que coletamos por meio da função input().
Dessa forma, não importa o que você digite no terminal, não importa quantas vezes sua resposta mude. Contanto que seja uma resposta à pergunta feita pela função input(), ela será armazenada na variável. Enquanto aguarda a impressão da variável, a resposta é extraída e exibida no display.
No mundo do código, essas informações/respostas/dados exibidos no terminal podem ser chamados de valores de entrada – o conteúdo que inserimos na função.
Agora, vamos tentar nós mesmos:
Por favor, atribua o resultado de input('Por favor, digite o nome da casa para a qual deseja ir entre as quatro opções a seguir [Grifinória; Sonserina; Corvinal; Lufa-Lufa]: ') para nome, Em seguida, imprima o nome da variável para ver se o a resposta que você digitou aparece. [Pontos-chave: atribuição, função input(), função print()]
name=input('请在以下四个选项【格兰芬多；斯莱特林；拉文克劳；赫奇帕奇】中，输入你想去的学院名字:')
print(name+'学院欢迎你！')
resultado da operação:
请在以下四个选项【格兰芬多；斯莱特林；拉文克劳；赫奇帕奇】中，输入你想去的学院名字:格兰芬多哈
格兰芬多哈学院欢迎你！
Agora há pouco, a informação que inserimos no terminal - o nome da faculdade (cada um insere conteúdos diferentes), é o valor de entrada.
Ao mesmo tempo, para extrair o valor de entrada a qualquer momento e de forma conveniente, precisamos atribuir o resultado da função input() ao nome da variável.
Quando tivermos preparado o caminho para a coleta de informações e atribuído valores às informações obtidas, podemos prosseguir para a última etapa e imprimir o resultado final.
Em seguida, mostre outra onda de operações: 1. Solicite informações. Selecione o item mágico que você mais deseja possuir entre as seguintes opções [Espelho de Erised; Vira Tempo; Vassoura Voadora; Capa da Invisibilidade]:; 2. Adicione os resultados Atribua o valor à variável magic; 3. Imprima o resultado magic+' é a magia que eu mais quero ter! '[Pontos-chave: atribuição, função input(), emenda de variáveis, função print()]
Resposta de referência:
magic=input('请在以下选项【厄里斯魔镜；时间转换器；飞天扫帚；隐形斗篷】中，选择出你最想拥有的魔法物品：')
print(magic+'是我最想拥有的魔法！')
resultado da operação:
请在以下选项【厄里斯魔镜；时间转换器；飞天扫帚；隐形斗篷】中，选择出你最想拥有的魔法物品：隐形斗篷
隐形斗篷是我最想拥有的魔法！
Há um ponto importante aqui: quando entendemos o código, a ordem de pensamento em nosso cérebro é primeiro coletar informações e depois atribuir o resultado da função input() à variável.
No entanto, para escrever especificações e evitar informações perdidas, precisamos primeiro seguir o formato de escrita do código e atribuir valores aos resultados da função input().
Com base no conhecimento que aprendemos anteriormente, como usar a função input()?
Primeiro, precisamos atribuir um valor ao resultado da função input(), depois usar a função input() para coletar informações e, finalmente, usar a função print() para gerar o resultado.
Vamos usar outra imagem para resumir intuitivamente.
Agora que dominamos os cenários de uso abrangentes da função input(), vamos dar uma olhada no código da carta de Hogwarts no início deste nível.
print('那么，您的选择是什么？ 1 接受，还是 2 放弃呢？')
choice = input('请输入您的选择：')
#变量赋值
if choice == '1':
#条件判断:条件1
print('霍格沃茨欢迎您的到来。')
#条件1的结果
else:
#条件判断：其他条件
print('您可是被梅林选中的孩子，我们不接受这个选项。')
#其他条件的结果
Então, como esse conjunto de código foi escrito?
Do ponto de vista do pensamento, para simplificar: dou-lhe duas opções, você escolhe uma e depois mostro-lhe o resultado correspondente.
Portanto, o primeiro passo do código é atribuir um valor e fazer perguntas por meio da função input().
choice = input('请输入您的选择：')
#变量赋值
Na segunda etapa, precisamos fazer um julgamento condicional com base na resposta: se a resposta for 1, será exibido o resultado da condição 1; se outras opções forem selecionadas, serão exibidos os resultados de outras condições.
choice = input('请输入您的选择：')
#变量赋值
if choice == '1':
#条件判断:条件1
print('霍格沃茨欢迎您的到来。')
#条件1的结果
else:
#条件判断：其他条件
print('您可是被梅林选中的孩子，我们不接受这个选项。')
#其他条件的结果
O código está finalizado, mas surge a pergunta: por que a variável escolha sob a condição if é a string '1'? Se não for um formato de string, mas um número inteiro 1, qual será o resultado?
Em seguida, copie o código acima e altere a condição if de '1' no formato string para 1 no formato inteiro. Após clicar em Executar, digite 1 no terminal e observe os resultados da execução [Dica: Clique em Executar → Insira 1]
choice=input('请输入你的选择：')
if choice==1:
print('霍格沃茨欢迎您的到来')
else:
print('您可是被梅林选中的孩子，我们不接受这个选项')
resultado da operação:
请输入你的选择：1
您可是被梅林选中的孩子，我们不接受这个选项
Que tal isso? Você digitou 1 e o resultado exibido é o resultado sob a condição else: 'Você é o filho selecionado por Merlin, não aceitamos esta opção. '?
Por que é isso? O que inserimos é o número 1 na opção condicional? Por que os resultados correspondentes não podem aparecer?
Aqui chegamos ao terceiro ponto de conhecimento da função input():
Tipo de dados da função input()
Agora, vamos primeiro decompor esse grupo de códigos linha por linha a partir da lógica da linguagem de computador:
choice = input('请输入您的选择：')
#变量赋值
if choice == 1:
#条件判断:条件1
print('霍格沃茨欢迎您的到来。')
#条件1的结果
else:
#条件判断：其他条件
print('您可是被梅林选中的孩子，我们不接受这个选项。')
#其他条件的结果
Então, vamos primeiro dar uma olhada na instrução de atribuição na primeira linha do código.
choice = input('请输入您的选择：')
#变量赋值
Primeiro, vamos ver isso como um todo. O que esse código significa é que ele usa a função input() para receber dados e atribuí-los à variável choice.
Em segundo lugar, vamos decompô-lo para ver o que cada parte desta linha de código representa:
Para a função input(), não importa a resposta que inserirmos, se você inserir o número inteiro 1234 ou a string "A capa da invisibilidade é a magia que mais quero ter", o valor de entrada da função input() (resposta coletada) , sempre será [obrigatório] convertido para o tipo [string]. (Regras fixas do Python3)
Não acredite? Verifique com a função type() que aprendemos no primeiro nível?
choice = input('请输入1或2:')
print(type(choice))
resultado da operação:
请输入1或2:1
<class 'str'>
Não é? O inteiro [1] ou [2] que inserimos será convertido à força em uma string de ['1'] ou ['2'].
Portanto, não importa o que inserirmos na área do terminal, o valor de entrada da função input() deve ser [string].
Desta forma, como utilizamos o operador de atribuição [=] para atribuir o resultado string da função input() à variável choice, esta variável também deve ser do tipo string.
Agora, determinamos que o tipo de dados da escolha da variável é string. A seguir, vamos dar uma olhada no código por trás.
Vamos primeiro dar uma olhada na instrução condicional if [if choice==1] no primeiro bloco de código e desmontá-la:
Com base no conhecimento de julgamento condicional aprendido no Nível 2, podemos interpretar a condição if na primeira linha como: se a variável escolha for igual ao número inteiro 1, então execute o resultado desta condição if.
Você encontrou algum problema desta vez? Lembra-se do tipo de dados da escolha da variável que mencionamos quando desmontamos a função input()?
Na primeira atribuição de variável, o valor de entrada da função input() é uma string, e '1' também é uma string; mas quando se trata do julgamento da condição if, a condição if se torna [choice == 1] - 1 desapareceu. As aspas são do tipo inteiro.
É isso, porque a informação que inserimos é sempre uma string, escolha é um tipo de string e 1 é um tipo inteiro, claro que não podem ser iguais, a condição [choice == 1] não pode ser estabelecida, e só podemos realizar a seguinte operação else - —Print "Você é o filho escolhido por Merlin. Não aceitamos esta opção." 』
Agora, por favor, mostre sua magia. Altere a instrução de erro da condição if no código a seguir para a correta igual ao tipo de string e execute-a.
choice = input('请输入您的选择：')
#变量赋值
if choice == 1:
#条件判断:条件1
print('霍格沃茨欢迎您的到来。')
#条件1的结果
else:
#条件判断：其他条件
print('您可是被梅林选中的孩子，我们不接受这个选项。')
#其他条件的结果
Resposta de referência:
choice=input('请输入你的选择:')
if choice=='1':
print('霍格沃斯欢迎您')
else:
print('您可是被梅林选中的孩子，我们不接受这个选项')
resultado da operação:
请输入你的选择:1
霍格沃斯欢迎您
Agora, sabemos como percorrer o código modificando o tipo de dados da condição if. Você aprendeu isso?
Então, suponha que exista um trecho de código como o seguinte:
age = 59
choice = input('请你猜一下斯内普教授的年龄：')
if choice == age:
print('猜对惹～你好厉害！ ヽ✿゜▽゜)ノ～～～')
elif choice < age:
print('斯内普的提示：你猜小了（；´д｀）ゞ。。。。')
else:
print('斯内普的提示：乃猜大了惹(＞﹏＜)～～')
Se você clicar em Executar e inserir os dados, receberá imediatamente uma mensagem de erro e será esfregado no chão. Então, onde está a origem do erro no código do Professor Snape?
Nós desmontamos linha por linha. Na instrução de atribuição da primeira linha do código, a variável idade é do tipo inteiro e a escolha da variável da segunda linha é do tipo string. Essas duas variáveis não podem ser comparadas devido a tipos diferentes.
Que tal, você respondeu corretamente? A seguir, vamos usar uma imagem para aprofundá-lo, o que é muito útil no futuro e também é um ponto de conhecimento muito importante:
Em nosso exemplo, havia apenas duas opções. Mas supondo que você tenha 1, 2, 3, 4... 365 opções, independentemente de a conversão do tipo de dados estar correta ou não, digitar aspas simples uma por uma é muito demorado.
Então, precisamos de um método mais simples e que economize trabalho para alterar os tipos de dados de todos os valores de entrada em números inteiros de uma só vez.
Conversão forçada do resultado da função input()
Mas professor, você não acabou de me dizer que a informação coletada pela função input() é sempre uma string? Também pode ser alterado para um número inteiro?
É isso mesmo, o valor de entrada da função input() pode se tornar um número inteiro sob certas circunstâncias. Então, você se lembra de como converter uma string em um número inteiro?
Certo? int() é uma conversão de tipo forçada de ponto de conhecimento no Nível 1, que pode converter à força uma string em um número inteiro.
Com a função int(), podemos converter o conteúdo de entrada em um número inteiro da fonte da função input().
choice = int(input('请输入您的选择：'))
#将输入值强制转换为整数，并赋值给变量choice
No entanto, esta sequência de código parece lançar toda a função input().
Mas, na verdade, realizamos a conversão forçada no resultado obtido pela função input() e atribuímos o resultado da conversão forçada a uma caixa variável chamada escolha.
Dessa forma, mesmo que a condição if seja um número inteiro, o programa pode ser executado com precisão.
Então, quando usaremos a conversão forçada do resultado da função input()?
A ideia é simples, quando a resposta que você deseja é um número, como idade:
age = int(input('猜一猜巫师的『法定成年年龄』是几岁，请输入：'))
#将输入的岁数(字符串)，强制转换为整数
if age > 17:
#当年龄(整数)大于17(整数）时
print('哈哈，居然比这个年龄还要小呢！')
#打印if条件下的结果
elif age == 17:
#当年龄(整数)等于17(整数）时
print('正确！我猜你是个巫师啦～')
#打印if条件下的结果
else:
#当年龄(整数)小于17(整数)时
print('呜呜，这个年龄～我还是个宝宝呢，正确答案是17岁哦')
#打印else条件下的结果
Outro exemplo é quando as informações que precisam ser inseridas são horário, salário ou outros números:
money = int(input('你一个月工资多少钱？'))
#将输入的工资数（字符串），强制转换为整数
if money >= 10000:
#当工资数（整数）大于等于10000（整数）时
print('土豪我们做朋友吧！')
#打印if条件下的结果
else:
#当工资数（整数）小于10000（整数）时
print('我负责赚钱养家，你负责貌美如花～')
#打印else条件下
Em seguida, por favor, agite suas asas invisíveis e adicione outra condição ao código de salário mensal acima: [Quando o salário for maior que 5.000 e menor que 10.000]. Resultado de impressão: [Somos todos transportadores de tijolos. . . ], e escreva o código inteiro após adicionar as condições na área abaixo. [Dica principal: quando três condições coexistem, use instruções if…elif…else…]
Resposta de referência:
money = int(input('你一个月工资多少钱？'))
#将输入的工资数（字符串），强制转换为整数
if money >= 10000:
#当工资数（整数）大于等于10000（整数）时
print('土豪我们做朋友吧！')
#打印if条件下的结果
elif 5000 < money < 10000:
#当工资数（整数）大于5000（整数）小于10000（整数）时
print('我们都是搬砖族。。。')
#打印elif条件下的结果
else:
#当工资数（整数）小于等于5000（整数）时
print('我负责赚钱养家，你负责貌美如花～')
#打印else条件下的结果
resultado da operação:
你一个月工资多少钱？8000
我们都是搬砖族。。。
Finalmente, vamos resumir os pontos de conhecimento sobre a coerção do tipo de dados da função input():
Assim, apresentamos todos os pontos de conhecimento da função input(), foco deste nível. Finalmente, vamos resolver os pontos-chave da função input().
Resumo dos pontos de conhecimento da função input()
Agora, lembre-se com atenção. Neste ponto, sabemos como usar a função input() e combinar as variáveis, atribuições, julgamentos condicionais e conversões forçadas de tipo que aprendemos antes com a função input()? Revisamos e usamos de novo? Você concluiu a comunicação interativa com o computador?
Revisão compreensiva
No início, conhecemos a função mais simples e comumente usada no mundo Python – a função print().
Embora esta função pareça simples, se você se aprofundar, descobrirá que esta função de impressão mais simples também tem seus próprios segredos e contém a lógica de operação mais básica do mundo da programação.
Porém, se você deseja atingir o objetivo de comunicação interativa com o computador, também precisa dominar a linguagem de comunicação do computador.
Somente quando o computador entende o que estamos dizendo é que ele pode nos dar o feedback correto.
Tal como nós, humanos, o funcionamento dos computadores também requer lógica formal, por isso, no nível 2, dominamos a lógica de como comunicar com os computadores.
Com linguagem e lógica, podemos nos comunicar interativamente com computadores.
Então, chegamos ao nível de hoje e aprendemos a função input().
No entanto, depois de aprender esses pontos de conhecimento, como podemos escrever nós mesmos um trecho de código, como um código como a carta de Hogwarts? Qual é o formato geral do grupo de códigos?
Olhando para trás, depois de passar por esses quatro níveis, você descobre que aprendeu muito sem nem perceber? Fui exposto a um mundo totalmente novo.
Vamos lá, você eventualmente se tornará o chefe dos seus sonhos!