help with my first use of a class

[BartlebyScrivener]

I am a mere hobbyist. Spent several hours trying to make a class,
because I think this is an occasion where I need one. But I can't make
it work.

This code "works" (only because of the global c, which I know I'm
supposed to avoid, by using a Class). I edited the rest to leave out
the irrelevant formatting and printing of the quotations.

I've read about Classes several times, but I don't "get" them yet.
Obviously. If I can solve one real life problem like this, then maybe
I'll see the light.

If I understand the power of Classes correctly, I could make one that
would allow me to make a new instance that would connect to, say, an
SQLite3 db instead of the Access db, as well as to create more methods
that will do different SQL searches.

Thank you for any help,

rd

--------------------------------------

import mx.ODBC.Windows as odbc
import sys
import random

def connect():
global c
db='DSN=Quotati ons'
conn = odbc.DriverConn ect(db)
c = conn.cursor()

def random_quote():
"""
Counts all of the quotes in MS Access database Quotations2005. mdb.
Picks one quote at random and displays it using textwrap.
"""
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")
# Yields the number of rows with something in the quote field
total_quotes = c.fetchone()
# Get a random number somewhere between 1 and the number of total
quotes
quote_number = (random.randint (1, total_quotes[0]),)
# Select a quote where the ID matches that number
c.execute ("SELECT Author, Quote FROM PythonQuoteQuer y WHERE ID=?",
quote_number)
quote = c.fetchone()
blah blah blah

def print_quote()
code to format and print the quote (which will also have to be
global, unless I learn Classes!)
if __name__ == '__main__':
if len(sys.argv) == 1:
connect()
random_quote()
print_quote()

[BartlebyScrivener]

Whoah. At least I got the connection. I think. Maybe I can figure more
on my own. Any help appreciated.

Thanks

---------

class Connection:
def __init__(self, aDatasource):
self.db = aDatasource
self.conn = odbc.DriverConn ect(self.db)
self.conn.curso r()

def random_quote():
"""
Counts all of the quotes in MS Access database Quotations2005. mdb.
Picks one quote at random and displays it using textwrap.
"""
c = Connection('DSN =Quotations')
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")

[wittempj]

BartlebyScriven er wrote:

I am a mere hobbyist. Spent several hours trying to make a class,
because I think this is an occasion where I need one. But I can't make
it work.

This code "works" (only because of the global c, which I know I'm
supposed to avoid, by using a Class). I edited the rest to leave out
the irrelevant formatting and printing of the quotations.

I've read about Classes several times, but I don't "get" them yet.
Obviously. If I can solve one real life problem like this, then maybe
I'll see the light.

If I understand the power of Classes correctly, I could make one that
would allow me to make a new instance that would connect to, say, an
SQLite3 db instead of the Access db, as well as to create more methods
that will do different SQL searches.

Thank you for any help,

rd

--------------------------------------

import mx.ODBC.Windows as odbc
import sys
import random

def connect():
global c

This means you want to use a global variable c which doesn't exist yet,
an example would be to save this code to a file:

#!/usr/bin/env python

c = 0
def test_global():
global c
c = 1

print c

this will print 0 when you run it

db='DSN=Quotati ons'
conn = odbc.DriverConn ect(db)
c = conn.cursor()

def random_quote():
"""
Counts all of the quotes in MS Access database Quotations2005. mdb.
Picks one quote at random and displays it using textwrap.
"""
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")
# Yields the number of rows with something in the quote field
total_quotes = c.fetchone()
# Get a random number somewhere between 1 and the number of total
quotes
quote_number = (random.randint (1, total_quotes[0]),)
# Select a quote where the ID matches that number
c.execute ("SELECT Author, Quote FROM PythonQuoteQuer y WHERE ID=?",
quote_number)
quote = c.fetchone()
blah blah blah

def print_quote()
code to format and print the quote (which will also have to be
global, unless I learn Classes!)

A class structure could look like - please bear in mind that I don't
know mx.ODBC.Windows - I guess it is not completely DB-API compliant,
as you don't use a connect method.

class SQLQuery(object ):
"""Object which connects to the database and can execurte SQL
commands
"""
def __init__(self, conn):
"""conn is a dictionary {'serverId': XX, 'userId': YY,
'passWord': ZZ}
"""
self.connection = connect(conn['userId'], conn['passWord'],
conn['serverId'])
self.cursor = self.__connecti on.cursor()

def select(self, selectqry):
"""argument selectqry specifies a sql which returns data, like a
select
"""
self.cursor.exe cute(selectqry)
return self.cursor.fet chall()

sql = SQLQuery('serve rId': 'XX', 'userId': 'YY', 'passWord': 'ZZ')
qoutes = sql.select("SEL ECT COUNT(Quote) FROM PythonQuoteQuer y")
print quotes

