Conhecimentos prévios em Python

Anexo 1 do tutorial em vídeo - sintaxe python: https://singtown.com/learn/50061/

Vantagens de usar python

O OpenMV pode usar Python para desenvolvimento. Existem vários benefícios:

Fácil de começar
Não é necessário se preocupar com alocação e liberação de memória
Existem muitas bibliotecas MicroPython que podem ser usadas diretamente (não são compatíveis com os módulos Python de PC)
A equipe de desenvolvimento criou diversos algoritmos e módulos para o OpenMV usar

Python é uma linguagem muito utilizada, amplamente aplicada em processamento de imagens, aprendizado de máquina e programação de redes. E Python é uma linguagem muito fácil de usar. Se você já tem experiência de programação em outras linguagens (como C, C++, Java), será mais fácil começar.

Se você já tem experiência anterior de programação em C/C++/Java (ou qualquer outra linguagem), recomendo\ o Tutorial de Python de Liao Xuefeng
Se você não tem experiência de programação anterior, recomenda-se\ Learn Python the hard way

REPL e porta serial

A IDE do OpenMV vem com um assistente de porta serial para conectar ao OpenMV, e também pode se conectar a outras portas seriais, como Arduino, pyboard, esp8266.

Primeiro, desconecte o OpenMV da IDE, caso contrário a porta serial entrará em conflito!

Abra Ferramentas → Abrir Terminal → Novo Terminal no OpenMV

Digite no terminal

print("hello OpenMV!")

Ele exibirá

hello OpenMV!

Sintaxe Python

Saída

Use print() para adicionar uma string entre parênteses e exibir o texto especificado na tela. Por exemplo, para exibir 'hello, world', o código é o seguinte:

   print('hello, world')

hello, world

A função print() também pode aceitar múltiplas strings, separadas por vírgulas ",", e então elas podem ser concatenadas em uma string para saída:

  print('The quick brown fox', 'jumps over', 'the lazy dog')

The quick brown fox jumps over the lazy dog

print() imprimirá cada string em sequência, e um espaço será exibido ao encontrar uma vírgula ",", de modo que a string de saída é montada assim:

The quick brown fox jumps over the lazy dog

print() também pode imprimir números inteiros ou resultados de cálculos:

  print(300)

  print(100 + 200)

Portanto, podemos imprimir o resultado do cálculo 100 + 200 de forma mais elegante:

   print('100 + 200 =', 100 + 200)

100 + 200 = 300

Observe que, para 100 + 200, o interpretador Python calcula automaticamente o resultado 300, mas '100 + 200 =' é uma string, não uma fórmula matemática, e o Python a trata como uma string.

Variáveis

Em Python, o sinal de igual = é uma instrução de atribuição, que pode atribuir qualquer tipo de dado a uma variável. A mesma variável pode ser atribuída repetidamente, podendo ser uma variável de tipos diferentes, por exemplo:

  a = 123 # a é um número inteiro
  print(a)
  a = 'ABC' # a se torna uma string
  print(a)

