总括和分组

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import sqlalchemy

  6. from sqlalchemy import
    create_engine,Column,Integer,String,func

  7. from sqlalchemy.ext.declarative import
    declarative_base

  8. from sqlalchemy.orm import sessionmaker

  1.  

  2. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=False)
  1.  

  2. Base = declarative_base()

  3.  

  4.  

  5. class
    User(Base):

  6.     __tablename__ = ‘USER’

  7.     ID =
    Column(Integer,primary_key=True)

  8.     NAME = Column(String(32))

  9.     PASSWORD = Column(String(64))

  1.  

  2.     def __repr__(self):

  3.         return “<ID : %s | NAME : %s | PASSWORD :
    %s>” %(self.ID,self.NAME,self.PASSWORD)

  4.  

  5. Session_class =
    sessionmaker(bind=engine)

  6. Session = Session_class()

  7. # 统计ha开头的NAME个数

  8. print(Session.query(User).filter(User.NAME.like(“ha%”)).count())

  9. # 分组

  10. print(Session.query(User.NAME,func.count(User.NAME)).group_by(User.NAME).all())

有学无学之争的平昔

在音信学领域里,“有学无学”之争困扰了学科一百余年,那么争论有学与无学又是为了什么呢?难道因为无学,就可以放下这门课业不必读书呢?假设说有学的话,为啥还兼具“是否有学”的这种争辨?

华夏有句古话:“名不正则言不顺”,用在音讯学争持上非常方便。龃龉信息有学的关键在于建立学科“合法性”,无论是教育学、地质学、仍旧政治学,这个的科目内容丰富庞杂,知识体系盘根错节,自然不会有人质疑他们的合法性地位。而当新兴学科音讯学建立后,就面对着如此一个规模:自己是不是有自信能和这多少个建立千百余年的人经济学科一同并肩站立?假诺后劲不足,觉得自己很难进入人经济学科的话,自然要从“科学”两字身上寻求尊敬——有学的话,自然就是一门科学,科学来裁定消息学是否创设可以被建设成学科。有趣的是,所有讨论都将“科学”与“学科”建立关系,即只要信息有学,他就会变成学科;无学,则就是一门熟识工,谈不上反驳的。

ORM的优点

1、隐藏了数额访问细节,”封闭”的通用数据库交互,ORM的为主。使得通用数据库的互相变得简单易行,并且完全不用考虑SQL语句。

2、ORM使社团固化数据结构变得简单易行。

结语

作者高校所修专业为音讯学,“是否有学”问题烦扰了整个高校期间,假若有学,为什么习得的始末如此浅薄,即便无学,那么我们学习的新闻理论又是何许呢?课程设置上,各个学科也凭借着人文科学——信息法靠“法”,消息史靠“史”,而音信写作则是文艺底子,音讯源自则日渐模糊,也多亏由此,笔者将兴趣完全转移到音讯历史趋势。

音讯学与其他科学不同,它与海外几乎与此同时开动,而教化格局、教材选拔,探究水平也几乎和海外持平。但是由于音信学自身的弱项,导致学科发展后劲不足,出现了“消息无学”和“学科命名”的争辩,表面上看是争一家高下,实际上是对学科前景、商讨方向方向深深的焦虑。消息学若想有所为,首先要形成认知认同与工作认可。自己做好音讯教育,将信息本业教好,这样才能使得业界认可,职场也会对情报专业加以爱抚。音讯专业不断跑马圈地,显示了这多少个专业现在发展的瓶颈与无奈,不过依然这句话,不光要做大,更要做强。这样新闻专业才会转运。


图表来源网络,欢迎转载,转载请联系作者~

回滚

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import sqlalchemy

  6. from sqlalchemy import
    create_engine,Column,Integer,String

  7. from sqlalchemy.ext.declarative import
    declarative_base

  8. from sqlalchemy.orm import sessionmaker

  1.  

  2. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=False)
  1. Base = declarative_base()

  2.  

  3. class
    User(Base):

  4.     __tablename__ = ‘USER’

  5.     ID =
    Column(Integer,primary_key=True)

  6.     NAME = Column(String(32))

  7.     PASSWORD = Column(String(64))

  1.  

  2.     def __repr__(self):

  3.         return “<ID : %s | NAME : %s | PASSWORD :
    %s>” %(self.ID,self.NAME,self.PASSWORD)

  4.  

  5. Session_class =
    sessionmaker(bind=engine)

  6. Session = Session_class()

  7.  

  8. my_user =
    Session.query(User).filter_by(ID=1).first()

  9. my_user.NAME = ‘Mark’

  10.  

  11. fake_user =
    User(NAME=’Merry’,PASSWORD=’999999′)

  12. Session.add(fake_user)

  13. # 查看刚刚添加和修改的数据

  14. print(Session.query(User).filter(User.NAME.in_([‘Merry’,’Mark’])).all())

  1. # rollback

  2. Session.rollback()

  3. # 再次查询

  4. print(Session.query(User).filter(User.NAME.in_([‘Merry’,’Mark’])).all())

