Dynamic Attributes in Python

Dynamic attributes in Python are terminologies for attributes that are defined at

runtime, after creating the objects or instances. In Python we call all functions,
methods also as an object. So you can define a dynamic instance attribute for
nearly anything in Python. Consider the below example for better understanding
about the topic.
Example 1:

class GFG:

    None

     def value():

 return 10

  # Driver Code

g = GFG()

  # Dynamic attribute of a

# class object

g.d1 = value

  # Dynamic attribute of a

# function
 value.d1 = "Geeks"

  print(value.d1)

print(g.d1() == value())

Output:
Geeks
True
Now, the above program seems to be confusing, but let’s try to understand it.
Firstly let’s see the objects, g and value(functions are also considered as objects in
Python) are the two objects. Here the dynamic attribute for both the objects is
“d1”. This is defined at runtime and not at compile time like static attributes.
Note: The class “GFG” and all other objects or instances of this class do not know
the attribute “d1”. It is only defined for the instance “g”.
Example 2:

class GFG:

    employee = True

  # Driver Code

e1 = GFG()

e2 = GFG()
 e1.employee = False

e2.name = "Nikhil"

  print(e1.employee)

print(e2.employee)

print(e2.name)

  # this will raise an error

# as name is a dynamic attribute

# created only for the e2 object

print(e1.name)

Output:
False
True
Nikhil

CASE STUDY AN ATM

Basic ATM Function Requirements
In the previous ATM program in Python we completed a list a of basic ATM requirements as
shown below:

 Input user pin for authentication

 Check account balance
  Deposit funds
 Withdraw funds
 Create random generated transaction id
 Account interest rate and monthly accrued interest rate
Additional ATM Function Requirements
In this module, the ATM program will add the below additional requirements:

 Separate balance into a checking account balance and a savings account balance
 Create a transfer of funds between checking account and savings account
 Create a transfer of funds between savings account and checking account
By completing the above, multiple new class objects and functions will need to be completed.
Also, the formatting of print statements will be different to accommodate the balance of funds to
two decimal places.

Import Python Module Random and Time

In order to complete the above ATM, we will need to import two Python modules; random and
time.
1 import random
2 import time

ATM Class Objects and Functions Create Class and Define Functions
What are class objects?
When creating the ATM program, the class objects are created under a class and these objects
have variables with an associated behavior. For instance, when depositing funds into an account,
the balance will increase and a withdraw of funds the balance will decrease but never go below a
fund of amount of $0.00. So, objects are needed in the ATM program class to completed these
examples.

class Account:
    # Construct an Account object
    def __init__(self, id, checkingBalance = 0, savingsBalance = 0, annualInterestRateSavings =
3.4):
        self.id = id
        self.checkingBalance = checkingBalance
        self.savingsBalance = savingsBalance
        self.annualInterestRateSavings = annualInterestRateSavings

    def getId(self):
        return self.id

    def checkingAccountBalance(self):
        return self.checkingBalance
 
    def withdrawCheckingAccount(self, amount):
        self.checkingBalance -= amount

    def depositCheckingAccount(self, amount):

        self.checkingBalance += amount
 
    def transferCheckingAccount(self, amount):
        self.checkingBalance += amount
        self.savingsBalance -= amount
        
    def savingsAccountBalance(self):
        return self.savingsBalance
 
    def withdrawSavingsAccount(self, amount):
        self.savingsBalance -= amount

    def depositSavingsAccount(self, amount):

        self.savingsBalance += amount
 
    def transferSavingsAccount(self, amount):
        self.savingsBalance += amount
        self.checkingBalance -= amount

    def savingsAccountMonthlyInterest(self):
        return self.savingsBalance * self.savingsAccountMonthlyInterest()
    
    def savingsAccountAnnualInterestRate(self):
        return self.annualInterestRateSavings

    def savingsAccountMonthlyInterestRate(self):
        return self.annualInterestRateSavings / 12

