pymysql 基操全套

pymysql：python操作mysql

什么是pymysql?

pymysql是一个python连接操作mysql数据的一个模块。没有他我们就不能和mysql连接所以安装...

安装

>: pip3 install pymysql

什么是Cursor游标?

游标（Cursor）是处理数据的一种方法，为了查看或者处理结果集中的数据，游标提供了在结果集中一次一行或者多行前进或向后浏览数据的能力。

设置pymysql.cursors.DictCursor，查询的结果是字典，key是表的字段

语法

? conn.commit() 提交
? conn.cursor(pymysql.cursors.DictCursor)设置游标对象
? cursor.execute(sql) 执行语sql语句
? conn.cursor(pymysql.cursors.DictCursor)设置DictCursor
? 特殊fetch 取
? 查询需要通过fetchone操作
? fetchmany(个数)
? fetchall()全部

增删改查

增删改查之前需要自己创建数据库

# 选取操作的模块 pymysql

# pymysql连接数据库的必要参数：主机、端口、用户名、密码、数据库
# 注：pymysql不能提供创建数据库的服务，数据库要提前创建
import pymysql
from pymysql.cursors import DictCursor
# 1）建立数据库连接对象 conn  就可以创建sql的游标对象
# 2）通过 conn 创建操作sql的 游标对象理:结果集中的数据，游标提供了在结果集中一次一行或者多行前进或向后浏览数据的能力。
# 3）编写sql交给 cursor 执行
# 4）如果是查询，通过 cursor光标对象 获取结果
# 5）操作完毕，端口操作与连接

# 1）建立数据库连接对象 conn
conn = pymysql.connect(user='root', passwd='root', database='oldboy')
# conn = pymysql.connect(user='root', passwd='root', database='oldboy', autocommit=True)

# 2）通过 conn 创建操作sql的 游标对象
# 注：游标不设置参数，查询的结果就是数据元组，数据没有标识性
# 设置pymysql.cursors.DictCursor，查询的结果是字典，key是表的字段
cursor = conn.cursor(pymysql.cursors.DictCursor)

# 3）编写sql交给 cursor 执行

sql5 = 'select * from t1'
row = cursor.execute(sql5)  # 返回值是执行语句的行数
print(row)
创建表
# 创建表
sql1 = 'create table t1(id int, x int, y int)'
cursor.execute(sql1)
增
sql2 = 'insert into t1 values(%s, %s, %s)'

# 增1
cursor.execute(sql2, (1, 10, 100))
cursor.execute(sql2, (2, 20, 200))
# 重点：在创建conn对象时，不设置autocommit，默认开启事务，增删改操作不会直接映射到数据库中，
# 需要执行 conn.commit() 动作
conn.commit()

# 增多
cursor.executemany(sql2, [(3, 30, 300), (4, 40, 400)])
conn.commit()
delete删
sql3 = 'delete from t1 where id=%s'
cursor.execute(sql3, 4)
conn.commit()
update改

sql4 = 'update t1 set y=666 where id=2'
cursor.execute(sql4)
conn.commit()
fetch取

sql5 = 'select * from t1'
row = cursor.execute(sql5)  # 返回值是执行语句受影响的行数
print(row)

# 4）如果是查询表内记录，通过 cursor对象 获取结果
# fetchone() 偏移一条取出，fetchmany(n) 偏移n条取出，fetchall() 偏移剩余全部
r1 = cursor.fetchone()
print(r1)
r2 = cursor.fetchone()
print(r2)
r3 = cursor.fetchmany(1)
print(r3)
r4 = cursor.fetchall()
print(r4)
# 5）操作完毕，端口操作断开连接
cursor.close()
conn.close()

游标操作

import pymysql
from pymysql.cursors import DictCursor

# 1）建立数据库连接对象 conn
conn = pymysql.connect(user='root', passwd='root', db='oldboy')
# 2）通过 conn 创建操作sql的 游标对象
cursor = conn.cursor(DictCursor)
# 3）编写sql交给 cursor 执行
sql = 'select * from t1'
# 4）如果是查询，通过 cursor对象 获取结果
row = cursor.execute(sql)
if row:
    r1 = cursor.fetchmany(2)
    print(r1)

    # 操作游标
    # cursor.scroll(0, 'absolute')  # absolute绝对偏移，游标重置，从头开始偏移
    cursor.scroll(-2, 'relative')  # relative相对偏移，游标在当前位置进行左右偏移

    r2 = cursor.fetchone()
    print(r2)

# 5）操作完毕，端口操作与连接
cursor.close()
conn.close()

pymysql事务

?

? 要保证他的安全性
? 逻辑要写好

如果是转账的话必须检测两个都成功才可以提交数据库

import pymysql
from pymysql.cursors import DictCursor
conn = pymysql.connect(user='root', passwd='root', db='oldboy')
cursor = conn.cursor(DictCursor)

