7 Python basics for JavaScript engineers
Tags: python, javascript, beginners
Published: 2020-03-16 19:38:31

I’ll be honest. My main expertise and experience is in JavaScript with Node and frontend frameworks like React. I took a [Python Introduction to Computer Science course through EdX](https://www.edx.org/course/introduction-to-computer-science-and-programming-7) a few years back and have only really needed to use it sporadically since then. That all changed two weeks ago when a new project started at work. My team was tasked with rapidly getting ramped up on Python and writing a new back-end service in the language.

Here are 7 things I’ve learned so far writing in the Python language every day:

### 1. Python version management

I feel like it’s less common for folks to alternate between different versions of Node these days but the tool to do that in nvm. Python has competing solutions for this problem. Two of those are [conda](https://docs.conda.io/en/latest/) and [pyenv](https://github.com/pyenv/pyenv) with [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv). 

`pyenv` allows you to use different versions of python and and `pyenv-virtualenv` allows you to sandbox different environments with those different python versions so they don’t conflict. For a while `pyenv` and `pyenv-virtualenv` were working fine until one day I kept getting really cumbersome openssl issues preventing me from installing dependencies with [pip](https://pypi.org/project/pip/).

I switched to `conda`. `conda` is both an environment and package manager. A practice I learned recently was to create a new environment for each project you are working on. So far no issues. 

### 2. Python dependency management

In JavaScript, you are typically using a [NPM package registry](https://www.npmjs.com/), using `yarn` or `npm` to download those dependencies to your local machine, and the `package.json` file to list the dependencies that need to be downloaded.

In Python the public package registry is the [Python Package Index (PyPI)](https://pypi.org/)([https://pypi.org/](https://pypi.org/)), you use `pip` to download dependencies, and the list of dependencies are in `requirements.txt` and `requirements_test.txt`.

### 3. Python property/method reference

You can refer to properties in many different ways in JavaScript and you can use any of them regardless of context. You can refer to the `assign` property of `Object` with `Object.assign` or `Object["assign"]`, the only real rule being that string property names are generally referred to with dot notation and number property names must use the bracket notation.

In Python dot notation and bracket notation communicates the relationship of the property to the object. Classes must use the dot notation and dicts must use the bracket notation. Don’t worry, Python will let you know when you make a mistake with `AttributeError` if you try to use dot notation with a dict and `object is not subscriptable` when you use bracket notation for a class property. Those errors are forever burned into my mind.

### 4. Python async/await

Finally something familiar to JavaScript folks and more or less works the same. In JavaScript async/await works out of the box assuming you’re using a recent enough version of Node. In Python you need to import in [asyncio](https://docs.python.org/3/library/asyncio.html) and make sure the [async/await happens within the context of a created event loop](https://snarky.ca/how-the-heck-does-async-await-work-in-python-3-5/). JavaScript also doesn’t allow you to `await` in a global context. This might change with the [proposal for global await](https://github.com/tc39/proposal-top-level-await) but for now you have to use `await` within the context of a `async` function.

### 5. Python types

Most of the JavaScript I write these days is with TypeScript. Python has the [typing](https://docs.python.org/3/library/typing.html) standard library package which can be extended with [pydantic](https://pydantic-docs.helpmanual.io/usage/models/).

### 6. Python case

JavaScript favors camelCase. Python favors snake_case. I suppose you see a bit of both in out in the wild in terms of API JSON formats. 

One way Python tackles this is you can use `pydantic` for your type models so that you can use the idiomatic snake_case in your Python service yet use camelCase for the output when you JSON serialize. [Here’s one tutorial](https://medium.com/analytics-vidhya/camel-case-models-with-fast-api-and-pydantic-5a8acb6c0eee).

### 7. Python anonymous functions

In JavaScript, anonymous functions are declared like so: `() => {}`. You can assign this to a var `const myFunc = () => {}` or even declare and invoke in place as an immediately invoked anonymous function `(() => {})()`.

In Python the equivalent is a lambda function:

```python
def add_one = lambda x: x + 1
```

In the above example we are declaring a function that accepts argument `x` and returns `x + 1`. You might be wandering why on Earth this is called a “lamba function”. According to this [informative article from Real Python](https://realpython.com/python-lambda/), lamba functions have roots in something called “lambda abstractions” that were developed as a part of “lambda calculus” in the 1930s, which is one of the foundational building blocks of functional programming..

### Conclusion

I hope to write a few more of these posts as long as I’m continuing to write Python at work and learning things. I’m enjoying it quite a bit, in a way that feels different than when I was in a similar situation learning Go for another service at work some time ago.