Noções Básicas em

Sobre Noções Básicas

Python é uma linguagem de programação dinâmica e fortemente tipada. Utiliza tanto duck typing como tipagem gradual, através de anotações de tipo. Os estilos de programação imperativo, declarativo (por exemplo, funcional) e orientado a objetos são todos suportados, mas internamente tudo em Python é um objeto.

O Python dá grande importância à legibilidade do código e (à semelhança do Haskell) usa indentação significativa para assinalar definições de funções, métodos e classes.

O Python foi criado por Guido van Rossum e lançado pela primeira vez em 1991. A Python Software Foundation gere e orienta os recursos para o desenvolvimento do Python e do CPython e recebe propostas de alterações à linguagem por parte dos membros da comunidade, através das Python Enhancement Proposals, ou PEPs.

A documentação completa da versão atual está disponível em docs.python.org.

• Tutorial do Python
• Referência da Biblioteca do Python
• Referência da Linguagem Python
• Guias práticos do Python
• Perguntas frequentes do Python
• Glossário de Termos do Python

Neste primeiro conceito vais conhecer 4 grandes características da linguagem Python:

1. Atribuição de nomes (variáveis e constantes),
2. Funções (as palavras-chave def e return),
3. Comentários, e
4. Docstrings.

Atribuição de nomes (variáveis e constantes)

Em Python, não se usam palavras-chave para criar variáveis ou constantes. Em vez disso, quem programa pode associar nomes (também chamados variáveis) a qualquer tipo de objeto, usando o operador de atribuição =: <name> = <value>. Ao longo da sua vida, um nome pode ser reatribuído (ou reassociado) a valores diferentes (tipos de objeto diferentes).

Por exemplo, my_first_variable pode ser reatribuído muitas vezes com =, e pode referir-se a tipos de objeto diferentes a cada reatribuição:

>>> my_first_variable = 1  # my_first_variable bound to an integer object of value one.
>>> my_first_variable = 2  # my_first_variable re-assigned to integer value 2.

>>> print(type(my_first_variable))
<class 'int'>

>>> print(my_first_variable)
2

>>> my_first_variable = "Now, I'm a string." # <--You may re-bind a name to a different object type and value.
>>> print(type(my_first_variable))
<class 'str'>

>>> my_first_variable = 'You can call me "str".' # <--Strings can be declared using single or double quote marks.
>>> print(my_first_variable)
You can call me "str".

>>> import collections
>>> my_first_variable = collections.Counter([1,1,2,3,3,3,4,5,6,7]) # <--Now my_first_variable has been re-bound to a Counter object.
>>> print(type(my_first_variable))
<class 'collections.Counter'>

>>> print(my_first_variable)
Counter({3: 3, 1: 2, 2: 1, 4: 1, 5: 1, 6: 1, 7: 1})

Constantes

As constantes são nomes que devem ser atribuídos apenas uma vez num programa. Devem ser definidas ao nível do módulo (ficheiro) e, habitualmente, são visíveis para todas as funções e classes do programa. Usar SCREAMING_SNAKE_CASE assinala que o nome não deve ser reatribuído nem o seu valor alterado.

# All caps signal that this is intended as a constant.
MY_FIRST_CONSTANT = 16

# Re-assignment will be allowed by the compiler & interpreter,
# but this is VERY strongly discouraged.
# Please don't do this, it could create problems in your program!
MY_FIRST_CONSTANT = "Some other value"

Funções

Em Python, as unidades de funcionalidade estão encapsuladas em funções, que são elas próprias objetos (é turtles all the way down).

As funções podem ser executadas por si próprias, passadas como argumentos a outras funções, aninhadas ou associadas a uma classe. Quando as funções estão associadas ao nome de uma classe, são designadas por métodos. As funções e classes relacionadas (com os respetivos métodos) podem ser agrupadas no mesmo ficheiro ou módulo e importadas total ou parcialmente para uso noutros programas.

A palavra-chave def inicia uma definição de função. Cada função pode ter zero ou mais parâmetros formais entre parênteses (), seguidos de dois pontos :. As instruções do corpo da função começam na linha seguinte ao def e têm de estar indentadas num bloco:

# The body of a function is indented by 2 spaces & prints the sum of the numbers.
def add_two_numbers(number_one, number_two):
  total = number_one + number_two
  print(total)  

>>> add_two_numbers(3, 4)
7


# Inconsistent indentation in your code blocks will raise an error.
>>> def add_three_numbers_misformatted(number_one, number_two, number_three):
...     result = number_one + number_two + number_three   # This was indented by 4 spaces.
...    print(result)     # <--This was only indented by 3 spaces.
...
...
  File "<stdin>", line 3
    print(result)
    ^
IndentationError: unindent does not match any outer indentation level

As funções devolvem explicitamente um valor ou um objeto através da palavra-chave return:

# Function definition on first line, explicit return used on final line.
def add_two_numbers(number_one, number_two):
  return number_one + number_two   


# Calling the function in the Python shell returns the sum of the numbers.
>>> add_two_numbers(3, 4)
7

