#!\/bin\/bash\n\n# Specify where to write logs, open the file for writing:\nexec 3>\/path\/to\/log\/file\nBASH_XTRACEFD=3 # which file descriptor to output debug information to\n\nset -x # enable debugging\n# ... code to debug ...\nset +x # disable debugging\n<\/code><\/pre>\nSuch logs can also be written to the systemd journal if implementing a simple service:<\/p>\n
#!\/bin\/bash\n\n# Specify where to write logs:\nexec 3> >(systemd-cat --priority=debug)\nBASH_XTRACEFD=3 # which stream to output debug information to\n\nset -x # enable debugging\n# ... code to debug ...\nset +x # disable debugging\n<\/code><\/pre>\nDebugging in Bash will show which commands are being executed and with which arguments. If you need to get the current values of variables or the code of executed functions, you can do this with the set<\/code> command without arguments. However, since the output of the command can be quite large, set<\/code> is more suitable for manual debugging than for event logging.<\/p>\n<\/span>Debugging via trap<\/span><\/h4>\nAnother debugging method is setting handlers for command execution using the trap<\/code> command on the special „trap” DEBUG. The commands being executed can be obtained through the built-in variable BASH_COMMAND<\/code>. However, you cannot get the return code from this handler because it is executed before the command itself is called.<\/p>\ntrap 'echo \"+ ${BASH_COMMAND}\"' DEBUG\n<\/code><\/pre>\nBut it will be more useful to intercept errors and output the command and line number where the error occurred. To inherit this interception by functions, you also need to set the functrace<\/code> option:<\/p>\nset -o functrace\ntrap 'echo \"+ line ${LINENO}: ${BASH_COMMAND} -> $?\"' ERR\n\n# Test:\nls \"${PWD}\"\nls unknown_file\n<\/code><\/pre>\n<\/span>Debugging in Python<\/span><\/h3>\n<\/span>Debugging via pdb<\/span><\/h4>\nPython has rich debugging and logging tools. For debugging, Python has the pdb<\/code> module. You can run a script with debugging enabled from the console, in which case the debug mode will be activated in exceptional situations:<\/p>\npython3 -m pdb my_script.py\n<\/code><\/pre>\nDirectly in the code, you can set breakpoints using the built-in breakpoint()<\/code> function.<\/p>\n#!\/usr\/bin\/python3\n\nimport os\n\nbreakpoint()\n# Now you can try, for example, the source os command:\n# (Pdb) source os\n<\/code><\/pre>\nThe language is object-oriented, and everything in it is an object. You can see the methods available for an object using the dir()<\/code> command. For example, dir(1)<\/code> will show the methods available for the object 1<\/code>. Example of calling one of these methods: (1).bit_length()<\/code>. In many cases, this helps to understand arising questions without the need to read the documentation. In debug mode, you can also use the dir()<\/code> command to get information about objects and print()<\/code> to get variable values.<\/p>\n<\/span>Logging via the logging module<\/span><\/h4>\nPython provides the logging<\/code> module, which allows you to log debug information with specified logging levels and log sources. In general, logging looks something like this:<\/p>\nimport logging\n\nlogging.basicConfig(\n filename=\"myscript.log\",\n level = logging.DEBUG, # output DEBUG, INFO, WARNING, ERROR, and CRITICAL levels\n)\n\nlogger = logging.getLogger('MyApp')\n\nlogger.debug('Some debug information')\nlogger.error('Some error')\n<\/code><\/pre>\n<\/span>Comparison of Bash and Python Semantics<\/span><\/h2>\n<\/span>Variables and Data Types<\/span><\/h3>\n<\/span>Primitive Data Types<\/span><\/h4>\nIn Bash, all variables are strings, but string variables can also be used as numbers. For arithmetic calculations, the syntax $(( expression ))<\/code> is used.<\/p>\nstr_var=\"some_value\" # string, array of characters\n\nint_var=1234 # string \"1234\", but can be used in calculations\nint_var=$(( 1 + (int_var - 44) \/ 111 - 77 )) # string: \"-66\"\n<\/code><\/pre>\nIn Python:<\/p>\n
str_var=\"some_value\" # class str\nint_var = 1234 # class int\nint_var = 1 + (int_var - 44) \/\/ 111 - 77 # -66, class int\n<\/code><\/pre>\nFloating-point numbers are not supported in Bash. And this is logical, because if you need to use floating-point numbers in command-line scripts, you are clearly doing something at the wrong level or in the wrong programming language. However, floating-point numbers are supported in Ksh.<\/p>\n
<\/span>String Formatting<\/span><\/h4>\nBoth Bash and Python support variable substitution in formatted strings. In Bash, formatted strings are strings enclosed in quotes, while in Python, they are strings with the f<\/code> prefix.<\/p>\nBoth languages also support C-like style output of formatted strings. In Bash, this way you can even format floating-point numbers, although the language itself does not support them (the decimal separator is determined by the locale).<\/p>\n
var1='Some string'\nvar2=0,5\necho \"Variable 1: ${var1}, variable 2: ${var2}\"\n# Variable 1: Some string, variable 2: 0,5\n\n# Without the current locale\nLANG=C \\\nprintf 'String: %s, number: %d, floating-point number: %f.\\n' \\\n 'str' '1234' '0.1'\n\n# With the current locale\nprintf 'String: %s, number: %d, floating-point number: %f.\\n' \\\n 'str' '1234' '0,1'\n# String: str, number: 1234, floating-point number: 0,100000.\n<\/code><\/pre>\nIn Python:<\/p>\n
var1 = 'Some string'\nvar2 = 0.5\nprint(f\"Variable 1: {var1}, variable 2: {var2}\")\n# Variable 1: Some string, variable 2: 0.5\n\n# Without the current locale:\nprint('String: %s, number: %d, floating-point number: %f.'\n % ('str', 1234, 0.1))\n# String: str, number: 1234, floating-point number: 0.100000.\n\n# With the current locale:\nimport locale\nlocale.setlocale('') # apply the current locale\nprint(locale.format_string('String: %s, number: %d, floating-point number: %f.',\n ('str', 1234, 0.1)))\n# String: str, number: 1234, floating-point number: 0,100000.\n<\/code><\/pre>\nYou can notice a difference regarding the locale\u2014in Python, the print()<\/code> function ignores the locale. If you need to output values considering the locale, you must use the locale.format_string()<\/code> function.<\/p>\n<\/span>Arrays<\/span><\/h4>\nIn Bash, arrays are essentially text separated by spaces (by default). The syntax is very specific; for example, to copy an array (via @<\/code>), you must enclose all its elements in quotes; otherwise, any spaces in the elements themselves will cause the element to be split into parts. But in general, working with arrays is similar in simple cases:<\/p>\narr=( 'First item' 'Second item' 'Third item' )\necho \"${arr(0)}\" \"${arr(1)}\" \"${arr(2)}\"\narr_copy=\"${arr(@)}\" # copying the array, quotes are mandatory\narr(0)=1\narr(1)=2\narr(2)=3\necho \"${arr(@)}\"\necho \"${arr_copy(0)}\" \"${arr_copy(1)}\" \"${arr_copy(2)}\"\n<\/code><\/pre>\nIn Python:<\/p>\n
arr = ( 'First', 'Second', 'Third' )\nprint(arr(0), arr(1), arr(2))\narr_copy = arr.copy() # but you can also do it like in Bash: ( *arr )\narr(0) = 1\narr(1) = 2\narr(2) = 3\nprint(*arr)\nprint(arr_copy(0), arr_copy(1), arr_copy(2))\n<\/code><\/pre>\nThe *<\/code> operator in Python performs unpacking of lists, dictionaries, iterators, etc. That is, the elements of the array are listed as if they were separated by commas as arguments.<\/p>\n<\/span>Associative Arrays<\/span><\/h4>\nBash also supports associative arrays (unlike Sh), but the capabilities for working with them are limited. In Python, associative arrays are called dictionaries, and the language provides very rich capabilities for working with them.<\/p>\n
declare -A assoc_array=(\n (name1)='Value 1'\n (name2)='Value 2'\n (name3)='Value 3'\n)\n\n# Assigning a value by key:\nassoc_array('name4')='Value 4' # assigning a value\n\n# Element-wise access:\necho \"${assoc_array('name1')}\" \\\n \"${assoc_array('name2')}\" \\\n \"${assoc_array('name3')}\" \\\n \"${assoc_array('name4')}\"\n\necho \"${!assoc_array(@)}\" # output all keys\necho \"${assoc_array(@)}\" # output all values\n\n# Iterate over all elements\nfor key in \"${!assoc_array(@)}\"; do\n echo \"Key: ${key}\"\n echo \"Value: ${assoc_array($key)}\"\ndone\n<\/code><\/pre>\nIn Python:<\/p>\n
assoc_array = {\n 'name1': 'Value 1',\n 'name2': 'Value 2',\n 'name3': 'Value 3',\n}\n\n# Assigning a value by key:\nassoc_array('name4') = 'Value 4'\n\n# Element-wise access\nprint(\n assoc_array('name1'),\n assoc_array('name2'),\n assoc_array('name3'),\n assoc_array('name4')\n)\n\nprint(*assoc_array) # output all keys\nprint(*assoc_array.values()) # output all values\n\nfor key, value in assoc_array.items():\n print(f\"Key: {key}\")\n print(f\"Value: {value}\")\n<\/code><\/pre>\n<\/span>Module Importing<\/span><\/h3>\nIn Bash, there are no modules as such. But you can execute a script in the current interpreter using the source<\/code> command. Essentially, this is analogous to importing modules, since all functions of the included script become available in the current interpreter’s namespace. In Python, there is full support for modules with the ability to import them. Moreover, the Python standard library contains a large number of modules for a wide variety of use cases. Essentially, what is implemented in Bash by third-party command-line utilities may be available in Python as standard library modules (and if not, you can install additional libraries).<\/p>\nIn Bash:<\/p>\n
# Include the file mylib.sh with some functions:\nsource mylib.sh\n\n# Let's see the list of available functions (all of them):\ndeclare -F\n<\/code><\/pre>\nIn Python:<\/p>\n
# Import the module mylib.py or mylib.pyc:\nimport mylib\n\n# Let's see the list of available objects in the mylib module:\nprint(dir(mylib))\n<\/code><\/pre>\n<\/span>Conditionals and Loops<\/span><\/h3>\n<\/span>Conditional Operator<\/span><\/h4>\nIn Bash, conditions work on two principles: either a command is provided as a condition, and its return code is checked, or built-in Bash double square or double round brackets are used. In the case of a return code, 0 is true (everything is fine), while in the case of double round brackets, it’s the opposite\u2014the result of an arithmetic expression is checked, where 0 is false.<\/p>\n
In Python, the standard approach for programming languages is used: False<\/code>, 0<\/code>, ''<\/code>,