NumPy para usuários MATLAB

Ref.: NumPy > NumPy for MATLAB users

NumPy para usuários MATLABIntroduçãoAlgumas diferenças chaveEquivalentes PróximosEquivalentes GeraisEquivalentes de álgebra linearNotas:array ou matrix? Qual devo usar?Solução curtaResposta longaExemplosPersonalizando seu ambienteFunções Simpleselif no lugar de *elseifArrays iniciam do zeroMatlab load/saveReferênciasUso do MATLAB

Introdução

MATLAB® e NumPy têm muito em comum, mas o NumPy foi criado para trabalhar com Python, não para ser um clone do MATLAB. Este guia ajudará os usuários do MATLAB a começar a usar o NumPy.

Algumas diferenças chave

MATLAB	Python/NumPy
No MATLAB, o tipo básico, mesmo para escalares, é uma matriz multidimensional. As atribuições de matrizes no MATLAB são armazenadas como matrizes 2D de números de ponto flutuante de precisão dupla, a menos que você especifique o número de dimensões e o tipo. As operações nas instâncias 2D dessas matrizes são modeladas em operações matriciais em álgebra linear.	No NumPy, o tipo básico é um `array` multidimensional. Atribuições de array no NumPy são geralmente armazenadas como arrays n-dimensionais com o tipo mínimo necessário para manter os objetos em sequência, a menos que você especifique o número de dimensões e o tipo. O NumPy realiza operações elemento por elemento, então multiplicar arrays 2D com ``, não é uma multiplicação de matrizes* – é uma multiplicação elemento por elemento. (O operador `@`, disponível desde o Python 3.5, pode ser usado para multiplicação de matrizes convencional.)
Índice no MATLAB iniciam em 1: `a(1)` corresponde ao primeiro elemento. See note INDEXING	No NumPy (assim como Python, ou lingaugem C, C++), os indices inicial em 0; `a[0]` corresponde ao primeiro elemento.
A linguagem de script do MATLAB foi criada para álgebra linear, então a sintaxe para algumas manipulações de array é mais compacta do que a do NumPy. Por outro lado, a API para adicionar GUIs e criar aplicativos completos é mais ou menos um reflexo tardio.	NumPy é baseado em Python, uma linguagem de uso geral. A vantagem do NumPy é o acesso a bibliotecas Python, incluindo: SciPy, Matplotlib, Pandas, OpenCV e muito mais. Além disso, o Python é frequentemente incorporado como uma linguagem de script em outros softwares, permitindo que o NumPy seja usado lá também.
O fatiamento de matriz MATLAB usa semântica passagem por valor (pass-by-value), com um esquema preguiçoso de cópia na gravação para evitar a criação de cópias até que sejam necessárias. As operações de fatiamento copiam partes da matriz.	O fatiamento da matriz NumPy usa passagem por referência (pass-by-reference), que não copia os argumentos. Operações de fatiamento são visualizações em uma matriz.

Equivalentes Próximos

A tabela abaixo fornece equivalentes aproximados para algumas expressões comuns de MATLAB. Estas são expressões semelhantes, não equivalentes. Para detalhes, consulte a documentação.

Na tabela abaixo, presume-se que você executou os seguintes comandos em Python:


xxxxxxxxxx
import numpy as np
from scipy import io, integrate, linalg, signal
from scipy.sparse.linalg import cg, eigs

Também suponha abaixo que quando se fala sobre “matriz”, os argumentos são entidades bidimensionais (2D).

Equivalentes Gerais

