本篇对于Python操作MySQL主要使用两种方式：

1、原生模块pymsql。

2、ORM框架SQLAchemy。

pymsql

pymsql是Python中操作MySQL的模块，其使用方法和MySQLdb几乎相同。

windows下载安装

pip3 install pymysql

使用操作

执行SQL

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import pymysql
# 创建连接
conn = pymysql.connect(host='192.168.31.134',port=3306,user='root',passwd='123456',db='information_schema')
# 创建游标
cursor = conn.cursor()
# 执行SQL，并返回受影响行数
effect_row = cursor.execute("select * from tables")
print(effect_row)
# 取出一条数据
print(cursor.fetchone())
# 取出前n条数据
print("*********************************************************")
print(cursor.fetchmany(5))
# 取出所有数据
print("*********************************************************")
print(cursor.fetchall())
# 提交，不然无法保存新建或修改的数据
conn.commit()
# 关闭游标
cursor.close()
# 关闭连接
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、改表法

[root@lnmp ~]# mysql -uroot -p123456
mysql> use test;
Database changed
mysql> update user set host = '%' where user = 'root';
mysql> select host,user from user;
mysql> flush rivileges;

2、授权法

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

mysql> grant all privileges on *.* to 'user'@'%' identified by 'password' with grant option;
mysql> flush privileges;

允许用户user从ip192.168.1.122的主机连接到mysql服务器，并使用password作为密码。

mysql> grant all privileges on *.* to 'user'@'192.168.1.122' identified by 'password' with grant option;
mysql> flush privileges;

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

mysql> grant all privileges on test_db.* to 'user'@'192.168.1.122' identified by 'password' with grant option;
mysql> flush privileges;

插入数据

# 插入数据
effect_row = cursor.executemany("inster into table_name(field_name1,field_name2) values(%s,%s)",[("value_1","value_2"),("value_3","value_4")])

SQLAlchemy ORM

ORM介绍

对象关系映射（Object Relational Mapping，简称ORM），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的——"虚拟对象数据库"。

面向对象是从软件工程基本原则（如耦合、聚合、封装）的基础上发展起来的，而关系数据库则是从数学理论发展而来的，两套理论存在显著的区别。为了解决这个不匹配的现象，对象关系映射技术应运而生。

对象关系映射（Object Relational Mapping）提供了概念性的、易于理解的模型化数据的方法。ORM方法论基于三个核心原则。简单，以最基本的形式建模数据。传达性，数据库结构被任何人都能理解的语言文档化。精确性，基于数据模型创建正确标准化的结构。典型地，建模者通过收集来自那些熟悉应用程序但不熟练数据建模者开发信息模型。建模者必须能够用非技术企业专家可以理解的术语在概念层次上与数据结构进行通讯。建模者也必须能以简单的单元分析信息，对样本数据进行处理。ORM专门被设计为改进这种联系。

ORM的优点

1、隐藏了数据访问细节，"封闭"的通用数据库交互，ORM的核心。使得通用数据库的交互变得简单易行，并且完全不用考虑SQL语句。

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

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)不能很好解决。

常用的ORM框架

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

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

3、EclipseLink一个可扩展的支持JPA的ORM框架，提供强大的缓存功能，缓存支持集群。

4、Apache OJB等等。

5、在Python中最著名的ORM框架是SQLAlchemy。

SQLAlchemy安装

SQLAlchemy的理念是，SQL数据库的量级和性能重要于对象集合，而对象集合的抽象又重要与表和行。

Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作。

MySQL-Python
mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
pymysql
mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
MySQL-Connector
mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
cx_Oracle
oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html

安装sqlalchemy

pip3 install sqlalchemy

SQLAlchemy基本使用

创建一个表。

SQL实现：

CREATE TABLE USER(
ID INTEGER NOT NULL AUTO_INCREMENT,
NAME VARCHAR(32),
PASSWORD VARCHAR(64),
PRIMARY KET (ID)
)

