python-PIL模块画图

Bertha 。 2022-06-01 14:22 359阅读 0赞

**python中执行mysql遇到like 怎么办 ？**  
  
 sql = "SELECT \* FROM T\_ARTICLE WHERE title LIKE '%%%% **%s** %%%%'" % searchStr  
  
执行成功，print出SQL语句之后为：  
  
SELECT \* FROM T\_ARTICLE WHERE title LIKE '%%生活%%'  
  
原因：  
Python在执行sql语句的时候，同样也会有%格式化的问题，仍然需要使用%%来代替%。因此要保证在执行sql语句的时候格式化正确。而不只是在sql语句（字符串）的时候正确。  
  
  
  
import Image, ImageDraw, ImageFont, ImageFilter  
  
import random  
  
  
\# 随机字母  
def rndChar():  
     **return chr(random.randint(65, 90))**  
  
  
\# 随机颜色1  
def rndColor():  
     **return (random.randint(64, 255), random.randint(64, 255), random.randint(64, 255))**  
  
  
\# 随机颜色2  
def rndColor2():  
    ** return (random.randint(32, 127), random.randint(32, 127), random.randint(32, 127))**  
  
  
\# 240 \* 60  
width = 60 \* 4  
height = 60  
**image = Image.new('RGB', (width, height), (255,255,255))**  
  
  
\# 创建Font对象  
**font = ImageFont.truetype('/usr/share/fonts-droid/truetype/DroidSansFallback.ttf', 36)**  
  
  
\# 创建Draw对象  
**draw = ImageDraw.Draw(image)**  
  
  
\# 填充每个像素  
for x in range(width):  
    for y in range(height):  
         **draw.point((x, y),fill=rndColor())**  
  
  
\# 输出文字  
for t in range(4):  
     **draw.text((60 \* t +10, 10), rndChar(), font=font, fill=rndColor2())**  
  
  
\# 模糊  
image =  **image.filter(ImageFilter.BLUR)  
**  
image.save('/home/godben/code.jpg', 'jpeg')  
  
  
  
\#!/usr/bin/env python  
\#coding=utf-8  
import random  
from PIL import Image, ImageDraw, ImageFont, ImageFilter  
  
\_letter\_cases = "abcdefghjkmnpqrstuvwxy" \# 小写字母，去除可能干扰的i，l，o，z  
\_upper\_cases = \_letter\_cases.upper() \# 大写字母  
**\_numbers = ''.join(map(str, range(3, 10))) \# 数字**  
  
**init\_chars = ''.join((\_letter\_cases, \_upper\_cases, \_numbers))**  
  
