Curso básico de programação com Python para iniciantes - D[4] - Hoje às 18 horas
comentada em 12/11/2021 16:52

@ThiagoDV to acompanhando a área de tecnologia lá e queria saber: esse curso de python é como se fosse todos aqueles vídeos que já tem sobre python (breves lições) só que estruturado? Pois estava acompanhando aqueles outros.

@mauricio.eletrica é sim. Tou meio que revendo aqueles mas em formato de chat pro pessoal tirar dúvida ao vivo se quiser. E nesse vou mais além do que os que já tem gravados ... Os já gravados deram uma estagnada porque resolvi seguir nesse novo formato. 

- Crie uma função que recebe o nome do usuário e mande um alô para ele

- Crie uma função que escreva 9 quadrantes (como se fosse um jogo da velha)

- Crie uma mini calculadora, com 4 funções básicas que calculam as 4 operações matemáticas básicas (soma, subtração, multiplicação e divisão) e que recebem dois argumentos numéricos. Interaja com sua calculadora usando o modo interativo (python -i nome_do_programa.py)

Acho que consegui resolver os exercícios, galera. Mas talvez tenha formas melhores ou mais práticas de resolvê-los... o que acham?

# Exercicio 1 da aula 04:
# Crie uma funcao que recebe o nome do usuario e da um alo para ele:

# Resposta:

def alo_usuario():
    nome_usuario = input('digite_seu_nome ')
    return 'Alô ' + nome_usuario


print(alo_usuario())


############################################################################

# Exercicio 2 da aula 04:
# Crie uma função que escreva 9 quadrantes (como se fosse um jogo da velha)

def tabuleiro_jogo_da_velha():
    print('       |       |       ')
    print('       |       |       ')
    print('_______|_______|_______')
    print('       |       |       ')
    print('       |       |       ')
    print('_______|_______|_______')
    print('       |       |       ')
    print('       |       |       ')
    print('       |       |       ')

tabuleiro_jogo_da_velha()


##########################################################################


# Exercicio 3 da aula 04:
# Crie uma mini calculadora, com 4 funções básicas que calculam as 4
# operações matemáticas básicas (soma, subtração, multiplicação e divisão)
# e que recebem dois argumentos numéricos.

def calc(x, y, operacao):
    '''
    funcao de mini calculadora simples - aplica as 4 operacoes basicas
    apenas para dois numeros. E necessario informar a operacao que
    sera realizada: 'somar', 'subtrair', 'multiplicar' ou 'dividir'
    '''
    if operacao == 'somar':
        return x + y
    if operacao == 'subtrair':
        return x - y
    if operacao == 'multiplicar':
        return x * y
    if operacao == 'dividir':
        return x / y


print(calc(33, 55, 'somar'))
print(calc(35, 14, 'subtrair'))
print(calc(6, 7, 'multiplicar'))
print(calc(40, 10, 'dividir'))