if __name__ == '__main__':
if len(sys.argv) == 1:

sys.argv is a list, where the first argument is the name of the running
script, the second element is the first argument, etc.

connect()
random_quote()
print_quote()

[James Stroud]

BartlebyScriven er wrote:

I am a mere hobbyist. Spent several hours trying to make a class,
because I think this is an occasion where I need one. But I can't make
it work.

This code "works" (only because of the global c, which I know I'm
supposed to avoid, by using a Class). I edited the rest to leave out
the irrelevant formatting and printing of the quotations.

I've read about Classes several times, but I don't "get" them yet.
Obviously. If I can solve one real life problem like this, then maybe
I'll see the light.

If I understand the power of Classes correctly, I could make one that
would allow me to make a new instance that would connect to, say, an
SQLite3 db instead of the Access db, as well as to create more methods
that will do different SQL searches.

Thank you for any help,

rd

--------------------------------------

import mx.ODBC.Windows as odbc
import sys
import random

def connect():
global c
db='DSN=Quotati ons'
conn = odbc.DriverConn ect(db)
c = conn.cursor()

def random_quote():
"""
Counts all of the quotes in MS Access database Quotations2005. mdb.
Picks one quote at random and displays it using textwrap.
"""
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")
# Yields the number of rows with something in the quote field
total_quotes = c.fetchone()
# Get a random number somewhere between 1 and the number of total
quotes
quote_number = (random.randint (1, total_quotes[0]),)
# Select a quote where the ID matches that number
c.execute ("SELECT Author, Quote FROM PythonQuoteQuer y WHERE ID=?",
quote_number)
quote = c.fetchone()
blah blah blah

def print_quote()
code to format and print the quote (which will also have to be
global, unless I learn Classes!)
if __name__ == '__main__':
if len(sys.argv) == 1:
connect()
random_quote()
print_quote()

You really don't need classes for this, just parameters + return values.
Probably best would be to master the idea of parameters + return values
before yo move on to classes. This is called "procedural " programming.
Notice that there is no name collision because of strict python
namespaces (a good idea, according to Tim Peters).
For example:

def connect():
db='DSN=Quotati ons'
conn = odbc.DriverConn ect(db)
c = conn.cursor()
# NOTE THE RETURN VALUE:
return c

def random_quote(c) : # <== NOTE THE PARAMETER
"""
Counts all of the quotes in MS Access database Quotations2005. mdb.
Picks one quote at random and displays it using textwrap.
"""
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")
# Yields the number of rows with something in the quote field
total_quotes = c.fetchone()
# Get a random number somewhere between 1 and ...
quote_number = (random.randint (1, total_quotes[0]),)
# Select a quote where the ID matches that number
q = "SELECT Author, Quote FROM PythonQuoteQuer y WHERE ID=?"
c.execute (q, quote_number)
quote = c.fetchone()
# NOTE THE RETURN VALUE:
return quote

def print_quote(quo te): # <== NOTE THE PARAMETER
print quote # <== WHATEVER YOU WANT TO DO

if __name__ == '__main__':
if len(sys.argv) == 1:
c = connect() # <== NO COLLISION: NAMESPACES
quote = random_quote(c) # <== DITTO
print_quote(quo te) # THERE YOU HAVE IT
James

[BartlebyScrivener]

Wow,

That's great, James.

Thanks. I shall put it together.

Appreciate it.

rd

[Bruno Desthuilliers]

BartlebyScriven er wrote:

I am a mere hobbyist. Spent several hours trying to make a class,
because I think this is an occasion where I need one. But I can't make
it work.

This code "works" (only because of the global c, which I know I'm
supposed to avoid, by using a Class). I edited the rest to leave out
the irrelevant formatting and printing of the quotations.

I've read about Classes several times, but I don't "get" them yet.

Think of a class as both a "blueprint" for objects and a factory
creating these objects. The class lets you define the attributes and
behaviors of it's instances.

Obviously. If I can solve one real life problem like this, then maybe
I'll see the light.

If I understand the power of Classes correctly, I could make one that
would allow me to make a new instance that would connect to, say, an
SQLite3 db instead of the Access db, as well as to create more methods
that will do different SQL searches.

Thank you for any help,
import mx.ODBC.Windows as odbc
import sys
import random

def connect():
global c
db='DSN=Quotati ons'
conn = odbc.DriverConn ect(db)
c = conn.cursor()

