python3 sqlAlchemy

python3 sqlAlchemy

其实Python3 可以搞它！----------------》》> python3 sqlAlchemy -----------它是ORM技术！ORM技术：Object-Relational Mapping，把关系数据库的表结构映射到对象上。是不是很简单？ 

SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

 

　Python3为什么要借助sqlAlchemy 来搞MySQL呢。----------因为不用写sql语句，不用重写sql语句。！

　　　　这个玩意就是把sql语句封装成了类，我们直接调用对象。不正是python3 之道吗？

　通过sqlalchemy 搞一搞原生的sql语句！

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Author:liushubao
from sqlalchemy import create_engine    # 导入创建引擎模块
engine = create_engine("mysql+mysql://root:@127.0.0.1:3306/s12_testdb",max_overflow=5) # 创建一个引擎

## 引擎操作原生的sql语句：：：：

engine.execute(
    "INSERT INTO ts_test (a, b) VALUES ('2', 'v1')"
)

engine.execute(
     "INSERT INTO ts_test (a, b) VALUES (%s, %s)",
    ((555, "v1"),(666, "v1"),)
)
engine.execute(
    "INSERT INTO ts_test (a, b) VALUES (%(id)s, %(name)s)",
    id=999, name="v1"
)

result = engine.execute('select * from ts_test')
result.fetchall()

简单实用sqlalchemy

单个表-增删改查！

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Author:liushubao
from sqlalchemy.ext.declarative import declarative_base  # 导入可以创建的基类的模块
from sqlalchemy import Column, Integer, String
from sqlalchemy import create_engine                    # 从sqlalchemy 导入创建引擎这个模块
from sqlalchemy.orm import sessionmaker,session
Base = declarative_base()                   # 创建一个ORM基类 ，这是个固定写法，因为下面要用类对数据库操作，要继承这个类。

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/liushubao", max_overflow=5,echo=False) #echo是显示创建过程！
#创建一个引擎，        用MySQL      用户名：密码@主机名：端口号/那个数据库，最大连接数！

# 创建单表
class Users(Base):      #继承刚刚那个基类必须！
    __tablename__ = 'users' #  开始了，这个是要创建的表单名字
    id = Column(Integer, primary_key=True,autoincrement=True) #列的属性
    name = Column(String(32),unique=True,nullable=False)     #列的属性
    extra = Column(String(16),unique=True,nullable=False)    #列的属性

#------------------上面表示影射成功，但不代表创建，-----------------
Base.metadata.create_all(engine)  #创建表所有结构！！
#--------------------增加数据------------------------
if __name__ =='__main__':
    SessionCls = sessionmaker(bind=engine)  #创建与数据库连接的session！它返回的是一个类名！
    h1 = Users(name='liushubao',extra = 'hello world')      #给表里插入数据！！
    h2 = Users(name='shubao', extra='welcome to hello world!')  # 给表里插入数据！！
    session.add(h1) # 单个添加
    session.add_all([h1,h2])  #批量添加
    session.commit()  # 添加生效！
#########################查询修改##############################################
if __name__ =='__main__':
    SessionCls = sessionmaker(bind=engine)  #创建与数据库连接的session！它返回的是一个类名！
    obj = session.query(Users).filter(Users.name = 'liushubao').first() #查询后返回的是一个对象
    obj.name = 'LIUSHUBAO'
    session.commit()  # 添加生效！
#########################    删除    ##############################################
if __name__ =='__main__':
    SessionCls = sessionmaker(bind=engine)  #创建与数据库连接的session！它返回的是一个类名！
    obj = session.query(Users).filter(Users.name = 'LIUSHUBAO').first() #返回的是一个对象
    session.delete(obj)  # 删除
    session.commit()  # 添加生效！

sqlalchemy

多表、联表！

# Author:Alex Li
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s13", max_overflow=5)

Base = declarative_base()

