域——类的变量和对象的变量
1：类的变量：由一个类的所有对象(实例)共享使用，只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。我理解为：其实它就是一个类的全局变量，类实例化后的对象都可以调用该变量。
2：对象的变量： 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。我理解的是：不同的对象调用该变量，其值改变后互不影响，跟C#的语法一样，我还因为不理解第一点纠结了半天 ！
属于类级别的变量，在使用它的时候一定要带上类型名字 比如 MyClass.count
属于每个对象级别的变量，在调用的时候一定要带上self表明属于当前对象。self.name
构造方法的使用
​ 很多类都倾向于将对象创建为有初始化状态.因此类可以定义一个名为init()的特殊方法(构造方法)来实例化一个对象。
构造方法也叫做构造器,是指当实例化一个对象(创建一个对象)的时候,第一个被自动调用的方法。
析构函数调用的契机【对象被销毁的时候】：
1、程序执行结束，会自动调用析构函数
2、使用del 删除对象的时候，系统会自动调用析构函数

自己写构造函数
class FooBar:
	somevar= 0
    def  init(self):
        self.somevar = 100
foo = FooBar()
print(foo.somevar)
100

调用内置方法
在Python中，创建构造函数很容易，只需将方法 init 的名称从普通的 init 改为魔法版 __init__即可。
class FooBar:
    def __init__(self):
        self.somevar = 25
        
foo = FooBar()
print(foo.somevar)
25

超类的构造函数
# 基类
class Bird:
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print('Aaaah ... nice')
            self.hungry = False
        else:
            print('No, thanks!')

bird = Bird()
bird.hungry
bird.eat()
# Aaaah ... nice

# SongBird 类继承了 Bird  类
class SongBird(Bird):
    def __init__(self):
        self.sound = 'Sing a song!'
    def sing(self):
        print(self.sound)
songB = SongBird()
songB.sing()

# 超类调用基类的方法
songB.eat()

# 运行报错
'''
Sing a song!
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-107-800cd686db7a> in <module>
     10 
     11 # 超类调用基类的方法
---> 12 songB.eat()

<ipython-input-105-3615908d8440> in eat(self)
      4         self.hungry = True
      5     def eat(self):
----> 6         if self.hungry:
      7             print('Aaaah ... nice')
      8             self.hungry = False

AttributeError: 'SongBird' object has no attribute 'hungry'
'''

因为在SongBird 中重写了构造函数，但新的构造函数没有包含任何初始化属性 hungry 的代码。要消除这种错误， SongBird 的构造函数必须调用其超类（ Bird ）的构造函数，以确保基本的初始化得以执行。为此，有两种方法：调用未关联的超类构造函数，以及使用函数 super 。接下来的两节将介绍这两种方法。
调用未关联的超类构造函数
class SongBird(Bird):
    def __init__(self):
        Bird.__init__(self)
        self.sound = 'Sing a song!'
    def sing(self):
        print(self.sound)
songB = SongBird()
songB.sing()

# 对实例调用方法时，方法的参数 self 将自动关联到实例（称为关联的方
# 法），这样的示例你见过多个。然而，如果你通过类调用方法（如 Bird.__init__ ），就没有实例
# 与其相关联。在这种情况下，你可随便设置参数 self 。这样的方法称为未关联的。

使用函数 super
class SongBird(Bird):
    def __init__(self):
        # Bird.__init__(self)
        super().__init__()
        self.sound = 'Sing a song!'
    def sing(self):
        print(self.sound)
songB = SongBird()
songB.sing()

总结
相比较直接对超类调用未关联的方法（Bird.init(self)， 不是调用一个示例的方法，而是直接使用类名调用方法），使用函数super更直观。但这并非其唯一的优点。实际上，函数 super 很聪明，因此即便有多个超类，也只需调用函数 super 一次（条件是所有超类的构造函数也使用函数 super ）。

构造函数

