Difference between revisions of "Python"

From wiki
Jump to: navigation, search
(collections)
(collections)
 
Line 114: Line 114:
  
 
<code>from collections import defaultdict</code>
 
<code>from collections import defaultdict</code>
;defaultdict(<type>)
+
;adict = defaultdict(<type>)
 
:Create a dictionary key of the provided type automagically when it is used (WARNINIG, also when you try to read it). Use this to avoid checking if a key already exists before you populate it.
 
:Create a dictionary key of the provided type automagically when it is used (WARNINIG, also when you try to read it). Use this to avoid checking if a key already exists before you populate it.
 +
 +
;adict = defaultdict(lambda<nowiki>: defaultdict(lambda: defaultdict()))</nowiki>
 +
:Use lambda function to handle multilevel dictionaries
  
 
=Variables=
 
=Variables=

Latest revision as of 09:57, 18 December 2019


Style

The Python style guide is in [PEP 8]

Python is very strict on indentation. Code blocks are kept together by their indent. Use either tabs or spaces (recommended) not both.

For readability long lines can be over more lines using () around a statement or \ to escape new-line's

(this = a(verylongline,
    so you can use parentheses)
)
you can also use \
    to escape the end-of-line character

Modules

Modules need to be imported into your program by the import command.

To add the location of your own modules to the python search path put it in the PYTHONPATH see #sys below variable.

Import finds a file <modulename>.py or __init__.py in directory <modulename>. <modulename>.py or __init__.py are executed on import. Usually not many code is in modules to execute immediately, functions and classes are mostly in there.

import <module>
Import everything from the module, address components as <module>.<component>.
import <module> as <short>
Calls can have the short name. E.g. numpy is often imported as np
from <module> import *
Module components can be called without the module name. Beware of duplicates.
from <module> import <component>
Import a specific component from a modules, callable by just the component name.


We try to use modules that are available by default (on linux systems). If not it will be mentioned in this article. Only modules for which we use a very limited number of functions are listed here. More complex modules have there own article

sys

Provides a number of system variables

sys.argv
List of everything on the commandline. sys.argv[0] is the program itself.
sys.version
The python version you run
sys.path
The directories python looks into when doing an import. The script location always in sys.path. Directories in the environment variable $PYTHONPATH are added to sys.path

datetime

Date and time functions

from datetime import datetime
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

time

Time functions

time.sleep(3)
Sleep for 3 seconds
from time import sleep 
sleep(3)

subprocess

Module to execute shell commands

In python2

import subprocess
exitcode = subprocess.call("<any command>")
commandoutput = subprocess.check_output("<any command>")

Use ("command",shell=True) to have the call work like it would on the commandline

In python3

import subprocess
CompletedProcess = subprocess.run("<any command>")

The CompletedProcess returned has (args, returncode, stdout, stderr)

random

Generate random numbers.

random.random()
Return a floating point in the range from 0.0 to 1.0 (including both)
random.randint(start,stop)
Return an integer in the range from start to stop (including both)
Pick a random element from a list:
list[random.randint(0,len(list)-1)]
list[int(random.random()*len(list))]

threading

Enable parallel processing

t1=threading.Thread(target=<a function>)
Return a thread object to run <a function> in the background
t1.start()
Start the thread for the function targeted by t1
t1.join(<timeout>)
Wait until t1 is ready or until <timeout> has expired. Returns None always.
t1.is_alive()
Return True if t1 is still running (usefull e.g. after join with timeout).

getopt

Module to parse the commandline arguments (sys.argv).

collections

from collections import defaultdict

adict = defaultdict(<type>)
Create a dictionary key of the provided type automagically when it is used (WARNINIG, also when you try to read it). Use this to avoid checking if a key already exists before you populate it.
adict = defaultdict(lambda: defaultdict(lambda: defaultdict()))
Use lambda function to handle multilevel dictionaries

Variables

Everything is an object in python. Objects can be variables and functions.

Variables are always pointers to objects.

a = 2
b = 2

Both a and b point to the same object (the immutable integer '2')

Variables are local by default. If a routine has any assignment to a variable it is local. If you have defined a variable outside a routine and need assignments to it in the routine you have to declare it global explicitly.

a = 'a string'

def main():
    global a
    print(a)
    a = "This would fail with 'local variable 'a' referenced before assignment' if 'a' was not declared as global"

main()

[Geeks for Geeks] has as good page about this.