#Crie uma função que recebe o nome do usuário e mande um alô para ele
def nome_usu():
    nome_usuario = input('Qual seu nome de usuário?
')
    print(f'Alô, {nome_usuario}')

nome_usu()

#---------------------------------------------------------

#Crie uma função que escreva 9 quadrantes (como se fosse um jogo da velha)

def Jogo_da_Velha_layout():
    print('         |             |           ')
    print('         |             |           ')
    print('         |             |           ')
    print('_________|_____________|___________')
    print('         |             |           ')
    print('         |             |           ')
    print('         |             |           ')
    print('_________|_____________|___________')
    print('         |             |           ')
    print('         |             |           ')
    print('         |             |           ')
    print('         |             |           ')

Jogo_da_Velha_layout()

#---------------------------------------------------------

#Crie uma mini calculadora, com 4 funções básicas (soma, subtração, multiplicação e divisão) 
#Que recebem dois argumentos numéricos. 
#Interaja com sua calculadora usando o modo interativo (python -i nome_do_programa.py)

def soma_xy(x,y):
    return (x+y)
    
def subt_xy(x,y):
    return (x-y)

def mult_xy(x,y):
    return (x*y)

def divi_xy(x,y):
    return x/y

Boa, pessoal. 

Ao fim de cada "módulo" agora vou tentar passar mais e mais exercícios. Esses no começo são mais bestinhas mesmo mas a coisa vai evoluir mais. 

#Exercicio 1
def manda_salve(nome):
    print(f'Um salve para {nome}!')

manda_salve(input('Digite seu nome: '))

# Exercício 2
def tabuleiro_jogo_da_velha():
    print('         |             |           ')
    print('         |             |           ')
    print('         |             |           ')
    print('_________|_____________|___________')
    print('         |             |           ')
    print('         |             |           ')
    print('         |             |           ')
    print('_________|_____________|___________')
    print('         |             |           ')
    print('         |             |           ')
    print('         |             |           ')
    print('         |             |           ')

tabuleiro_jogo_da_velha()

# Exercício 3
def somar_numeros(num1, num2):
    return num1 + num2

def subtrair_numeros(num1, num2):
    return num1 - num2

def multiplicar_numeros(num1, num2):
    return num1 * num2

def dividir_numeros(num1, num2): #num2 <> 0
    return num1 / num2

'''
Exercício 1
Crie uma função que recebe o nome do usuário e manda um alô para ele
'''

def manda_alo(user_name):
    print(user_name)

user_name = input()

manda_alo('Fala aí ' + user_name)

'''
Exercício 2
Crie uma função que escreva 9 quadrantes (como se fosse um jogo da velha)
'''

def grid_vertical():
    print('   ' + '|' + '   ' + '|' + '   ')
    
def grid_horizontal():
    print('---' + ' ---' + ' ---')

def jogo_velha():
    grid_vertical()
    grid_horizontal()
    grid_vertical()
    grid_horizontal()
    grid_vertical()

jogo_velha()

'''
Exercício 3
Crie uma mini calculadora, com 4 funções básicas que calculam as 4 operações (soma, subtração, multiplicação e divisão) e que recebem dois argumentos numéricos. Interaja com sua calculadora usando o modo interativo (python -i nome_program.py)
'''
def soma(num1, num2):
    return num1 + num2

def subtracao(num1, num2):
    return num1 - num2

def multiplicacao(num1, num2):
    return num1 * num2

def divisao(num1, num2):
    return num1 / num2

print('Defina o primeiro número: ')
num1 = int(input())
print('Defina o segundo número: ')
num2 = int(input())
print('Defina a operação: 1=soma, 2=subtracao,3=multiplicacao, 4=divisao')
op = input()

#abaixo um dado do tipo dicionário
oper = {'1':'soma',
        '2':'subtracao',
        '3':'multiplicacao',
        '4':'divisao'
        }
operacao = oper[op]
print (operacao)

if op == '1':
    print (soma(num1, num2))
elif op == '2':
    print (subtracao(num1, num2))
elif op == '3':
    print (multiplicacao(num1, num2))
else:
    print (divisao(num1, num2))

'''
Exercício 1
Crie uma função que recebe o nome do usuário e manda um alô para ele
'''

def name_call_hello():
    name = input('nome: ')
    return 'hello ' + name 

print(name_call_hello())

'''
Exercício 2
Crie uma função que escreva 9 quadrantes (como se fosse um jogo da velha)
'''

def horizontal_line():
    print('       |         |      ')   

def vertical_line():
    print('-------------------------')

def jogo_da_velha(): 
    horizontal_line()
    horizontal_line()
    vertical_line()
    horizontal_line()
    horizontal_line()
    vertical_line()
    horizontal_line()
    horizontal_line()

print(jogo_da_velha())

'''
Exercício 3
Crie uma mini calculadora, com 4 funções básicas que calculam as 4 operações (soma, subtração, multiplicação e divisão) e que recebem dois argumentos numéricos. Interaja com sua calculadora usando o modo interativo (<mark data-markjs="true" class="highlight">python</mark> -i nome_program.py)
'''

import math

def addition(x, y):
    return x + y

def multiplication(x, y):
    return x * y

def subtraction(x, y):
    return x - y

def division(x, y):
    return x / y

def square_root(x):
    return math.sqrt(x)

@Estevaopp


Tenta aí:  não sei se 9 ou 8 no fim do range()

for i in range(1, 9):

    if (i % 3 == 0):
          vertical_line()
    else:
          horizontal_line()

@FlyCavok

Deu certo e ficou com muito menos código, só não entendi meu bem a função, pode me explicar, por favor?

edit1: estou testando a função e acho que estou entendendo, agora só falta pesquisar o que é o 'for' e o 'in'.

postado por @Estevaopp em 11/11/2021 16:54

FlyCavok

Deu certo e ficou com muito menos código, só não entendi meu bem a função, pode me explicar, por favor?

edit1: estou testando a função e acho que estou entendendo, agora só falta pesquisar o que é o 'for' e o 'in'.

For é para repetir o código que estiver dentro dele. i in range(a,b)  cria uma variável i cujo valor começa em a e termina em b. Esse i existe e pode ser lido enquanto o for estiver repetindo o codigo. O for vai repetir o código enquanto houver i a criar:

Então a primeira repetição o i é 0
A segunda 1
A terceira 2
...
Até chegar no 9 e parar de repetir 

If (i % 3 == 0) testa se o valor de i é multiplo de 3, pois i % 3 é o resto da divisão de i por 3. Se o resto é zero, é por que é multiplo.

Se é multiplo de 3, exibe a linha vertical. É o equivalente a dizer que a cada 3 linhas, imprima a vertical. Se não, imprimia a horizontal 

@Estevaopp o legal de fazer assim é que você pode montar uma função que coloca o X ou o O no quadrante, e aí criar o joguinho mesmo :)