def create\_validate\_code(size=(120, 30),  
                         chars=init\_chars,  
                         img\_type="GIF",  
                         mode="RGB",  
                         bg\_color=(255, 255, 255),  
                         fg\_color=(0, 0, 255),  
                         font\_size=18,  
                         font\_type="kk.TTF",  
                         length=4,  
                         draw\_lines=True,  
                         n\_line=(1, 2),  
                         draw\_points=True,  
                         point\_chance = 2):  
    '''  
    @todo: 生成验证码图片  
    @param size: 图片的大小，格式（宽，高），默认为(120, 30)  
    @param chars: 允许的字符集合，格式字符串  
    @param img\_type: 图片保存的格式，默认为GIF，可选的为GIF，JPEG，TIFF，PNG  
    @param mode: 图片模式，默认为RGB  
    @param bg\_color: 背景颜色，默认为白色  
    @param fg\_color: 前景色，验证码字符颜色，默认为蓝色\#0000FF  
    @param font\_size: 验证码字体大小  
    @param font\_type: 验证码字体，默认为 ae\_AlArabiya.ttf  
    @param length: 验证码字符个数  
    @param draw\_lines: 是否划干扰线  
    @param n\_lines: 干扰线的条数范围，格式元组，默认为(1, 2)，只有draw\_lines为True时有效  
    @param draw\_points: 是否画干扰点  
    @param point\_chance: 干扰点出现的概率，大小范围\[0, 100\]  
    @return: \[0\]: PIL Image实例  
    @return: \[1\]: 验证码图片中的字符串  
    '''  
    width, height = size \# 宽， 高  
     **img = Image.new(mode, size, bg\_color) \# 创建图形**  
    draw = ImageDraw.Draw(img) \# 创建画笔  
  
  
    def get\_chars():  
        '''生成给定长度的字符串，返回列表格式'''  
         **return random.sample(chars, length)**  
  
  
    def create\_lines():  
        '''绘制干扰线'''  
         **line\_num = random.randint(\*n\_line) \# 干扰线条数**  
        for i in range(line\_num):  
            \# 起始点  
            begin = (random.randint(0, size\[0\]), random.randint(0, size\[1\]))  
            \#结束点  
            end = (random.randint(0, size\[0\]), random.randint(0, size\[1\]))  
             **draw.line(\[begin, end\], fill=(0, 0, 0))**  
  
  
    def create\_points():  
        '''绘制干扰点'''  
         **chance = min(100, max(0, int(point\_chance))) \# 大小限制在\[0, 100\]**  
                                                                                                   
        for w in xrange(width):  
            for h in xrange(height):  
                ** tmp = random.randint(0, 100)**  
                if tmp > 100 - chance:  
                     **draw.point((w, h), fill=(0, 0, 0))**  
  
  
    def create\_strs():  
        '''绘制验证码字符'''  
        c\_chars = get\_chars()  
         **strs = ' %s ' % ' '.join(c\_chars) \# 每个字符前后以空格隔开**  
                                                                                                   
        font = ImageFont.truetype(font\_type, font\_size)  
        font\_width, font\_height = font.getsize(strs)  
         **draw.text(((width - font\_width) / 3, (height - font\_height) / 3),**  
**                    strs, font=font, fill=fg\_color)**  
                                                                                                   
        return ''.join(c\_chars)  
    if draw\_lines:  
        create\_lines()  
    if draw\_points:  
        create\_points()  
    strs = create\_strs()  
    \# 图形扭曲参数  
    params = \[1 - float(random.randint(1, 2)) / 100,  
              0,  
              0,  
              0,  
              1 - float(random.randint(1, 10)) / 100,  
              float(random.randint(1, 2)) / 500,  
              0.001,  
              float(random.randint(1, 2)) / 500  
              \]  
  
    ** img = img.transform(size, Image.PERSPECTIVE, params) \# 创建扭曲**  
     **img = img.filter(ImageFilter.EDGE\_ENHANCE\_MORE) \# 滤镜，边界加强（阈值更大）**  
  
    return img, strs  
  
if \_\_name\_\_ == "\_\_main\_\_":  
    code\_img = create\_validate\_code()  
    code\_img\[0\].save("xiaorui.cc.gif", "GIF")    
  
  
\#coding:utf-8  
\#编写验证码  
    \#随机的数值  
    \#图片  
import random \#python随机模块  
from PIL import Image \#图片  
from PIL import ImageDraw \#画笔  
from PIL import ImageFont \#字体  
from PIL import ImageFilter \#滤镜 验证码扭曲  
  
\#验证码编写步骤  
  
**\#1、定义随机数**  
sample\_text = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"  
sample\_list = random.sample(sample\_text,4)  
randomText = "".join(sample\_list)  
  
**\#2、定义图片**  
img = Image.new("RGB",(150,50),(255,255,255))  
    \#第一个参数是配色方案  
    \#第二个参数是图片的尺寸px 宽高  
    \#第三个参数是颜色 255,255,255是白色  
  
**\#3、图片上绘制干扰项**  
  
    \#实例化画笔  
draw = ImageDraw.Draw(img)  
    \#绘制干扰线  
for i in range(random.randint(10,20)): \#随机循环1-10次  
  
  
    draw.line(  
        \#两个点决定一条线  
        \#每个点有x,y两个值  
        \[  
            (  
                random.randint(1,150), \# x  
                random.randint(1,150), \# y  
            ),\#点一  
  
  
            (  
                random.randint(1,150),  \# x  
                random.randint(1,150),  \# y  
            )\#点二  
  
  
        \],\#一条线  
  
  
        fill = (random.randint(0,255),random.randint(0,255),random.randint(0,255)) \#线条颜色  
  
  
    ) \#绘制线条  
  
  
    \#绘制点  
for j in range(1000):  
    draw.point(       
           \[   random.randint(1, 150),  \# x  
            random.randint(1, 150),  \# y  
        \],\#一个点  
        fill=(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))  \# 线条颜色  
  
  
    )  
**\#4、书写文字**  
    \#定义字体  
  
text = "".join(randomText)  
  
font = ImageFont.truetype("simsun.ttc",36) \#定义字体  
  
**draw.text((random.randint(1, 10),random.randint(1, 5)),text,font = font,fill = "green")**  \#书写文字  
  
  
    \#文字起始位置  
    \#文字内容  
    \#文字字体  
    \#文字颜色  
\#5、进行滤镜扭曲  
\#定义扭曲的参数  
  