def random_quote():
"""
Counts all of the quotes in MS Access database Quotations2005. mdb.
Picks one quote at random and displays it using textwrap.
"""
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")
# Yields the number of rows with something in the quote field
total_quotes = c.fetchone()
# Get a random number somewhere between 1 and the number of total
quotes
quote_number = (random.randint (1, total_quotes[0]),)
# Select a quote where the ID matches that number
c.execute ("SELECT Author, Quote FROM PythonQuoteQuer y WHERE ID=?",
quote_number)
quote = c.fetchone()
blah blah blah

def print_quote()
code to format and print the quote (which will also have to be
global, unless I learn Classes!)

Ever wondered what arguments and return values were for ?-)

if __name__ == '__main__':
if len(sys.argv) == 1:
connect()
random_quote()
print_quote()

First, notice that you *don't* need a class here to avoid globals.
Learning to use function as *functions* (ie: taking arguments and
returning values) instead of procedure would help:

def random_quote(cu rsor):
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")
total_quotes = c.fetchone()
quote_number = (random.randint (1, total_quotes[0]),)
c.execute (
"SELECT Author, Quote FROM PythonQuoteQuer y WHERE ID=?",
quote_number
)
return c.fetchone()

def format_quote(qu ote):
# code here
return formatted_quote

def main(*args):
if len(args) < 2:
print >sys.stderr, "Missing dsn arg\nusage : %s dsn" % args[0]
return 1
dsn = args[1]
try:
conn = odbc.DriverConn ect(dsn)
except <SomeODBCErrorH ere>, e:
print >sys.stderr "Cannot connect to %s : %s" % (dsn, e)
return 1
quote = random_quote(co nn.cursor())
print format_quote(qu ote)
conn.close()
return 0

if __name__ == '__main__':
sys.exit(main(* sys.argv))
Now for an OO version - that won't buy you much IMHO:

class SQLFortune(obje ct):
def __init__(self, dsn):
self._dsn = dsn
self._cnx = None

@apply
def connection():
def fget(self):
if self._cnx is None:
self._cnx = odbc.DriverConn ect(self.dsn)
return self._cnx
def fset(self, _):
raise AttributeError( "Attribute is read-only")
return property(**loca ls())

def random_quote(se lf):
c = self.connection .cursor()
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")
total_quotes = c.fetchone()
quote_number = (random.randint (1, total_quotes[0]),)
c.execute (
"SELECT Author, Quote FROM PythonQuoteQuer y WHERE ID=?",
quote_number
)
return c.fetchone()

def format_quote(se lf, quote):
# code here
return formatted_quote

def close(self):
try: self._cnx.close ()
except: pass

def main(*args):
if len(args) < 2:
print >sys.stderr, "Missing dsn arg\nusage : %s dsn" % args[0]
return 1
dsn = args[1]
fortune = SQLFortune(dsn)
print fortune.format_ quote(fortune.r andom_quote())
fortune.close()
return 0

if __name__ == '__main__':
sys.exit(main(* sys.argv))
--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[Bruno Desthuilliers]

BartlebyScriven er wrote:

Whoah. At least I got the connection. I think. Maybe I can figure more
on my own. Any help appreciated.

Thanks

---------

class Connection:
def __init__(self, aDatasource):
self.db = aDatasource
self.conn = odbc.DriverConn ect(self.db)
self.conn.curso r()

This creates a cursor, that's immediatly discarded.

def random_quote():
"""
Counts all of the quotes in MS Access database Quotations2005. mdb.
Picks one quote at random and displays it using textwrap.
"""
c = Connection('DSN =Quotations')
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")

And this will raise an AttributeError, since your (mostly useless)
Connection class doesn't define an 'execute' method.

--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[Fredrik Lundh]

Bruno Desthuilliers wrote:

First, notice that you *don't* need a class here to avoid globals.
Learning to use function as *functions* (ie: taking arguments and
returning values) instead of procedure would help:

def random_quote(cu rsor):
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")

make that "cursor.execute " (etc)

</F>

[Bruno Desthuilliers]

Fredrik Lundh wrote:

Bruno Desthuilliers wrote:

>First, notice that you *don't* need a class here to avoid globals.
Learning to use function as *functions* (ie: taking arguments and
returning values) instead of procedure would help:

def random_quote(cu rsor):
c.execute ("SELECT COUNT(Quote) FROM PythonQuoteQuer y")

make that "cursor.execute " (etc)

oops, sorry - not enough coffein, I guess.
Thanks for the correction.

--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom. gro'.split('@')])"

[BartlebyScrivener]

Thanks, Bruno. Very educational.

rd

Bruno Desthuilliers wrote:

Think of a class as both a "blueprint" for objects and a factory
creating these objects. The class lets you define the attributes and
behaviors of it's instances.

First, notice that you *don't* need a class here to avoid globals.
Learning to use function as *functions* (ie: taking arguments and
returning values) instead of procedure would help:

Now for an OO version - that won't buy you much IMHO: