python学习

最近学习神经网络，以及牵连出来的虚拟助理

均在python的基础上

为了提高生产力，浅浅回顾一下大学时接触的python工具的使用，顺带扩展工具的应用

准备从一下几方面着手学习

1、搭建一个简单的helloword

2、熟悉常见包，知晓几种导入依赖包的方式

3、熟悉常用框架组件

4、写一个常用脚本

5、写一个exe工具包

6、接入Java

7、重新整理神经网络和虚拟助理

第一章：搭建一个简单的helloword

工具 IDEA

安装python插件

创建python项目

创建python软件包

在.py文件中编写语句并运行

第二章：熟悉常见包，知晓几种导入依赖包的方式

__init__.py文件的作用

可以在__init__.py 文件中导入模块中类、不建议在__init.py 文件中写一些函数进行导入

第三章：熟悉常用框架组件

Django 网络编程框架环境搭建

Django 是由 Python 编写的一个开源 Web 应用框架，Python + Django 是快速开发、设计、部署网站的最佳组合。

pip安装法

pip3 install Django

更新pip

python -m pip install –upgrade pip

检查是否安装成功

import django
django.get_version()

创建一个demo

目录结构说明

demo2_django 项目主目录

manage.py 一个实用的命令行工具，可以让你以各种方式与改django项目交互

demo2_django/__init.py__ 空文件，python包的初始化文件

demo2_django/settings.py 该django项目的配置

demo2_django/urls.py 路由文件，匹配不同的url链接，调用不同的视图函数处理

demo2_django/views.py 视图函数文件，里面是一些自己写的函数，这个文件自己创建，名称一般创建为该名称

demo2_django/wsgi.py web网关服务的配置文件，生产正式运行时通常需要用到

进入项目目录启动项目

python manage.py runserver 127.0.0.1:8000

django输出helloword

添加views.py文件，其内容如下

from django.http import HttpResponse


def hello(request):
    return HttpResponse("Hello world ! ")

修改urls.py文件，其内容如下

from django.urls import path
from . import views
urlpatterns = [
    path('', views.hello),
]

启动项目

Scrapy是适用于Python的一个快速、高层次的屏幕抓取和web抓取框架，用于抓取web站点并从页面中提取结构化的数据。

pip安装法

pip3 install scrapy

创建demo

scrapy startproject mySpider

cd .\mySpider\

scrapy genspider hutool hutool.cn

scrapy crawl hutool

修改spiders/hutool.py文件

def parse(self, response):
        names = response.xpath('//a[1][@class="btn btn-primary btn-outline"]/b/text()')
        print("开始输出")
        print(names)
        print("结束输出")
        pass

使用.xpath语法，编写逻辑

‘//h4/a/text()’: 某h4标签下的a标签中的内容

‘//p[@class=”author”]/a[1]/text()’: 某p标签，class属性为“author”，下面的第一个a标签下的内容

例 book_names = e.xpath(‘//h4/a/text()’)

authors = e.xpath(‘//p[@class=”author”]/a[1]/text()’)

参考使用xpath语法，解析HTMLhttps://www.cnblogs.com/leafchen/p/12809770.html

第四章：写一个常用脚本

图片格式转换

from PIL import Image

img = Image.open('test.png')
img.save('test1.jpg')

第五章：写一个exe工具包

pyinstaller 将 python 文件转成 exe 文件

pip安装

pip3 install pyinstaller

在cmd中，将路径更改为.py文件所在位置

输入指令pyinstaller -F XXX.py。(XXX：文件名)

pyinstaller -F .\test\A.py

cd .\dist\

.\A.exe

第六章：接入Java

实际工程项目中可能会用到Java和python两种语言结合

Java中执行python语句

此方法需要引入org.python包，需要下载jpython

springboot项目引入依赖包

<dependency>
            <groupId>org.python</groupId>
            <artifactId>jython-standalone</artifactId>
            <version>2.7.0</version>
        </dependency>

创建demo文件

package com.example.demo.jpython;

import org.python.util.PythonInterpreter;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * @Create: IntelliJ IDEA.
 * @Author: subtlman_ljx
 * @Date: 2022/10/18/10:24
 * @Description:
 */
public class demo1 {
    public static void main(String[] args) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.exec("a=[5,2,3,9,4,0]; ");
        interpreter.exec("print(sorted(a));"); //此处python语句是3.x版本的语法
        interpreter.exec("print sorted(a);"); //此处是python语句是2.x版本的语法




        Process proc;
        try {
            // 执行py文件 A.py为1+2
            proc = Runtime.getRuntime().exec("D:\\python\\python.exe D:\\python\\workspace\\space1\\demo\\test\\A.py");
            // 用输入输出流来截取结果
            BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
            String line = null;
            while ((line = in .readLine()) != null) {
                System.out.println(line);
            }
            in .close();
            proc.waitFor();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

}

执行结果

python调用Java代码

使用jpype模块

pip3 install jpype1

调用jar文件

java文件生成jar

参考Java字符匹配娱乐https://www.cnblogs.com/subtlman/p/16409069.html

编写测试代码

java代码

public class Demo2 {
    public static void main(String[] args) {
        System.out.println("调用成功");
        System.out.println(t());
    }
    public static String t(){
        return "t方法调用成功";
    }
}

python代码

import jpype

jarpath = 'D:/Desktop/test/Demo2.jar'  # jar绝对路径

jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % jarpath)
# start(JVM路径,模式,jar文件路径)
obj = jpype.JClass('Demo2')  # 获取类

test = obj()  # 实例化
tk = test.t()
print(tk)

jpype.shutdownJVM()

第七章：重新整理神经网络和虚拟助理

神经网络

接上文神经网络的学习

java、encog实现的demo

Java实现代码

package com.example.demo.encog;

import org.encog.Encog;
import org.encog.engine.network.activation.ActivationSigmoid;
import org.encog.ml.data.MLData;
import org.encog.ml.data.MLDataPair;
import org.encog.ml.data.MLDataSet;
import org.encog.ml.data.basic.BasicMLDataSet;
import org.encog.neural.networks.BasicNetwork;
import org.encog.neural.networks.layers.BasicLayer;
import org.encog.neural.networks.training.propagation.resilient.ResilientPropagation;
import org.encog.persist.EncogDirectoryPersistence;

import java.io.File;

/**
 * @Create: IntelliJ IDEA.
 * @Author: subtlman_ljx
 * @Date: 2022/10/14/10:55
 * @Description:
 */
public class T {

    /**
     * 1、从代码层面来看
     * 创建一个神经网络
     * 添加神经图层
     * 确定神经结构
     *
     * 引入训练数据
     *
     * 关联处理后的神经网络和训练数据
     *
     * 2、联想
     * 线程存储在树节点中
     * 借助对象关联在树节点中
     *
     * 参考网址 https://blog.csdn.net/u012970287/article/details/79872495
     * 材料网址
     * https://blog.51cto.com/u_15077537/4523720
     * https://www.cnblogs.com/codeDog123/p/6754391.html
     * http://t.zoukankan.com/quietwalk-p-7524427.html
     * https://www.cnblogs.com/subtlman/p/16791456.html
     * https://www.heatonresearch.com/encog/
     * @param args
     */

    public static void main(String[] args) {
       getInstance().t1();

    }


    String filename="D:\\IDEA\\workspace1\\demo2\\src\\main\\java\\com\\example\\demo\\encog\\encogback.eg";

    public static T getInstance(){
        return new T();
    }

    public void t1(){
        //使用训练模型，不用再次创建神经网络，不用再次训练数据
        System.out.println("loading network");
        BasicNetwork network = (BasicNetwork) EncogDirectoryPersistence.loadObject(new File(filename));
        //创建训练数据
        double XOR_INPUT[][] = {{0.0, 1.0}, {1.0, 0.0}, {0.0, 1.0}, {1.0, 1.0}};
        double XOR_OUTPUT[][] = {{1.0}, {1.0}, {1.0}, {0.0}};
        MLDataSet trainingSet = new BasicMLDataSet(XOR_INPUT,XOR_OUTPUT);
        double e = network.calculateError(trainingSet);
        System.out.println("Network trained`s error is(should be same as above):"+e); // 6.991768111366914E-4

        System.out.println("Neural Network Results: ");
        for(MLDataPair pair: trainingSet){
            final MLData output = network.compute(pair.getInput());
            System.out.println(pair.getInput().getData(0) +
                    "," + pair.getInput().getData(1) +
                    ", actual=" + output.getData(0) + ",ideal=" +
                    pair.getIdeal().getData(0));
        }

    }

    public void t2(){
        //神经网络 创建、训练、保存eg文件
        //创建一个神经网络
        BasicNetwork network = new BasicNetwork();

        //BasicLayer 参数： 激活函数、是否偏移、该层神经元数目
        network.addLayer(new BasicLayer(null, true, 2));
        network.addLayer(new BasicLayer(new ActivationSigmoid(), true, 3));
        network.addLayer(new BasicLayer(new ActivationSigmoid(), true, 1));
        network.getStructure().finalizeStructure();

        // 使用Nguyen Widrow随机重置权重矩阵和偏差值，范围在-1和1之间的。
        // 如果网络没有输入、输出或隐藏层，则不能使用Nguyen Widrow，将使用-1到1之间的简单随机范围
        network.reset();

        //创建训练数据
        double XOR_INPUT[][] = {{0.0, 0.0}, {1.0, 0.0}, {0.0, 1.0}, {1.0, 1.0}};
        double XOR_OUTPUT[][] = {{0.0}, {1.0}, {1.0}, {0.0}};
        MLDataSet trainingSet = new BasicMLDataSet(XOR_INPUT,XOR_OUTPUT);

        //训练神经网络
        final ResilientPropagation train = new ResilientPropagation(network, trainingSet);

        int epoch = 1;

        do {
            train.iteration();
            System.out.println("Epoch #" + epoch + " Error: " + train.getError());
            epoch++;
        }while(train.getError() > 0.001);

        //保存神经网络
        double e = network.calculateError(trainingSet);
        System.out.println("Network trained to error:"+e); // 0.001869494889330012 9.876912370293156E-4
        System.out.println("Saving network");
        EncogDirectoryPersistence.saveObject(new File(filename),network);


        //测试神经网络
        System.out.println("Neural Network Results: ");
        for(MLDataPair pair: trainingSet){
            final MLData output = network.compute(pair.getInput());
            System.out.println(pair.getInput().getData(0) +
                    "," + pair.getInput().getData(1) +
                    ", actual=" + output.getData(0) + ",ideal=" +
                    pair.getIdeal().getData(0));
        }
        //Encog关闭
        Encog.getInstance().shutdown();
    }


}

对于神经网络的实际应用至此还是无法体现

附上利用机器学习识别验证码（从0到1）

python代码

文件结构

c.py

import os
import random

from PIL import ImageFont, Image, ImageDraw, ImageFilter


# 生成验证码

def auth_code():
    size = (140, 40)  # 图片大小
    font_list = list("0123456789")  # 验证码范围
    c_chars = "  ".join(random.sample(font_list, 4))  # 4个+中间加个俩空格
    print(c_chars)
    img = Image.new("RGB", size, (33, 33, 34))  # RGB颜色
    draw = ImageDraw.Draw(img)  # draw一个
    font = ImageFont.truetype("arial.ttf", 23)  # 字体
    draw.text((5, 4), c_chars, font=font, fill="white")  # 字颜色
    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)
    img.save(f'./test_img/{c_chars}.png')


if __name__ == '__main__':
    if not os.path.exists('./test_img'):
        os.mkdir('./test_img')
    while True:
        auth_code()
        if len(os.listdir('./test_img')) >= 3000:  # 你改成 10000就行了
            # 我这个电脑太老了。
            break

D.py

import os
import time

from PIL import Image


# 验证码分割

def read_img():
    img_array = []
    img_lable = []
    file_list = os.listdir('./test_img')
    for file in file_list:
        try:
            image = file
            img_array.append(image)
        except:
            print(f'{file}:图像已损坏')
            os.remove('./test_img/' + file)
    return img_array


def sliceImg(img_path, count=4):
    if not os.path.exists('train_data_img'):
        os.mkdir('train_data_img')
    for i in range(10):
        if not os.path.exists(f'train_data_img/{i}'):
            os.mkdir(f'train_data_img/{i}')
    img = Image.open('./test_img/' + img_path)
    w, h = img.size
    eachWidth = int((w - 17) / count)
    img_path = img_path.replace(' ', '').split('.')[0]

    for i in range(count):
        box = (i * eachWidth, 0, (i + 1) * eachWidth, h)
        img.crop(box).save(f'./train_data_img/{img_path[i]}/' + img_path[i] + str(time.time()) + ".png")


if __name__ == '__main__':
    img_array = read_img()
    for i in img_array:
        print(i)
        sliceImg(i)

E.py

from PIL import Image
import numpy as np
import os
from sklearn.neighbors import KNeighborsClassifier as knn
def img2vec(fname):
    '''将图片转为向量'''
    im = Image.open(fname).convert('L')
    im = im.resize((30,30))
    tmp = np.array(im)
    vec = tmp.ravel()
    return vec
tarin_img_path = 'train_data_img'
def split_data(paths):
    X = []
    y = []
    for i in os.listdir(tarin_img_path):
        path = os.path.join(tarin_img_path, i)
        fn_list = os.listdir(path)
        for name in fn_list:
            y.append(name[0])
            X.append(img2vec(os.path.join(path,name)))
    return X, y                 # x向量   y标签
def knn_clf(X_train,label):
    '''构建分类器'''
    clf = knn()
    clf.fit(X_train,label)
    return clf
def knn_shib(test_img):
    X_train,y_label = split_data(tarin_img_path)
    clf = knn_clf(X_train,y_label)
    result = clf.predict([img2vec(test_img)])
    return result

import random,time
import os
from PIL import ImageFont,Image,ImageDraw,ImageFilter
def auth_code():
    size = (140,40)                             #图片大小
    font_list = list("0123456789")             #验证码范围
    c_chars = "  ".join(random.sample(font_list,4))  # 4个+中间加个俩空格
    print(c_chars)
    img = Image.new("RGB",size,(33,33,34))      #RGB颜色
    draw = ImageDraw.Draw(img)                  #draw一个
    font = ImageFont.truetype("arial.ttf", 23)      #字体
    draw.text((5,4),c_chars,font=font,fill="white") #字颜色
    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)
    random_name = str(time.time())[-7:]
    img.save(f'./test_data_img/{random_name}.png')
if __name__ == '__main__':
    if not os.path.exists('./test_data_img'):
        os.mkdir('./test_data_img')
    while True:
        auth_code()
        if len(os.listdir('./test_data_img'))>=30:
            break

G.py

from D import *
from E import *

def sliceImg(img_path, count = 4):
    if not os.path.exists('test_split_img'):
        os.mkdir('test_split_img')
    img = Image.open(img_path)
    w, h = img.size
    eachWidth = int((w - 17) / count)
    for i in range(count):
        box = (i * eachWidth, 0, (i + 1) * eachWidth, h)
        img.crop(box).save('./test_split_img/' + f"{i+1}.png")

if __name__ == '__main__':
    test_data_img = r'test_data_img\2276516.png'
    # test_data_img = r'test_data_img\.059682.png'
    sliceImg(test_data_img)
    result = []
    for img in os.listdir('test_split_img'):
        result.append(knn_shib('test_split_img/'+img)[0])
    print(result)