MATLAB	NumPy	Observações
`help func`	`info(func)` ou `help(func)` ou `func?` (No IPython)	Obtenha ajuda para função func.
`which func`	veja a nota AJUDA	Descobrir onde func é definida
`type func`	`np.source(func)` ou `func??` (No IPython)	Fonte de impressão para func (se não for uma função nativa)
`% comentário`	`# comentário (numa linha)`	Comentando uma linha de código com o texto
for i=1:3 fprintf('%i\n',i) end	for i in range(1, 4): print(i)	Usar um loop for para imprimir os números 1, 2 e 3 usando`range`.
`a && b`	`a and b`	Operador lógico AND (operador nativo Python); apenas argumentos escalares.
`a \|\| b`	`a or b`	Operador lógico OR (operador nativo Python); apenas argumentos escalares.
>> 4 == 4 ans = 1 >> 4 == 5 ans = 0 `	>>> 4 == 4 True >>> 4 == 5 False `	Os objetos booleanos em Python são True e False, ao contrário dos tipos lógicos 1 e 0 do MATLAB.
a=4 if a==4 fprintf('a = 4\n') elseif a==5 fprintf('a = 5\n') end `	a = 4 if a == 4: print('a = 4') elif a == 5: print('a = 5')	Cria uma instrução if-else para verificar se a é 4 ou 5 e imprima o resultado.
`1i`, `1j`, `1i`, `1j`	`1j`	Números Complexos.
`load data.mat`	`io.loadmat('data.mat')`	Carregar variáveis do MATLAB salvas no arquivo `data.mat`. (Observação: ao salvar matrizes em `data.mat` no MATLAB/Octave, use um formato binário recente. scipy.io.loadmat criará um dicionário com as matrizes salvas e informações adicionais.)

Equivalentes de álgebra linear

MATLAB	NumPy	Observações
`ndims(a)`	`np.ndim(a)` or `a.ndim`	número de dimensões da matriz`a`
`numel(a)`	`np.size(a)` or `a.size`	número de elementos da matriz`a`
`size(a)`	`np.shape(a)` or `a.shape`	“tamanho” da matriz`a`
`size(a,n)`	`a.shape[n-1]`	$n-$ ésema dimensão da matriz `a`. (Observe que o MATLAB usa indexação baseada em 1, enquanto o Python usa indexação baseada em 0, Consulte note INDEXING)
`[ 1 2 3; 4 5 6 ]`	`np.array([[1., 2., 3.], [4., 5., 6.]])`	Define um array 2D (matrix), de 2 linhas x 3 colunas.
`[ a b; c d ]`	`np.block([[a, b], [c, d]])`	Construir uma matriz a partir dos blocos `a`, `b`, `c` e `d`.
`a(end)`	`a[-1]`	Acessar o último elemento no vetor MATLAB (1 x n ou n x 1) ou matriz `a`NumPy 1D (length n).
`a(2,5)`	`a[1, 4]`	Acessar elemento na segunda linha, quinta coluna na matriz `a` 2D. (Lembrar que índides em Python iniciam em 0 e não em 1).
`a(2,:)`	`a[1]` or `a[1, :]`	Recuperar todas as coluna da 2a-linha do array `a`. (Lembrar que índides em Python iniciam em 0 e não em 1).
`a(1:5,:)`	`a[0:5]` or `a[:5]` or `a[0:5, :]`	Recuperar as 5 primeiras linhas (todas as colunas) do array `a.` (Lembrar que índides em Python iniciam em 0 e não em 1).
`a(end-4:end,:)`	`a[-5:]`	Últimas 5 colunas do array `a`.
`a(1:3,5:9)`	`a[0:3, 4:9]`	Acessar as 3 primeiras linhas , colunas 5 à 9 do array `a`.
`a([2,4,5],[1,3])`	`a[np.ix_([1, 3, 4], [0, 2])]`	Acessar as linhas 2, 4 e 5 e as colunas 1 e 3. Isso permite que uma nova matriz seja criada (ou modificada) e não requer um fatiamento regular (linear).
`a'`	`a.transpose()` or `a.T`	$a$ .
`a'`	`a.conj().transpose()` or `a.conj().T`	$a$ .
`a * b`	`a @ b` ou: `np.multiply(a, b)`	Multiplicação de matrizes.
`a .* b`	`a * b`	Multiplicação elemento à elemento (element-wise multiply). Somente em matrizes de mesmas dimensões.
`a./b`	`a/b`	Divisão elemento à elementos. Somente em matrizes de mesmas dimensões.
`a.^3`	`a**3`	Elevar à potência, elemento à elemento de uma matriz.
`(a > 0.5)`	`(a > 0.5)`	$i,j$ $a_{ij} > 0,5$ . O resultado do MATLAB é uma matriz de valores lógicos 0 e 1. O resultado do NumPy é uma matriz dos valores booleanos False e True. (Confirmar)
`find(a > 0.5)`	`np.nonzero(a > 0.5)`	$a$ $a > 0.5$ .
`a(:,find(v > 0.5))`	`a[:,np.nonzero(v > 0.5)[0]]`	$a$ $v>0.5$ .
`a(:,find(v>0.5))`	`a[:, v.T > 0.5]`	$a$ $v>0.5$ .
`a(:) = 3`	`a[:] = 3`	$a$ com valor 3.
`y=x`	`y = x.copy()`	NumPy: atribuição por referência (!?)
`y=x(2,:)`	`y = x[1, :].copy()`	NumPy: realizando fatiamento por referência.
`y=x(:)`	`y = x.flatten()`	Apenas no Python: transforma matriz em vetor 1D (observe que isso força uma cópia).
`x = 1:10`	`np.arange(1., 11.)` or `np.r_[1.:11.]` or `np.r_[1:10:10j]`	Cria um vetor com elementos crescentes com valores variando entre 1 à 10, passo inteiro 1 (veja a nota INTERVALOS). (Verificar parte do Python)
`x = 0:9`	`np.arange(10.)` or `np.r_[:10.]` or `np.r_[:9:10j]`	Cria um vetor com elementos crescentes com valores variando entre 0 à 9, passo inteiro 1 (veja a nota INTERVALOS). (Verificar parte do Python)
`x = [1:10]'`	`np.arange(1.,11.)[:, np.newaxis]`	Cria um vetor 1D contendo linhas com elementos variando de 1 até 10 (passo inteiro 1).
`zeros(3,4)`	`np.zeros((3, 4))`	Cria uma matriz 3 x 4 (2D), contendo apenas elementos nulos (zeros).
`zeros(3,4,5)`	`np.zeros((3, 4, 5))`	Cria uma matriz 3D, de dimensoes 3 x 4 x 5, contendo apenas elementos nulos (zeros).
`ones(3,4)`	`np.ones((3, 4))`	Cria uma matriz 2D, 3 x 4, onde todos os elementos possuem valor 1.
`eye(3)`	`np.eye(3)`	Cria uma matriz identidade 3 x 3.
`diag(a)`	`np.diag(a)`	$a$ .
rng(42,'twister'); rand(3,4)	from numpy.random import default_rng rng = default_rng(42) rng.random((3, 4)) ou usando versão mais antiga: `random.rand((3, 4))`	gerar uma matriz 3x4 aleatória com gerador de números aleatórios padrão e semente = 42.
`linspace(1,3,4)`	`np.linspace(1,3,4)`	4 amostras igualmente espaçadas entre 1 e 3, inclusive.
`[x,y]=meshgrid(0:8,0:5)`	`np.mgrid[0:9.,0:6.]` ou `np.meshgrid(r_[0:9.],r_[0:6.])`	duas matrizes 2D: uma de valores `x`, a outra de valores `y`.
	`ogrid[0:9.,0:6.]` or `np.ix_(np.r_[0:9.],np.r_[0:6.]`	a melhor maneira de avaliar funções em uma grade (grid). (!?)
