Yes.

learning another language has two kinds of benefits: tactical and strategic.

The tactical benefit is its immediate use. More opportunities to be hired, easier time doing a side / hobby / fun project.

The strategic benefit is that you start seeing computing differently, get a better picture, and a better set of mental tools. This applies across the board then, enhances all you already know.

My idea of a spectrum of languages to be acquainted with, for strategic purposes, in no particular order:

- SQL: utterly practical, and also an example of a completely declarative language. Learn it well, it's used everywhere, and will stay.

- JavaScript, then Typescript: both utterly practical and widely applicable. JS is simple, similar enough to Python, and shows you the many pitfalls of early language design. Typescript adds a static, gradual type system on top of it, which allows you to work on bigger codebases without drowning in errors. JS / TS have excellent and ergonomic async support, very refreshing after Python.

- Erlang or better Elixir: reasonably practical, shows concurrency via messaging / actor systems, and reasonable bits of functional programming. Small enough to become productive in under a week. Teaches you the design of (highly) concurrent systems which you can then apply anywhere.

- Go: pretty practical, in high demand. So small one can learn it in a weekend. Shows concurrency at a somehow different angle than Elixir. Shows the many compromises that language designers make to keep things simple (but also boring and repetitive).

- Kotlin: pretty practical (and not only for Android development). A good example of a modern strongly-typed language, with many creature comforts and excellent IDE support. Widely uses higher-order functions and other FP stuff without drowning you in the jargon. (One could pick OCaml instead, but it's distinctly less practical.)

- Any Lisp (I'd take Clojure or Scheme): not very practical (few jobs), but shows very well how a program and data are made of the same stuff, how programs can transform programs (metaprogramming), and how complex data and algorithm structures are built form elementary particles, so to say. Shows and explains many idioms and notions which resurface in other languages.

- Haskell: not really practical, but has an immense learning value. It changes the way you think about programming (again). It explains the underpinnings of it in a way Lisp or C can't: if you ever wondered what is the real meaning of null or the semicolon (sequential execution) in other language, it gives you the answers. Again, the insights you gain from learning it even superficially will apply to all your programming practice. A great help if you decide to pick up Rust later.

- C: reasonably practical; a ton of stuff is still written in C. Pretty simple, can be learned in a weekend. Terrible in various ways, but shows you reasonably well how the machine works at lower level. (Still not really well; you need assembly to really appreciate that.) Allows you to connect bits to higher-level languages, or at least understand how it's done. Also shows very well why much of the software if full of vulnerabilities, and makes you appreciate the convenience and safety that high-level languages give you.

(For bonus curiosity points: any RISC assembly, FORTH, XSLT, TCL, Prolog, Q or J or K or APL.)