Difference between revisions of "Python:DataTypes"
(14 intermediate revisions by the same user not shown) | |||
Line 36: | Line 36: | ||
;count = lst1.count[x] | ;count = lst1.count[x] | ||
:Return the number of occurrences of x in lst1 | :Return the number of occurrences of x in lst1 | ||
+ | |||
+ | ;lst1.index(x) | ||
+ | :Return the position of x (first occurrence) in lst1 | ||
;lst1.sort() | ;lst1.sort() | ||
Line 46: | Line 49: | ||
;print '[%s]' % ', '.join(map(str, lst1)) | ;print '[%s]' % ', '.join(map(str, lst1)) | ||
+ | ;print (','.join(lst1)) | ||
:Print lst1 as [<element>,..] | :Print lst1 as [<element>,..] | ||
− | ;Put | + | ;Put items matching a regular expression in newlist. |
More on regular expressions in [[Python:Strings#Regular_Expressions_(regexp)]] | More on regular expressions in [[Python:Strings#Regular_Expressions_(regexp)]] | ||
<syntaxhighlight lang=python> | <syntaxhighlight lang=python> | ||
import re | import re | ||
− | + | newlist = filter(re.compile(<regular expression>).search,list1) | |
− | |||
</syntaxhighlight> | </syntaxhighlight> | ||
Line 61: | Line 64: | ||
* Sets cannot hold duplicate objects (adding an object again does not change the 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. | * 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 <code>for a in set:</code> | ||
+ | * You cannot take a [[Python:DataTypes#Slicing | slice]] from a set. | ||
;set1 = set() | ;set1 = set() | ||
Line 73: | Line 80: | ||
;set1.discard(2) | ;set1.discard(2) | ||
:Remove the '2' object from set1 (returns None object) | :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 = set1 - set2 | ||
Line 92: | 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. | ||
− | ;dict1.keys() | + | ;list(dict1.keys()) |
:[[Python:DataTypes#list|List]] of keys in dict1 | :[[Python:DataTypes#list|List]] of keys in dict1 | ||
− | ;dict1.values() | + | ;list(dict1.values()) |
:[[Python:DataTypes#list|List]] of values in dict1 | :[[Python:DataTypes#list|List]] of values in dict1 | ||
− | ;dict1.items() | + | ;list(dict1.items()) |
− | :[[Python:DataTypes#list|List]] of key-value pairs in dict1 | + | :[[Python:DataTypes#list|List]] of key-value pairs [[#Tuple]]s in dict1 |
;<code>dict1.update(dict2)</code> | ;<code>dict1.update(dict2)</code> | ||
Line 110: | Line 121: | ||
Code example: | Code example: | ||
<syntaxhighlight lang=python> | <syntaxhighlight lang=python> | ||
− | + | from collections import defaultdict | |
− | dict | + | dict = defaultdict{lambda: defaultdict()} |
dict["name1"]["street"] = "mystreet" | dict["name1"]["street"] = "mystreet" | ||
Line 137: | Line 148: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | Create a list of dict values where the key matches a string | + | Create a list of dict values where the key matches a string (List comprehension for dicts) |
<syntaxhighlight lang=python> | <syntaxhighlight lang=python> | ||
− | [value for key, value in d.items() if 'searchstring' in key()] | + | [value for key, value in d.items() if 'searchstring' in key] |
+ | [value for key, value in d.items() if key == 'keyname'] | ||
</syntaxhighlight> | </syntaxhighlight> | ||
This very non-intuitive syntax is the same as: | This very non-intuitive syntax is the same as: | ||
Line 169: | Line 181: | ||
from datetime import datetime | from datetime import datetime | ||
timestamp = datetime.now().strftime("%y%m%d_%H%M%S") | timestamp = datetime.now().strftime("%y%m%d_%H%M%S") | ||
+ | </syntaxhighlight> | ||
+ | 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. | ||
+ | <syntaxhighlight lang=python> | ||
+ | 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") | ||
</syntaxhighlight> | </syntaxhighlight> | ||
Line 179: | Line 206: | ||
Examples: | Examples: | ||
<syntaxhighlight lang=python> | <syntaxhighlight lang=python> | ||
− | |||
'last element'[-1] | 'last element'[-1] | ||
− | 'elements | + | '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] | ||
</syntaxhighlight> | </syntaxhighlight> |
Revision as of 12:33, 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:
from collections import defaultdict
dict = defaultdict{lambda: defaultdict()}
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]