try:
    sql = 'create table t2(id int, name char(4), money int)'
    row = cursor.execute(sql)
    print(row)
except:
    print('表已创建')
    pass

# 空表才插入
row = cursor.execute('select * from t2')
if not row:
    sql = 'insert into t2 values(%s,%s,%s)'
    row = cursor.executemany(sql, [(1, 'tom', 10), (2, 'Bob', 10)])
    conn.commit()

# 可能会出现异常的sql
"""
try:
    sql1 = 'update t2 set money=money-1 where name="tom"'
    cursor.execute(sql1)
    sql2 = 'update t2 set moneys=money+1 where name="Bob"'
    cursor.execute(sql2)
except:
    print('转账执行异常')
    conn.rollback()
else:
    print('转账成功')
    conn.commit()
"""

try:
    sql1 = 'update t2 set money=money-1 where name="tom"'
    r1 = cursor.execute(sql1)
    sql2 = 'update t2 set money=money+1 where name="ruakei"'  # 转入的人不存在
    r2 = cursor.execute(sql2)
except:
    print('转账执行异常')
    conn.rollback()
else:
    print('转账没有异常')
    if r1 == 1 and r2 == 1:
        print('转账成功')
        conn.commit()
    else:
        conn.rollback()

sql注入

什么是sql注入?

目的最终达到欺骗服务器执行恶意的sql命令.

是什么:

sql注入,就是通过sql命令插入到web表单提交或输入域名或者页面请求的查询字符串,

如何实现

前提自己拼接参数用占位符
知道用户名
利用注释和"
都不知道
利用or的特性
注意
自己拼接参数的时候一定有sql注入,将数据的占位填充给pymysql

代码详解


import pymysql
from pymysql.cursors import DictCursor
conn = pymysql.connect(user='root', passwd='root', db='oldboy')
cursor = conn.cursor(DictCursor)

try:
    sql = 'create table user(id int, name char(4), password char(6))'
    row = cursor.execute(sql)
    print(row)
except:
    print('表已创建')
    pass

# 空表才插入
row = cursor.execute('select * from user')
if not row:
    sql = 'insert into user values(%s,%s,%s)'
    row = cursor.executemany(sql, [(1, 'tom', '123'), (2, 'bob', 'abc')])
    conn.commit()

# 用户登录
usr = input('usr: ')
pwd = input('pwd: ')

# 自己拼接参数一定有sql注入，将数据的占位填充交给pymysql

"""
sql = 'select * from user where name="%s" and password="%s"' % (usr, pwd)
row = cursor.execute(sql)
if row:
    print('登录成功')
else:
    print('登录失败')
"""
sql = 'select * from user where name=%s and password=%s'
row = cursor.execute(sql, (usr, pwd))
if row:
    print('登录成功')
else:
    print('登录失败')

# 知道用户名时
# 输入用户时：
#   tom => select * from user where name="tom" and password="%s"
#   tom" # => select * from user where name="tom" #" and password="%s"

# 不自定义用户名时
#   " or 1=1 # => select * from user where name="" or 1=1 #" and password="%s"

索引

索引就是 键 - key

键是用来干嘛的

1）键 是添加给数据库表的 字段 的
2）给表创建 键 后，该表不仅会形参 表结构、表数据，还有 键的B+结构图

缺点

1）键的结构图是需要维护的，在数据完成增、删、改操作时，只要影响到有键的字段，结构图都要维护一次
所以创建键后一定会降低 增、删、改 的效率
2）键可以极大的加快查询速度(开发需求中，几乎业务都和查有关系)

建立方式

建立键的方式：主键、外键、唯一键、index

代码详解



import pymysql
from pymysql.cursors import DictCursor
conn = pymysql.connect(user='root', passwd='root', db='oldboy')
cursor = conn.cursor(DictCursor)

# 创建两张表
# sql1 = """create table a1(
#     id int primary key auto_increment,
#     x int,
#     y int
# )"""
# cursor.execute(sql1)
# sql2 = """create table a2(
#     id int primary key auto_increment,
#     x int,
#     y int,
#     index(x)
# )"""
# cursor.execute(sql2)

# 每个表插入5000条数据
# import random
# for i in range(1, 5001):
#     x = i
#     y = random.randint(1, 5000)
#     cursor.execute('insert into a1(x, y) values(%s, %s)', (x, y))
#     cursor.execute('insert into a2(x, y) values(%s, %s)', (x, y))
#
# conn.commit()

import time
# a1的x、a1的id、a2的x
b_time = time.time()
sql = 'select * from a1 where id=4975'
cursor.execute(sql)
e_time = time.time()
print(e_time - b_time)

b_time = time.time()
sql = 'select * from a1 where x=4975'
cursor.execute(sql)
e_time = time.time()
print(e_time - b_time)