信息学教育与衰老

“知名之下,其实难副”。

音讯学要借助于任何人工学科——不假,即便百年未来,目前的资讯教育也是相同。以美利坚同盟国威斯康星大学信息学专业为例,教授们要求学生们周周都要读书200页以上的文艺和野史名著,培育学生阅读写作能力与领会能力。在科目设置上,消息专业的科目由70%的文科基础知识和30%的专业知识组成,所以要求学生们广泛阅读文科类书籍。这多少个学习内容和科目设置都标明没有人文科学的辅佐,消息难以独立成学。弥利坚信息大学在讲课选取上,则是高校派与执行派同仁一视。在报社工作退休的老牌编辑、记者会被学院邀请任教,由这一个退休的新闻从业人士组成的教授阵容对学生的力量提升有很大功用。音讯理论、音信历史将由没有情报从业经验大学派老师担任,二者融合、不相干预。这和本国音信高校都是以“大学派”为主的指导完全两样。

美利哥德克萨斯大学音讯大学,被喻为“花旗国记者的源头”

进去新世纪之后,中外音讯学专业发展的特性就是持续地跑马圈地和消息专业地位的减退。中国进来新世纪以后,信息学助教们明确指出要将传播学与社会心绪学的教程学科纳入消息专业。李良荣曾明确提议,中国的新闻学发展要向公众传播学看齐,向社会学看齐,从原先的报刊、期刊中剥离出来才有上扬空间。同样,在各中国省市信息高校建设上也听从了“跑马圈地”这一见识。在情报高校传统的消息学和广播电视音讯学后,增设摄影、编导、广播电视播音主持等专业,已经偏离了信息学专业的“报纸的研究”这一本行,而将更多的关联不严密甚至毫无关联的业内纳入信息大学上边,分明就是为了扩展队伍容貌,而在壮大消息传播趋势的武力数量时很明确忽略了质地。容纳来的正经庞杂,理论上鲜有突破,而教学质料相应回落,这就是跻身新世纪的这么些音信学专业现状。所以,有一句话是“消息学专业更欣赏做大,而非做强。”

中华人传统上欣赏“大”,无可厚非,而不喜欢做强一方面是因为囿于“音讯无学”的驳斥瓶颈,另一方面是在扩展新闻学研究范围的时候,已经很少有此外标准能被音讯学这多少个不太有“底气”的标准吸收了。

日本历年来各高等学校信息高校课程内容设定表,新闻学跳出报纸跑马圈地可见一斑

东邻东瀛的音讯学地位下降情状也很显明。在上世纪70年代,一项对于日本国立高校和公立高校中新闻高校课程名称的检察展现,和传颂有关的学科有71门,和报纸相关的有45门,以新闻命名课程的只有7门。不过到了2004年,和散播有关的教程激增到540门,报纸相关课程为51门,而以音讯明显专业课者扩充到300门。在三十年间,报纸与消息学本业相关的科目增长相当慢性,而传播学以每年20门的速度疯狂增长,当音讯被尊重后,80年间末98门加强到300门。以山梨县高校的新闻学院为例,以传播大学和消息大学的命名的大学数量远多于名为“音信大学”者。日本的音信大学的钻研方向一度因而科目命名变化体现了出来:音讯工程、丰田传播、媒体。而和报纸相关的课程,30年间几乎从未进步,而在大学建设提升,消息大学雨后春笋般建立的背景下,音信专业相同于大踏步的落伍。

美国的信息学的提升困境在于与传播学的争议。由于情报高校的建立者多为像普利策一样的报界大亨,建顿时间也更长,历史悠久也有优秀的观念,所以大部分大学更名为“音讯传播大学”,还是封存了“信息”这一名字和它的传统,可是更多的教学是在传播学领域中的,也就是所谓的“借信息学之名,行传播学之实”。大部分执教的头衔是传播学助教,而非消息学助教。

SQLAlchemy安装

SQLAlchemy的意见是,SQL数据库的量级和性质首要于对象集合,而目的集合的肤浅又着重与表和行。

图片 1

Dialect用于和数据API举行交换,按照配置文件的不同调用不同的数据库API,从而实现对数据库的操作。

  1. MySQL-Python

  2.     mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

  1.  

  2. pymysql

  3.     mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

  1.  

  2. MySQL-Connector

  3.     mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

  1.  

  2. cx_Oracle

  3.     oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value…]

  1.  

  2. 更多详见:http://docs.sqlalchemy.org/en/latest/dialects/index.html

