Going from MATLAB to Python does introduce quite a bit of syntax overhead. One way to quantify it is the nice QuantEcon cheatsheet which showcases how there's a lot of extra "stuff" going on when trying to write simple linear algebra commands in Python. The verbose NumPy syntax is really just a symptom of how it was not developed as a technical computing language, so unlike in languages like MATLAB and Julia, scientific computing commands like those in linear algebra did not get nice special syntax. It's a small issue, but it does add up.
In general you can do what you did in MATLAB and translate it over to Python, but there are some caveats. There are a lot of areas in the standard scientific libraries in Python which are still underdeveloped. For example, in SciPy you won't find DAEs, so there's no direct alternative to
ode15i. In addition, benchmarks do show that moving from MATLAB to Python will give a performance hit on non-stiff ODEs, and will give a performance hit on stiff ODEs if you don't use
LSODA. This is where the dark side of SciPy's differential equation support appears. Its
LSODA wrappers are by far its most efficient methods, but it just turns out that these are missing a lot of features. If you search the solve_ivp documentation page, you'll see for example that Jacobian sparsity handling and a bunch of other options are not available when using those methods, which means SciPy doesn't really have a good option when the stiff problems get difficult. There are lot of other issues to point out, like the stability of its event handling system, etc. So "it supports" a lot (but not all) of the things from MATLAB, but in many cases you can only use that option if you use the slow methods and/or the features are prone to bugs.
But there are other alternatives you might want to look at. Octave and Scilab are free MATLAB alternatives but once again lack a lot of the differential equation solver features you'd expect from MATLAB, such as event handling on DAEs. I also find that R's deSolve is much better behaved than SciPy, so that's worth a look too.
However, one alternative you may want to consider above all of those is Julia. As shown in the benchmarks above, switching from MATLAB to Julia can give around a 100x acceleration (usually we see around 20x-30x in real-world scenarios). The DifferentialEquations.jl library in Julia has a feature superset of the MATLAB ODE suite, which includes high order, implicit, adaptive, etc. methods for ODEs, SDEs, DAEs, DDEs, etc. The event handling is more fully featured, for example allowing changing the number of ODEs along the way, and features like automated GPU-acceleration and parameter estimation with adjoint sensitivities is built right into the library.
If you want a deeper overview of what's out there, I wrote a blog post that went into detail on what the methods are, the history behind them, and how they are evolving/continuing to be wrapped.
(Disclosure: I am the developer of the Julia DifferentialEquations.jl library, so please feel free to follow the links, look at the documentations, and re-run the benchmarks on your own computer to independently verify any statements.)