`[x,y]=meshgrid([1,2,4],[2,4,5])`	`np.meshgrid([1,2,4],[2,4,5])`	(!?)
	`np.ix_([1,2,4],[2,4,5])`	a melhor maneira de avaliar funções em uma grade (grid). (!?)
`[a b]`	`np.concatenate((a,b),1)` ou `np.hstack((a,b))` or`np.column_stack((a,b))` ou `np.c_[a,b]`	Concatena (junta) colunas de `a` e `b`.
`[a; b]`	`np.concatenate((a,b))` or `np.vstack((a,b))` or `np.r_[a,b]`	Concatena linhas de `a`e `b`.
`max(max(a))`	`a.max()` or `np.nanmax(a)`	Maior elemento de `a` (com `ndims(a)<=2` para MATLAB, se houver NaN’s, `nanmax()` irá ignorá-los e retornar o maior valor) (!?)
`max(a)`	`a.max(0)`	Maior elemento do array `a`.
`max(a,[],2)`	`a.max(1)`	Maior elemento de ca linha do array `a`.
`max(a,b)`	`np.maximum(a, b)`	Compara `a` e `b`, elemento a elemento e retorna o valor máximo.
`a & b`	`logical_and(a,b)`	Operador lógico AND elemeno à elemento (NumPy ufunc !?) See note LOGICOPS.
`a \| b`	`np.logical_or(a,b)`	Operador lógico OR elemeno à elemento (NumPy ufunc !?) See note LOGICOPS.
`inv(a)`	`linalg.inv(a)`	Inversa da matriz `a` (2D).
`pinv(a)`	`linalg.pinv(a)`	Pseudo-inversa da matriz `a` (2D).
`rank(a)`	`np.linalg.matrix_rank(a)`	Ranking da matriz 2D `a`
`a\b`	`linalg.solve(a, b)` Se `a` é quadrada; `linalg.lstsq(a, b)` caso contrario.	$a \cdot x = b$ $x$ . (Verificar)
`b/a`	Solve `a.T x.T = b.T` instead	$a \cdot x = b$ $x$ . (Verificar)
`[V,D]=eig(a)`	`D,V = linalg.eig(a)`	$\lambda$ $v$ `a` $a \cdot v = \lambda \cdot v$ .
`[V,D]=eig(a,b)`	`D,V = linalg.eig(a, b)`	$\lambda$ $v$ `a` $a \cdot v = \lambda \cdot b \cdot v$ .
`[V,D]=eigs(a,3)`	`D,V = eigs(a, k=3)`	$k=3$ maiores autovalores e autovetores da matriz 2D, `a`.
`[Q,R]=qr(a,0)`	`Q,R = linalg.qr(a)`	Decomposição QR.
`fft(a)`	`np.fft.fft(a)`	Transformada de Fourier de `a` (apenas algoritmo FFT, não espectro do sinal!)
`ifft(a)`	`np.fft.ifft(a)`	Transforda Inversa de Fourier de `a`
`sort(a)`	`np.sort(a)` or `a.sort(axis=0)`	Ordenar os elementos do array `a`

