This short article teaches you 4 common switches to use in the command line with Python.<\/p>\n\n
The Python \ud83d\udc0d command has many different switches.<\/p>\n
Here are the 4 switches I use the most:<\/p>\n
-c cmd<\/code>: program passed in as string;<\/li>\n-m mod<\/code>: run library module as a script;<\/li>\n-i<\/code>: inspect interactively after running script; and<\/li>\n-q<\/code>: don't print version and copyright messages on interactive startup.<\/li>\n<\/ol>\n-c<\/code><\/a><\/h2>\nThe switch -c<\/code> runs code directly from the command line.\nIt doesn't open the REPL, and it is convenient for short, one-off expressions.\nThe result isn't printed by default, so don't forget your print<\/code>!<\/p>\n# What is the factorial of 15?\n\u03bb python -c \"import math; print(math.factorial(15))\"\n1307674368000\n\n# What is 2 + 2?\n\u03bb python -c \"print(2 + 2)\"\n4<\/code><\/pre>\n-m<\/code><\/a><\/h2>\nThe switch -m<\/code> runs a module as a script.\nThis will run an installed module's section that is inside if __name__ == \"__main__\":<\/code>.\nThe one I use the most is the module timeit<\/code> to measure execution time:<\/p>\n\u03bb python -m timeit -s \"import math\" \"math.factorial(15)\"\n2000000 loops, best of 5: 167 nsec per loop\n\n\u03bb python -m timeit -s \"import math\" \"math.factorial(150)\"\n200000 loops, best of 5: 1.52 usec per loop<\/code><\/pre>\n-i<\/code><\/a><\/h2>\nThe switch -i<\/code> stands for Inspect Interactively.\nBy running your code with -i<\/code>, after the script is done,\nyou get a REPL session with the variables and functions from that script.\nUseful to play around with functions you just defined.<\/p>\nSuppose this is your file example.py<\/code>:<\/p>\nx = 3\ny = 5\n\ndef add(x, y):\n return x + y<\/code><\/pre>\nIf you run it with -i<\/code>, you get to play around with the variables x<\/code> and y<\/code> and with the function add<\/code>:<\/p>\n\u03bb python -i example.py\n>>> x\n3\n>>> y\n5\n>>> add(x, 10)\n13<\/code><\/pre>\n-q<\/code><\/a><\/h2>\nThe switch -q<\/code> opens the REPL Quietly.\nWhat this means is that it opens the REPL without displaying all the version\/platform information.\nI use it when recording videos and demoing things.<\/p>\n\u03bb python -q\n>>> # This is a standard REPL<\/code><\/pre>\n\nThis article was generated automatically from this thread<\/a> I published on Twitter @mathsppblog<\/a>.\nThen it was edited lightly.<\/p>\n<\/div>","summary":"This short article teaches you 4 common switches to use in the command line with Python.","date_modified":"2024-08-10T20:53:03+02:00","tags":["programming","python"]},{"title":"3 different ways to create a dictionary","date_published":"2022-08-26T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/twitter-threads\/3-different-ways-to-create-a-dictionary","url":"https:\/\/mathspp.com\/blog\/twitter-threads\/3-different-ways-to-create-a-dictionary","content_html":"This short article teaches you 3 ways of creating a Python dictionary.<\/p>\n\n
Here are 3 ways in which you can create a Python \ud83d\udc0d dictionary:\n(Of the three, the last one is the least commonly used.)<\/p>\n
>>> dict([(1, \"one\"), (2, \"two\")])\n{1: 'one', 2: 'two'}\n\n>>> dict(name=\"Rodrigo\", twitter=\"mathsppblog\")\n{'name': 'Rodrigo', 'twitter': 'mathsppblog'}\n\n>>> dict.fromkeys([\"likes\", \"retweets\"], 0)\n{'likes': 0, 'retweets': 0}<\/code><\/pre>\nAn iterable of key, value pairs<\/a><\/h2>\nThe built-in dict<\/code> can take an iterable with key, value pairs.\nUseful, for example, when you have a bunch of keys and a bunch of values that you put together with zip<\/code>:<\/p>\n>>> dict([(1, \"one\"), (2, \"two\")])\n{1: 'one', 2: 'two'}\n\n>>> keys = range(1, 4)\n>>> values = \"one two three\".split()\n>>> dict(zip(keys, values))\n{1: 'one', 2: 'two', 3: 'three'}<\/code><\/pre>\nIn this particular case, you could also get creating with enumerate<\/code>\nand make use of the keyword argument start<\/code><\/a>:<\/p>\n>>> dict(enumerate(values, start=1))\n{1: 'one', 2: 'two', 3: 'three'}<\/code><\/pre>\nKeyword arguments<\/a><\/h2>\nYou can use keyword arguments in dict<\/code> to define key, value pairs in your dictionary!\nHowever, this only works if your keys are valid variable names:<\/p>\n# Values don't have to be strings:\n>>> dict(one=1, two=2)\n{'one': 1, 'two': 2}\n\n# But the keys have to:\n>>> dict(1=\"one\", 2=\"two\")\n File \"<stdin>\", line 1\n dict(1=\"one\", 2=\"two\")\n ^\nSyntaxError: expression cannot contain assignment, perhaps you meant \"==\"?\n\n# Keys have to be valid variable names:\n>>> dict(name=\"Rodrigo\", twitter=\"mathsppblog\")\n{'name': 'Rodrigo', 'twitter': 'mathsppblog'}<\/code><\/pre>\nClass method dict.fromkeys<\/code><\/a><\/h2>\nThe class method dict.fromkeys<\/code> accepts an iterable and a value, and produces a dictionary where all keys have that value.\nBy default, that value is None<\/code>:<\/p>\n# Default value is None:\n>>> dict.fromkeys(\"abc\")\n{'a': None, 'b': None, 'c': None}\n>>> dict.fromkeys(range(5))\n{0: None, 1: None, 2: None, 3: None, 4: None}\n\n# Different default values:\n>>> dict.fromkeys(range(5), \";)\")\n{0: ';)', 1: ';)', 2: ';)', 3: ';)', 4: ';)'}\n>>> dict.fromkeys([\"likes\", \"retweets\"], 0)\n{'likes': 0, 'retweets': 0}<\/code><\/pre>\nThe class method .fromkeys<\/code> has a gotcha associated with it, though.\nBe careful when using mutable values, because the value isn't copied to each key.\nIt's exactly the same object used over and over:<\/p>\n>>> d = dict.fromkeys(range(3), [])\n>>> d\n{0: [], 1: [], 2: []}\n\n>>> d[0].append(\"zero\")\n>>> d[1].append(\"one\")\n\n>>> d[2] # Shouldn't d[2] be empty?!\n['zero', 'one']\n>>> d\n{0: ['zero', 'one'], 1: ['zero', 'one'], 2: ['zero', 'one']} # \ud83e\udd2f<\/code><\/pre>\nThese are just 3 ways of creating a Python dictionary.\nSoon, I'll send out a Mathspp Insider article talking about all the ways in which you can create dictionaries in Python \ud83d\udc0d\nJoin to keep learning: https:\/\/mathspp.com\/insider<\/a><\/p>\nSummary<\/a><\/h2>\nHere's a quick recap:<\/p>\n
\ndict<\/code> accepts an iterable that contains key, value pairs;<\/li>\n- use keyword arguments in
dict<\/code> if you want string keys; and<\/li>\n.fromkeys<\/code> gives the same value (default is None<\/code>) to a bunch of keys.<\/li>\n<\/ol>\nComment other ways in which you can create a Python \ud83d\udc0d dict!<\/p>\n
\nThis article was generated automatically from this thread<\/a> I published on Twitter @mathsppblog<\/a>.\nThen it was edited lightly.<\/p>\n<\/div>","summary":"This short article teaches you 3 ways of creating a Python dictionary.","date_modified":"2025-09-27T16:50:04+02:00","tags":["programming","python"]},{"title":"3 ways to reverse a Python list","date_published":"2022-08-25T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/twitter-threads\/3-ways-to-reverse-a-python-list","url":"https:\/\/mathspp.com\/blog\/twitter-threads\/3-ways-to-reverse-a-python-list","content_html":"This short article teaches you 3 ways of reversing a Python list.<\/p>\n\n
Here are 3 simple ways in which you can reverse a Python \ud83d\udc0d list:<\/p>\n
>>> lst = [42, 73, 0]\n>>> rev1 = reversed(lst)\n>>> rev2 = lst[::-1]\n>>> lst.reverse()<\/code><\/pre>\nLet's see how they are different.<\/p>\n
Built-in reversed<\/code><\/a><\/h2>\nThe built-in reversed<\/code> accepts a sequence and returns an object that knows how to iterate over that sequence in reverse order.\nHence, reversed<\/code>.\nNotice it doesn't return a list:<\/p>\n>>> reversed(lst)\n<list_reverseiterator object at 0x00000241D77BD520><\/code><\/pre>\nThe list_reverseiterator<\/code> object that is returned is \u201clinked\u201d to the original list...\nSo, if you change the original list, the reverse iterator will notice:<\/p>\n>>> lst = [42, 73, 0]\n>>> rev = reversed(lst)\n>>> lst[1] = 999999 # Change something in the original list.\n\n>>> for n in rev: # Go over the reverse iterator.\n... print(n)\n...\n0\n999999 # This was changed as well.\n42<\/code><\/pre>\nSlicing with [::-1]<\/code><\/a><\/h2>\nThe slicing syntax with brackets []<\/code> and colons :<\/code> accepts a \u201cstep\u201d that can be negative.\nIf the \u201cstart\u201d and \u201cstop\u201d are omitted and the \u201cstep\u201d is -1, we get a copy in the reverse order:<\/p>\n>>> lst = [42, 73, 0]\n>>> lst[::-1]\n[0, 73, 42]<\/code><\/pre>\nSlices in Python \ud83d\udc0d are regular objects, so you can also name them.\nThus, you could go as far as creating a named slice to reverse lists, and then use it:<\/p>\n
>>> lst\n[42, 73, 0]\n\n>>> reverse = slice(None, None, -1)\n>>> lst[reverse]\n[0, 73, 42]<\/code><\/pre>\nNotice that slices are not \u201clinked\u201d to the original list.\nThat's because slicing creates a copy of the list.\nSo, if you change the elements in a given index, the reversed list will not notice:<\/p>\n
>>> lst = [42, 73, 0] # Original list.\n>>> rev = lst[::-1] # Reverse copy.\n>>> lst[1] = 999999 # Change something in the original.\n>>> rev # The copy didn't notice.\n[0, 73, 42]<\/code><\/pre>\nSlicing is very powerful and useful, and that is why I wrote a whole chapter of my free book \u201cPydon'ts\u201d<\/a> on the subject.<\/p>\nList method .reverse<\/code><\/a><\/h2>\nLists have a method .reverse<\/code> that reverses the list in place<\/strong>.\nWhat this means is that you do not get a return value with the reversed list...\nInstead, the list itself gets flipped around \ud83d\ude43<\/p>\n>>> lst = [42, 73, 0]\n>>> lst.reverse()\n>>> lst\n[0, 73, 42]<\/code><\/pre>\nSummary<\/a><\/h2>\nHere is a quick summary:<\/p>\n
Reverse a Python list with:<\/p>\n
\n- the built-in
reversed<\/code> that will notice changes to the original list;<\/li>\n- slicing
[::-1]<\/code> that creates a copy of the original list; and<\/li>\n- the method
.reverse<\/code> that reverses a list in place.<\/li>\n<\/ol>\n\nThis article was generated automatically from this thread<\/a> I published on Twitter @mathsppblog<\/a>.\nThen it was edited lightly.<\/p>\n<\/div>","summary":"This short article teaches you 3 ways of reversing a Python list.","date_modified":"2024-08-10T20:53:03+02:00","tags":["programming","python"]},{"title":"Deciphering David Beazley's monstrosity","date_published":"2022-08-22T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/twitter-threads\/deciphering-david-beazleys-monstrosity","url":"https:\/\/mathspp.com\/blog\/twitter-threads\/deciphering-david-beazleys-monstrosity","content_html":"This short article explains a monstrous piece of code that David Beazley wrote.<\/p>\n\n
I just found another Python \ud83d\udc0d monstrosity:<\/p>\n
sub = lambda x,y,c: c(x-y)\nmul = lambda x,y,c: c(x*y)\neqv = lambda x,y,c: c(x==y)\nbnz = lambda t,c,a: (a,c)[t]()\n\ndef fact(n, c):\n (loop:= lambda n, r0: (\n eqv(n, 1, lambda r1:\n bnz(r1, lambda: c(r0), lambda:\n mul(n, r0, lambda r2:\n sub(n, 1, lambda r3:\n loop(r3, r2)))))))\\\n (n, 1)\n\nfact(5, print)<\/code><\/pre>\nThis one was brought to you by the infamous David Beazley.\nBut what does it do?<\/p>\n
Let us start by looking at the four lambdas at the top.<\/p>\n
The first three are quite similar to each other:<\/p>\n
sub = lambda x,y,c: c(x-y)\nmul = lambda x,y,c: c(x*y)\neqv = lambda x,y,c: c(x==y)\nbnz = lambda t,c,a: (a,c)[t]()\n\nsub(5, 3, print) # Prints 2\nmul(5, 3, print) # Prints 15\neqv(5, 3, print) # Prints False<\/code><\/pre>\nTake the first two arguments, operate on them, and recursively call c<\/code> with the result.<\/p>\nSo, David is going to chain operations by doing these crazy recursive calls.<\/p>\n
The fourth lambda is a bit more interesting but also crazier: it implements conditionals.\n(I have no idea what \u201cbnz\u201d means, though \ud83e\udd37)\nThe first argument is the Boolean value, then:<\/p>\n
\n- if the Boolean is
True<\/code>, we call c<\/code>;<\/li>\n- if it is
False<\/code>, we call the alternative a<\/code>.<\/li>\n<\/ul>\nbnz = lambda t,c,a: (a,c)[t]()\n\nyes = lambda: print(\"heya\")\nno = lambda: print(\":(\")\n\nbnz(True, yes, no) # Prints heya\nbnz(False, yes, no) # Prints :(<\/code><\/pre>\nAlright, we are halfway there!\nNow, we just need to understand how David put everything together to implement the factorial function.<\/p>\n
The function fact<\/code> defines loop<\/code> in its body, which is a tail recursive factorial.\nRemember that the 3rd arguments of sub<\/code>, mul<\/code>, and eqv<\/code>, can be seen as what happens after that operation.<\/p>\ndef fact(n, c):\n (loop:= lambda n, r0: ( # Start computing with n and r0.\n eqv(n, 1, lambda r1: # Is n equal to 1?\n bnz(r1, lambda: c(r0), lambda: # If it is, call c(r0) and end, if not...\n mul(n, r0, lambda r2: # multiply n with r0 and call it r2, then\n sub(n, 1, lambda r3: # compute n - 1 and call it r3, and\n loop(r3, r2)))))))\\ # go to the top, with the new values for n and r0.\n (n, 1)<\/code><\/pre>\nIn the lambda loop<\/code>, n<\/code> is the value for which we still have to compute the factorial,\nand it decreases with each call.\nr0<\/code> is the accumulated factorial that grows as we reduce the value of n<\/code>.<\/p>\nDoes this make sense?<\/p>\n
\nThis article was generated automatically from this thread<\/a> I published on Twitter @mathsppblog<\/a>.\nThen it was edited lightly.<\/p>\n<\/div>","summary":"This short article explains a monstrous piece of code that David Beazley wrote.","date_modified":"2024-08-10T20:53:03+02:00","tags":["programming","python"]},{"title":"Chunking iterables","date_published":"2022-08-17T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/twitter-threads\/chunking-iterables","url":"https:\/\/mathspp.com\/blog\/twitter-threads\/chunking-iterables","content_html":"This short article shows how to chunk iterables into pieces of a fixed length.<\/p>\n\n
If you need to chunk a list or another iterable into groups of n<\/code> items,\nyou can do that with the built-in zip<\/code>:<\/p>\n>>> def chunk(iterable, chunk_size):\n... return list(zip(*[iter(iterable)] * chunk_size))\n...\n>>> chunk(range(10), 5)\n[(0, 1, 2, 3, 4), (5, 6, 7, 8, 9)]<\/code><\/pre>\nYou can also add a third argument to process each chunk after it is created:<\/p>\n
>>> chunk(\"Hello, world\", 3)\n[('H', 'e', 'l'), ('l', 'o', ','), (' ', 'w', 'o'), ('r', 'l', 'd')]\n\n# Redefine `chunk`:\n>>> def chunk(iterable, chunk_size, on_chunk=None):\n... on_chunk = on_chunk or (lambda x: x)\n... return [on_chunk(chunk) for chunk in zip(*[iter(iterable)] * chunk_size)]\n...\n>>> chunk(\"Hello, world\", 3, \"\".join)\n['Hel', 'lo,', ' wo', 'rld']<\/code><\/pre>\nThe code above has a limitation, though:\nit ignores the last elements if the chunk size doesn't divide evenly into the length of the iterable.\nSometimes this is ok... Sometimes, it is not.<\/p>\n
If you use itertools.zip_longest<\/code>, you get the opposite behaviour:<\/p>\n>>> chunk(range(8), 5)\n[(0, 1, 2, 3, 4)] # where are 5, 6, and 7??\n\n>>> from itertools import zip_longest\n>>> def chunk_longest(iterable, chunk_size):\n... return list(zip_longest(*[iter(iterable)] * chunk_size))\n...\n\n>>> chunk_longest(range(8), 5)\n[(0, 1, 2, 3, 4), (5, 6, 7, None, None)]<\/code><\/pre>\nBy using zip_longest<\/code>, you get padding with the value None<\/code>.\nYou could also customise this padding.<\/p>\nFinally, if you want your chunks to always have the same size, you can use strict=True<\/code> in zip<\/code>!\nThis will make your chunk<\/code> function error if the chunk size doesn't divide evenly!\nHowever, this only works in Python 3.10+ because that is when zip(..., strict=True)<\/code> was added.<\/p>\n>>> def chunk_strict(iterable, chunk_size):\n... return list(zip(*[iter(iterable)] * chunk_size, strict=True))\n...\n\n# 2 divides into 6\n>>> chunk_strict(range(6), 2)\n[(0, 1), (2, 3), (4, 5)]\n\n# 5 does NOT divide into 8\n>>> chunk_strict(range(8), 5)\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\n File \"<stdin>\", line 2, in chunk_strict\nValueError: zip() argument 4 is shorter than arguments 1-3<\/code><\/pre>\n\nThis article was generated automatically from this thread<\/a> I published on Twitter @mathsppblog<\/a>.\nThen it was edited lightly.<\/p>\n<\/div>","summary":"This short article shows how to chunk iterables into pieces of a fixed length.","date_modified":"2024-08-10T20:53:03+02:00","tags":["programming","python"]},{"title":"bisect module","date_published":"2022-08-10T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/twitter-threads\/bisect-module","url":"https:\/\/mathspp.com\/blog\/twitter-threads\/bisect-module","content_html":"This short article shows how to use the module bisect<\/code> from the Python standard library.<\/p>\n\n