Harness the power of Python magic methods and lazy objects.
|
|
|
- Randolph Freeman
- 5 years ago
- Views:
Transcription
1 Harness the power of Python magic methods and lazy objects. By Sep Dehpour Aug 2016 zepworks.com sep at zepworks.com
2 Lazy Loading Defer initialization of an object until the point at which it is needed.
3 Why lazy? Better performace (depending on your design) Better illusion of performance (when dealing with heavy objects) Less hits to your database (depending on your design) Why not lazy? Inconsistent state. Code complexity. More hits to your database (depending on your design).
4 Why Lazy? Better performance, less hits to database >>> q = Entry.objects.filter(headline startswith="what") >>> q = q.filter(pub_date lte=datetime.date.today()) >>> q = q.exclude(body_text icontains="food") >>> print(q) # <-- evaluated here
5 Why Lazy? Better performance, less hits to database Example: Fetching 100 keys from Redis 100 x Get one key: 4.84 miliseconds 1 x Mget 100 keys: 0.93 miliseconds
6 Why Lazy? Better illusion of performance Example: Unlimited scroll. Load chunks of big graph as you need.
7 Why Lazy? Less memory usage Load chunks of big graph as you need.
8 Why not lazy? Code maintainability
9 Why not lazy? Inconsistent state
10 Why not lazy? More hits to your database for obj in all_lazy_objects: print(obj) # evaluates one by one in a bad design.
11 Case Study Create a Redis client. <html> <head> <title>{{ title }}</title> </head> <body> Hello, We do {{ x }}, {{ y }} and {{ z }}. {{ footer }} </body> </html>
12 option 1: multiple get Multiple get requests to Redis context = dict( title = redis.get('root.homepage.title'), x = redis.get('root.things.x'), y = redis.get('root.things.y'), z = redis.get('root.things.z'), footer = redis.get('root.footer') ) <html> <head> <title>{{ title }}</title> </head> <body> Hello, We do {{ x }}, {{ y }} and {{ z }}. {{ footer }} </body> </html>
13 option 2: mget Multiple get requests to Redis context = dict( title, x, y, z, footer = redis.mget('root.homepage.title', 'root.things.x', 'root.things.y', 'root.things.z', 'root.footer') ) <html> <head> <title>{{ title }}</title> </head> <body> Hello, We do {{ x }}, {{ y }} and {{ z }}. {{ footer }} </body> </html>
14 option 3: lazy Let the frontend guys handle it. context = {'root': root} <html> <head> <title>{{ root.homepage.title }}</title> </head> <body> Hello, We do {{ root.things.x }}, {{ root.things.y }} and {{ root.things.z }}. {{ root.footer }} </body> </html>
15 Create a Redis Client
16 Redis data types overview String get, mget, set, mset (m = multi) List lrange (get a range), rpush (append), rpop (pop) Hash (Dictionary) hset (set a key), hsetall (set a whole dict), hgetall (get a whole dict) Set sadd, smembers
17 Create a Redis client Step 1: Load strings >>> print(root.something) value of root.something in Redis
18 Python magic methods method
19 Python magic methods init
20 Python magic methods new
21 Python magic methods del
22 Garbage Collector runs del
23 Magic methods Protocol for containers (to define containers like lists,...) getitem (self, key) setitem (self, key, value) Descriptor (custom class attributes that we fully control) get (self, obj, cls=none) set (self, obj, val) Called when no attribute found getattr (self, name) delitem (self, key) delete (self, obj)
24 Magic methods Called whether the attribute is found or not Called when garbage collecting. setattr (self, name, value) delattr (self, name) del (self) Not recommended. Instead use exit (context manager)
25 Step 1: load Goal: >>> print(root.something) value of root.something in Redis
26 getattr class Root: def getattr (self, key): class_name = self. class. name.lower() return redis.get("{}.{}".format(class_name, key)) >>> print(root.something) value of root.something in Redis >>> print(root.anotherthing) value of root.anotherthing in Redis
27 Step 2: save Goal: >>> root.something = "value" $ redis-cli :6379> get root.something "value"
28 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something)
29 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) return redis.get("{}.{}".format(self.class_name, key)) RecursionError: maximum recursion depth exceeded while calling a Python object
30 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) return redis.get("{}.{}".format(self.class_name, key)) RecursionError: maximum recursion depth exceeded while calling a Python object Hint: in Python when maximum depth recursion: key = "class_name" 2 keys in Redis: class_nameand something
31 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) return redis.get("{}.{}".format(self.class_name, key)) RecursionError: maximum recursion depth exceeded while calling a Python object getattr Called when no attribute found setattr Called whether the attribute is found or not
32 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs.
33 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set.
34 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set. 3. setattr is run to set self.class_name.
35 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set. 3. setattr is run to set self.class_name. 4. The key `class_name` is saved into Redis.
36 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set. 3. setattr is run to set self.class_name. 4. The key `class_name` is saved into Redis. 5. root.something = "value" sets key `something` into redis too.
37 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set. 3. setattr is run to set self.class_name. 4. The key `class_name` is saved into Redis. 5. root.something = "value" sets key `something` into redis too. 6. print(root.something)
38 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set. 3. setattr is run to set self.class_name. 4. The key `class_name` is saved into Redis. 5. root.something = "value" sets key `something` into redis too. 6. print(root.something) 7. getattr for `something` is run.
39 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set. 3. setattr is run to set self.class_name. 4. The key `class_name` is saved into Redis. 5. root.something = "value" sets key `something` into redis too. 6. print(root.something) 7. getattr for `something` is run. 8. in order to get the key from Redis, it needs to get self.class_name.
40 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set. 3. setattr is run to set self.class_name. 4. The key `class_name` is saved into Redis. 5. root.something = "value" sets key `something` into redis too. 6. print(root.something) 7. getattr for `something` is run. 8. in order to get the key from Redis, it needs to get self.class_name. 9. But self.class_name was never set on the object. It was saved into Redis.
41 class Root: def init (self): self.class_name = self. class. name.lower() def getattr (self, key): return redis.get("{}.{}".format(self.class_name, key)) def setattr (self, key, value): redis.set(key, value) root = Root() root.something = "value" print(root.something) 1. init runs. 2. self.class_name needs to be set. 3. setattr is run to set self.class_name. 4. The key `class_name` is saved into Redis. 5. root.something = "value" sets key `something` into redis too. 6. print(root.something) 7. getattr for `something` is run. 8. in order to get the key from Redis, it needs to get self.class_name. 9. But self.class_name was never set on the object. It was saved into Redis. 10. Tries to get self.class_name which needs self.class_name itself.
42 Solution Keep track of native attributes. Save to and read from dict
43 NATIVE_ATTRIBUTES = {'class_name'} class Root: def init (self): self.class_name = self. class. name.lower() def get_redis_key_path(self, key): return "{}.{}".format(self.class_name, key) def getattr (self, key): if key in NATIVE_ATTRIBUTES: return self. dict [key] else: key = self.get_redis_key_path(key) return redis.get(key) def setattr (self, key, value): if key in NATIVE_ATTRIBUTES: self. dict [key] = value else: key = self.get_redis_key_path(key) redis.set(key, value) root = Root() root.something = 10 print(root.something) # b"10"
44 Step 3: Make it lazy >>> obj = root.something >>> obj <Lazy root.something> >>> print(root.something) b"10"
45 OLD NATIVE_ATTRIBUTES = {'class_name'} class Root: def init (self): self.class_name = self. class. name.lower() def get_redis_key_path(self, key): return "{}.{}".format(self.class_name, key) def getattr (self, key): if key in NATIVE_ATTRIBUTES: return self. dict [key] else: key = self.get_redis_key_path(key) return redis.get(key) def setattr (self, key, value): if key in NATIVE_ATTRIBUTES: self. dict [key] = value else: key = self.get_redis_key_path(key) redis.set(key, value)
46 NEW NATIVE_ATTRIBUTES = {'class_name'} class Root: def init (self): self.class_name = self. class. name.lower() def get_redis_key_path(self, key): return "{}.{}".format(self.class_name, key) def getattr (self, key): if key in NATIVE_ATTRIBUTES: return self. dict [key] else: key = self.get_redis_key_path(key) return Lazy(key) def setattr (self, key, value): if key in NATIVE_ATTRIBUTES: self. dict [key] = value else: key = self.get_redis_key_path(key) redis.set(key, value)
47 class Lazy: def init (self, key): self.key = def value(self): # Redis keeps strings as bytes return redis.get(self.key).decode('utf-8') def repr (self): return "<Lazy {}>".format(self.key) def str (self): return self.value >>> root = Root() >>> root.something = 10 >>> root.something <Lazy root.something> >>> print(root.something) # evaluates b"10"
48 class Lazy: def init (self, key): self.key = def value(self): # Redis keeps strings as bytes return redis.get(self.key).decode('utf-8') def repr (self): return "<Lazy {}>".format(self.key) def str (self): return self.value >>> root = Root() >>> root.something = 10 >>> root.something > 8
49 class Lazy: def init (self, key): self.key = def value(self): # Redis keeps strings as bytes return redis.get(self.key).decode('utf-8') def repr (self): return "<Lazy {}>".format(self.key) def str (self): return self.value >>> root = Root() >>> root.something = 10 >>> root.something > 8 TypeError: unorderable types: Lazy() > int()
50 class Lazy: def init (self, key): self.key = def value(self): # Redis keeps strings as bytes return redis.get(self.key).decode('utf-8') def repr (self): return "<Lazy {}>".format(self.key) def str (self): return self.value def gt (self, other): return float(self.value) > other
51 class Lazy: def init (self, key): self.key = def value(self): # Redis keeps strings as bytes return redis.get(self.key).decode('utf-8') def repr (self): return "<Lazy {}>".format(self.key) def str (self): return self.value def gt (self, other): return float(self.value) > other >>> root.something > 8 True
52 class Lazy: def init (self, key): self.key = def value(self): # Redis keeps strings as bytes return redis.get(self.key).decode('utf-8') def repr (self): return "<Lazy {}>".format(self.key) def str (self): return self.value def gt (self, other): return float(self.value) > other def lt (self, other): return float(self.value) < other >>> root.something < 11 True
53 class Lazy: def init (self, key): self.key = key def repr (self): return "<Lazy {}>".format(self.key) def str (self): return def value(self): return redis.get(self.key).decode('utf-8') def gt (self, other): return float(self.value) > other def lt (self, other): return float(self.value) < other >>> root.something = 10 >>> root.something == 10
54 class Lazy: def init (self, key): self.key = def value(self): return redis.get(self.key).decode('utf-8') def repr (self): return "<Lazy {}>".format(self.key) def str (self): return self.value def gt (self, other): return float(self.value) > other def lt (self, other): return float(self.value) < other >>> root.something = 10 >>> root.something == 10 False
55 class Lazy: def init (self, key): self.key = def value(self): return redis.get(self.key).decode('utf-8') def repr (self): return "<Lazy {}>".format(self.key) def str (self): return self.value def gt (self, other): return float(self.value) > other def lt (self, other): return float(self.value) < other def eq (self, other): return float(self.value) == other
56 class Lazy: def init (self, key): self.key = def value(self): return redis.get(self.key).decode('utf-8')... def lt (self, other): return float(self.value) < other def gt (self, other): return float(self.value) > other def eq (self, other): return float(self.value) == other >>> root.something = 10 >>> root.something == 10 True
57 class Lazy: def init (self, key): self.key = def value(self): return redis.get(self.key).decode('utf-8')... def lt (self, other): return float(self.value) < other def gt (self, other): return float(self.value) > other def eq (self, other): return float(self.value) == other >>> root.something = 10 >>> root.something == 10 True >>> root.something is 10
58 class Lazy: def init (self, key): self.key = def value(self): return redis.get(self.key).decode('utf-8')... def lt (self, other): return float(self.value) < other def gt (self, other): return float(self.value) > other def eq (self, other): return float(self.value) == other >>> root.something = 10 >>> root.something == 10 True >>> root.something is 10 False
59 >>> root.something.another = 10
60 >>> root.something.another = 10 # works!
61 >>> root.something.another = 10 # works! >>> print(root.something.another)
62 >>> root.something.another = 10 # works! >>> print(root.something.another) AttributeError: 'Lazy' object has no attribute 'another'
63 >>> root.something.another = 10 # works! >>> print(root.something.another) Solution: 1. root.something is the lazy object
64 >>> root.something.another = 10 # works! >>> print(root.something.another) Solution: 1. root.something is the lazy object 2. root.something.another should return the same lazy object using getattr
65 >>> root.something.another = 10 # works! >>> print(root.something.another) Solution: 1. root.something is the lazy object 2. root.something return self for any non-native attribute 3. Update self.key from `root.something` to `root.something.another`
66 Step 5: save lists root.sides = ["fries", "salad"]
67 OLD class Root: def init (self): self.class_name = self. class. name.lower() def get_redis_key_path(self, key): return "{}.{}".format(self.class_name, key) def getattr (self, key): if key in NATIVE_ATTRIBUTES: return self. dict [key] else: key = self.get_redis_key_path(key) return Lazy(key) def setattr (self, key, value): if key in NATIVE_ATTRIBUTES: self. dict [key] = value else: key = self.get_redis_key_path(key) redis.set(key, value)
68 NEW class Root: def init (self): self.class_name = self. class. name.lower() def get_redis_key_path(self, key): return "{}.{}".format(self.class_name, key) def getattr (self, key): if key in NATIVE_ATTRIBUTES: return self. dict [key] else: key = self.get_redis_key_path(key) return Lazy(key) def setattr (self, key, value): if key in NATIVE_ATTRIBUTES: self. dict [key] = value else: key = self.get_redis_key_path(key) if isinstance(value, strings): redis.set(key, value) elif isinstance(value, Iterable): redis.delete(key) redis.rpush(key, *value)
69 Works! >>> root.sides = ["fries", "salad"] $ redis-cli :6379> lrange root.sides 0-1 1) "fries" 2) "salad"
70 Step 5: load lists root.sides = ["fries", "salad"] print(root.sides) ["fries", "salad"]
71 OLD class Lazy: def init (self, key): self.key = def value(self): return redis.get(self.key).decode('utf-8')
72 NEW class Lazy: def init (self, key): self.key = def value(self): thetype = redis.type(self.key) if thetype == b'string': result = redis.get(self.key).decode('utf-8') elif thetype == b'list': result = redis.lrange(self.key, 0, -1) result = [i.decode('utf-8') for i in result] return result
73 class Lazy: def init (self, key): self.key = def value(self): thetype = redis.type(self.key) if thetype == b'string': result = redis.get(self.key).decode('utf-8') elif thetype == b'list': result = redis.lrange(self.key, 0, -1) result = [i.decode('utf-8') for i in result] return result >>> root.sides = ["fries", "salad"] print(root.sides) "fries"
74 class Lazy: def init (self, key): self.key = def value(self): thetype = redis.type(self.key) if thetype == b'string': result = redis.get(self.key).decode('utf-8') elif thetype == b'list': result = redis.lrange(self.key, 0, -1) result = [i.decode('utf-8') for i in result] return result >>> root.sides = ["fries", "salad"] print(root.sides[0]) ["fries", "salad"] >>> print(root.sides[0])
75 class Lazy: def init (self, key): self.key = def value(self): thetype = redis.type(self.key) if thetype == b'string': result = redis.get(self.key).decode('utf-8') elif thetype == b'list': result = redis.lrange(self.key, 0, -1) result = [i.decode('utf-8') for i in result] return result >>> root.sides = ["fries", "salad"] print(root.sides[0]) ["fries", "salad"] >>> print(root.sides[0]) TypeError: 'Lazy' object does not support indexing
76 Magic methods Protocol for containers (to define containers like lists,...) getitem (self, key) setitem (self, key, value) Descriptor (custom class attributes that we fully control) get (self, obj, cls=none) set (self, obj, val) Called when no attribute found getattr (self, name) delitem (self, key) delete (self, obj)
77 OLD class Lazy: def init (self, key): self.key = def value(self): thetype = redis.type(self.key) if thetype == b'string': result = redis.get(self.key).decode('utf-8') elif thetype == b'list': result = redis.lrange(self.key, 0, -1) result = [i.decode('utf-8') for i in result] return result
78 NEW class Lazy: def init (self, key): self.key = def value(self): thetype = redis.type(self.key) if thetype == b'string': result = redis.get(self.key).decode('utf-8') elif thetype == b'list': result = redis.lrange(self.key, 0, -1) result = [i.decode('utf-8') for i in result] return result def getitem (self, key): return self.value[key]
79 After class Lazy: def init (self, key): self.key = def value(self): thetype = redis.type(self.key) if thetype == b'string': result = redis.get(self.key).decode('utf-8') elif thetype == b'list': result = redis.lrange(self.key, 0, -1) result = [i.decode('utf-8') for i in result] return result def getitem (self, key): return self.value[key] >>> root.sides = ["fries", "salad"] print(root.sides[0]) ["fries", "salad"] >>> print(root.sides[0]) fries
80 It can get complicated.
81 RedisWorks Based on DotObject Lazy Redis Queries Multi Query evaluation Dynamic Typing Ease of use
82 PyRedis >>> from redis import StrictRedis >>> redis = StrictRedis() >>> redis.set("root.something", "value") RedisWorks
83 PyRedis >>> from redis import StrictRedis >>> redis = StrictRedis() >>> redis.set("root.something", "value") RedisWorks >>> from redisworks import Root >>> root=root() >>> root.something = "value"
84 PyRedis >>> redis.rpush("root.sides", 10, "root.something", "value") >>> values = redis.lrange("root.sides", 0, -1) >>> values [b'10', b'root.something', b'value'] RedisWorks
85 PyRedis >>> redis.rpush("root.sides", 10, "root.something", "value") >>> values = redis.lrange("root.sides", 0, -1) >>> values [b'10', b'root.something', b'value'] RedisWorks >>> root.sides = [10, "fries", "coke"] >>> root.sides[1] 'fries' >>> "fries" in root.sides True >>> type(root.sides[0]) int
86 PyRedis >>> values = [10, [1, 2]] >>> redis.rpush("root.sides", *values) 2 >>> redis.lrange("root.sides", 0, -1) [b'10', b'[1, 2]'] RedisWorks
87 PyRedis >>> values = [10, [1, 2]] >>> redis.rpush("root.sides", *values) 2 >>> redis.lrange("root.sides", 0, -1) [b'10', b'[1, 2]'] RedisWorks >>> root.sides = [10, [1, 2]] >>> root.sides [10, [1, 2]] >>> type(root.sides[1]) <class 'list'>
88 PyRedis >>> redis.hmset("root.something", {1:"a", "b": {2: 2}}) >>> val = redis.hgetall("root.something") >>> val {b'b': b'{2: 2}', b'1': b'a'} >>> val[b'b'] b'{2: 2}' RedisWorks
89 PyRedis >>> redis.hmset("root.something", {1:"a", "b": {2: 2}}) >>> val = redis.hgetall("root.something") >>> val {b'b': b'{2: 2}', b'1': b'a'} >>> val[b'b'] b'{2: 2}' RedisWorks >>> root.something = {1:"a", "b": {2: 2}} >>> root.something {'b': {2: 2}, 1: 'a'} >>> root.something['b'][2] 2
90 Harness the power of Python magic methods and lazy objects. By Sep Dehpour Aug 2016 zepworks.com sep at zepworks.com Thanks to ChowNow for hosting.
Lecture #16: Generic Functions and Expressivity. Last modified: Fri Feb 26 19:16: CS61A: Lecture #16 1
Lecture #16: Generic Functions and Expressivity Last modified: Fri Feb 26 19:16:38 2016 CS61A: Lecture #16 1 Consider the function find: Generic Programming def find(l, x, k): """Return the index in L
Lecture #15: Generic Functions and Expressivity. Last modified: Wed Mar 1 15:51: CS61A: Lecture #16 1
Lecture #15: Generic Functions and Expressivity Last modified: Wed Mar 1 15:51:48 2017 CS61A: Lecture #16 1 Consider the function find: Generic Programming def find(l, x, k): """Return the index in L of
CIS192 Python Programming
CIS192 Python Programming Introduction Robert Rand University of Pennsylvania September 16, 2015 Robert Rand (University of Pennsylvania) CIS 192 September 16, 2015 1 / 21 Outline 1 Object Orientation
CIS192 Python Programming
CIS192 Python Programming Object-Oriented Programming Robert Rand University of Pennsylvania February 10, 2016 Robert Rand (University of Pennsylvania) CIS 192 February 10, 2016 1 / 25 Outline 1 Object
Beyond Blocks: Python Session #1
Beyond Blocks: Session #1 CS10 Spring 2013 Thursday, April 30, 2013 Michael Ball Beyond Blocks : : Session #1 by Michael Ball adapted from Glenn Sugden is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike
Iterators & Generators
Iterators & Generators Sequences A sequence is something that you can: Index into Get the length of What are some examples of sequences? Sequences We ve been working with sequences all semester! Examples:
(IUCAA, Pune) kaustubh[at]iucaa[dot]ernet[dot]in.
![(IUCAA, Pune) kaustubh[at]iucaa[dot]ernet[dot]in.](/thumbs/96/127502450.jpg "(IUCAA, Pune) kaustubh[at]iucaa[dot]ernet[dot]in.")
Basics of Python - 2 by Kaustubh Vaghmare (IUCAA, Pune) E-mail: kaustubh[at]iucaa[dot]ernet[dot]in 1 of 54 Sunday 16 February 2014 05:30 PM Our First Program - Rewritten! Let us introduce the following
Introductory Linux Course. Python I. Martin Dahlö UPPMAX. Author: Nina Fischer. Dept. for Cell and Molecular Biology, Uppsala University
Introductory Linux Course Martin Dahlö UPPMAX Author: Nina Fischer Dept. for Cell and Molecular Biology, Uppsala University August, 2018 Outline Python basics get started with Python Data types Control
Dr. Chuck Cartledge. 19 Nov. 2015
CS-695 NoSQL Database Redis (part 1 of 2) Dr. Chuck Cartledge 19 Nov. 2015 1/21 Table of contents I 1 Miscellanea 2 DB comparisons 3 Assgn. #7 4 Historical origins 5 Data model 6 CRUDy stuff 7 Other operations
Python OOP. Stéphane Vialette. LIGM, Université Paris-Est Marne-la-Vallée. October 19, 2010
Python OOP Stéphane Vialette LIGM, Université Paris-Est Marne-la-Vallée October 19, 2010 Stéphane Vialette (LIGM, Université Paris-Est Marne-la-Vallée) Python OOP October 19, 2010 1 / 59 Outline 1 Introduction
COMP519 Web Programming Lecture 21: Python (Part 5) Handouts
COMP519 Web Programming Lecture 21: Python (Part 5) Handouts Ullrich Hustadt Department of Computer Science School of Electrical Engineering, Electronics, and Computer Science University of Liverpool Functions
LECTURE 27. Python and Redis
LECTURE 27 Python and Redis PYTHON AND REDIS Today, we ll be covering a useful but not entirely Python-centered topic: the inmemory datastore Redis. We ll start by introducing Redis itself and then discussing
Programming with Python
Programming with Python Lecture 3: Python Functions IPEC Winter School 2015 B-IT Dr. Tiansi Dong & Dr. Joachim Köhler Python Functions arguments return obj Global vars Files/streams Function Global vars
CP215 Application Design
CP215 Application Design New ATLAS humanoid robot: https://youtu.be/rvlhmgqgdky Tech News! Tech News! New ATLAS humanoid robot: https://youtu.be/rvlhmgqgdky Spotify moving data to Google Cloud Hacker's
Python - 2. Jim Eng
Python - 2 Jim Eng jimeng@umich.edu Lists Dictionaries Try... except Methods and Functions Classes and Objects Midterm Review Overview Patterns in programming - 1 Sequential steps Conditional steps Repeated
A Guide to Python s Magic Methods
A Guide to Python s Magic Methods Rafe Kettler September 4, 2015 1 Introduction This guide is the culmination of a few months worth of blog posts. The subject is magic methods. What are magic methods?
Extended Introduction to Computer Science CS1001.py
Extended Introduction to Computer Science CS1001.py Lecture 15: Data Structures; Linked Lists Binary trees Instructors: Benny Chor, Amir Rubinstein Teaching Assistants: Michal Kleinbort, Yael Baran School
Object-Oriented Python
Object-Oriented Python Everything is an object. Every object has a value. a type. an identity. a namespace. CS105 Python def initstudent(student, eid): global A class is like a namespace. CS105 Python
CS61A Lecture 15 Object Oriented Programming, Mutable Data Structures. Jom Magrotker UC Berkeley EECS July 12, 2012
CS61A Lecture 15 Object Oriented Programming, Mutable Data Structures Jom Magrotker UC Berkeley EECS July 12, 2012 COMPUTER SCIENCE IN THE NEWS http://www.iospress.nl/ios_news/music to my eyes device converting
Positional, keyword and default arguments
O More on Python n O Functions n Positional, keyword and default arguments in repl: >>> def func(fst, snd, default="best!"):... print(fst, snd, default)... >>> func(snd='is', fst='python') ('Python', 'is',
Python review. 1 Python basics. References. CS 234 Naomi Nishimura
Python review CS 234 Naomi Nishimura The sections below indicate Python material, the degree to which it will be used in the course, and various resources you can use to review the material. You are not
Redis - a Flexible Key/Value Datastore An Introduction
Redis - a Flexible Key/Value Datastore An Introduction Alexandre Dulaunoy AIMS 2011 MapReduce and Network Forensic MapReduce is an old concept in computer science The map stage to perform isolated computation
Fun with Python Descriptors
Fun with Python Descriptors Author: Jeff Rush Date: 2006-11-25 include directive disabled... include:: Overview What are descriptors? Implementation: attribute watcher Implementation: property()
Fundamentals of Programming (Python) Object-Oriented Programming. Ali Taheri Sharif University of Technology Spring 2018
Fundamentals of Programming (Python) Object-Oriented Programming Ali Taheri Sharif University of Technology Outline 1. Python Data Types 2. Classes and Objects 3. Defining Classes 4. Working with Objects
jxmlease Documentation
jxmlease Documentation Release 1.0.2dev1 Juniper Networks April 18, 2016 Contents 1 Welcome 1 1.1 Installation................................................ 1 1.2 Parsing XML...............................................
Sage Reference Manual: Python technicalities
Sage Reference Manual: Python technicalities Release 8.1 The Sage Development Team Dec 09, 2017 CONTENTS 1 Various functions to debug Python internals 3 2 Variants of getattr() 5 3 Metaclasses for Cython
SI Networked Computing: Storage, Communication, and Processing, Winter 2009
University of Michigan Deep Blue deepblue.lib.umich.edu 2009-01 SI 502 - Networked Computing: Storage, Communication, and Processing, Winter 2009 Severance, Charles Severance, C. (2008, December 19). Networked
Algorithms in Systems Engineering ISE 172. Lecture 5. Dr. Ted Ralphs
Algorithms in Systems Engineering ISE 172 Lecture 5 Dr. Ted Ralphs ISE 172 Lecture 5 1 References for Today s Lecture Required reading Chapter 3 ISE 172 Lecture 5 2 Delving into the Lists As we have seen
Python Tutorial. Day 1
Python Tutorial Day 1 1 Why Python high level language interpreted and interactive real data structures (structures, objects) object oriented all the way down rich library support 2 The First Program #!/usr/bin/env
Visualize ComplexCities
Introduction to Python Chair of Information Architecture ETH Zürich February 22, 2013 First Steps Python Basics Conditionals Statements Loops User Input Functions Programming? Programming is the interaction
CS 234 Python Review Part 2
CS 234 Python Review Part 2 Recap import function: define, return boolean, conditional, branching loop: for, range, while file: open, close, readlines string: split Classes Define blueprint for a custom
Computational Mathematics with Python
Numerical Analysis, Lund University, 2012 1 Computational Mathematics with Python Unit 8: Object oriented programming with classes Numerical Analysis, Lund University Claus Führer, Olivier Verdier, Tony
WHY YOU DON'T NEED DESIGN PATTERNS IN PYTHON? EuroPython 2017
WHY YOU DON'T NEED DESIGN PATTERNS IN PYTHON? EuroPython 2017 EVERYTHING STARTS WITH A STORY... Zen of Python! STORY OF A PYTHON DEVELOPER TDD FOR THE WIN!!! Readability first! Thousands+ lines of code
Object Model Comparisons
Object Model Comparisons 1 Languages are designed, just like programs Someone decides what the language is for Someone decides what features it's going to have Can't really understand a language until
Hashing. So what we do instead is to store in each slot of the array a linked list of (key, record) - pairs, as in Fig. 1. Figure 1: Chaining
Hashing Databases and keys. A database is a collection of records with various attributes. It is commonly represented as a table, where the rows are the records, and the columns are the attributes: Number
CS61A Lecture 21. Amir Kamil UC Berkeley March 11, 2013
CS61A Lecture 21 Amir Kamil UC Berkeley March 11, 2013 Announcements HW7 due on Wednesday Ants project out Looking Up Names Name expressions look up names in the environment Dot expressions look
pygtrie Release Jul 03, 2017
pygtrie Release Jul 03, 2017 Contents 1 Features 3 2 Installation 5 3 Upgrading from 0.9.x 7 4 Trie classes 9 5 PrefixSet class 19 6 Version History 21 Python Module Index 23 i ii Implementation of a
Software Development Python (Part B)
Software Development Python (Part B) Davide Balzarotti Eurecom 1 List Comprehension It is a short way to construct a list based on the content of other existing lists Efficient Elegant Concise List comprehensions
Short Python function/method descriptions:
Last Name First Name Student#. Short Python function/method descriptions: builtins : len(x) -> integer Return the length of the list, tuple, dict, or string x. max(l) -> value Return the largest value
Python. Tutorial Lecture for EE562 Artificial Intelligence for Engineers
Python Tutorial Lecture for EE562 Artificial Intelligence for Engineers 1 Why Python for AI? For many years, we used Lisp, because it handled lists and trees really well, had garbage collection, and didn
Introductory Linux Course. Python I. Pavlin Mitev UPPMAX. Author: Nina Fischer Dept. for Cell and Molecular Biology, Uppsala University
Introductory Linux Course Python I Pavlin Mitev UPPMAX Author: Nina Fischer Dept. for Cell and Molecular Biology, Uppsala University August, 2017 Outline Python introduction Python basics get started with
Data Structures (CS 1520) Lecture 23 Name:
Data Structures (CS ) Lecture Name: ListDict object _table Python list object.... Consider the following ListDict class implementation. class Entry(object): """A key/value pair.""" def init (self, key,
Python Objects. Charles Severance. Python for Everybody
Python Objects Charles Severance Python for Everybody www.py4e.com Warning This lecture is very much about definitions and mechanics for objects This lecture is a lot more about how it works and less about
CNRS ANF PYTHON Objects everywhere
CNRS ANF PYTHON Objects everywhere Marc Poinot Numerical Simulation Dept. Outline Python Object oriented features Basic OO concepts syntax More on Python classes multiple inheritance reuse introspection
Basilisk Documentation
Basilisk Documentation Release 0.1 Bonnier Business Polska November 12, 2015 Contents 1 Indices and tables 7 Python Module Index 9 i ii Contents: Basilisk enables Pythonic use of Redis hashes, lists and
Index. Cache, 20 Callables, 185 call () method, 290 chain() function, 41 Classes attributes descriptors, 145 properties, 143
Index A add_column() method, 284 add() method, 44 addtypeequalityfunc() method, 253 Affero General Public License (AGPL), 260 American Standard Code for Information Interchange (ASCII), 218 219 and operator,
Recursion. Presentation Subtitle. Brad Miller David Ranum 1 12/19/2005. Luther College. Binary Search Trees. 1 Department of Computer Science
Presentation Subtitle Brad Miller David Ranum 1 1 Department of Computer Science Luther College 12/19/2005 Outline 1 Binary Search Trees Outline Binary Search Trees 1 Binary Search Trees BinaryTree() Create
Announcements. Homework 1 due Monday 10/12 (today) Homework 2 released next Monday 10/19 is due 11/2
61A Extra Lecture 6 Announcements Homework 1 due Monday 10/12 (today) Homework 2 released next Monday 10/19 is due 11/2 Homework 3 is to complete an extension to Project 4 Due at the same time as Project
1 Classes. 2 Exceptions. 3 Using Other Code. 4 Problems. Sandeep Sadanandan (TU, Munich) Python For Fine Programmers May 16, / 19
1 Classes 2 Exceptions 3 Using Other Code 4 Problems Sandeep Sadanandan (TU, Munich) Python For Fine Programmers May 16, 2009 1 / 19 Start with an Example Python is object oriented Everything is an object
61A Lecture 16. Wednesday, October 5
61A Lecture 16 Wednesday, October 5 Policy Changes Based on the Survey Homework can now be completed in pairs, if you wish. Every individual should still submit his/her own homework Please write your partner's
Computational Mathematics with Python
Numerical Analysis, Lund University, 2015 1 Computational Mathematics with Python Unit 7: Object oriented programming with classes Numerical Analysis, Lund University Lecturer: Claus Führer 2015 Classes
Friday, 11 April 14. Advanced methods for creating decorators Graham Dumpleton PyCon US - April 2014
Advanced methods for creating decorators Graham Dumpleton PyCon US - April 2014 Intermission Rant about the history of this talk and why this topic matters. Python decorator syntax @function_wrapper def
Lecture #21: Search Trees, Sets. Last modified: Tue Mar 18 18:15: CS61A: Lecture #21 1
Lecture #21: Search Trees, Sets Last modified: Tue Mar 18 18:15:49 2014 CS61A: Lecture #21 1 General Tree Class (From Last Lecture) class Tree: """A Tree consists of a label and a sequence of 0 or more
Course May 18, Advanced Computational Physics. Course Hartmut Ruhl, LMU, Munich. People involved. SP in Python: 3 basic points
May 18, 2017 3 I/O 3 I/O 3 I/O 3 ASC, room A 238, phone 089-21804210, email hartmut.ruhl@lmu.de Patrick Böhl, ASC, room A205, phone 089-21804640, email patrick.boehl@physik.uni-muenchen.de. I/O Scientific
GIS 4653/5653: Spatial Programming and GIS. More Python: Statements, Types, Functions, Modules, Classes
GIS 4653/5653: Spatial Programming and GIS More Python: Statements, Types, Functions, Modules, Classes Statement Syntax The if-elif-else statement Indentation and and colons are important Parentheses and
The current topic: Python. Announcements. Python. Python
The current topic: Python Announcements! Introduction! reasons for studying languages! language classifications! simple syntax specification Object-oriented programming: Python Types and values Syntax
New York University School of Continuing and Professional Studies Management and Information Technology. Advanced Python. Homework, Session 5
New York University School of Continuing and Professional Studies Management and Information Technology Advanced Python Homework, Session 5 5.1. design classes Guestbook and Entry. These classes will be
Database Solution in Cloud Computing
Database Solution in Cloud Computing CERC liji@cnic.cn Outline Cloud Computing Database Solution Our Experiences in Database Cloud Computing SaaS Software as a Service PaaS Platform as a Service IaaS Infrastructure
Simulation Algorithms
Simulation Algorithms Simulations are immensely useful, both for profit (design validation) and fun (games such as Angry Birds). Simulations can be optimized with the aid of data structures such as heap-backed
Classifying malware using network traffic analysis. Or how to learn Redis, git, tshark and Python in 4 hours.
Classifying malware using network traffic analysis. Or how to learn Redis, git, tshark and Python in 4 hours. Alexandre Dulaunoy January 9, 2015 Problem Statement We have more 5000 pcap files generated
n 1 i = n + i = n + f(n 1)
2 Binary Search Trees Lab Objective: A tree is a linked list where each node in the list may refer to more than one other node. This structural flexibility makes trees more useful and efficient than regular
Data Structures I: Linked Lists
Lab 4 Data Structures I: Linked Lists Lab Objective: Analyzing and manipulating data are essential skills in scientific computing. Storing, retrieving, and rearranging data take time. As a dataset grows,
Complete Python call :
Module 1 (Baics Python Rs.4000 ) 30 hours CHAPTER Instant Hacking: The Basics Installing Python Windows Linux and UNIX Macintosh Other Distributions Keeping In Touch and Up to Date The Interactive Interpreter
CIS192 Python Programming
CIS192 Python Programming Generators Exceptions and IO Eric Kutschera University of Pennsylvania February 13, 2015 Eric Kutschera (University of Pennsylvania) CIS 192 February 13, 2015 1 / 24 Outline 1
Princeton University COS 333: Advanced Programming Techniques A Subset of Python 2.7
Princeton University COS 333: Advanced Programming Techniques A Subset of Python 2.7 Program Structure # Print "hello world" to stdout. print 'hello, world' # Print "hello world" to stdout. def f(): print
Objects CHAPTER 6. FIGURE 1. Concrete syntax for the P 3 subset of Python. (In addition to that of P 2.)
CHAPTER 6 Objects The main ideas for this chapter are: objects and classes: objects are values that bundle together some data (attributes) and some functions (methods). Classes are values that describe
A Class to Manage Large Ensembles and Batch Execution in Python
Introduction Ensemble Class Argument Expansion A Class to Manage Large Ensembles and Batch Execution in Python PyCon Canada Andre R. Erler November 12 th, 2016 Introduction Ensemble Class Argument Expansion
Sets and Maps. Set Commands Set ADT Set ADT implementation Map ADT Map ADT implementation
Sets and Maps Set Commands Set ADT Set ADT implementation Map ADT Map ADT implementation Set The Set is a common container used in programming. Represents the mathematical set structure: Stores unordered
Linked Structures Chapter John Wiley & Sons, Data Structures and Algorithms Using Python, by Rance D. Necaise.
Linked Structures Chapter 6 Linked Structure Constructed using a collection of objects called nodes. Each node contains data and at least one reference or link to another node. Linked list a linked structure
CIS192 Python Programming
CIS192 Python Programming Iterators, Generators, Exceptions & IO Raymond Yin University of Pennsylvania September 28, 2016 Raymond Yin (University of Pennsylvania) CIS 192 September 28, 2016 1 / 26 Outline
CIS192 Python Programming
CIS192 Python Programming Object Oriented Programming Harry Smith University of Pennsylvania February 15, 2016 Harry Smith (University of Pennsylvania) CIS 192 Lecture 5 February 15, 2016 1 / 26 Outline
Advanced Python. Executive Summary, Session 1
Advanced Python Executive Summary, Session 1 OBJECT: a unit of data of a particular type with characteristic functionality (i.e., methods and/or use with operators). Everything in Python is an object.
COMPSCI 105 S Principles of Computer Science. Classes 3
S2 2017 Principles of Computer Science Classes 3 Exercise } Exercise } Create a Student class: } The Student class should have three attributes: id, last_name, and first_name. } Create a constructor to
Effective Programming Practices for Economists
Effective Programming Practices for Economists 14. Object-oriented programming Hans-Martin von Gaudecker Department of Economics, Universität Bonn Revisiting abstractions Reminder of the example Reconsider
Introductory Linux Course. Python I. Nina Fischer Dept. for Cell and Molecular Biology, Uppsala University
Introductory Linux Course Python I Nina Fischer Dept. for Cell and Molecular Biology, Uppsala University nina.fischer@icm.uu.se January 12, 2017 Outline q Python introducjon q Python basics get started
Introductory Linux Course. Python I. Nina Fischer Dept. for Cell and Molecular Biology, Uppsala University
Introductory Linux Course Python I Nina Fischer Dept. for Cell and Molecular Biology, Uppsala University nina.fischer@icm.uu.se August 26, 2016 Outline q Python introducjon q Python basics get started
Lecture 16: Binary Search Trees
Extended Introduction to Computer Science CS1001.py Lecture 16: Binary Search Trees Instructors: Daniel Deutch, Amir Rubinstein Teaching Assistants: Michal Kleinbort, Amir Gilad School of Computer Science
6.006 Recitation. Build
6.006 Recitation Build 2008.14 Coming up next... Open addressing Karp-Rabin coming back from the dead to hunt us Open Addressing Goal: use nothing but the table Hoping for less code, better caching Hashing
PyCon 2010: Maximize your program s laziness
Gordon Bell observed: The cheapest, fastest and most reliable components of a computer system are those that aren't there. This has a parallel in data structures: The fastest, most parsimonious, and best
CSCE 110 Programming I
CSCE 110 Programming I Basics of Python (Part 3): Functions, Lists, For Loops, and Tuples Dr. Tiffani L. Williams Department of Computer Science and Engineering Texas A&M University Spring 2014 Tiffani
Dangerously Advanced Python
Dangerously Advanced Python Mike Verdone for Protospace, Calgary May 2009 http://mike.verdone.ca/ Introspection and Metaprogramming Introspection: Programs that can interrogate their own data structures
Lecture 6: A step back
Lecture 6: A step back Last time We introduced a scripting language known as Python -- We started with the barest of motivation in terms of historical context and then jumped right in, focusing mainly
PyTrie Documentation. Release 0.3. George Sakkis
PyTrie Documentation Release 0.3 George Sakkis Jun 05, 2017 Contents 1 Usage 3 2 Reference documentation 5 2.1 Classes.................................................. 5 2.2 Trie methods...............................................
pysharedutils Documentation
pysharedutils Documentation Release 0.5.0 Joel James August 07, 2017 Contents 1 pysharedutils 1 2 Indices and tables 13 i ii CHAPTER 1 pysharedutils pysharedutils is a convenient utility module which
Python for C programmers
Python for C programmers The basics of Python are fairly simple to learn, if you already know how another structured language (like C) works. So we will walk through these basics here. This is only intended
Short Python function/method descriptions:
Last Name First Name Student#. Short Python function/method descriptions: builtins : len(x) -> integer Return the length of the list, tuple, dict, or string x. max(l) -> value Return the largest value
Overloading. F21SC Industrial Programming: Python: Advanced Language Features. Overloading. Overloading arithmetic operations
F21SC Industrial Programming: Python: Advanced Language Features Hans-Wolfgang Loidl School of Mathematical and Computer Sciences, Heriot-Watt University, Edinburgh Semester 1 2016/17 0 No proprietary
Lecture 15: Intro to object oriented programming (OOP); Linked lists
Extended Introduction to Computer Science CS1001.py Lecture 15: Intro to object oriented programming (OOP); Linked lists Instructors: Daniel Deutch, Amir Rubinstein Teaching Assistants: Michal Kleinbort,
CIS192 Python Programming
CIS192 Python Programming Iterators, Generators, IO, and Exceptions Harry Smith University of Pennsylvania February 15, 2018 Harry Smith (University of Pennsylvania) CIS 192 Lecture 5 February 15, 2018
>>> print( X ) [0,1,2,3] def mystery(l):??
![>>> print( X ) [0,1,2,3] def mystery(l):??](/thumbs/80/80937486.jpg ">>> print( X ) [0,1,2,3] def mystery(l):??")
REVIEW EXERCISES Problem 4 What is the output of the following script? Disclaimer. I cannot guarantee that the exercises of the final exam are going to look like this. Also, for the most part, the exercises
Lecture 21. Programming with Subclasses
Lecture 21 Programming with Subclasses Announcements for Today Reading Today: See reading online Tuesday: Chapter 7 Prelim, Nov 9 th 7:30-9:00 Material up to Today Review has been posted Recursion + Loops
I/O Files. Chapter 10
Chapter 10 I/O Files So far we have worked reading and writing text files. However, operating systems represent most of its files as sequences of bytes, not as text. Since reading bytes and converting
What We ll Be Seeing Today
1 INTRO2CS Tirgul 8 What We ll Be Seeing Today 2 Introduction to Object-Oriented Programming (OOP). Using Objects Special methods What is OOP? 3 So far our programs were made of different variables and
ENGR 101 Engineering Design Workshop
ENGR 101 Engineering Design Workshop Lecture 2: Variables, Statements/Expressions, if-else Edgardo Molina City College of New York Literals, Variables, Data Types, Statements and Expressions Python as
json2xls Documentation
json2xls Documentation Release 0.1.3c axiaoxin Aug 10, 2017 Contents 1 3 2 5 3 API 9 i ii json2xls Documentation, Release 0.1.3c jsonexceljsonexceljson jsonjsonurljsonjson Contents 1 json2xls Documentation,
Overloading. F21SC Industrial Programming: Python: Advanced Language Features. Overloading. Overloading arithmetic operations
F21SC Industrial Programming: Python: Advanced Language Features Hans-Wolfgang Loidl School of Mathematical and Computer Sciences, Heriot-Watt University, Edinburgh Semester 1 2015/16 0 No proprietary
Classes and Objects 1 / 13
Classes and Objects 1 / 13 Python is Object-Oriented Every value in Python is an object, meaning an instance of a class. Even values that are considered "primitive" in some other languages. >>> type(1)
Comp Exam 1 Overview.
Comp 170-400 Exam 1 Overview. Resources During the Exam The exam will be closed book, no calculators or computers, except as a word processor. In particular no Python interpreter running in a browser or
Python. Executive Summary
Python Executive Summary DEFINITIONS OBJECT: a unit of data of a particular type with characteristic functionality (i.e., methods and/or response to operators). Everything in Python is an object. "atomic"
Lecture 21. Programming with Subclasses
Lecture 21 Programming with Subclasses Announcements for This Lecture Assignments Prelim 2 A4 is now graded Mean: 90.4 Median: 93 Std Dev: 10.6 Mean: 9 hrs Median: 8 hrs Std Dev: 4.1 hrs A5 is also graded