Initial commit

field.py

+
+# 我们来定义Field类，用来保存数据库表的字段名称和字段类型
+class Field(object):
+    def __init__(self, column_name, column_type):
+        self.column_name = column_name
+        self.column_type = column_type
+
+class StringField(Field):
+    def __init__(self, column_name):
+        super(StringField,self).__init__(column_name, 'varchar(200)')
+
+
+class IntegerField(Field):
+    def __init__(self, column_name):
+        super(IntegerField, self).__init__(column_name, 'bigint')
+
+
+class TextField(Field):
+    def __init__(self, column_name):
+        super(TextField, self).__init__(column_name, 'text')
+
+
+
+# 第二种写法
+class DataField(Field):
+    def __init__(self, column_name, column_type):
+        super(DataField, self).__init__(column_name, column_type)
+
+
+
+
+

my_db_config/mysql_config_set.py

+
+
+def set_mysql_conf(env):
+    # 这里代表了测试环境的配置
+    if env == "dev":
+        db_config = {
+            'host': '192.168.1.35',
+            'user': 'admin',
+            'passwd': '123456',
+            'db': 'python_ai_basic',
+            'port': 3306,
+            'charset': 'utf8'
+        }
+
+    # 这里代表了生产环境的配置
+    if env == "pro":
+        db_config = {
+            'host': '192.168.1.35',
+            'user': 'admin',
+            'passwd': '123456',
+            'db': 'python_ai_basic',
+            'port': 3306,
+            'charset': 'utf8'
+        }
+    return db_config
\ No newline at end of file

my_db_pool.py

+import pymysql
+from DBUtils.PooledDB import PooledDB
+from my_db_config.mysql_config_set import set_mysql_conf
+
+def create_pool():
+    db_config = set_mysql_conf("dev")
+    return PooledDB(pymysql,
+                    5,
+                    host=db_config['host'],
+                    user=db_config['user'],
+                    passwd=db_config['passwd'],
+                    db=db_config['db'],
+                    port=db_config['port'],
+                    charset=db_config['charset']).connection()
\ No newline at end of file

my_metaclass.py

+
+class Person():
+    pass
+
+# print(Person)
+#
+# p = Person
+# print(p)
+# p.name = "zhangsan"
+# print(p.name)
+
+
+def func(p):
+    print(p.name)
+
+# func(Person)
+
+
+# type
+
+
+def get_class(name):
+    if name == "dog":
+        class Dog():
+            def run(self):
+                print("dog run")
+        return Dog
+    else:
+        class Cat():
+            def run(self):
+                print("cat run")
+
+        return Cat
+#
+# c = get_class("dog")
+# print(c)
+# c.run(c)
+# c = get_class("c")
+# print(c)
+# c.run(c)
+#
+# print(type("2"))
+# print(type(1))
+
+class Person():
+    pass
+
+
+Person2 = type('Person2', (), {})
+# print(Person2)
+# p2 = Person2()
+# print(p2)
+
+class Person3():
+    name = "张三"
+# print(Person3.name)
+
+Person3 = type('Person3', (), {'name':'李四'})
+# print(Person3.name)
+
+# 继承
+Person4 = type('Person4', (Person3,), {})
+# print(Person4.name)
+
+@staticmethod
+def person4_run():
+    print("person4 run")
+
+def person4_run2(self):
+    print("person4 run2")
+
+Person4 = type('Person4', (Person3,), {'person4_run': person4_run, 'person4_run2': person4_run2})
+p = Person4()
+# p.person4_run()
+# p.person4_run2()
+
+# 元类
+
+class MyMetaClass(type):
+
+    def __new__(cls, name, bases, attrs):
+        print("元类new方法运行")
+        print(name)
+        print(bases)
+        attrs['add'] = lambda self, value: value + value
+        print(attrs)
+        return type.__new__(cls, name, bases, attrs)
+
+class MyClass(metaclass=MyMetaClass):
+    pass
+
+my_class = MyClass()
+r = my_class.add(2)
+print(r)
+
+
+
+
+
+
+
+
+