安装sqlalchemy

  1. pip3 install sqlalchemy

反驳:消息是否有学

从音信学作为标准学科教育建立后,“是否有学”就起来烦扰音信学专业,但是这些题目和质疑又是什么人指出的呢?又是何人有权利裁定音信是不是知识呢?“有学无学”,自然分成两派,中国自音信学诞生开头,就存在这种争持,而在别国,持信息无学观点的紧要性是情报从业者以及非音讯专业的人艺术学科的执教们,而坚定不移认为信息有大家来自音信学教育阵地——各高等高校的信息大学。中国人崇尚中庸之道,在音信学这一题目上反映得酣畅淋漓,持有学观点者没有纯净的认同音信就是正确,而是态度暧昧地称其是“特殊科学”、“综合科学”,似乎具备妥协;持音讯无学观点者也并非认定信息毫无学问之处,有些态度缓和者称学科现阶段尚处于幼稚发展期,要给一定的时光,才能见到是否有学。而外国人的立场似乎就很坚定了,有就是有,没有就是没有。

普利策、Hearst等报业巨头没有学过正统的情报文化却建立了高大的报业帝国,这在“无学派”看来是极好的论据。

“无学派”旗帜显然——音信没什么可学的,就是行家。持无学观点的一端很大一些人起点信息从业者,是信息行内人,他们以为音信不需要学,需要的是经验。他们觉得普利策、Hearst、格里利、Bennett等欧美报业巨头没有标准音讯教育的背景,经过长年累月在报界的跑龙套,将音讯行业做得好,就证实了这一观点。消息记者需要的是“经验”,是“术”而非“学”,几十年的采集经历胜过谍报理论一纸空文。

“无学派”阵营还有一大票援助者,他们来自其余人文学科的上课,是情报行别人。他们观察信息学即将成为一门人文科学,表示很不知道,因为她们觉得消息学不享有和文学、农学、文学、社会学等人文科学并立的身价。“音讯学决无法脱离政治、经济、历史、地理、心情、总计等基本科学。”其潜台词是情报本无学,它的“学”来自其他学科,而这多少个科目都是已改为“科学”的多谋善算者学科。一个词概括,就是“难以服众”。

据悉这张总括表来看,信息学属于“拿来”,理论要从不同的人经济学科中汲取营养,而此旁人法学科很少需要信息学的内容。

依照这几人管经济学科的上课的价值观,音讯学若要独立成学,必定要有拿得动手的亲善的辩护和研讨成果,而早期的音讯学侧重于探讨信息发展历史、报刊理论与音讯法规,显著要依赖教育学、文学这些“大腿”型的人理学科的声援,这也是让这多少个教师们很反感的地点。音讯专业声称自己是独立学科,却要依靠其外人文学科的钻研措施、钻探成果,这也使得“音信无学”论甚嚣尘上。

在中原,“无学派”从消息学的名目动手,将信息无学观点站稳——音讯学,中国名字是日本舶来品,而扶桑的“信息学”一词,也是松本君平旅欧学习的产物,追本溯源,如故源于西方。音讯学在西文中是Journalism,报刊、音讯主义的意思。上世纪二三十年份的消息业者刘元钊认为,西文中,专业学科的最终是以logy结尾的,如地军事学,人类学,乃至神秘学。然则以ism结尾者,多为思想、方法的趣味,所以音讯学在天堂一起初的限制就应该是是“方法”,而不是“学科”。也就是说,大部分特别琢磨音信学的学者也不觉得信息可以独自成学。研商者桑榆等人觉得信息现在不足以独立成学,是因为消息学相相比较于任谁管经济学科,成立时间晚,绝对于任何成熟的人农学科,幼稚了有些。但刘元钊所说“音讯学在此时此刻无法成为科学,但最终一定会是变成一门科学的。”这句话说的很没有底气。

民国知名记者,《京报》创办者,交大信息学琢磨会助教邵飘萍,因报道三一八惨案被直鲁联军枪杀。

有认为无学的,自然就有觉得有学的。作为《京报》的开创者,闻名报人邵飘萍提出:

“消息和社会、政治关系重大,已为世界各国公认,作为学科加以探讨者,仍属近代之事……我国音信业不鼎盛,音信业既不鼎盛,则‘信息学’者尚属婴孩学步,夫岂足怪哉也!”

——邵飘萍:《我国信息学提高之大势》(1924)

邵飘萍的有学观点为多边打了一个调和,有学无学不要那么苛刻,学问是有的,然则需要时日让它表达自己的市值。有了邵飘萍的话,很多持“有学派”观点的人底气也壮了诸多,萨空了、陶良鹤、徐宝璜等人的眼光和邵飘萍基本持同——音讯专业资历尚浅,但足以在事后独立成学。不过邵飘萍当时所处时代,音讯学确属于刚刚确立,可在数十年后仍无定论。