params = \[  
    1-float(random.randint(1,2))/100,  
    0,  
    0,  
    0,  
    1 - float(random.randint(1, 2)) / 100,  
    float(random.randint(1, 2)) / 100,  
    0.001,  
    float(random.randint(1, 2)) / 100  
\]  
  
**\#使用滤镜**  
img = img.transform((150,50),Image.PERSPECTIVE,params)  
img = img.filter(ImageFilter.EDGE\_ENHANCE\_MORE)  
  
**\#6、查看效果**  
img.show() \#展示  
img.save("%s.jpg"%randomText,"JPEG") \#保存，保存路径    
  
  
\# 生成随机验证码图片  
   
import string  
from random import randint, sample  
from PIL import Image, ImageDraw, ImageFont, ImageFilter  
\# Image 负责处理图片  
\# ImageDraw 画笔  
\# ImageFont 文字  
\# ImageFileter 滤镜  
   
**\# 定义变量**  
img\_size = (150,50)        \# 定义画布大小  
img\_rgb = (255,255,255)    \# 定义画布颜色，白色  
img = Image.new("RGB",img\_size,img\_rgb)  
   
**img\_text = " ".join(sample(string.ascii\_letters+string.digits, 5))**  
  
\# print(img\_text.replace(' ',''))  
   
\# 画图  
drow = ImageDraw.Draw(img)  
for i in range(10):  
     **\# 随机画线**  
    drow.line(\[tuple(sample(range(img\_size\[0\]),2)), tuple(sample(range(img\_size\[0\]),2))\], fill=(0,0,0))  
for i in range(99):  
     **\# 随机画点**  
    drow.point(tuple(sample(range(img\_size\[0\]),2)), fill=(0,0,0))  
   
\# 文字  
font = ImageFont.truetype("simsun.ttc", 24)     \# 定义文字字体和大小  
**drow.text((6,6), img\_text, font=font, fill="green")**  
   
\# 扭曲图片和滤镜  
params = \[  
    1 - float(randint(1,2)) / 100,  
    0,  
    0,  
    0,  
    1 - float(randint(1,10)) /100,  
    float(randint(1,2)) / 500,  
    0.001,  
    float(randint(1,2)) / 500  
\]  
  
**img = im** **** **g.transform(img\_size, Image.PERSPECTIVE, params)  
**  
**img = img.filter(ImageFilter.EDGE\_ENHANCE\_MORE)**  
   
\# 展示图片  
img.show()   
  
  
**\# 写一个理财计算器，实现将每日/月/年的利息进行复投进行计算**  
   
money = float(input('请输入您打算用来投资的本金 \\> '))  
year = int(input('请输入投资期限(单位：年) \\> '))  
rate = float(input('请输入投资年化收益率 \\> '))  
Type = int(input('''1.每日利息复投 2.每月利息复投 3.每年利息复投   请选择复投方式 \\> '''))  
   
**def day\_return(money,year,rate=0.12):**  
    '方案：每日利息加入本金复投！'  
    for y in range(year):  
        for day in range(365):  
            money = money\*rate/365 + money  
        print('第%d年结束时，本金为：%.2f' % (y+1,money))  
   
**def month\_return(money,year,rate=0.12):**  
    '方案：每月利息加入本金复投！'  
    for y in range(year):  
        for month in range(12):  
            money = money\*rate/12 + money  
        print('第%d年结束时，本金为：%.2f' % (y+1,money))  
   
**def year\_return(money,year,rate=0.12):**  
    '方案：每年利息加入本金复投！'  
    for y in range(year):  
        money = money\*rate + money  
        print('第%d年结束时，本金为：%.2f' % (y+1,money))  
   
   
if Type == 1:  
    day\_return(money,year,rate)  
elif Type == 2:  
    month\_return(money,year,rate)  
elif Type == 3:  
    year\_return(money,year,rate)  
else:  
    print('输入有误！')  
  
**\# 百度翻译**  
\# Python 3.5.1  
   
from urllib import request, parse  
import json  
   
url = 'http://fanyi.baidu.com/v2transapi'  
context = input('请输入需要翻译的内容 :\\> ')  
   
if context >= '\\u4e00' and context <= '\\u9fa5':  
    \# 判断输入内容是否为汉字  
    From,To = 'zh','en'  
else:  
    From,To = 'en','zh'  
   
data = \{   
    'query':context,  
    'from':From,  
    'to':To,  
    'transtype':'translang',  
    'simple\_means\_flag':3  
\}  
**data = parse.urlencode(data).encode('utf-8')**  
   