ORM实现：

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
# echo=True打印信息
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=True)
# 生成orm基类
Base = declarative_base()
class User(Base):
# 表名
__tablename__ = 'USER'
# 定义字段ID，并设置为主键
ID = Column(Integer,primary_key=True)
NAME = Column(String(32))
PASSWORD = Column(String(64))
# 创建表结构
Base.metadata.create_all(engine)

除了上面的创建表之外，还有一种创建表的方式。

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine,Table,MetaData,Column,Integer,String,ForeignKey
from sqlalchemy.orm import mapper
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=True)
metadata = MetaData()
user = Table('USER_TABLE',metadata,
Column('ID',Integer,primary_key=True),
Column('NAME',String(50)),
Column('FULLNAME',String(50)),
Column('PASSWORD',String(12))
)
class User(object):
def __init__(self,name,fullname,password):
self.name = name
self.fullname = fullname
self.password = password
mapper(User,user)
# 创建表结构
metadata.create_all(engine)

第一种方式创建的表是基于第二种方式的再封装。

使用ORM创建一条数据。

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine,Column,Integer,String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=True)
Base = declarative_base()
class User(Base):
__tablename__ = 'USER'
ID = Column(Integer,primary_key=True)
NAME = Column(String(32))
PASSWORD = Column(String(64))
Base.metadata.create_all(engine)
# 创建与数据库的会话session class，注意这里返回给session的是一个class，不是实例
Session_class = sessionmaker(bind=engine)
# 生成session实例
Session = Session_class()
# 生成要创建的数据对象
user_obj = User(NAME="")
# 此时还没有创建对象
print(user_obj.NAME,user_obj.ID)
# 把需要创建的数据对象添加到session
Session.add(user_obj)
# 此时还没有创建对象
print(user_obj.NAME,user_obj.ID)
# 创建数据，统一提交
Session.commit()

查询、修改

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine,Column,Integer,String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=False)
Base = declarative_base()
class User(Base):
__tablename__ = 'USER'
ID = Column(Integer,primary_key=True)
NAME = Column(String(32))
PASSWORD = Column(String(64))
def __repr__(self):
return "<NAME : %s | PASSWORD : %s>" %(self.NAME,self.PASSWORD)
Session_class = sessionmaker(bind=engine)
Session = Session_class()
# first 查出NAME='Golden'的第一个
my_user = Session.query(User).filter_by(NAME='Golden').first()
print(my_user.NAME,my_user.PASSWORD)
# NAME='Golden'
data = Session.query(User).filter_by(NAME='Golden').all()
print(data[0].PASSWORD)
#all 查出所有
data_2 = Session.query(User).filter_by().all()
print(data_2)
data_3 = Session.query(User).filter(User.ID == 1).all()
print(data_3)
data_4 = Session.query(User).filter_by(ID=1).all()
print(data_4)
# 多条件查询
data_5 = Session.query(User).filter(User.ID > 1).filter(User.ID < 4).all()
print(data_5)
data_6 = Session.query(User).filter().first()
print(data_6)
# 修改
data_6.NAME = 'zhangsan'
data_6.PASSWORD = '110'
# 提交
Session.commit()

回滚

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine,Column,Integer,String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=False)
Base = declarative_base()
class User(Base):
__tablename__ = 'USER'
ID = Column(Integer,primary_key=True)
NAME = Column(String(32))
PASSWORD = Column(String(64))
def __repr__(self):
return "<ID : %s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
Session_class = sessionmaker(bind=engine)
Session = Session_class()
my_user = Session.query(User).filter_by(ID=1).first()
my_user.NAME = 'Mark'
fake_user = User(NAME='Merry',PASSWORD='999999')
Session.add(fake_user)
# 查看刚刚添加和修改的数据
print(Session.query(User).filter(User.NAME.in_(['Merry','Mark'])).all())
# rollback
Session.rollback()
# 再次查询
print(Session.query(User).filter(User.NAME.in_(['Merry','Mark'])).all())