见“有学派”大有反击之势,“无学派”也亟需一个有份量的人来发话:民国知名记者顾执中站了出来,观点掷地有声——

“经验就是新闻学,音信记者是一时的, 是负责人时代。
时代的上扬关系于记者极大。
你假诺现行已是一个新闻记者,这末你随时所收获的新经验,
便是你的最好的音讯学, 用不到再进哪样学校。”

——顾执中 《经验便是音信学》(1937)

老牌报人顾执中,民国时期曾任法国巴黎《时报》记者、日本东京《信息报》采访老总,创办迪拜民治消息专科高校,解放后任高等教育出版社编审

资讯是否有学的争辨日趋衍生和变化成为“音信有学,但未曾形成系统”的见地,而在情报有学的见地里仍存在争议——信息学是概括科学依旧独立科学?是社会科学依旧新鲜科学?认为消息是汇总科学者较多,鲁风指出,消息学是概括科学,涉及范围极广,单音讯五个字便已经到家了。潘公展认为要研讨信息学就得研商关于人生的没错。上述所有观点都曾经提出,信息学不可以脱离其别人文科学、自然科学独立成学,可是坚贞不屈认为音讯学科是独自科学的人也有,如傅襄谟,但其实是硕果仅存。

五四以来,德先生和赛先生成为最盛行的口号,消息学也慌忙地贴上了赛先生的标签。

争执来顶牛去,无论是哪一方面,即便传统不同,但有一点是一致的——尺度。用哪些衡量它是不是有学问?“科学”这把尺子。科学一词由日本引入,在即刻被清楚为“学上之学”,“学上之道”,“分科之学”,成为其它科目的命名者,规定者,加上近代中国对西方科学技术的崇拜,一时间,“科学”一词地位至尊,权力至大,无人能出其右。固然到新文化运动时期,陈独秀也指出“德先生”与“赛先生”一碗水端平一说,科学一词的身份历经清末民国无可动摇。然音信学要单独出来改成一种独立科学,这是当下多数人所不可能接受的。近代的话,德先生和赛先生影响深入,中国人普遍有“赛先生情节”。似乎能贴上科学的就是好的,就是发展的,就是能为普罗起亚所帮助的,也正是基于此,近代音讯学者迫不及待地给消息贴上了“科学”的标签,希望借此让音信学“一炮而红”。

但也正因而,才在情报刚刚举办之初引起广大中伤。

多对多关系

成立多对多关联表

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. from sqlalchemy import
    Table,Column,Integer,String,DATE,ForeignKey,create_engine

  6. from sqlalchemy.orm import
    relationship,sessionmaker

  7. from sqlalchemy.ext.declarative import
    declarative_base

  8.  

  9. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=False)
  1.  

  2. Base = declarative_base()

  3.  

  4. book_m2m_author =
    Table(‘book_m2m_author’,Base.metadata,

  5.                         Column(‘book_id’,Integer,ForeignKey(‘books.id’)),

  1.                         Column(‘author_id’,Integer,ForeignKey(‘authors.id’)))
  1.  

  2. class
    Book(Base):

  3.     __tablename__ = ‘books’

  4.     id =
    Column(Integer,primary_key=True)

  5.     name = Column(String(64))

  6.     pub_date = Column(DATE)

  7.     authors =
    relationship(‘Author’,secondary=book_m2m_author,backref=’books’)

  1.  

  2.     def __repr__(self):

  3.         return self.name

  4.  

  5.  

  6. class
    Author(Base):

  7.     __tablename__ = ‘authors’

  1.     id =
    Column(Integer,primary_key=True)

  2.     name = Column(String(32))

  3.  

  4.     def __repr__(self):

  5.         return self.name

  6.  

  7. Base.metadata.create_all(engine)

  1. Session_class =
    sessionmaker(bind=engine)

  2. session = Session_class()

 