r = request.Request(url,data)  
r.add\_header('User-Agent','Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:50.0) Gecko/20100101 Firefox/50.0')  
**html = request.urlopen(r).read().decode('utf-8')**  
Result = json.loads(html)  
   
print('翻译结果为:' + Result\['trans\_result'\]\['data'\]\[0\]\['dst'\])  
  
  
  
**\# 简单的拼手气红包**  
   
import random  
from time import sleep  
   
\# 所有涉及金额的浮点数都需要用 round 方法保留2位小数，避免出现最终结果多出0.01  
amount = round(float(input('请设置红包的金额 \\> ')),2)  
num = int(input('请设置红包的数量 \\> '))  
hb\_dict = \{\}  
xing = '赵钱孙李周吴郑王'  
ming = '一二三四五六七八九十'  
   
while num:  
   
    xingming = ** random.choice** (xing)+random.choice(ming)+random.choice(ming)  
    if xingming in hb\_dict.keys():  
        xingming = random.choice(xing)+random.choice(ming)+random.choice(ming)  
   
    num -= 1  
    if num == 0:  
        print('%s抢到红包%.2f元 红包抢完了!' % (xingming,amount))  
        hb\_dict\[amount\] = xingming  
        amount -= amount  
    elif num > 0:  
        hb =  **round(random.uniform(0.01,amount)/num,2)**  
        hb\_dict\[hb\] = xingming  
        \# 算法: 在0.01到红包总金额之间随机一个浮点数 / 红包剩余个数  
        print('%s抢到红包%.2f元 剩余%d个!' % (xingming,hb,num))  
        amount = round((amount - hb),2)  
   
    sleep(1)  
   
\# 转置字典中的 key / value  
\# hb\_dict2 = \{value:key for key,value in hb\_dict.items()\}  
max\_hb = max(hb\_dict.items())  
print('%s运气最佳 抢得%.2f元!!' % (max\_hb\[1\],max\_hb\[0\]))  
  
  
**随机生成200个序列号**  
  
  
import random  
import string  
   
for num in range(200):  
    numlist = \[\]  
    for i in range(12):  
         **numlist.append(random.choice(string.ascii\_uppercase+string.digits))**  
    \# print(''.join(numlist))  
    with open('200.txt', 'a') as f:     \# 'a' 表示追加写入  
        f.write(''.join(numlist)+'\\n')  
  
  
    f.close  
  
  
import Image, ImageFont, ImageDraw  
text = "EwWIieAT"  
im = Image.new("RGB",(130,35), (255, 255, 255))  
dr = ImageDraw.Draw(im)  
  
**font = ImageFont.truetype("kk.TTF", 24)**  
\#simsunb.ttf 这个从windows fonts copy一个过来  
**dr.text((10, 5), text, font=font, fill="\#000000")  
**  
im.show()  
im.save("t.png")   
  
**缩略图**  
  
from PIL import Image  
img = Image.open('god.jpg')  
**img = img.resize((250, 156), Image.ANTIALIAS)**  
img.save('sharejs\_small.jpg')   
  
  
  
PythonWare公司提供了免费的图像处理工具包PIL(Python Image Library),该软件包提供了基本的图像处理功能，本文介绍了使用PIL工具包中的Image模块进行比对的过程。  
  
\#!/usr/bin/env python  
\# -\*- coding:utf-8 -\*-  
  
import Image, ImageChops  
  
img1 = Image.open(r'C:\\cygwin\\tmp\\Sonic1.jpg')                      Capture1.PNG  
img2 = Image.open(r'C:\\cygwin\\tmp\\Sonic2.jpg')                                Diff.jpg  
**img3 = ImageChops.invert(img2)**  
**Image.blend(img1,img3,0.5).show() **  
  
  
**PIL处理图片之加水印**  
  
\#!/usr/bin/env python  
\# -\*- coding: utf-8 -\*-  
  
import Image, ImageEnhance, ImageDraw, ImageFont   
  