Notas:

Sub-matrizes: A atribuição a uma sub-matriz pode ser feita com listas de índices usando o comando ix_. Por exemplo, para a matriz 2D a, pode-se ober com: ind=[1, 3]; a[np.ix_(ind, ind)] += 100(!?).

HELP: (AJUDA): Não há um equivalente direto do comando which no MATLAB, mas os comandos help geralmente listarão o nome do arquivo onde a função está localizada (!?). O Python também tem um módulo inspect (do import inspect) que fornece um getfile que geralmente funciona.

INDEXAÇÃO: O MATLAB usa uma indexação baseada em 1, portanto, o elemento inicial de uma sequência tem índice 1. Python usa indexação baseada em zero, então o elemento inicial de uma sequência tem índice 0.

RANGES (FAIXAS): No MATLAB, 0:5 pode ser usado tanto como um literal de intervalo quanto como um índice de ‘fatia’ (slices) (dentro de parênteses); no entanto, em Python, construções como 0:5 podem somente ser usadas como um índice de fatiamento (slices) (dentro de colchetes).

LOGICOPS (OPERADORES LÓGICOS): & ou | em NumPy são AND/OR bit a bit, enquanto no MATLAB, & e | são operadores lógicos AND/OR. Os dois podem parecer funcionar da mesma forma, mas há diferenças importantes. Se você estiver usado os operadores & ou | do MATLAB, você deveria usar o NumPy ufuncs logical_and/logical_or. As diferenças notáveis entre os operadores & e | do MATLAB e do NumPy são:

Entradas não lógicas {0,1}: a saída do NumPy é o AND bit a bit das entradas. O MATLAB trata qualquer valor diferente de zero como 1 e retorna o AND lógico. Por exemplo, (3 & 4) no NumPy é 0, enquanto no MATLAB tanto 3 quanto 4 são considerados verdadeiros lógicos e (3 & 4) retorna 1.
Precedência: O operador & do NumPy tem precedência maior do que operadores lógicos como < e >; No MATLAB é o inverso.