ATM main() Function

The main() function is a core function of the ATM program and is only executed when the
Python program is executed by the user. The main() function will serve as the Python interpreter
to execute source file code. A very important note is that the main() function will not call any
method if it’s not within the code. In the below main() function, there are 9 functions to execute
with the user input, but will only execute when the user input the number associated with the
transaction type at the ATM.  This is why the main() method has a technique, so that the main()
method will be executed when the program is executed directly and not when the module is
imported. Also, when inserting a bank ATM card, a user is requested to provide the ATM pin (4-
digits) and below is an example of this (also included in the basic ATM program).

1 def main():

2     # Creating accounts

3     accounts = []

4     for i in range(1000, 9999):

5         account = Account(i, 0)

6         accounts.append(account)

Data Modeling in Python

 

Overview
A datastore entity has a key and a set of properties. An application
uses the datastore API to define data models, and create instances
of those models to be stored as entities. Models provide a common
structure to the entities created by the API, and can define rules for
validating property values.

Model Classes
The Model Class

An application describes the kinds of data it uses with models. A

model is a Python class that inherits from the Model class. The
model class defines a new Kind of datastore entity and the
properties the Kind is expected to take. The Kind name is defined
by the instantiated class name that inherits from db.Model.

Model properties are defined using class attributes on the model

class. Each class attribute is an instance of a subclass of
the Property class, usually one of the provided property classes. A
property instance holds configuration for the property, such as
whether or not the property is required for the instance to be valid,
or a default value to use for the instance if none is provided.
from google.appengine.ext import db

class Pet(db.Model):
    name = db.StringProperty(required=True)
    type = db.StringProperty(required=True, choices=set(["cat", "dog", "bird"]))
    birthdate = db.DateProperty()
    weight_in_pounds = db.IntegerProperty()
    spayed_or_neutered = db.BooleanProperty()

An entity of one of the defined entity kinds is represented in the API

by an instance of the corresponding model class. The application
can create a new entity by calling the constructor of the class. The
application accesses and manipulates properties of the entity using
attributes of the instance. The model instance constructor accepts
initial values for properties as keyword arguments.

from google.appengine.api import users

pet = Pet(name="Fluffy",
          type="cat")
pet.weight_in_pounds = 24

Note: The attributes of the model class are configuration for the

model properties, whose values are Property instances. The
attributes of the model instance are the actual property values,
whose values are of the type accepted by the Property class.

The Model class uses the Property instances to validate values

assigned to the model instance attributes. Property value validation
occurs when a model instance is first constructed, and when an
instance attribute is assigned a new value. This ensures that a
property can never have an invalid value.

Because validation occurs when the instance is constructed, any

property that is configured to be required must be initialized in the
constructor. In this example, name and type are required values, so
their initial values are specified in the constructor. weight_in_pounds is
not required by the model, so it starts out unassigned, then is
assigned a value later.

An instance of a model created using the constructor does not exist

in the datastore until it is "put" for the first time.

Note: As with all Python class attributes, model property

configuration is initialized when the script or module is first imported.
Because App Engine caches imported modules between requests,
module configuration may be initialized during a request for one
user, and re-used during a request for another. Do not initialize
model property configuration, such as default values, with data
specific to the request or the current user. See App Caching for
more information.
The Expando Class

A model defined using the Model class establishes a fixed set of

properties that every instance of the class must have (perhaps with
default values). This is a useful way to model data objects, but the
datastore does not require that every entity of a given kind have the
same set of properties.

Sometimes it is useful for an entity to have properties that aren't

necessarily like the properties of other entities of the same kind.
Such an entity is represented in the datastore API by an "expando"
model. An expando model class subclasses
the Expando superclass. Any value assigned to an attribute of an
instance of an expando model becomes a property of the datastore
entity, using the name of the attribute. These properties are known
as dynamic properties. Properties defined using Property class
instances in class attributes are fixed properties.

An expando model can have both fixed and dynamic properties.