统计和分组

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine,Column,Integer,String,func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=False)
Base = declarative_base()
class User(Base):
__tablename__ = 'USER'
ID = Column(Integer,primary_key=True)
NAME = Column(String(32))
PASSWORD = Column(String(64))
def __repr__(self):
return "<ID : %s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
Session_class = sessionmaker(bind=engine)
Session = Session_class()
# 统计ha开头的NAME个数
print(Session.query(User).filter(User.NAME.like("ha%")).count())
# 分组
print(Session.query(User.NAME,func.count(User.NAME)).group_by(User.NAME).all())

连表

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine,Column,Integer,String,DATE
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=True)
Base = declarative_base()
class User(Base):
__tablename__ = 'USER'
ID = Column(Integer,primary_key=True)
NAME = Column(String(32))
PASSWORD = Column(String(64))
def __repr__(self):
return "<ID :%s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
class Student(Base):
__tablename__ = 'STUDENT'
ID = Column(Integer,primary_key=True)
NAME = Column(String(32),nullable=False)
REGISTER_DATE = Column(DATE,nullable=False)
GENDER = Column(String(32),nullable=False)
def __repr__(self):
return "<NAME : %s | PASSWORD : %s>" %(self.NAME,self.REGISTER_DATE)
Base.metadata.create_all(engine)
Session_class = sessionmaker(bind=engine)
Session = Session_class()
# 外联
print(Session.query(User,Student).filter(User.ID == Student.ID).all())
# 两个表必须有外键关联才能使用 Can't find any foreign key relationships between 'A' and 'B'
print(Session.query(User).join(Student).all())
print(Session.query(User).join(Student,isouter=True).all())
Session.commit()

实现两个表的外键关联

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine,Column,Integer,String,DATE,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=False)
Base = declarative_base()
class Student(Base):
__tablename__ = 'student'
id = Column(Integer,primary_key=True)
name = Column(String(32),nullable=False)
register_date = Column(DATE,nullable=False)
def __repr__(self):
return "<name : %s | register_date : %s>"%(self.name,self.register_date)
class StudyRecord(Base):
__tablename__ = "study_record"
id = Column(Integer,primary_key=True)
day = Column(Integer,nullable=False)
status = Column(String(32),nullable=False)
# 创建外键
stu_id = Column(Integer,ForeignKey("student.id"))
#
student = relationship("Student",backref="my_study_record")
def __repr__(self):
return "<%s day :%s | status : %s>"%(self.student.name,self.day,self.status)
# 创建表结构
Base.metadata.create_all(engine)
# 创建与数据库的会话session
Session_class = sessionmaker(bind=engine)
# 生成session实例
session = Session_class()
"""添加数据
s1 = Student(name="Golden",register_date="2017-12-24")
s2 = Student(name="Jack",register_date="2017-11-13")
s3 = Student(name="Rain",register_date="2017-10-11")
s4 = Student(name="Eric",register_date="2017-07-07")
study_obj1 = StudyRecord(day=1,status="Yes",stu_id=1)
study_obj2 = StudyRecord(day=2,status="No",stu_id=1)
study_obj3 = StudyRecord(day=3,status="Yes",stu_id=1)
study_obj4 = StudyRecord(day=1,status="Yes",stu_id=2)
# 一次性全部创建
session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])
"""
stu_obj = session.query(Student).filter(Student.name == "Golden").first()
print(stu_obj)
print(stu_obj.my_study_record)
# 提交
session.commit()

多外键关联

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

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
from sqlalchemy.orm import relationship
from sqlalchemy import create_engine,Column,Integer,String,DATE,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class Customer(Base):
__tablename__ = 'customer'
id = Column(Integer,primary_key=True)
name = Column(String(64))
billing_address_id = Column(Integer,ForeignKey("address.id"))
shipping_address_id = Column(Integer,ForeignKey("address.id"))
billing_address = relationship("Address",foreign_keys=[billing_address_id])
shipping_address = relationship("Address",foreign_keys=[shipping_address_id])
class Address(Base):
__tablename__ = 'address'
id = Column(Integer,primary_key=True)
street = Column(String(64))
city = Column(String(64))
state = Column(String(64))
def __repr__(self):
return self.street
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=False)
# 创建表结构
# Base.metadata.create_all(engine)