安插数据和询问

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import os,sys

  6. path =
    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

  1. sys.path.append(path)

  2. from day11 import orm_m2m

  3. from sqlalchemy.orm import sessionmaker

  1.  

  2. Session_class =
    sessionmaker(bind=orm_m2m.engine)

  3. session = Session_class()

  4.  

  5. # 创立数据

  6. # b1 = orm_m2m.Book(name=”Python”)

  7. # b2 = orm_m2m.Book(name=”JAVA”)

  8. # b3 = orm_m2m.Book(name=”C++”)

  9. # b4 = orm_m2m.Book(name=”c#”)

  10. #

  11. # a1 = orm_m2m.Author(name=”Golden”)

  12. # a2 = orm_m2m.Author(name=”Jack”)

  13. # a3 = orm_m2m.Author(name=”Rain”)

  14. #

  15. # b1.authors = [a1,a2]

  16. # b2.authors = [a1,a2,a3]

  17. #

  18. #
    session.add_all([b1,b2,b3,b4,a1,a2,a3])

  19. # session.commit()

  20.  

  21. print(“通过书表查询关联的作者”.center(50,”*”))

  22. book_obj =
    session.query(orm_m2m.Book).filter_by(name=”JAVA”).first()

  23. print(book_obj.name,book_obj.authors)

  1. print(“通过作者表查询关联的书”.center(50,”*”))

  2. author_obj =
    session.query(orm_m2m.Author).filter_by(name=”Golden”).first()

  3. print(author_obj.name,author_obj.books)

  1.  

  2. #
    多对多删除,删除数据时不要管book_m2m_author,sqlalchemy会自动删除相应的数目

  1. # 通过书删除作者

  2. book_obj.authors.remove(author_obj)

  1.  

  2. # 直接删除作者

  3. author_obj2 =
    session.query(orm_m2m.Author).filter_by(name=”Jack”).first()

  4. session.delete(author_obj2)

  5. session.commit()

 

windows下载安装

  1. pip3 install pymysql

实现多少个表的外键关联

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4. import sqlalchemy

  5. from sqlalchemy import
    create_engine,Column,Integer,String,DATE,ForeignKey

  6. from sqlalchemy.orm import
    sessionmaker,relationship

  7. from sqlalchemy.ext.declarative import
    declarative_base

  8.  

  9. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=False)
  1. Base = declarative_base()

  2.  

  3. class
    Student(Base):

  4.     __tablename__ = ‘student’

  1.     id =
    Column(Integer,primary_key=True)

  2.     name =
    Column(String(32),nullable=False)

  3.     register_date =
    Column(DATE,nullable=False)

  4.  

  5.     def __repr__(self):

  6.         return “<name : %s | register_date :
    %s>”%(self.name,self.register_date)

  7.  

  8.  

  9. class
    StudyRecord(Base):

  10.     __tablename__ = “study_record”

  11.     id =
    Column(Integer,primary_key=True)

  12.     day =
    Column(Integer,nullable=False)

  13.     status =
    Column(String(32),nullable=False)

  14.     # 创立外键

  15.     stu_id =
    Column(Integer,ForeignKey(“student.id”))

  16.     #

  17.     student = relationship(“Student”,backref=”my_study_record”)

  18.  

  19.     def __repr__(self):

  20.        return “<%s day :%s | status :
    %s>”%(self.student.name,self.day,self.status)

  21. # 创造表结构

  22. Base.metadata.create_all(engine)

  1. # 创立与数据库的会话session

  2. Session_class =
    sessionmaker(bind=engine)

  3. # 生成session实例

  4. session = Session_class()

  5.  

  6. “””添加数据

  7. s1 = Student(name=”Golden”,register_date=”2017-12-24″)

  8. s2 = Student(name=”Jack”,register_date=”2017-11-13″)

  9. s3 = Student(name=”Rain”,register_date=”2017-10-11″)

  10. s4 = Student(name=”Eric”,register_date=”2017-07-07″)

  11.  

  12. study_obj1 =
    StudyRecord(day=1,status=”Yes”,stu_id=1)

  13. study_obj2 =
    StudyRecord(day=2,status=”No”,stu_id=1)

  14. study_obj3 =
    StudyRecord(day=3,status=”Yes”,stu_id=1)

  15. study_obj4 =
    StudyRecord(day=1,status=”Yes”,stu_id=2)

  16.  

  17. # 五遍性全体成立

  18. session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])

  1. “””

  2. stu_obj =
    session.query(Student).filter(Student.name == “Golden”).first()

  3. print(stu_obj)

  4. print(stu_obj.my_study_record)

  1. # 提交

  2. session.commit()

1、原生模块pymsql。

pymsql

pymsql是Python中操作MySQL的模块,其利用模式和MySQLdb几乎相同。

SQLAlchemy基本使用

创办一个表。

SQL实现:

  1. CREATE TABLE USER(

  2.    ID INTEGER NOT NULL AUTO_INCREMENT,

  1.    NAME VARCHAR(32),

  2.    PASSWORD VARCHAR(64),

  3.    PRIMARY KET (ID)

  4. )