The model class simply sets class attributes with Property
configuration objects for the fixed properties. The application
creates dynamic properties when it assigns them values.

class Person(db.Expando):
    first_name = db.StringProperty()
    last_name = db.StringProperty()
    hobbies = db.StringListProperty()

p = Person(first_name="Albert", last_name="Johnson")
p.hobbies = ["chess", "travel"]

p.chess_elo_rating = 1350

p.travel_countries_visited = ["Spain", "Italy", "USA", "Brazil"]

p.travel_trip_count = 13

Because dynamic properties do not have model property definitions,

dynamic properties are not validated. Any dynamic property can
have a value of any of the datastore base types, including None. Two
entities of the same kind can have different types of values for the
same dynamic property, and one can leave a property unset that
the other sets.

Unlike fixed properties, dynamic properties need not exist. A

dynamic property with a value of None is different from a non-
existent dynamic property. If an expando model instance does not
have an attribute for a property, the corresponding data entity does
not have that property. You can delete a dynamic property by
deleting the attribute.

Attributes whose names begin with an underscore (_) are not saved
to the datastore entity. This allows you to store values on the model
instance for temporary internal use without affecting the data saved
with the entity.
Note: Static properties will always be saved to the datastore entity regardless
of whether it is Expando, Model, or begins with an underscore (_).
del p.chess_elo_rating

A query that uses a dynamic property in a filter returns only entities

whose value for the property is of the same type as the value used
in the query. Similarly, the query returns only entities with that
property set.

p1 = Person()
p1.favorite = 42
p1.put()

p2 = Person()
p2.favorite = "blue"
p2.put()

p3 = Person()
p3.put()

people = db.GqlQuery("SELECT * FROM Person WHERE favorite < :1", 50)

# people has p1, but not p2 or p3

people = db.GqlQuery("SELECT * FROM Person WHERE favorite > :1", 50)

# people has no results

Note: The example above uses queries across entity groups, which

may return stale results. For strongly consistent results,
use ancestor queries within entity groups.

The Expando class is a subclass of the Model class, and inherits all

of its methods.

The PolyModel Class

The Python API includes another class for data modeling that allows
you to define hierarchies of classes, and perform queries that can
return entities of a given class or any of its subclasses. Such
models and queries are called "polymorphic," because they allow
instances of one class to be results for a query of a parent class.

The following example defines a Contact class, with the

subclasses Person and Company:

from google.appengine.ext import db

from google.appengine.ext.db import polymodel

class Contact(polymodel.PolyModel):
    phone_number = db.PhoneNumberProperty()
    address = db.PostalAddressProperty()

class Person(Contact):
    first_name = db.StringProperty()
    last_name = db.StringProperty()
    mobile_number = db.PhoneNumberProperty()

class Company(Contact):
    name = db.StringProperty()
    fax_number = db.PhoneNumberProperty()

This model ensures that all Person entities and all Company entities

have phone_number and address properties, and queries
for Contact entities can return either Person or Company entities.
Only Person entities have mobile_number properties.

The subclasses can be instantiated just like any other model class:

p = Person(phone_number='1-206-555-9234',
           address='123 First Ave., Seattle, WA, 98101',
           first_name='Alfred',
           last_name='Smith',
           mobile_number='1-206-555-0117')
p.put()

c = Company(phone_number='1-503-555-9123',
            address='P.O. Box 98765, Salem, OR, 97301',
            name='Data Solutions, LLC',
            fax_number='1-503-555-6622')
c.put()

A query for Contact entities can return instances of

either Contact, Person, or Company. The following code prints
information for both entities created above:

for contact in Contact.all():

    print 'Phone: %s\nAddress: %s\n\n' % (contact.phone_number,
                                          contact.address)

A query for Company entities returns only instances of Company:

for company in Company.all()

    # ...

For now, polymorphic models should not passed to the Query class

constructor directly. Instead, use the all() method, as in the example
above.