The following is an incomplete set of functions to export Mathematica formulas to Python functions. While you could conceivably use simpy, I find that this is somewhat easier and does not require third-party libraries. It is also a useful example of how to manipulate Mathematica expressions with pattern matching.

The core routine is simply a loop that converts an expression to Python, preceding it with variable definitions that have been created along the process.

Clear[ToPython];
ToPython[expression_,extravars_:{},outputvar_:"output",indent_:""]:=
Block[{
(* Python code that precedes our expression.
 Includes auxiliary vars and functions *)
PythonBuffer="",
(* Last number of defined variable *)
PythonVar=0,
(* Spaces to indent each line of Python code *)
PythonIndent=indent,
(* Was Sqrt[] used? Then we have to define it *)
PythonSqrt=False,
(* Was Pi used? We define π variable in Python *)
PythonPi=False},
(* We begin by parsing 'extravars' which is a list
{{var1, exp1},{var2,exp2},...}
of variables that are used in our formula. This is used for
simplifying expressions, as shown later on. *)
Do[
Module[{var=def[[1]],value=def[[2]]},
PythonBuffer=PythonBuffer<>PythonIndent<>ToString[var]<>"="<>ToPython2[value]<>";\n"],
{def,extravars}];
(*
  The actual conversion takes place here, recursively
 calling the function ToPython2, which does the work.
 *)
Module[{aux=ToPython2[expression]},
(* If Sqrt[] was used, we introduce a function that works with
  complex numbers, since np.sqrt does not *)
If[PythonSqrt,
PythonBuffer=PythonIndent<>"def mysqrt(x): return np.sqrt((1.+0j)*x)\n\n"<>PythonBuffer];
(* Define π as a Python variable *)
If[PythonPi,
PythonBuffer=PythonIndent<>"π=math.pi;\n\n"<>PythonBuffer];
(* Output Python code preceded by all variable definitions. *)
PythonBuffer<>PythonIndent<>outputvar<>"="<>aux<>";\n"]];

The following is a key piece of code. Essentially, PythonWrap converts an expression into Python. If that expression is too long, it is stored in an auxiliary variable. We do this to make the code more readable. It also takes care (in a very imperfect way) of parenthesis.

Clear[ToPythonVar];
ToPythonVar[a_]:=
Module[{name="aux"<>ToString[PythonVar]},
PythonBuffer=PythonBuffer<>PythonIndent<>name<>"="<>a<>";\n";
PythonVar=PythonVar+1;
name];

Clear[AlreadyWrapped];
AlreadyWrapped[s_]:=(StringPosition[s,"("]=={{1,1}})&&(StringPosition[s,")"]=={{StringLength[s],StringLength[s]}});

Clear[PythonWrap];
PythonWrap[expa_,limit_:70]:=
Module[{a=ToPython2[expa]},
If[StringLength[a]>limit,
ToPythonVar[a],
If[Not[AtomQ[expa]]&&!AlreadyWrapped[a],
"("<>a<>")",
a]]];

Then comes the actual conversion. We only have included some conversions that are needed in our code. Feel free to add more. It is easy!

(* Conversions for the most common expressions *)
Clear[ToPython2];
ToPython2[Sqrt[x_]]:=Module[{},
PythonSqrt=True;
"mysqrt("<>PythonWrap[x]<>")"];
ToPython2[Log[x_]]:="np.log("<>PythonWrap[x]<>")"
ToPython2[Exp[x_]]:="np.exp("<>PythonWrap[x]<>")"
ToPython2[Sin[x_]]:="np.sin("<>PythonWrap[x]<>")"
ToPython2[Cos[x_]]:="np.cos("<>PythonWrap[x]<>")"
ToPython2[(E^(x_))]:="np.exp("<>PythonWrap[x]<>")"
ToPython2[E^x_]:="np.exp("<>PythonWrap[x]<>")"
ToPython2[a_+b_]:=ToPythonOp["+",a,b]
ToPython2[a_*b_]:=ToPythonOp["*",a,b]
ToPython2[a_-b_]:=ToPythonOp["-",a,b]
ToPython2[a_/b_]:=ToPythonOp["/",a,b]
ToPython2[a_^2]:="("<>PythonWrap[a]<>"**2)"
ToPython2[a_^b_]:=PythonWrap[ToPythonOp["**",a,b]]
ToPython2[x_?NumberQ]:=
If[Head[x]===Complex,
"("<>ToPython2[Re[x]]<>"+"<>ToPython2[Im[x]]<>"j)",
ToString[N[x]]];
ToPython2[-x_]:="(-"<>ToPython2[x]<>")"
ToPython2[π]:=Module[{},PythonPi=True;"π"]
ToPython2[γ]:="γ"
ToPython2[Ω]:="Ω"
ToPython2[Δ]:="Δ"
ToPython2[x_]:=ToString[x];

(* This is for converting inline operations *)
Clear[ToPythonOp];
ToPythonOp[op_,expa_,expb_]:=
PythonWrap[expa]<>op<>PythonWrap[expb];

One example of use

ToPython[Exp[g*Log[(-3+2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])) (Ω^2)]/Log[(-1+2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])) (Ω^2)]]]

This is a more complicated example:

ExpP[Ω_,Δ_, g_, γ_]:= Exp[-((g^2) (2 π (Sqrt[((1-2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)]))/(-1+2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])))]) (Δ^5) Ω-(1-2 (π^2) (γ^2)-2 π γ (Sqrt[-1+(π^2) (γ^2)])) (Ω^4)) Log[-(1/((Sqrt[1-2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])]) Ω))]+2 (Δ^5) Ω Log[(1/((Sqrt[1-2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])]) Ω))]-2 (π^2) (γ^2) (Sqrt[1-2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])]) (Ω^6) Log[(-1+2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])) (Ω^2)]+2 π γ (Sqrt[-1+(π^2) (γ^2)]) (Sqrt[1-2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])]) (Ω^6) Log[(-1+2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])) (Ω^2)])/(π (Sqrt[-1+(π^2) (γ^2)]) (Sqrt[1-2 (π^2) (γ^2)+2 π γ (Sqrt[-1+(π^2) (γ^2)])]) ((((Δ^4)+2 (-1+2 (π^2) (γ^2)) (Δ^2) (Ω^2)+(Ω^4)))^2))];

We export to Python after simplifying the expression a little bit, to reducethe number of variables.

Code=Block[{$Assumptions={Ω>0,γ>0,y>0}},
Module[{aux=ExpP[Ω,Δ, g, γ]},
Module[{
vars={{y,γ π},{x,(Sqrt[-1+(y^2)])},{z,1+2 x y-2 (y^2)},{w,-1+2 x y +2 (y^2)},{u,(Sqrt[(z/w)])}}
},
aux=Simplify[aux/.{γ->y/π}];
aux=Simplify[aux/.{(Sqrt[-1+(y^2)])->x}];
aux=Simplify[aux/.{1+2 x y-2 (y^2)->z}];
aux=Simplify[aux/.{-1+2 x y +2 (y^2)->w}];
aux=Simplify[aux/.{(Sqrt[(z/w)])->u}];
Print[aux];
ToPython[aux,vars,"output","    "(* Indentation *)]
]]]

This code can be exported to a Python file in Unicode format (so that Greek characters can be used)

Export[NotebookDirectory[]<>"foo.py",Code,"Text",CharacterEncoding->"Unicode"]