Essa linguagem em que o tipo da variável em si não é fixo é chamada de linguagem dinâmica, e o seu oposto é a linguagem estática. Linguagens estáticas exigem que o tipo da variável seja especificado ao defini-la. Se o tipo não corresponder ao atribuir um valor, um erro será reportado. Por exemplo, Java é uma linguagem estática, e a instrução de atribuição é a seguinte (// indica um comentário):

  int a = 123; // a é uma variável do tipo inteiro
  a = "ABC"; // erro: não é possível atribuir uma string a uma variável do tipo inteiro

Em comparação com linguagens estáticas, as linguagens dinâmicas são mais flexíveis, e é por isso.

Lista

Um dos tipos de dados embutidos do Python é a lista: list. Uma lista é uma coleção ordenada na qual elementos podem ser adicionados e removidos a qualquer momento.\ Por exemplo, para listar os nomes de todos os colegas da turma, você pode usar uma lista para representá-los:

 classmates = ['Michael', 'Bob', 'Tracy']
 classmates

['Michael', 'Bob', 'Tracy']

A variável classmates é uma lista. Use a função len() para obter o número de elementos da lista:

  len(classmates)

Use o índice para acessar o elemento em cada posição da lista. Lembre-se de que o índice começa em 0:

 classmates[0]

'Michael'

 classmates[1]

'Bob'

 classmates[2]

'Tracy'

 classmates[3]

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Quando o índice está fora do intervalo, o Python reportará um erro IndexError, então certifique-se de que o índice não ultrapasse o limite. Lembre-se de que o índice do último elemento é len(classmates) - 1.

Se você quiser obter o último elemento, além de calcular a posição do índice, você também pode usar -1 como índice para obter o último elemento diretamente:

  classmates[-1]

'Tracy'

Por analogia, você pode obter o penúltimo e o antepenúltimo:

   classmates[-2]

'Bob'

   classmates[-3]

'Michael'

   classmates[-4]

Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  IndexError: list index out of range

É claro que o quarto a partir do fim está fora dos limites.

Uma lista é uma lista ordenada mutável, então você pode adicionar elementos ao final da lista:

  classmates.append('Adam')
  classmates

  ['Michael', 'Bob', 'Tracy', 'Adam']

Você também pode inserir elementos em uma posição especificada, como o índice 1:

  classmates.insert(1, 'Jack')
  classmates

  ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

Para remover um elemento do final de uma lista, use o método pop():

  classmates.pop()

  'Adam'

  classmates

  ['Michael', 'Jack', 'Bob', 'Tracy']

Para substituir um elemento por outro, você pode atribuir diretamente o valor à posição de índice correspondente:

   classmates[1] = 'Sarah'

 classmates
  ['Michael', 'Sarah', 'Tracy']

Os tipos de dados dos elementos em uma lista também podem ser diferentes, por exemplo:

   L = ['Apple', 123, True]

Se uma lista não tiver elementos, ela é uma lista vazia com comprimento 0:

 L = []

 len(L)

 0

Tupla

Outra lista ordenada é chamada de tupla. Tuplas são muito semelhantes a listas, mas, uma vez inicializada, uma tupla não pode ser modificada. Por exemplo, também listando os nomes dos colegas de classe:

  classmates = ('Michael', 'Bob', 'Tracy')

Agora, a tupla classmates não pode ser alterada, e ela não possui métodos como append() e insert(). Outros métodos para obter elementos são os mesmos das listas. Você pode usar classmates[0] e classmates[-1] normalmente, mas não pode atribuí-los a outros elementos.

Qual é o significado de tuplas imutáveis? Como as tuplas são imutáveis, o código é mais seguro. Se possível, use tuplas em vez de listas.

Armadilha da tupla: quando você define uma tupla, os elementos da tupla devem ser determinados no momento da definição, por exemplo:

  t = (1, 2)

  t

  (1, 2)

No entanto, para definir uma tupla com apenas 1 elemento, se você a definir assim:

   t = (1)

   t

   1

A definição não é uma tupla, t é uma variável inteira, e o valor da variável t é 1! Isso ocorre porque os parênteses () podem representar tanto tuplas quanto parênteses em fórmulas matemáticas, o que gera ambiguidade. Portanto, o Python determina que, nesse caso, o cálculo é feito de acordo com os parênteses, e o resultado do cálculo é naturalmente 1.

Portanto, uma vírgula, ,, deve ser adicionada ao definir uma tupla com apenas 1 elemento para eliminar a ambiguidade:

   t = (1,)

   t

  (1,)

O Python também adiciona uma vírgula, ,, ao exibir uma tupla com apenas 1 elemento, para que você não a confunda com um parêntese no sentido de cálculo matemático.

Estruturas condicionais

A forma completa da instrução if é:

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

Por exemplo:

age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

Laços de repetição

Python tem dois tipos de laços de repetição. Um é o laço for...in, que percorre cada elemento na lista ou tupla em sequência. Veja o exemplo:

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

Executar este código imprimirá cada elemento de names em sequência:

  Michael
  Bob
  Tracy

Então o laço for x in ... substitui cada elemento na variável x, e então executa as instruções no bloco indentado.

Se você quiser calcular a soma dos inteiros de 1 a 100, é um pouco difícil escrever de 1 a 100. Felizmente, o Python oferece a função range(), que pode gerar uma sequência de inteiros, que pode ser convertida em uma lista por meio da função list(). Por exemplo, range(5) gera uma sequência de inteiros menores que 5 começando em 0:

  list(range(5))

  [0, 1, 2, 3, 4]

range(101) pode gerar uma sequência de inteiros de 0 a 100, e o cálculo é o seguinte:

sum = 0
for x in range(101):
    sum = sum + x
print(sum)

O segundo laço é o laço while. Por exemplo, se quisermos calcular a soma de todos os números ímpares dentro de 100, podemos usar um laço while para implementá-lo:

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

===== Conversão de tipo de dado =====

As funções comuns embutidas do Python também incluem funções de conversão de tipo de dado, como a função int(), que pode converter outros tipos de dados em inteiros:

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

===== Função =====

Em Python, para definir uma função, você precisa usar a instrução def, escrever o nome da função, os parênteses, os parâmetros entre parênteses e os dois pontos em sequência, depois escrever o corpo da função no bloco indentado, e retornar o valor da função com a instrução return.

Vamos primeiro escrever uma função para calcular x2:

def power(x):
    return x * x

Para a função power(x), o parâmetro x é um parâmetro posicional.

Quando chamamos a função power, devemos passar um, e apenas um, parâmetro x:

power(5)\ 25\ power(15)\ 225

Agora, e se quisermos calcular x3? Podemos definir outra função power3, mas e se quisermos calcular x4, x5, etc.? Não podemos definir infinitas funções.

Você deve ter pensado que podemos modificar power(x) para power(x, n) para calcular xn, e fazer isso imediatamente:

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

Para essa função power(x, n) modificada, podemos calcular qualquer potência de n:

power(5, 2)\ 25\ power(5, 3)\ 125

A função power(x, n) modificada tem dois parâmetros: x e n. Ambos os parâmetros são posicionais. Ao chamar a função, os dois valores passados são atribuídos aos parâmetros x e n na ordem de posição.

Fatiamento (Slicing)

Pegar parte de uma lista ou tupla é uma operação muito comum. Por exemplo, uma lista é a seguinte:

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

Pegue os primeiros 3 elementos e fatie-os com uma linha de código:

L[0:3]\ ['Michael', 'Sarah', 'Tracy']

L[0:3] significa começar no índice 0 e terminar no índice 3, mas sem incluir o índice 3. Ou seja, os índices 0, 1 e 2 são exatamente 3 elementos.

Se o primeiro índice for 0, ele pode ser omitido:

L[:3]\ ['Michael', 'Sarah', 'Tracy']

Você também pode começar no índice 1 e pegar 2 elementos:

L[1:3]\ ['Sarah', 'Tracy']

Tupla também é um tipo de lista, a única diferença é que a tupla é imutável. Portanto, tuplas também podem ser operadas com fatias, mas o resultado da operação ainda é uma tupla:

(0, 1, 2, 3, 4, 5)[:3]\ (0, 1, 2)

A string 'xxx' também pode ser considerada uma lista, e cada elemento é um caractere. Portanto, strings também podem ser operadas com fatias, mas o resultado da operação ainda é uma string:

'ABCDEFG'[:3]\ 'ABC'

Objeto

Python é uma programação orientada a objetos, como um LED

from pyb import LED

red_led = LED(1)
red_led.on()

LED é uma classe, red_led é um objeto, e esse objeto pode ser operado, como ligar, desligar e verificar o valor.

Módulo

Uso de módulo

Conhecimentos básicos de Python