Se você sabe que tem argumentos booleanos, você pode se safar usando os operadores bitwise do NumPy, mas tenha cuidado com parênteses, como este: z = (x > 1) & (x < 2). A ausência de formas de operadores NumPy de logical_and e logical_or é uma consequência infeliz do design do Python.

RESHAPE e INDEXAÇÃO LINEAR: O MATLAB sempre permite que matrizes multidimensionais sejam acessadas usando índices escalares ou lineares, o NumPy não. Índices lineares são comuns em programas MATLAB, por exemplo, find() em uma matriz os retorna, enquanto o find() do NumPy se comporta de forma diferente. Ao converter o código MATLAB, pode ser necessário primeiro remodelar uma matriz para uma sequência linear, executar algumas operações de indexação e então remodelar de volta. Como o reshape (geralmente) produz visualizações no mesmo armazenamento, deve ser possível fazer isso de forma bastante eficiente. Observe que a ordem de varredura usada por reshape no NumPy é padronizada para o padrão da linguagem C, enquanto o MATLAB usa o padrão da linguagem Fortran. Se você estiver simplesmente convertendo para uma sequência linear e vice-versa, isso não importa. Mas se você estiver convertendo remodelações do código MATLAB que depende da ordem de varredura, então este código MATLAB: z = reshape(x,3,4); deve se tornar algom como: z = x.reshape(3,4,order='F').copy() no NumPy.

array ou matrix? Qual devo usar?

Historicamente, o NumPy forneceu um tipo de matriz especial, np.matrix, que é uma subclasse de ndarray que faz operações binárias de álgebra linear. Você pode vê-lo usado em algum código existente em vez de np.array. Então, qual usar?

Solução curta

Use arrays.

Eles suportam a álgebra de matriz multidimensional que é suportada no MATLAB.
Eles são o tipo de vetor/matriz/tensor padrão do NumPy. Muitas funções NumPy retornam matrizes, não matrizes.
(Tensor no Python significa matrizes 3D).
Há uma distinção clara entre as operações de elementos e as operações de álgebra linear.
Você pode ter vetores padrão ou vetores de linha/coluna, se quiser.

Até o Python 3.5, a única desvantagem de usar o tipo array era que você tinha que usar dot em vez de * para multiplicar (reduzir) dois tensores (produto escalar, multiplicação de vetores de matriz etc.). Desde o Python 3.5, você pode usar o operador de multiplicação de matriz @.

Diante do exposto, pretende-se descontinuar o uso de matrix (eventualmente).

Resposta longa

NumPy contém uma classe array e uma classe matrixarray $n-$ dimensional de propósito geral para muitos tipos de computação numérica, enquanto matrix tem a intenção de facilitar cálculos de álgebra linear especificamente. Na prática, há apenas um punhado de diferenças importantes entre as duas.

Operatores * e @, funções dot(), e multiply():
- Para array, * significa multiplicação elemento a elemento, enquanto @ significa multiplicação de matrizes; eles têm funções associadas multiply() e dot(). (Antes do Python 3.5, @ não existia e era preciso usar dot() para multiplicação de matrizes).
- Para matrix, * significa multiplicação de matrizes, e para multiplicação elemento a elemento, é preciso usar a função multiply().

Há prós e contras em usar ambos:

array
- 😄 A multiplicação elemento a elemento é fácil: A*B.
- 😟 Você deve lembrar que a multiplicação de matrizes tem seu próprio operador, @.
- 😄 Você pode tratar arrays unidimensionais como vetores de linha ou coluna. A @ v trata v como um vetor de coluna, enquanto v @ A trata v como um vetor de linha. Isso pode evitar que você tenha que realizar muitas transposições.
- 😄 array é o tipo NumPy “padrão”, por isso é o mais testado e é o tipo com maior probabilidade de ser retornado por código de terceiros que usa NumPy.
- 😄 É bastante facilitado o manuseio de dados de qualquer número de dimensões.
- 😄 Mais próximo em semântica da álgebra tensorial, se você estiver familiarizado com isso.
- 😄 Todas as operações (*, /, +, - etc.) são feitas elemento por elemento.
- 😟 Matrizes esparsas de scipy.sparse não interagem tão bem com arrays.
matrix
- 😄 O comportamento é mais parecido com o das matrizes do MATLAB.
- 😟 Máxima dimensão é 2D (bidimensional). Para armazenar dados tridimensionais, você precisa de array ou talvez uma lista Python de matrix.
- 😟 Mínimo de bidimensional. Você não pode ter vetores. Eles devem ser convertidos como matrizes de coluna única ou linha única.
- 😟 Como array é o padrão no NumPy, algumas funções podem retornar um array mesmo se você der a elas uma matrix como argumento. Isso não deveria acontecer com funções NumPy (se acontecer, é um bug), mas códigos de terceiros baseados em NumPy podem não honrar a preservação de tipos como o NumPy faz.
- 😄 A*B é uma multiplicação de matrizes, então parece que você a escreveu em álgebra linear (para Python >= 3.5, matrizes simples têm a mesma conveniência com o operador @).
- 😟 A multiplicação elemento a elemento requer a chamada de uma função, multiply(A,B).
- 😟O uso de sobrecarga de operadores é um pouco ilógico: * não funciona em termos de elementos, mas / funciona.
- 😕 A interação com scipy.sparse é um pouco mais clara.

O array é, portanto, muito mais aconselhável de usar. De fato, pretende-se descontinuar matrix.

Exemplos

Multiplicação elemento por elemento vs multiplicação de matrizes no Python


xxxxxxxxxx
import numpy as np
# Matrizes de exemplo
A = np.array([[1, 2], [3, 4]])  # 2x2
B = np.array([[5, 6], [7, 8]])  # 2x2
# Produto matricial
C_matricial = A @ B # ou np.dot(A, B) ou np.matmul(A, B)
print("Produto matricial (@):\n", C_matricial)
# Multiplicação elemento a elemento
C_elemento = A * B # Isso NÃO é multiplicação matricial!
print("\nElemento a elemento (*):\n", C_elemento)

Saída:


xxxxxxxxxx
Produto matricial (@):
 [[19 22]
 [43 50]]
Elemento a elemento (*):
 [[ 5 12]
 [21 32]]

Personalizando seu ambiente

No MATLAB, a principal ferramenta disponível para você personalizar o ambiente é modificar o caminho de busca com os locais de suas funções favoritas. Você pode colocar essas personalizações em um script de inicialização que o MATLAB executará na inicialização.

NumPy, ou melhor, Python, tem recursos semelhantes.

Para modificar seu caminho de pesquisa Python para incluir os locais de seus próprios módulos, defina a variável de ambiente PYTHONPATH.
Para que um arquivo de script específico seja executado quando o interpretador Python interativo for iniciado, defina a variável de ambiente PYTHONSTARTUP para conter o nome do seu script de inicialização.

Ao contrário do MATLAB, onde qualquer coisa em seu caminho pode ser chamada imediatamente, com Python você precisa primeiro fazer uma instrução ‘import’ para tornar as funções em um arquivo específico acessíveis.

Por exemplo, você pode fazer um script de inicialização parecido com este (Nota: este é apenas um exemplo, não uma declaração de "melhores práticas"):


# Make all numpy available via shorter 'np' prefix
import numpy as np
#
# Make the SciPy linear algebra functions available as linalg.func()
# e.g. linalg.lu, linalg.eig (for general l*B@u==A@u solution)
from scipy import linalg
#
# Define a Hermitian function
def hermitian(A, **kwargs):
    return np.conj(A,**kwargs).T
# Make a shortcut for hermitian:
#    hermitian(A) --> H(A)
H = hermitian

Para usar a matriz obsoleta e outras funções matlib:


# Make all matlib functions accessible at the top level via M.func()
import numpy.matlib as M
# Make some matlib functions accessible directly at the top level via, e.g. rand(3,3)
from numpy.matlib import matrix,rand,zeros,ones,empty,eye

