{"categories":["Principles of Programming Languages"],"contentHtml":"

Python is a powerful jack-of-all-trades language that is much less limited than OCaml.

\n

Expressions

\n

Arithmetic works in a very simple and clear way in Python, basically like a calculator.

\n
2 # 2\n2 + 4 # 6\n(2 + 5) * (3 - 5) # -20\n
\n

Unlike in OCaml, operations can be performed between floats and integers with no issues; Python will simply change the types behind the scenes. This is called type coercion.

\n
2 + 3.5 # 5.5\n
\n

This causes an interesting side effect: what is the return type of this function?

\n
def add(a, b):\n    return a + b\n
\n

In OCaml, the equivalent function would have type int -> int -> int, since the operation + is only valid for int. However, this function is actually polymorphic in Python! In OCaml, you would call it type 'a. In Python, this type is called Any, and operation changes based on what the types are. The reason that this is possible is because everything in Python is an object. Essentially, the variables a and b are just boxes that could contain anything, and Python only checks whether the operation + is defined for the two variables at runtime.

\n

Strings

\n

String manipulation is a very common operation in Python, so there are some very useful ways to handle strings built into the language.

\n
\"hello \" + \"world\" # \"hello world\"\n\"hello\" * 3 # \"hellohellohello\"\n
\n

You can also convert types to strings very easily.

\n
str(5) # \"5\"\nstr(3.5) # \"3.5\"\n
\n

And vice versa.

\n
int(\"5\") # 5\nfloat(\"3.5\") # 3.5\n
\n

These are special built-in functions to make our lives earlier.

\n

Variables

\n

Like with OCaml, there is no need to specify types as in Java. Unlike OCaml, Python does not use type inference. Instead, every variable can contain any type in a box as mentioned earlier.

\n
a = 3\nb = \"hello\"\n
\n

Variables in Python work differently under the hood than other languages. A variable is essentially just a name for an element.

\n
c = b\n
\n

c here is not just equal to b... it is actually b itself! And any change you make to b will reflect in c because of that. Actual copies must be explicit.

\n

Slices

\n

Slices are one of the most powerful tools in Python. In fact, it might be what Python is most known for and most useful for. Slicing allows for powerful manipulation of list-like data.

\n

Ordinary list access uses bracket notation with a single number to access a single element. Slice notation works similarly, but it allows returning multiple elements as a sub-list of the original list.

\n
x = \"hello world\"\nx[1:7] # \"ello w\"\n
\n

You might notice that I just performed this operation on a string; didn't I just say that slices work on list-like types? In Python, strings are just fancy lists of chars!.

\n

Tuples and Lists

\n

A tuple is an immutable set of multiple elements, just like in OCaml. Slicing operations work the same way in that they return a subsequence tuple. There's a weird side effect where if you slice in a way that returns a single element, you can get a single-element tuple.

\n

Lists in Python are much more flexible in OCaml, as they can be heterogenous with any type within. They are also mutable, so elements of lists can be reassigned.

\n

Slicing can superpower this assignment by reassigning multiple values at once

\n

Control

\n

The traditional if statements are back, but with a bit of a twist. Python has significant whitespace, which means that the amount that you indent by affects the actual execution of the code. This is quite rare.

\n
if x == 15:\n    y = 0 # this tab is mandatory!\nx = 3 # this line is outside the if block\n
\n

There is a special keyword called pass which exists to allow empty blocks. Normally, this construct is forbidden:

\n
if x == 15:\nx = 3 # error!\n
\n

But by using pass, this is possible:

\n
if x == 15:\n    pass # does nothing\nx = 3\n
\n

Like in C, boolean evaluation is 0 for false, true for everything else. However, you cannot assign a variable in a conditional! So this C construct would not be allowed:

\n
while ((int x = some_func()) == 0) {\n    // this is allowed in C\n}\n
\n
while (x = some_func()) == 0:\n    pass # this is not allowed in Python!\n
\n

Functions

\n

Functions are defined using the def keyword.

\n
def fac(n):\n    if n < 0:\n        return \"negative!\"\n    elif n == 0:\n        return 1\n    else:\n        return n * fac(n - 1)\n
\n

Functional programming can be used similarly to OCaml where everything is a function.

\n
def compose(f, g):\n    def foo(x):\n        return f(g(x))\n    return foo\n
\n
let compose f g =\n    let foo x =\n        f g x\n    in foo x\n
","contentMarkdown":"Python is a powerful jack-of-all-trades language that is much less limited than OCaml.\n\n## Expressions\n\nArithmetic works in a very simple and clear way in Python, basically like a calculator.\n\n```python\n2 # 2\n2 + 4 # 6\n(2 + 5) * (3 - 5) # -20\n```\n\nUnlike in OCaml, operations can be performed between floats and integers with no issues; Python will simply change the types behind the scenes. This is called **type coercion**.\n\n```python\n2 + 3.5 # 5.5\n```\n\nThis causes an interesting side effect: what is the return type of this function?\n\n```python\ndef add(a, b):\n return a + b\n```\n\nIn OCaml, the equivalent function would have type `int -> int -> int`, since the operation `+` is only valid for `int`. However, this function is actually polymorphic in Python! In OCaml, you would call it type `'a`. In Python, this type is called **Any**, and operation changes based on what the types are. The reason that this is possible is because *everything* in Python is an object. Essentially, the variables `a` and `b` are just boxes that could contain anything, and Python only checks whether the operation `+` is defined for the two variables at runtime.\n\n## Strings\n\nString manipulation is a very common operation in Python, so there are some very useful ways to handle strings built into the language.\n\n```python\n\"hello \" + \"world\" # \"hello world\"\n\"hello\" * 3 # \"hellohellohello\"\n```\n\nYou can also convert types to strings very easily.\n\n```python\nstr(5) # \"5\"\nstr(3.5) # \"3.5\"\n```\n\nAnd vice versa.\n\n```python\nint(\"5\") # 5\nfloat(\"3.5\") # 3.5\n```\n\nThese are special built-in functions to make our lives earlier.\n\n## Variables\n\nLike with OCaml, there is no need to specify types as in Java. Unlike OCaml, Python does not use type inference. Instead, every variable can contain any type in a box as mentioned earlier.\n\n```python\na = 3\nb = \"hello\"\n```\n\nVariables in Python work differently under the hood than other languages. A variable is essentially just a name for an element.\n\n```python\nc = b\n```\n\n`c` here is not just equal to `b`... it is actually `b` itself! And any change you make to `b` will reflect in `c` because of that. Actual copies must be explicit.\n\n## Slices\n\n**Slices** are one of the most powerful tools in Python. In fact, it might be what Python is most known for and most useful for. Slicing allows for powerful manipulation of list-like data.\n\nOrdinary list access uses bracket notation with a single number to access a single element. Slice notation works similarly, but it allows returning multiple elements as a sub-list of the original list.\n\n```python\nx = \"hello world\"\nx[1:7] # \"ello w\"\n```\n\nYou might notice that I just performed this operation on a string; didn't I just say that slices work on list-like types? In Python, strings are just fancy lists of chars!.\n\n## Tuples and Lists\n\nA tuple is an immutable set of multiple elements, just like in OCaml. Slicing operations work the same way in that they return a subsequence tuple. There's a weird side effect where if you slice in a way that returns a single element, you can get a single-element tuple.\n\nLists in Python are much more flexible in OCaml, as they can be heterogenous with any type within. They are also mutable, so elements of lists can be reassigned.\n\nSlicing can superpower this assignment by reassigning multiple values at once\n\n## Control\n\nThe traditional `if` statements are back, but with a bit of a twist. Python has *significant whitespace*, which means that the amount that you indent by affects the actual execution of the code. This is quite rare.\n\n```python\nif x == 15:\n y = 0 # this tab is mandatory!\nx = 3 # this line is outside the if block\n```\n\nThere is a special keyword called `pass` which exists to allow empty blocks. Normally, this construct is forbidden:\n\n```python\nif x == 15:\nx = 3 # error!\n```\n\nBut by using `pass`, this is possible:\n\n```python\nif x == 15:\n pass # does nothing\nx = 3\n```\n\nLike in C, boolean evaluation is 0 for false, true for everything else. However, you *cannot* assign a variable in a conditional! So this C construct would not be allowed:\n\n```c\nwhile ((int x = some_func()) == 0) {\n // this is allowed in C\n}\n```\n\n```python\nwhile (x = some_func()) == 0:\n pass # this is not allowed in Python!\n```\n\n## Functions\n\nFunctions are defined using the `def` keyword.\n\n```python\ndef fac(n):\n if n < 0:\n return \"negative!\"\n elif n == 0:\n return 1\n else:\n return n * fac(n - 1)\n```\n\nFunctional programming can be used similarly to OCaml where everything is a function.\n\n```python\ndef compose(f, g):\n def foo(x):\n return f(g(x))\n return foo\n```\n\n```ocaml\nlet compose f g =\n let foo x =\n f g x\n in foo x\n```","dataUrl":"https://sharifhsn.dev/api/posts/python-crash-course.json","date":"2022-04-14","datePublished":"2022-04-14","description":"Python is a powerful jack-of-all-trades language that is much less limited than OCaml.","site":"https://sharifhsn.dev","slug":"python-crash-course","source":"Archive","sourceUrl":null,"tags":["Principles of Programming Languages"],"title":"A Crash Course in Python","url":"https://sharifhsn.dev/blog/python-crash-course/","version":"1","wordCount":833}