orm.py

+from object_packaging.field import Field
+from object_packaging.my_database import create_pool
+
+
+# 定义一个元类，控制model对象的创建
+class ModelMetaClass(type):
+    def __new__(cls, table_name, bases, attrs):
+        if table_name == "Model":
+            return super(ModelMetaClass, cls).__new__(cls, table_name, bases, attrs)
+        mappings = dict()
+        for k, v in attrs.items():
+            # 保存类属性和列的映射关系到mappings字典中
+            if isinstance(v, Field):
+                mappings[k] = v  # 这样，这个mappings就存放了  属性名称和字段名称及列的名字
+        for k in mappings.keys():
+            attrs.pop(k)   # 只有在实例中才可以进行访问。也就是说使用类名.属性就不能访问了
+        # 把表名转换为小写，表名就是类名
+        # 这个处理略显粗糙，应该继续做一些健壮性的判断，比如ModelMetaClass 变成表名应该是model_meta_class
+        attrs['__table__'] = table_name.lower()
+        # 保存属性和列的映射关系，创建类时添加一个__mappings__类的属性
+        attrs['__mappings__'] = mappings
+
+        return super(ModelMetaClass, cls).__new__(cls, table_name, bases, attrs)
+
+
+
+# 编写一个model子类，这个类用于被具体的model对象继承。 它实现了具体的增删改查方法
+# 这样以后的每一个model就都有了这些方法
+# 这里边我又继承了dict，那么也就是说这个Model也可以使用dict的方法
+
+class Model(dict, metaclass=ModelMetaClass):
+    def __init__(self, **kwargs):
+        super(Model, self).__init__(**kwargs)
+
+    def __getattr__(self, item):
+        try:
+            return self[item]
+        except KeyError:
+            raise AttributeError("这个Model没有这个属性，这个属性是%s" % item)
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+
+
+    def insert(self):
+        fields = []
+        params = []
+        args = []
+        for k, v in self.__mappings__.items():
+            fields.append(v.column_name)
+            params.append("?")
+            args.append(getattr(self, k))
+        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
+
+        res = self.__execute(sql, args)
+        print(res)
+
+    def __execute(self, sql, args):
+        try:
+            connection = create_pool()
+            cursor = connection.cursor()
+            cursor.execute(sql.replace('?', '%s'), args)
+            connection.commit()
+            affected = cursor.rowcount
+        finally:
+            cursor.close()
+            connection.close()
+
+        return affected
+
+# 下边是作业
+
+    # get  select
+    def select(self):
+        fields = []
+        params = []
+        args = []
+        for k, v in self.__mappings__.items():
+            fields.append(v.column_name)
+            params.append("?")
+            args.append(getattr(self, k))
+        sql = 'select * from  %s where (%s) = (%s)' % (self.__table__, ','.join(fields), ','.join(params))
+
+        res = self.__execute(sql, args)
+        print(res)
+
+
+    # update
+    def update(self):
+        fields = []
+        params = []
+        args = []
+        for k, v in self.__mappings__.items():
+            fields.append(v.column_name)
+            params.append("?")
+            args.append(getattr(self, k))
+        sql = 'update  %s set (%s) = (%s) where (%s) = (%s)' % (self.__table__, ','.join(fields), ','.join(params),','.join(fields), ','.join(params))
+
+        res = self.__execute(sql, args)
+        print(res)
+
+
+
+    # delete
+    def delete(self):
+        fields = []
+        params = []
+        args = []
+        for k, v in self.__mappings__.items():
+            fields.append(v.column_name)
+            params.append("?")
+            args.append(getattr(self, k))
+        sql = 'delete  from  %s where (%s) = (%s)' % (self.__table__, ','.join(fields), ','.join(params))
+
+        res = self.__execute(sql, args)
+        print(res)