b_time = time.time()
sql = 'select * from a2 where x=4975'
cursor.execute(sql)
e_time = time.time()
print(e_time - b_time)

原文地址：https://www.cnblogs.com/jhpy/p/11600891.html

时间： 2024-10-15 20:41:13

pymysql 基操全套的相关文章

Mongodb3.6 基操命令——help有大用（二）

前言 在上一篇文章Mongodb3.6 快速入门(一)中,我们主要使用两个命令: 1.mongod #启动服务 2.mongo #连接mongodb 对于刚接触mongo的人来说,该怎么给命令传递参数.又该传递什么参数都是一脸懵逼的.本人也是这样.在一开始学习mongo的时候,只能死记硬背别人的代码,别人是怎么写,照抄着来.但发现,这样容易忘记.一开始的时候觉得自己会了,可过了几天就会觉得自己一点不会:"怎么又忘记了,好像没学一样" 其实,对于大多数窗口shell操作,都是有提供hel

kafka基操

本文略长,ctrl+f kafka:0.10.1 confuent:3.1.2 7.通过时间戳查询指定分区的offset 使用的方法(offsetsForTimes()): Properties props = new Properties(); KafkaConsumer<String,String> consumer = new KafkaConsumer<>(props); java.util.Map<TopicPartition,OffsetAndTimestamp&

JavaScript之基操

局部变量前面要加var   如 var name = "jiahuai" 全局变量 name = "jiahuai" 写完每一行JavaScript代码用;号隔开 注释: 单行 // 多行 /* */ 原文地址:https://www.cnblogs.com/yaojiahuai/p/9652265.html

typroa 和markdown基操

目录 标题 一级标题 二级标题 字体 图片 来插入图片,如在同意文件夹上,可直接加图片名 数学公式 编辑表格 标题 一级标题 二级标题 三级标题 无序标题 *加空格,无序标题 也可以使用ctrl = 向上增大标题等级 ? ctrl - 向下减小标题等级 [ 中加TOC]加目录 字体 加粗** ** XXX ** 斜体 * XX* ==变色== == xx== 图片 来插入图片,如在同意文件夹上,可直接加图片名 ,也可输入网页图片地址 leetcodehttps://leetcode-cn.com

线段树基操

P1816 忠诚 st表竟然写挂了,线段树一遍过(就当练码力) P1198 [JSOI2008]最大数 1.动态在末尾插入一个数 2.输出末尾的L个数的最大值 线段树维护! P3870 [TJOI2009]开关 P2574 XOR的艺术 P2846 [USACO08NOV]光开关Light Switching 三倍经验题!!! 对一段01区间取^1,则若要修改这个o,这段区间的1的个数=区间长度-这段区间的1的个数(t[o].yihuo) 对于一个o,是否修改这个区间,可以对t[o].tag^1

小白学 Python 爬虫（19）：Xpath 基操

人生苦短,我用 Python 前文传送门: 小白学 Python 爬虫(1):开篇 小白学 Python 爬虫(2):前置准备(一)基本类库的安装 小白学 Python 爬虫(3):前置准备(二)Linux基础入门 小白学 Python 爬虫(4):前置准备(三)Docker基础入门 小白学 Python 爬虫(5):前置准备(四)数据库基础 小白学 Python 爬虫(6):前置准备(五)爬虫框架的安装 小白学 Python 爬虫(7):HTTP 基础 小白学 Python 爬虫(8):网页基

pandas-python入门基操

import numpy as npimport pandas as pd# ---------------------------------------------------------------# 目录# 生成数据# 查看数据# 选择# 缺失值# 运算-apply# 合并# 分组# 重塑-reshape# 数据透视表# 时间序列# 类别-Category# csv数据输入/输出# -----------------------------------------------------

tensor数据基操----索引与切片

玩过深度学习图像处理的都知道,对于一张分辨率超大的图片,我们往往不会采取直接压平读入的方式喂入神经网络,而是将它切成一小块一小块的去读,这样的好处就是可以加快读取速度并且减少内存的占用.就拿医学图像处理来说吧,医学CT图像一般都是比较大的,一张图片就可能达到500MB+,有的甚至超过1GB,下面是切过的一张已经被各种压缩过的肝脏CT图像的一角.        我们可以看到它的像素仍有5210*4200之多,如果直接把这样一张图片压平,将会得到一个5210*4200=21882000维的tenso

树的基操

树的深度 求树的深度 #include<bits/stdc++.h> using namespace std; const int N=1000006; vector<int>g[N]; int n,ans; void dfs(int u,int fa,int dep) { ans=max(ans,dep); for(int i=0;i<g[u].size();++i) { int v=g[u][i]; if(v==fa)continue; dfs(v,u,dep+1); }