ORM实现:

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import sqlalchemy

  6.  

  7. from sqlalchemy import create_engine

  1. from sqlalchemy.ext.declarative import
    declarative_base

  2. from sqlalchemy import
    Column,Integer,String

  3.  

  4. # echo=True打印音讯

  5. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=True)
  1.  

  2. # 生成orm基类

  3. Base = declarative_base()

  4.  

  5. class
    User(Base):

  6.     # 表名

  7.     __tablename__ = ‘USER’

  8.     # 定义字段ID,并设置为主键

  9.     ID =
    Column(Integer,primary_key=True)

  10.     NAME = Column(String(32))

  11.     PASSWORD = Column(String(64))

  1. # 创造表结构

  2. Base.metadata.create_all(engine)

除去下边的成立表之外,还有一种创立表的法子。

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import sqlalchemy

  6.  

  7. from sqlalchemy import
    create_engine,Table,MetaData,Column,Integer,String,ForeignKey

  1. from sqlalchemy.orm import mapper
  1.  

  2. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=True)
  1. metadata = MetaData()

  2.  

  3. user = Table(‘USER_TABLE’,metadata,

  1.              Column(‘ID’,Integer,primary_key=True),
  1.              Column(‘NAME’,String(50)),
  1.              Column(‘FULLNAME’,String(50)),
  1.              Column(‘PASSWORD’,String(12))
  1.              )

  2.  

  3.  

  4. class
    User(object):

  5.     def
    __init__(self,name,fullname,password):

  6.         self.name = name

  7.         self.fullname = fullname

  1.         self.password = password
  1.  

  2. mapper(User,user)

  3.  

  4. # 创造表结构

  5. metadata.create_all(engine)

先是种方法开创的表是基于第三种方法的再封装。

利用ORM创设一条数据。

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import sqlalchemy

  6. from sqlalchemy import
    create_engine,Column,Integer,String

  7. from sqlalchemy.orm import sessionmaker

  1. from sqlalchemy.ext.declarative import
    declarative_base

  2.  

  3. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=True)
  1. Base = declarative_base()

  2.  

  3. class
    User(Base):

  4.     __tablename__ = ‘USER’

  5.     ID =
    Column(Integer,primary_key=True)

  6.     NAME = Column(String(32))

  7.     PASSWORD = Column(String(64))

  1.  

  2. Base.metadata.create_all(engine)

  1. # 创立与数据库的会话session class,注意这里重返给session的是一个class,不是实例
  1. Session_class =
    sessionmaker(bind=engine)

  2. # 生成session实例

  3. Session = Session_class()

  4. # 生成要开创的多寡对象

  5. user_obj = User(NAME=”Golden”,PASSWORD=”123456″)

  6. # 此时还没有创制对象

  7. print(user_obj.NAME,user_obj.ID)

  1. # 把需要成立的数目对象添加到session
  1. Session.add(user_obj)

  2. # 此时还从未创设对象

  3. print(user_obj.NAME,user_obj.ID)

  1. # 成立数量,统一提交

  2. Session.commit()

扶助粤语

sqlalchemy设置编码字符集一定要在数据库访问的URL上加码charset=utf8,否则数据库的连接就不是utf8的编码格式。

  1. # 协理闽南语

  2. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db?charset=utf8”,echo=True)

常用的ORM框架

1、Hibernate全自动需要hql语句。

2、iBatis半自动自己写sql语句,可操作性强,小巧。

3、EclipseLink一个可增加的支撑JPA的ORM框架,提供有力的缓存效能,缓存扶助集群。

4、Apache OJB等等。

5、在Python中最显赫的ORM框架是SQLAlchemy。

2、ORM框架SQLAchemy。

本篇对于Python操作MySQL紧要运用二种模式:

使用操作

执行SQL

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4. import pymysql

  5.  

  6. # 创制连接

  7. conn =
    pymysql.connect(host=’192.168.31.134′,port=3306,user=’root’,passwd=’123456′,db=’information_schema’)

  1. # 创立游标

  2. cursor = conn.cursor()

  3. # 执行SQL,并赶回受影响行数

  4. effect_row = cursor.execute(“select * from tables”)

  5. print(effect_row)

  6. # 取出一条数据

  7. print(cursor.fetchone())

  8. # 取出前n条数据

  9. print(“*********************************************************”)

  1. print(cursor.fetchmany(5))

  2. # 取出富有数据

  3. print(“*********************************************************”)

  1. print(cursor.fetchall())

  2. # 提交,不然不可能保存新建或修改的数额

  1. conn.commit()

  2. # 关闭游标

  3. cursor.close()

  4. # 关闭连接

  5. conn.close()

也许报错:pymysql.err.InternalError: (1130, “Host ‘192.168.31.1’ is not
allowed to connect to this MySQL server”)

恐怕是因为你的账号不同意从远程登录,只可以在localhost登录。只需要在localhost的这台电脑登录mysql,更改对应数据库里的”user”表里的”host”项,把”localhost”改为”%”。

解决办法:

1、改表法

  1. [root@lnmp ~]# mysql -uroot -p123456
  1. mysql> use test;

  2. Database changed

  3. mysql> update user set host = ‘%’ where user = ‘root’;

  1. mysql> select host,user from user;
  1. mysql> flush rivileges;

2、授权法

同意用户user使用密码password从任何主机连接到mysql服务器。

  1. mysql> grant all privileges on *.*
    to ‘user’@’%’ identified by ‘password’ with grant option;

  2. mysql> flush privileges;

同意用户user从ip192.168.1.122的主机连接到mysql服务器,并利用password作为密码。

  1. mysql> grant all privileges on *.*
    to ‘user’@’192.168.1.122’ identified by ‘password’ with grant
    option;

  2. mysql> flush privileges;

允许用户user从ip192.168.1.122的主机连接到mysql服务器的test_db数据库,并接纳password作为密码。

  1. mysql> grant all privileges on
    test_db.* to ‘user’@’192.168.1.122’ identified by ‘password’ with
    grant option;

  2. mysql> flush privileges;

安插数据

  1. # 插入数据

  2. effect_row = cursor.executemany(“inster into
    table_name(field_name1,field_name2)
    values(%s,%s)”,[(“value_1″,”value_2”),(“value_3″,”value_4”)])

多外键关联

创制包含多外键的表结构。

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. from sqlalchemy.orm import relationship

  1. from sqlalchemy import
    create_engine,Column,Integer,String,DATE,ForeignKey

  2. from sqlalchemy.ext.declarative import
    declarative_base

  3.  

  4. Base = declarative_base()

  5.  

  6. class
    Customer(Base):

  7.     __tablename__ = ‘customer’

  1.     id =
    Column(Integer,primary_key=True)

  2.     name = Column(String(64))

  3.  

  4.     billing_address_id =
    Column(Integer,ForeignKey(“address.id”))

  5.     shipping_address_id =
    Column(Integer,ForeignKey(“address.id”))

  6.  

  7.     billing_address =
    relationship(“Address”,foreign_keys=[billing_address_id])

  1.     shipping_address =
    relationship(“Address”,foreign_keys=[shipping_address_id])
  1.  

  2. class
    Address(Base):

  3.     __tablename__ = ‘address’

  1.     id =
    Column(Integer,primary_key=True)

  2.     street = Column(String(64))

  3.     city = Column(String(64))

  4.     state = Column(String(64))

  5.  

  6.     def __repr__(self):

  7.         return self.street

  8.  

  9. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=False)
  1. # 成立表结构

  2. # Base.metadata.create_all(engine)

插入数据和询问。

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import os,sys

  6. path =
    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

  1. sys.path.append(path)

  2. from day11 import orm_many_fk

  3. from sqlalchemy.orm import sessionmaker

  1.  

  2. Session_class =
    sessionmaker(bind=orm_many_fk.engine)

  3. session = Session_class()

  4.  

  5. # 创造数据

  6. # addr1 =
    orm_many_fk.Address(street=”zhongshanroad”,city=”qiaokou”,state=’hankou’)

  7. # addr2 =
    orm_many_fk.Address(street=”dongyiroad”,city=”hongshan”,state=”wuchang”)

  8. # addr3 =
    orm_many_fk.Address(street=”guangshanroad”,city=”gaoxin”,state=”guanggu”)

  9. #

  10. #
    session.add_all([addr1,addr2,addr3])

  11. # c1 =
    orm_many_fk.Customer(name=”Golden”,billing_address=addr1,shipping_address=addr3)

  1. # c2 =
    orm_many_fk.Customer(name=”Jack”,billing_address=addr2,shipping_address=addr2)
  1. #

  2. # session.add_all([c1,c2])

  3.  

  4. # 查询数据

  5. obj =
    session.query(orm_many_fk.Customer).filter(orm_many_fk.Customer.name==”Golden”).first()

  6. print(obj.name,obj.billing_address,obj.shipping_address)

  1.  

  2. session.commit()

ORM介绍

对象关联映射(Object Relational
Mapping,简称ORM),是一种程序技术,用于落实面向对象编程语言里不同品类系统的数额里面的变换。从效用上说,它实际是成立了一个可在编程语言里应用的——”虚拟对象数据库”。

面向对象是从软件工程主题规则(如耦合、聚合、封装)的根底上前进起来的,而关周到据库则是从数学理论发展而来的,两套理论存在显明的分别。为了化解这个不般配的气象,对象关系映射技术出现。