Quanto ao exercício, pra deixar claro,
i começa em 0
i % 3 da 0 então print vertical 
i vai pra 1,
i % 3 da 1, então print horizontal
i vai pra 2

i % 3 da 1, print horizontal
i vai pra 3
i % 3 da 0, print vertical
(...)

Até sair do laço de repetição (looping) for.

Só achei esquisito os nomes dos seus métodos estarem invertidos rsrsrs
Horizontal imprime na vertical e vice versa..

@FlyCavok Entendi, muito abrigado, amigo.

KKKKKKK inverti mesmo, no começo tava quebrando cabeça por causa disso, fui ver que inverti só depois de muito tempo. 

@Estevaopp   hehehehe

Olha que eu te expliquei tudo com os nomes invertidos.

O legal disso é que dá para aproveitar o gancho e explicar algo bem interessante na computação.

Sabe por que eu não me confundi? Por que depois de muito tempo de profissão, você aprende que o programador é mentiroso e só quem é verdadeiro é o código.

Então você meio que se treina a dar muito mais importância à implementação do que ao nome dela, já que o nome dela pode ser uma mentira deslavada. Tá cheio de método que diz A e faz B. É só o que tem.

O cara escreve lá:  criar_arquivo_unico(....)  como método... Aí você descobre que o arquivo não é único. Mentira deslavada!! kkkkk

Normal. No dia-a-dia, você acaba esquecendo, se confundindo...

O mesmo raciocínio vale para comentários de código. Toda linguagem tem comentário, você pode ir lá e escrever texto livre. Python salvo engano é colocando "#" no começo, correto?

Pois bem. Comentário é a coisa mais mentirosa que existe, muito pior que o método... por que? O cara começa comentando uma coisa falando a verdade, mas uma verdade que existe só naquele momento ali.

Aí à medida que outras pessoas vão mexendo no código, ele vai mudando e, potencialmente, deixa de funcionar da maneira que o comentário disse que ele funcionava.

Em resumo, a melhor documentação que existe é o próprio código. É a única confiável.

Claro, vc tá trabalhando em uma empresa e os caras querem que você saia comentando tudo. Você tá sendo pago, vai ser o único maluco a dizer que não vai fazer? Você se adapta... mas o importante é ter na cabeça que qualquer coisa não-código é potencialmente mentirosa

@FlyCavok Perfeito, vou levar isso pra vida, to com 20 anos iniciando agora a programar, se Deus quiser começo a faculdade de sistemas de informação ano que vem. 

Estou ansioso pra aprender mais na area e conseguir um emprego ou estagio.