# 创建单表
class Users(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    extra = Column(String(16))

    __table_args__ = (
    UniqueConstraint('id', 'name', name='uix_id_name'),
        Index('ix_id_name', 'name', 'extra'),
    )

# 一对多
class Favor(Base):
    __tablename__ = 'favor'
    nid = Column(Integer, primary_key=True)
    caption = Column(String(50), default='red', unique=True)


class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    favor_id = Column(Integer, ForeignKey("favor.nid"))

# 多对多
class ServerToGroup(Base):
    __tablename__ = 'servertogroup'
    nid = Column(Integer, primary_key=True, autoincrement=True)
    server_id = Column(Integer, ForeignKey('server.id'))
    group_id = Column(Integer, ForeignKey('group.id'))

class Group(Base):
    __tablename__ = 'group'
    id = Column(Integer, primary_key=True)
    name = Column(String(64), unique=True, nullable=False)


class Server(Base):
    __tablename__ = 'server'

    id = Column(Integer, primary_key=True, autoincrement=True)
    hostname = Column(String(64), unique=True, nullable=False)
    port = Column(Integer, default=22)

# Base.metadata.create_all(engine)
# Base.metadata.drop_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

# obj = Users(name='alex111',extra='sss')
# session.add(obj)
# session.commit()
q = session.query(Users)
print(q)
ret = session.query(Users).all()
print(ret[0].name)
print(ret[0].id)
#
# session.commit()
# session.add_all()

 

paramiko

paramiko就是:Python SSH module。

一般使用paramiko的功能就是通过ssh远程执行命令，远程传输文件等等。

#!/usr/bin/python

import paramiko

 

t = paramiko.Transport(("某IP地址",22))

t.connect(username = "用户名", password = "口令")

sftp = paramiko.SFTPClient.from_transport(t)

remotepath='/tmp/test.txt'

localpath='/tmp/test.txt'

sftp.get(remotepath, localpath)

t.close()

 

paramiko实现上传下载文件

class SSHConnection(object):

    def __init__(self, host='192.168.11.61', port=22, username='alex',pwd='alex3714'):
        self.host = host
        self.port = port
        self.username = username
        self.pwd = pwd
        self.__k = None

    def run(self):
        self.connect()
        pass
        self.close()

    def connect(self):
        transport = paramiko.Transport((self.host,self.port))
        transport.connect(username=self.username,password=self.pwd)
        self.__transport = transport

    def close(self):
        self.__transport.close()

    def cmd(self, command):
        ssh = paramiko.SSHClient()
        ssh._transport = self.__transport
        # 执行命令
        stdin, stdout, stderr = ssh.exec_command(command)
        # 获取命令结果
        result = stdout.read()
        return result

    def upload(self,local_path, target_path):
        # 连接，上传
        sftp = paramiko.SFTPClient.from_transport(self.__transport)
        # 将location.py 上传至服务器 /tmp/test.py
        sftp.put(local_path, target_path)

ssh = SSHConnection()
ssh.connect()
r1 = ssh.cmd('df')
ssh.upload('s2.py', "/home/alex/s7.py")
ssh.close()

paramike上传文件

 

#!/usr/bin/python

import paramiko

 

t = paramiko.Transport(("某IP地址",22))

t.connect(username = "用户名", password = "口令")

sftp = paramiko.SFTPClient.from_transport(t)

remotepath='/tmp/test.txt'

localpath='/tmp/test.txt'

sftp.get(remotepath, localpath)

t.close()

paramiko现实下载文件

 

执行远程命令时有TAB补全功能：

import paramiko
import sys
import os
import socket
import select
import getpass
import termios
import tty
from paramiko.py3compat import u

tran = paramiko.Transport(('10.211.55.4', 22,))
tran.start_client()
tran.auth_password('wupeiqi', '123')

# 打开一个通道
chan = tran.open_session()
# 获取一个终端
chan.get_pty()
# 激活器
chan.invoke_shell()


# 获取原tty属性
oldtty = termios.tcgetattr(sys.stdin)
try:
    # 为tty设置新属性
    # 默认当前tty设备属性：
    #   输入一行回车，执行
    #   CTRL+C 进程退出，遇到特殊字符，特殊处理。

    # 这是为原始模式，不认识所有特殊符号
    # 放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器
    tty.setraw(sys.stdin.fileno())
    chan.settimeout(0.0)

    while True:
        # 监视 用户输入 和 远程服务器返回数据（socket）
        # 阻塞，直到句柄可读
        r, w, e = select.select([chan, sys.stdin], [], [], 1)
        if chan in r:
            try:
                x = u(chan.recv(1024))
                if len(x) == 0:
                    print('\r\n*** EOF\r\n')
                    break
                sys.stdout.write(x)
                sys.stdout.flush()
            except socket.timeout:
                pass
        if sys.stdin in r:
            x = sys.stdin.read(1)
            if len(x) == 0:
                break
            chan.send(x)

finally:
    # 重新设置终端属性
    termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)


chan.close()
tran.close()