插入数据和查询。

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import os,sys
path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(path)
from day11 import orm_many_fk
from sqlalchemy.orm import sessionmaker
Session_class = sessionmaker(bind=orm_many_fk.engine)
session = Session_class()
# 创建数据
# addr1 = orm_many_fk.Address(street="zhongshanroad",city="qiaokou",state='hankou')
# addr2 = orm_many_fk.Address(street="dongyiroad",city="hongshan",state="wuchang")
# addr3 = orm_many_fk.Address(street="guangshanroad",city="gaoxin",state="guanggu")
#
# session.add_all([addr1,addr2,addr3])
# c1 = orm_many_fk.Customer(name="Golden",billing_address=addr1,shipping_address=addr3)
# c2 = orm_many_fk.Customer(name="Jack",billing_address=addr2,shipping_address=addr2)
#
# session.add_all([c1,c2])
# 查询数据
obj = session.query(orm_many_fk.Customer).filter(orm_many_fk.Customer.name=="Golden").first()
print(obj.name,obj.billing_address,obj.shipping_address)
session.commit()

多对多关联

创建多对多关联表

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
from sqlalchemy import Table,Column,Integer,String,DATE,ForeignKey,create_engine
from sqlalchemy.orm import relationship,sessionmaker
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
encoding='utf-8',echo=False)
Base = declarative_base()
book_m2m_author = Table('book_m2m_author',Base.metadata,
Column('book_id',Integer,ForeignKey('books.id')),
Column('author_id',Integer,ForeignKey('authors.id')))
class Book(Base):
__tablename__ = 'books'
id = Column(Integer,primary_key=True)
name = Column(String(64))
pub_date = Column(DATE)
authors = relationship('Author',secondary=book_m2m_author,backref='books')
def __repr__(self):
return self.name
class Author(Base):
__tablename__ = 'authors'
id = Column(Integer,primary_key=True)
name = Column(String(32))
def __repr__(self):
return self.name
Base.metadata.create_all(engine)
Session_class = sessionmaker(bind=engine)
session = Session_class()

插入数据和查询

__author__ = 'Golden'
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import os,sys
path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(path)
from day11 import orm_m2m
from sqlalchemy.orm import sessionmaker
Session_class = sessionmaker(bind=orm_m2m.engine)
session = Session_class()
# 创建数据
# b1 = orm_m2m.Book(name="Python")
# b2 = orm_m2m.Book(name="JAVA")
# b3 = orm_m2m.Book(name="C++")
# b4 = orm_m2m.Book(name="c#")
#
# a1 = orm_m2m.Author(name="Golden")
# a2 = orm_m2m.Author(name="Jack")
# a3 = orm_m2m.Author(name="Rain")
#
# b1.authors = [a1,a2]
# b2.authors = [a1,a2,a3]
#
# session.add_all([b1,b2,b3,b4,a1,a2,a3])
# session.commit()
print("通过书表查询关联的作者".center(50,"*"))
book_obj = session.query(orm_m2m.Book).filter_by(name="JAVA").first()
print(book_obj.name,book_obj.authors)
print("通过作者表查询关联的书".center(50,"*"))
author_obj = session.query(orm_m2m.Author).filter_by(name="Golden").first()
print(author_obj.name,author_obj.books)
# 多对多删除，删除数据时不用管book_m2m_author,sqlalchemy会自动删除对应的数据
# 通过书删除作者
book_obj.authors.remove(author_obj)
# 直接删除作者
author_obj2 = session.query(orm_m2m.Author).filter_by(name="Jack").first()
session.delete(author_obj2)
session.commit()

支持中文

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

# 支持中文
engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db?charset=utf8",echo=True)

Python开发【第十一篇】：Python操作MySQL的更多相关文章