# Assigning the function call to a variable and printing 
# the variable will also return the value.
>>> sum_with_return = add_two_numbers(5, 6)
>>> print(sum_with_return)
11

As funções que não têm uma expressão explícita a seguir a um return devolvem implicitamente o objeto None. Os detalhes de None serão abordados num conceito mais adiante. Para efeitos deste exercício e desta explicação, None é um marcador que representa nada, ou null:

# This function will return `None`
def square_a_number(number):
    square = number * number
    return # <-- note that this return is not followed by an expression

# Calling the function in the Python shell appears 
# to not return anything at all.
>>> square_a_number(2)
>>>


# Using print() with the function call shows that 
# the function is actually returning the **None** object.
>>> print(square_a_number(2))
None

As funções que omitem o return também devolvem implicitamente o objeto None. Isto significa que, se não usares return numa função, o Python devolve o objeto None por ti.

# This function omits a return keyword altogether
def add_two_numbers(number_one, number_two):
  result = number_one + number_two

>>> add_two_numbers(5, 7)
>>> print(add_two_numbers(5, 7))
None

# Assigning the function call to a variable and printing 
# the variable will also show None.
>>> sum_without_return = add_two_numbers(5, 6)
>>> print(sum_without_return)
None

Chamar funções

As funções são chamadas ou invocadas usando o seu nome seguido de (). A notação de ponto (.) usa-se para chamar funções definidas dentro de uma classe ou de um módulo.

>>> def raise_to_power(number, power):
...     return number ** power
...

>>> raise_to_power(3,3) # Invoking the function with the arguments 3 and 3.
27


# A mis-match between the number of parameters and the number of arguments will raise an error.
>>> raise_to_power(4,)
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: raise_to_power() missing 1 required positional argument: 'power'


# Calling methods or functions in classes and modules.
>>> start_text = "my silly sentence for examples."
>>> str.upper(start_text)  # <--Calling the upper() method from the built-in str class on start_text.
'MY SILLY SENTENCE FOR EXAMPLES.'

# Because a string is an instance of the str class, methods can also be called on them "directly".
>>> start_text = "my silly sentence for examples."
>>> start_text.upper()  # <--Calling the upper() method on start_text directly.
'MY SILLY SENTENCE FOR EXAMPLES.'

# Alternatively, we can skip the variable assignment (although this gets messy quick).
>>> "my silly sentence for examples.".upper()
'MY SILLY SENTENCE FOR EXAMPLES.'


# Importing the math module
>>> import math
>>> math.pow(2,4)  # <--Calling the pow() function from the math module.
16.0

Comentários

Os comentários em Python começam com um # que não faça parte de uma string e terminam no fim da linha. Ao contrário de muitas outras linguagens de programação, o Python não suporta marcas de comentário multilinha. Cada linha de um bloco de comentários tem de começar com o caráter #.

Os comentários são ignorados pelo intérprete:

# This is a single line comment.

x = "foo"  # This is an in-line comment.

# This is a multi-line
# comment block over multiple lines --
# these should be used sparingly.

Docstrings

A primeira instrução do corpo de uma função pode ser, opcionalmente, uma docstring, que resume de forma concisa o propósito da função ou do objeto. As docstrings declaram-se com três aspas duplas (""") indentadas ao mesmo nível do bloco de código:

# An example from PEP257 of a multi-line docstring
# reformatted to use Google style non-type hinted docstrings.
# Some additional details can be found in the Sphinx documentation:
# https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html#getting-started

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword Arguments:
        real (float): The real part of the number (default 0.0)
        imag (float): The imaginary part of the number (default 0.0)
        
    """

    if imag == 0.0 and real == 0.0:
        return complex_zero

As docstrings são lidas por ferramentas automáticas de documentação e são devolvidas ao chamar o atributo especial .__doc__ no nome da função, do método ou da classe. São recomendadas para programas de qualquer dimensão que precisem de documentação, e as suas convenções estão descritas na PEP257.

As docstrings também podem funcionar como testes unitários ligeiros, que podem ser lidos e executados pelo PyTest ou importando o módulo doctest. Os testes e o doctest serão abordados num conceito mais adiante.

# An example on a user-defined function using a Google style docstring. 
>>> def raise_to_power(number, power):
    """Raise a number to an arbitrary power.

    Parameters:
        number (int): The base number.
        power (int): The power to raise the base number to.
    
    Returns:
        int: The number raised to the specified power.
    
    Takes a number and raises it to the specified power, returning the result.

    """

    return number ** power
...

# Calling the .__doc__ attribute of the function and printing the result.
>>> print(raise_to_power.__doc__)
Raise a number to an arbitrary power.

Parameters:
    number (int): The base number.
    power (int): The power to raise the base number to.

Returns:
    int: The number raised to the specified power.

Takes a number and raises it to the specified power, returning the result.

...

# Printing the __doc__ attribute of the built-in type: str.
>>> print(str.__doc__)
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to 'utf-8'.
errors defaults to 'strict'.