Difference between revisions of "Python:DataTypes"

From wiki
Jump to: navigation, search
(set)
(Dictionary or dict)
Line 102: Line 102:
 
:Initialize dictionary with data  
 
:Initialize dictionary with data  
  
 +
Check [[Python#collections|collections defaultdict]] for automatic key creation.
 
;<code>if key in dict:</code>
 
;<code>if key in dict:</code>
 
:Test if key exists in dict. <code>if dict[key]:</code> will throw a keyerror if it does not exist.  
 
:Test if key exists in dict. <code>if dict[key]:</code> will throw a keyerror if it does not exist.  

Revision as of 10:12, 18 December 2019


Object Classes

Lots of things to tell about strings, they have there own string page.

Also for numpy (module for scientific arithmetic) there is a special page

Objects are iterable if they can contain more than 1 ordered objects (string, list, tuple, dict). Objects are mutable if their content can be changed (list, set, dict)

isinstance(<obj>, <class>)
Boolean (returns True or False) to check if <obj> is an instance of <class>
if in locals()
Check if a variable exists as local
if in globals()
Check if a variable exists and is global.

Note: Variables are pointers to objects, not the object itself.

list

Class of iterable, mutable objects. Lists can be compared to arrays in other languages. Lists can contain a mixture of all kind of objects.

lst1 = []
Initialize an empty list
lst1.append(2)
Add the '2' object to the end of lst1
lst1.pop(n)
Remove and return nth element from lst1. Last element if n is not specified.
lst1 = list(object)
Convert object to a list (object is e.g. set, tuple or string)
count = lst1.count[x]
Return the number of occurrences of x in lst1
lst1.index(x)
Return the position of x (first occurrence) in lst1
lst1.sort()
Sort lst1 and return 'None' object
lst2 = sorted(iterable)
Return the iterable object sorted as list

More on sorting e.g. using keys.

print '[%s]' % ', '.join(map(str, lst1))
print (','.join(lst1))
Print lst1 as [<element>,..]
Put items matching a regular expression in newlist.

More on regular expressions in Python:Strings#Regular_Expressions_(regexp)

import re
newlist = filter(re.compile(<regular expression>).search,list1)

set

Class of iterable, mutable objects. Objects added to sets are hashed. Therefor:

  • Only immutable objects can be added to a set.
  • Sets cannot hold duplicate objects (adding an object again does not change the set).
  • Checking if a set holds an object is very fast.

A set is iterable but has no order, therfor:

  • You can loop over a set like for a in set:
  • You cannot take a slice from a set.
set1 = set()
Initialize an empty set
set1 = set([<values>])
Initialize a set with <values>. Note the list-format of <values>.
set1.add(2)
Add the '2' object to set1. You can add only 1 object at a time.
set1.discard(2)
Remove the '2' object from set1 (returns None object)
unionset = set1.union(set2)
Combine the sets (e.g.to remove duplicates)
diffset = set1 - set2
diffset will have all elements of set1 that are not in set2

Tuple

Class of iterable, immutable objects. Results from database queries are by default returned as tuple.

tpl1 = ()
Initialize an empty tuple

Dictionary or dict

Class of iterable, mutable objects. Dictionary's can be compared to perl hashes. Check the Python:JSON page too.

dict1 = {}
Initialize an empty dictionary.
dict1 = { column1: value1, column2: value2 }
Initialize dictionary with data

Check collections defaultdict for automatic key creation.

if key in dict:
Test if key exists in dict. if dict[key]: will throw a keyerror if it does not exist.
list(dict1.keys())
List of keys in dict1
list(dict1.values())
List of values in dict1
list(dict1.items())
List of key-value pairs #Tuples in dict1
dict1.update(dict2)
Add dict2 to dict1. Duplicate keys are overwritten in dict1.
dict1.pop(key)
Remove key from dict1, return dict1[key] if successful, None if key does not exist in dict1.

Code example:

dict = {}
dict["name1"] = {}
dict["name1"]["street"] = "mystreet"
 
for name in dict:
   print name
   for key2 in dict[name]:
      print key2,dict[name][key2]
 
for name in dict:
   print name
   for key2 in sorted(dict[name].keys()):
      print key2,dict[name][key2]

Recursively search a key:

def search_dict(data,skey=None):
    result = None
    if skey in data:
        result = data[skey]
    else:
        for key in data:
            if isinstance(data[key],dict):
                result = search_dict(data[key],skey)
    return result

Create a list of dict values where the key matches a string (List comprehension for dicts)

[value for key, value in d.items() if 'searchstring' in key]
[value for key, value in d.items() if key == 'keyname']

This very non-intuitive syntax is the same as:

list1 = list[]
for key,value in d.items():
    if 'searchstring' in key():
        list1.append(value)
return list1

None

The None object is returned e.g. if nothing is found in a re.search. The None object is not an empty string

Range

Constructor of immutable sequences of integers. Use with list, set, tuple to create the desired object, or for loops.

range(start,stop,step)
Generic format. If you leave out step, step = 1. If only 1 parameter is provided, it is the stop number, start = 0, step = 1
for i in range (2,8,2):
    print(i)

DateTime

Lots more to do than setting timestamps (to be added)

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

Other formats:

%s - Seconds since epoc (January 1, 1970 00:00:00)
%f - Nanoseconds or Milliseconds depends on what your system supports
Get an unique integer. Time is cheaper than datetime.
import time as t
# Use UTC-time 1 tick per second
nonce = int(t.mktime(t.gmtime()))
# This has greater precision (nanoseconds) but is in local time, not unique when the clock is set back.
nonce = int(t.time()*10000)
# I use datetime as that is loaded most time anyhow for other timestamps
from datetime import datetime
timestamp = datetime.utcnow().strftime("%s%f")

Slicing

You can address all iterable datatypes partly or in a difference sequence.

object[b:e:s]
Generic format where b=Begin (counting starts at 0), e=End, s=Stepsize (negative stepsize starts counting at the end)

Examples:

'last element'[-1]
'All elements except the last'[:-1]
'All elements in reversed order'[::-1]

'All elements from the second'[1:]
'Second until 5th element (element 1,2,3 and 4)'[1:5]  
'Elements in reversed order (element 5,4,3 and 2)'[5:1:-1]
'Element 1,3 and 5'[1:6:2]