Python开发【第一篇】：目录
本系列博文包含 Python基础.前端开发.Web框架.缓存以及队列等,希望可以给正在学习编程的童鞋提供一点帮助!!! Python开发[第一篇]:目录 Python开发[第二篇]:初识Python ...
【python自动化第十一篇】
[python自动化第十一篇:] 课程简介 gevent协程 select/poll/epoll/异步IO/事件驱动 RabbitMQ队列上节课回顾进程: 进程的诞生时为了处理多任务,资源的隔离, ...
Python开发【第二篇】：初识Python
Python开发[第二篇]:初识Python Python简介 Python前世今生 python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏 ...
Python开发【第一篇】:目录
本系列博文包含Python基础.前端开发.Web框架.缓存以及队列等,希望可以给正在学习Python编程的朋友们提供一点帮助! .Python开发[第一篇]:目录 .Python开发[第二篇]:初始P ...
孤荷凌寒自学python第三十一天python的datetime.timedelta模块
孤荷凌寒自学python第三十一天python的datetime.timedelta模块 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) datetime.timedelta模块是一个表示 ...
【神经网络与深度学习】【python开发】caffe-windows使能python接口使用draw_net.py绘制网络结构图过程
[神经网络与深度学习][python开发]caffe-windows使能python接口使用draw_net.py绘制网络结构图过程标签:[神经网络与深度学习] [python开发] 主要是想用py ...
Python开发【十一章】：数据库操作Memcache、Redis
一.Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的 ...
Python开发【第一篇】：初识Python
初识python 一.python简介 python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解 ...
python学习笔记（七）操作mysql
python操作mysql数据库需要先安装pymysql模块,在之前博客中可翻看如何安装,最简单的就是pip install pymysql 1.导入pymysql模块 import pymysq ...
跟着老男孩教育学Python开发【第一篇】：初识Python
Python简介 Python前世今生 Python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解 ...

随机推荐

C++日常应用-定时器
定时器的使用:分为有句柄无句柄两类有句柄情况下的使用:头文件: 1.添加映射 BEGIN_MSG_MAP(类名) MESSAGE_HANDLER(WM_TIMER, OnTimer) END_MS ...
asp.net mvc5中使用Swagger 自动生成WebApi文档笔记
Swagger可以自动生成Api说明文档,并内置在线测试,通过NSwagStudio还可以自动生成Api客户端调用代码,以下为具体实现步骤 1.写一个简单的WebApi并加上注释 public cla ...
java常见报错及解决
Java常见报错信息: Java 常见异常种类 Java Exception: 1.Error 2.Runtime Exception 运行时异常 3.Exception 4.throw 用户自定 ...
（转）K-近邻算法（KNN）
K-近邻算法(KNN)概述 KNN是通过测量不同特征值之间的距离进行分类.它的思路是:如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别 ...
FIFO使用技巧
FPGA中,经常会用到FIFO来缓冲数据或者跨时钟传递数据. 1.Almost full & Almost empty 作为初学者,最开始使用FIFO的时候,对于它的理解,无非是配置好位宽.深 ...
Linux SVN 操作详解（转）
1.将文件checkout到本地目录 svn checkout path(path是服务器上的目录) 例如:svn checkout svn://192.168.1.1/pro/domain ...
Java ---- 遍历链表（递归与非递归实现）
package test; //前序遍历的递归实现与非递归实现 import java.util.Stack; public class Test { public static void main( ...
转载---JQuery 对 Select option 的操作
下拉框: <select id="selectID" > <option value="1">1</option& ...
zookeeper启动报 Unexpected exception, exiting abnormally 错误
启动zookeeper---jps,未出现QuorumPeerMain进程原因: 电脑中的某些进程占用了2181 port 通过 sudo netstat -nltp|grep 2181查看进程并k ...
LeetCode 106. Construct Binary Tree from Inorder and Postorder Traversal 由中序和后序遍历建立二叉树 C++
Given inorder and postorder traversal of a tree, construct the binary tree. Note:You may assume that ...

Python开发【第十一篇】：Python操作MySQL