__init__初学者看着很吓人，其实它就是一个初始化方法，只是命名为__init__。然而，构造函数不同于普通方法的地方就在于，将在对象创建后自动调用它们。

在Python中，创建构造函数很简单，只需要将方法init的名称从普通的init改成魔法版的__init__即可。如示例1

#示例1
>>> class My:
...     def __init__(self):
...             self.number = 45
...
>>> F = My()
>>> F.number
45

构造函数中也可以添加参数，由于参数是可选的，所有你也可以指定这个参数具体如示例2

#示例2
>>> class My:
...     def __init__(self, value=45):
...             self.number = value
...
>>> F = My()
>>> F.number
45
>>> F = My(" this")
>>> F.number
' this'

编写构造函数

现在，我们来创建一个实例来尝试编写一个构造函数。编写一个Person类。具体见示例3

>>> class Person:
...     def __init__(self, name, job=None, pay=0):
...         self.name = name
...         self.job = job
...         self.pay = pay
...
>>> bob = Person('Bob Smith')
>>> sue = Person('Sue Jones', job='dev', pay=10000)
>>> print(bob.name, bob.job, bob.pay)
Bob Smith None 0
>>> print(sue.name, sue.job, sue.pay)
Sue Jones dev 10000

#这里的bob对象针对job和pay接受了默认值，但是sue显式地提供了值。
#注意在创建sue时是如何使用关键字参数的

赋给实例属性第一个值的通常方法是，在__init__构造函数方法中将它们赋给self，构造函数方法包含每次创建一个实例的时候Python会自动运行代码。在OO术语中，self就是新创建的实例对象，而name， job， pay变成了状态信息，即保存在对象中供随后使用的描述性数据。

关于构造函数的疑惑解答

为什么类方法函数中的第一个参数特殊？        类方法中函中的第一个参数之所以特殊，是因为它总是接受将方法调用视为隐含主体的实例对象，按照惯例，通常称为self。因为方法函数默认总是有这个隐含的主体对象环境，所以我们说这是”面向对象“，也就是设计用来处理或修改对象的。
	
__init__方法是做什么用的？        如果类中编写了或者继承了__init__方法，每次类实例创建时，Python会自动调用它。这也称为构造函数。除了明确传入类的名称的任何参数外，还会隐性的传入新实例。这也是最常见的运算符重载方法。如果没有__init__方法，实例刚创建时就是一个简单的空的命名空间。

	 
	
怎么创建实例？       你可以调用类名称来创建类实例。任何传给类名称的参数都要出现在__init__构造函数中第二和其后的参数。新的实例会记得创建它的类，从而可以实现继承目的。
 

问题：是否可以在不使用字符串构造函数的情况下将变量用作表名？
信息：
我现在正在研究一个项目，该项目对来自我的恒星模拟的数据进行分类。为此，我将所有数据加载到sqlite数据库中。它工作得很好，但是我决定为数据库增加更多的灵活性，效率和可用性。我计划稍后在模拟中添加小行星，并希望为每个恒星提供一张表格。这样，我就不必查询每个太阳系中1-4k的20m个小行星的表。
有人告诉我使用字符串构造函数是不好的，因为它使我容易受到SQL注入攻击。虽然这并不是什么大问题，因为我是唯一有权访问这些数据库的人，但我想遵循最佳实践。而且通过这种方式，如果我在向公众开放的情况下进行类似的项目，我也知道该怎么做。
目前，我正在这样做：
cursor.execute("CREATE TABLE StarFrame"+self.name+" (etc etc)")
这可行，但是我想做更多类似的事情：
cursor.execute("CREATE TABLE StarFrame(?) (etc etc)",self.name)
尽管我知道这可能是不可能的。虽然我会满足于
cursor.execute("CREATE TABLE (?) (etc etc)",self.name)
如果根本不可能，我将接受该答案，但是如果有人知道执行此操作的方法，请告知。:)
我在用python编码。