def text2img(text, font\_color="Blue", font\_size=25):  
  
    """生成内容为 TEXT 的水印"""  
  
     **font = ImageFont.truetype('simsun.ttc', font\_size)**  
  
  
    \#多行文字处理  
     **text = text.split('\\n')**  
    mark\_width = 0  
    for  i in range(len(text)):  
         **(width, height) = font.getsize(text\[i\])**  
        if mark\_width < width:  
            mark\_width = width  
    mark\_height = height \* len(text)  
  
    \#生成水印图片  
    mark = Image.new('RGBA', (mark\_width,mark\_height))  
    draw = ImageDraw.ImageDraw(mark, "RGBA")  
     **draw.setfont(font)**  
  
    for i in range(len(text)):  
         **(width, height) = font.getsize(text\[i\])**  
         **draw.text((0, i\*height), text\[i\], fill=font\_color)**  
    return mark  
  
  
 def set\_opacity(im, opacity):  
  
    """设置透明度"""  
  
    assert opacity >=0 and opacity < 1  
    if im.mode != "RGBA":  
         **im = im.convert('RGBA')**  
    else:  
        im = im.copy()  
    alpha = im.split()\[3\]  
     **alpha = ImageEnhance.Brightness(alpha).enhance(opacity)**  
    im.putalpha(alpha)  
    return im  
  
 def watermark(im, mark, position, opacity=1):  
  
  
    """添加水印"""  
  
  
    try:  
        if opacity < 1:  
            mark = set\_opacity(mark, opacity)  
        if im.mode != 'RGBA':  
            ** im = im.convert('RGBA')**  
        if im.size\[0\] < mark.size\[0\] or im.size\[1\] < mark.size\[1\]:  
            print "The mark image size is larger size than original image file."  
            return False  
  
        \#设置水印位置  
  
        if position == 'left\_top':  
            x = 0  
            y = 0  
        elif position == 'left\_bottom':  
            x = 0  
            y = im.size\[1\] - mark.size\[1\]  
        elif position == 'right\_top':  
            x = im.size\[0\] - mark.size\[0\]  
            y = 0  
        elif position == 'right\_bottom':  
            x = im.size\[0\] - mark.size\[0\]  
            y = im.size\[1\] - mark.size\[1\]  
        else:  
            x = (im.size\[0\] - mark.size\[0\]) / 2  
            y = (im.size\[1\] - mark.size\[1\]) / 2  
  
  
        layer =Image.new('RGBA', im.size,)  
        layer.paste(mark,(x,y))  
        returnImage.composite(layer, im, layer)  
  
  
     exceptExceptionas   
                 e:print">>>>>>>>>>> WaterMark EXCEPTION:  "+ str(e)  
 returnFalsedef   
main():  
    text = u'Linsir.水印.\\nvi5i0n@hotmail.com'\#   
    text = open('README.md').read().decode('utf-8')\#   
    print text  
    im =Image.open('origal.png')  
    mark = text2img(text)  
    image = watermark(im, mark,'center',0.9)  
    if image:  
        image.save('watermark.png')  
        image.show()else:print"Sorry, Failed."  
  
if \_\_name\_\_ =='\_\_main\_\_':   
  
  
import sys, Image    
    
img = Image.open(sys.argv\[1\]).convert('YCbCr')    
    
**w, h = img.size**     
    
**data = img.getdata() **    
    
cnt = 0    
    
for i, ycbcr in enumerate(data):    
    
    y, cb, cr = ycbcr    
    
    if 86 <= cb <= 117 and 140 <= cr <= 168:    
    
        cnt += 1    
    
print '%s %s a porn image.'%(sys.argv\[1\], 'is' if cnt > w \* h \* 0.3 else 'is not')    
  
运行：  
E:/>c:/python25/python test\_skin.py 114.jpeg    
    
114.jpeg is a porn image.     
  
  
  
import pymysql  
   
\# 获取一个数据库连接,注意如果是UTF-8类型的,需要制定数据库  
**db=** **pymysql.connect(host="127.0.0.1",user="root",passwd="123456",db="mysql",charset='utf8' )  
**  
\# 使用 cursor()方法创建一个游标对象 cursor  
cursor = db.cursor()  
  
\# 使用 execute()方法执行 SQL 查询  
**cursor.execute("SELECT user,host,password from user")**  
  
\# 使用 fetchall()方法获取所有行.  
**data = cursor.fetchall()**  
  
print(data)  
cursor.close()\#关闭游标  
db.close()\#关闭数据库连接  
  
  
  
import pymysql  
   
db = pymysql.connect(host='10.3.1.174',user='root',password='123456',db='test')  
**cursor = db.cursor()**  
\# SQL 插入数据  
sql = "INSERT INTO employee (first\_name, last\_name, age, sex, income) " \\  
      "VALUES ('w', 'Eason', '29', 'M', '8000')"  
  
\# SQL 更新数据  
\# sql = "UPDATE employee first\_name = Wang WHERE first\_name = w"  
  
\# SQL 删除数据  
\# sql = "DELETE FROM employee WHERE age > 20"  
   
try:  
    cursor.execute(sql)  
     **db.commit()**  
except:  
     **db.rollback()**  
   
db.close()