目的关系映射(Object Relational
Mapping)提供了概念性的、易于领悟的模型化数据的艺术。ORM方法论基于六个要旨标准。简单,以最大旨的款式建模数据。传达性,数据库结构被任什么人都能领略的语言文档化。精确性,基于数据模型创造正确原则的结构。典型地,建模者通过征集来自这些熟知应用程序但不在行数据建模者开发信息模型。建模者必须可以用非技术集团专家可以领略的术语在概念层次上与数据结构举行报道。建模者也务必能以简练的单元分析音信,对样本数量举办处理。ORM专门被规划为改进这种关联。

图片 2

ORM的缺点

1、自动化意味着映射和涉嫌管理,代价是牺牲性能。现在各个ORM框架都在品尝利用各个法子(如LazyLoad、Cache)来减轻性能的影响,效果相比显明。

2、面向对象的询问语言(OQL)作为一种数据库与对象之间的交接,即使隐藏了数额层面的事情抽象,但并无法完全的屏蔽掉数据库层的计划性,并且确实将净增学习成本。

3、对于复杂查询,ORM如故鞭长莫及。固然能够实现,但是不值得。视图能够缓解大部分calculated
column、case、group、having、order by、exists,可是查询条件a and b and
not c and (d or e)无法很好解决。

连表

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import sqlalchemy

  6. from sqlalchemy import
    create_engine,Column,Integer,String,DATE

  7. from sqlalchemy.orm import sessionmaker

  1. from sqlalchemy.ext.declarative import
    declarative_base

  2.  

  3. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=True)
  1. Base = declarative_base()

  2.  

  3. class
    User(Base):

  4.     __tablename__ = ‘USER’

  5.     ID =
    Column(Integer,primary_key=True)

  6.     NAME = Column(String(32))

  7.     PASSWORD = Column(String(64))

  1.  

  2.     def __repr__(self):

  3.         return “<ID :%s | NAME : %s | PASSWORD :
    %s>” %(self.ID,self.NAME,self.PASSWORD)

  4.  

  5.  

  6. class
    Student(Base):

  7.     __tablename__ = ‘STUDENT’

  1.     ID =
    Column(Integer,primary_key=True)

  2.     NAME =
    Column(String(32),nullable=False)

  3.     REGISTER_DATE =
    Column(DATE,nullable=False)

  4.     GENDER =
    Column(String(32),nullable=False)

  5.  

  6.     def __repr__(self):

  7.         return “<NAME : %s | PASSWORD : %s>”
    %(self.NAME,self.REGISTER_DATE)

  8.  

  9. Base.metadata.create_all(engine)

  1. Session_class =
    sessionmaker(bind=engine)

  2. Session = Session_class()

  3.  

  4. # 外联

  5. print(Session.query(User,Student).filter(User.ID
    == Student.ID).all())

  6. # 六个表必须有外键关联才能动用 Can’t
    find any foreign key relationships between ‘A’ and ‘B’

  7. print(Session.query(User).join(Student).all())

  1. print(Session.query(User).join(Student,isouter=True).all())
  1. Session.commit()

SQLAlchemy ORM

查询、修改

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import sqlalchemy

  6. from sqlalchemy import
    create_engine,Column,Integer,String

  7. from sqlalchemy.ext.declarative import
    declarative_base

  8. from sqlalchemy.orm import sessionmaker

  1. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,
  1.                        encoding=’utf-8′,echo=False)
  1. Base = declarative_base()

  2. class
    User(Base):

  3.     __tablename__ = ‘USER’

  4.     ID =
    Column(Integer,primary_key=True)

  5.     NAME = Column(String(32))

  6.     PASSWORD = Column(String(64))

  1.  

  2.     def __repr__(self):

  3.         return “<NAME : %s | PASSWORD : %s>”
    %(self.NAME,self.PASSWORD)

  4.  

  5. Session_class =
    sessionmaker(bind=engine)

  6. Session = Session_class()

  7. # first 查出NAME=’高尔德en’的率先个

  1. my_user =
    Session.query(User).filter_by(NAME=’Golden’).first()

  2. print(my_user.NAME,my_user.PASSWORD)

  1. # NAME=’Golden’

  2. data =
    Session.query(User).filter_by(NAME=’Golden’).all()

  3. print(data[0].PASSWORD)

  4. #all 查出所有

  5. data_2 =
    Session.query(User).filter_by().all()

  6. print(data_2)

  7. data_3 =
    Session.query(User).filter(User.ID == 1).all()

  8. print(data_3)

  9. data_4 =
    Session.query(User).filter_by(ID=1).all()

  10. print(data_4)

  11. # 多口径查询

  12. data_5 =
    Session.query(User).filter(User.ID > 1).filter(User.ID <
    4).all()

  13. print(data_5)

  14. data_6 =
    Session.query(User).filter().first()

  15. print(data_6)

  16. # 修改

  17. data_6.NAME = ‘zhangsan’

  18. data_6.PASSWORD = ‘110’

  19. # 提交

  20. Session.commit()