Funções Simples

Python e Matlab são similares em muitos aspectos, sintaticamente e semanticamente. Com a adição da biblioteca NumPy em Python, quase todas as operações numéricas em Matlab podem ser emuladas ou traduzidas diretamente. Aqui estão funções em cada linguagem que realizam a mesma operação:


xxxxxxxxxx
% Matlab
function [result] = times_two(number)
    result = number * 2;
end


xxxxxxxxxx
# Python
def times_two(number):
    result = number * 2
    return result

Algumas notas sobre as funções anteriores:

Os valores são retornados explicitamente com a instrução return. É possível retornar vários valores, como no Matlab, mas fazer isso sem um bom motivo pode levar a funções muito complicadas.
Ponto e vírgula não são usados para terminar instruções em python, e o espaço em branco é significativo. Depois que um bloco é iniciado (if, for, while, funções, classes), as linhas subsequentes devem ser recuadas com quatro espaços. O bloco termina quando o programador para de adicionar o nível extra de recuo.

elif no lugar de *elseif

Altere blocos elseif para blocos elif.

Código exemplo Python:


xxxxxxxxxx
if thing == 0:
    do_thing1()
elif thing ==1:
    do_thing2()
else:
    do_the_last_thing()

Arrays iniciam do zero

Os índices Python começam em zero em vez de um. As fatias de array e as operações de intervalo não incluem o limite superior, então apenas o limite inferior deve diminuir em um. Os exemplos a seguir são de código Python no console:


xxxxxxxxxx
>>> test_array = [0, 1, 2, 3, 4]
>>> test_array[0]
0
>>> test_array[1]
1
>>> test_array[0:2]
[0, 1]
>>>>>> test_array[:2]
[0, 1]
>>> test_array[2:]
[2, 3, 4]
>>>

Ponto e vírgula no Matlab são usados para suprimir saída no final das linhas e para organizar literais de array. Após organizar os arrays em listas aninhadas, todos os pontos e vírgulas podem ser removidos.
A palavra-chave end no Matlab é usada tanto para acessar o último elemento em um array quanto para fechar blocos. O caso de uso array pode ser substituído por -1 e os outros podem ser removidos completamente:


xxxxxxxxxx
>>> test_array = [0, 1, 2, 3, 4]
>>> test_array[-1]
4
>>>

Matlab load/save

O Matlab tem funções internas para salvar e carregar variáveis automaticamente de seus programas para o disco. Usar essas funções pode levar a um design de programa ruim e deve ser evitado, se possível. Seria melhor refatorar conforme você traduz, se elas estiverem sendo usadas. Poucas operações são tão caras que não podem ser refeitas toda vez que o programa é executado. Para a parte do programa que salva variáveis, considere fazer uma função que simplesmente as retorne.

Se seu programa Matlab estiver carregando arquivos .csv, então use a biblioteca Pandas ao trabalhar em python. Pandas funciona bem com NumPy e é a biblioteca ideal ao usar arquivos csv que contêm dados numéricos.

Referências

Outra referência cruzada MATLAB/NumPy um tanto desatualizada pode ser encontrada em http://mathesaurus.sf.net/

Uma extensa lista de ferramentas para trabalho científico com Python pode ser encontrada na página de software tópico.

Consulte Lista de software Python: script para uma lista de softwares que usam Python como linguagem de script

MATLAB® e SimuLink® são marcas registradas da The MathWorks, Inc.

Outras referências:

Eventualmente você queira "espiar": Replacing MATLAB with Python - Part 1.
Guia Volttron > Python for Matlab Users.
Guia A Python Primer for Matlab Users.
Video da Datacamp: Welcome to Python: Python for MATLAB users.

Uso do MATLAB

O MATLAB ainda é amplamente utilizado, especialmente nas indústrias automotiva e aeroespacial, mas o uso do Python cresceu drasticamente em muitos setores diferentes, já que ele pode ser usado para muitas outras coisas - como eu disse, para fins gerais.

Fernando Passold, em 06/04/2025