On 12/10/2018 01:19, Ryan Johnson wrote:
I am working on using mysql.connector in a class and have found an example of
how to create a single connection that spans the lifetime of all instances of
the class:
https://softwareengineering.stackexchange.com/a/358061/317228
however, I do not understand a few things about the class, including
1. Why it is subclassed as an object: `class Postgres(object):` ? I thought
classes were necessarily objects.
This was sometimes necessary in Python 2.
2. Why is this portion of code directly addressing the class, instead of using
the `cls` reference variable?
connection = Postgres._instance.connection = psycopg2.connect(**db_config)
cursor = Postgres._instance.cursor = connection.cursor()
In a subclass, the `cls' argument would refer to the subclass, while
`Postgres' would still refer to the original class. I have no idea what
this is trying to achieve, and I think it's probably a bug. Maybe
someone else has an idea.
3. And is it me or does anyone else think {anydb}.connector’s usage is messy
and inelegant? Ex:
print('connecting to PostgreSQL database...')
connection = Postgres._instance.connection = psycopg2.connect(**db_config)
cursor = Postgres._instance.cursor = connection.cursor()
cursor.execute('SELECT VERSION()')
db_version = cursor.fetchone()
Why can’t we associate the focus of the connection with the connection
itself, instead of creating a separate cursor object?
You can have multiple cursors on the same connection.
Also, within the code example, and in Python in general, why does there needs
to be a __new__ constructor when there’s an __init__ constructor? I’ve read
about the usage of singletons. It seems you could create singletons within
__init__ or __new__ . Any enlightenment would be really helpful. I am very
sleep-deprived, so I’m sorry if this seems like a dumb question.
I have read the official docs. Have also been reading “Python 3: Patterns,
Recipes, and Idioms”. The first was mildly helpful but I still don’t see the
benefit of a __new__ constructor.
You can't create a singleton with __init__: by the time __init__ is
called, a new instance has already been created, and you can't switch
the object for a different one. By using __new__, you can bypass the
creation of a new instance.
If what you want is some shared state between all instances, a class
variable or global will do just fine and there's no need for a singleton
instance of anything.
Why is there dislike for Metaclasses?
They can be confusing.
--
https://mail.python.org/mailman/listinfo/python-list
