zhuanzhudeyipi

zhuanzhudeyipi 查看完整档案

填写现居城市  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 个人简介什么都没有

个人动态

zhuanzhudeyipi 发布了文章 · 3月2日

外汇直接标价和间接标价之间有什么区别?

近几年外汇投资吸引了很多人,因为它的利益是很可观的,投入外汇市场的人对外汇直接标价和间接标价应该不陌生吧,今天我们就一起来看看他们之间有什么区别吧,

直接标价与间接标价区别是什么?

直接标价法,以一定单位的外国货币为基准(比如1,100等等),折合为一定数额的本国货币。中国,日本,加拿大等大多国家用的就是直接标价法。以中国的外汇牌价为例:目前,中国银行的外汇牌价显示:美元的外汇牌价是672.08,代表的是:100美元=672.08元。

间接间接标价法和直接标价法相反,它是指以一定单位的本国货币为基准(比如1,100等等),将其折合为一定数额的外国货币。美国,英国,欧元区等等是用的间接标价法。以美国为例,目前美国显示的人民币汇率一般是0.14左右,代表的是:1人民币=0.14美元。

在外汇市场,做外汇交易时,我们会碰见很多货币对,主要的直盘是美元/加元,英镑/美元,美元/日元,欧元/美元等等。为什不是加元/美元,美元/英镑,日元/美元?因为加元,日元默认是直接标价法,而英镑和欧元是间接标价法。(可以理解为:直接标价法以一定单位美元为基准,所以美元在分母位置)

以直接标价法标价的货币,一旦价格上升,就说明本国货币在贬值,而对应的外国货币升值。反之亦然。就像人民币对美元的汇率从8降到了现在的6,这说明这几年人民币增值了,美元在贬值。

直接标价法和间接标价法是可以转化的,计算上互为倒数关系。还是以人民币和美元为例。以1为基本单位,我国直接标价法是6.72,那么美国采用间接标价法就应该是1/6.72=0.1488,就算不一样,也差不了太多。也正因为各国汇率有时候不是统一的,中间也可以实现汇率互换的套利机制。
外汇名词解释(https://www.fx61.com/definitions
直接标价法和间接标价法对货币本身没有多大影响,只是标价方式不一样。

查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-24

对Excel表格的操作:Apache POI

1.简介:

Apache POI [是用Java编写的免费开源的跨平台的 Java API,Apache POI提供API给Java程式对Microsoft Office格式档案读和写的功能。其中使用最多的就是使用POI操作Excel文件。POI为“Poor Obfuscation Implementation”的首字母缩写,意为“简洁版的模糊实现”。

POI结构:

  • HSSF :提供读写Microsoft Excel XLS格式档案的功能
  • XSSF :提供读写Microsoft Excel OOXML XLSX格式档案的功能
  • HWPF : 提供读写Microsoft Word DOC格式档案的功能
  • HSLF : 提供读写Microsoft PowerPoint格式档案的功能
  • HDGF : 提供读Microsoft Visio格式档案的功能
  • HPBF : 提供读Microsoft Publisher格式档案的功能
  • HSMF : 提供读Microsoft Outlook格式档案的功能

maven坐标:

`<dependency>
  <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
  <version>3.14</version>
</dependency>

<dependency>
  <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
  <version>3.14</version>
</dependency>` 

2.代码测试

从一个已经存在的Excel文件中读取数据

对象解析:
外汇名词解释https://www.fx61.com/definitions

  • XSSFWorkbook:工作簿
  • XSSFSheet:工作表
  • Row:行
  • Cell:单元格
`//原理:遍历工作表获得行,遍历行获得单元格,最终获取单元格中的值
public static void main(String[] args) throws IOException {
        //创建工作簿
        XSSFWorkbook workbook = new XSSFWorkbook("H:hn.xlsx");
        //获取工作表,既可以根据工作表的顺序获取,也可以根据工作表的名称获取
        XSSFSheet sheet = workbook.getSheetAt(0);
        //遍历工作表获得行对象
        for (Row row : sheet) {
            //遍历行对象获取单元格对象
            for (Cell cell : row) {
                //获得单元格中的值
                String value = cell.getStringCellValue();
                System.out.println(value);
            }
        }
        workbook.close();
    }` 
`//原理:获取工作表最后一个行号,从而根据行号获得行对象,通过行获取最后一个单元格索引,从而根据单元格索引获取每行的一个单元格对象
public static void main(String[] args) throws IOException {
        //创建工作簿
        XSSFWorkbook workbook = new XSSFWorkbook("H:hn.xlsx");
        //获取工作表,既可以根据工作表的顺序获取,也可以根据工作表的名称获取
        XSSFSheet sheet = workbook.getSheetAt(0);
        //获取当前工作表最后一行的行号,行号从0开始
        int lastRowNum = sheet.getLastRowNum();
        for (int i = 0; i <= lastRowNum; i++) {
            //根据行号获取行对象
            XSSFRow row = sheet.getRow(i);
            short lastCellNum = row.getLastCellNum();
            for (short j = 0; j < lastCellNum; j++) {
                String value = row.getCell(j).getStringCellValue();
                System.out.println(value);
            }
        }
        workbook.close();
    }` 

创建一个Excel文件并将数据写入到这个文件,最后通过输出流将内存中的Excel文件下载到磁盘

public static void main(String[] args) throws IOException {
        //在内存中创建一个Excel文件
        XSSFWorkbook workbook = new XSSFWorkbook();
        //创建工作表,指定工作表名称
        XSSFSheet sheet = workbook.createSheet("poi测试");
        //创建行,0表示第一行
        XSSFRow row = sheet.createRow(0);
        //创建单元格,0表示第一个单元格
        row.createCell(0).setCellValue("序号");
        row.createCell(1).setCellValue("名字");
        row.createCell(2).setCellValue("年龄");
        XSSFRow row1 = sheet.createRow(1);
        row1.createCell(0).setCellValue("1");
        row1.createCell(1).setCellValue("张三");
        row1.createCell(2).setCellValue("20");
        XSSFRow row2 = sheet.createRow(2);
        row2.createCell(0).setCellValue("2");
        row2.createCell(1).setCellValue("李四");
        row2.createCell(2).setCellValue("22");
        //通过输出流将workbook对象下载到磁盘
        FileOutputStream out = new FileOutputStream("D:test.xlsx");
        workbook.write(out);
        out.flush();
        out.close();
        workbook.close();
    }
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-24

java优雅的处理程序中的异常

一、自定义异常类

(1)继承 Exception 或 RuntimeException
(2)定义构造方法

`/**
 * @author lqh
 * @date 2020/9/22
 * 业务逻辑异常
 */
public class ServiceException extends RuntimeException{

    private String code;
    private String msg;

    public ServiceException() {
    }

    public ServiceException(String msg) {
        this.msg = msg;
    }

    public ServiceException(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}` 

二、@ControllerAdvice

外汇常见问题https://www.fx61.com/faq

  @ControllerAdvice 实现全局异常处理,需配合@ExceptionHandler(注解用来指明异常的处理类型)使用。

`/**
 * @author lqh
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    @ResponseBody
    @ExceptionHandler(Exception.class)
    public ServerResponse exceptionHandler(Exception e) {
        return ServerResponse.error(ResponseCode.SERVER_ERROR.getMsg());
    }
    @ResponseBody
    @ExceptionHandler(ServiceException.class)
    public ServerResponse serviceExceptionHandler(ServiceException se) {
        return ServerResponse.error(se.getMsg());
    }
}` 



  ResponseCode是自定义枚举类,用于返回统一的状态

`/**
 * @author lqh
 * @date 2020/9/21
 * 响应状态码
 */
public enum ResponseCode {

    // 系统模块
    SUCCESS(200, "操作成功"),
    SAVE_SUCCESS(201,"保存成功"),
    DELETE_SUCCESS(202,"删除成功!"),
    UPDATE_SUCCESS(403,"更新成功!"),

    ERROR(400, "操作失败"),
    SAVE_ERROR(401,"保存失败"),
    DELETE_ERROR(402,"删除失败!"),
    UPDATE_ERROR(403,"更新成功"),

    SERVER_ERROR(500, "服务器异常"),
    EXCEPTION(-1,"Exception"),

    // 用户模块 0xxxx
    NEED_LOGIN(1001, "登录失效"),
    USERNAME_OR_PASSWORD_EMPTY(1002, "用户名或密码不能为空"),
    USERNAME_OR_PASSWORD_WRONG(1003, "用户名或密码错误"),
    USER_NOT_EXISTS(1004, "用户不存在"),
    WRONG_PASSWORD(1005, "密码错误"),
}` 


四、异常e相关方法(解释在方法注释中)

XM返佣https://www.fx61.com/brokerli...

 `@Test
    public void test01(){
        try {
            System.out.println(1/0);
        }catch (Exception e){
            /**
             * 获取异常种类和错误信息
             * java.lang.ArithmeticException: / by zero
             */
            System.out.println(e.toString());

            /**
             *获取错误信息
             * / by zero
             */
            System.out.println(e.getMessage());
            /**
             * 获取异常类的Class
             *class java.lang.ArithmeticException
             */
            System.out.println(e.getClass());
            /**
             *获取异常类名称
             *java.lang.ArithmeticException
             */
            System.out.println(e.getClass().getName());
            /**
             * 会打出详细异常,异常名bai称,出错位置,便于调试用
             * java.lang.ArithmeticException: / by zero
             at com.bluewit.exception.ExceptionTest.test01(ExceptionTest.java:13)
             at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
             at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
             at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
             at java.lang.reflect.Method.invoke(Method.java:498)
             at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
             at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
             at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
             at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
             at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
             at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
             at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
             at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
             at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
             at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
             at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
             at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
             at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
             at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
             at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
             at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
             at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
             at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
             */
            e.printStackTrace();

            /**
             * 返回的是通过getOurStackTrace方法获取的StackTraceElement[]数组,而这个StackTraceElement是ERROR的每一个cause by的信息。
             * [Ljava.lang.StackTraceElement;@4c203ea1
             */
            System.out.println(e.getStackTrace());

            /**
             * 返回一个包含所有被抑制的异常,通常由一个数组try -with-resources语句,为了实现这一例外。 如果没有例外被抑制或抑制被禁止 ,则返回一个空数组
             */
            System.out.println(e.getSuppressed());

            /**
             *回此异常的原因(尝试加载类时发生错误引发的异常;否则返回 null)
             * null
             */
            System.out.println(e.getCause());
        }
    }` 

五、自定义异常使用

(1)举例一:程序中根据业务判断抛出异常信息

 `if(1!=1){
        throw new ServiceException(ResponseCode.SUCCESS.getMsg());
    }` 

(2)举例二:根据异常信息抛出具体业务信息

 `try {
            System.out.println(1/0);
        }catch (Exception e){
            if(e.toString().contains("SyntaxError")){
                throw new ServiceException(ResponseCode.GRMMAR_RULES_ILLEGAL.getMsg());
            }
       }` 

六、写在最后,使用异常处理业务,而不是处理业务逻辑

异常设计的初衷是解决程序运行中的各种意外情况,且异常的处理效率比条件判断方式要低很多。

看一个反例(使用异常处理业务逻辑)

 `public void processMessage(String token,RedisTemplate businessTemplate) {
    try{
        // 处理消息验证
        // 处理消息解析
        // 处理消息入库
    }catch(ValidateException e ){
        // 验证失败
    }catch(ParseException e ){
        // 解析失败
    }catch(PersistException e ){
        // 入库失败
    }
  }` 

  上面这个例子,很明显使用异常进行业务处理,这种方式是禁止使用的。
修改后的业务逻辑正例(使用异常处理业务)

 `public void processMessage(String token,RedisTemplate businessTemplate) {
        if(StringUtils.isBlank(token)){
            throw new ServiceException(ResponseCode.ILLEGAL_ARGUMENT.getMsg());
        }
        if(!RedisUtil.hasKey(token,businessTemplate)){
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }
        if(!RedisUtil.del(businessTemplate,token)){
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }
 }` 

  上面这个例子,只管抛出异常,不做任何处理,由GlobalExceptionHandler统一处理,代码变得简洁清晰,没有太多的代码嵌套,同时所有的异常都得到了妥善的处理。

查看原文

赞 0 收藏 0 评论 1

zhuanzhudeyipi 发布了文章 · 2020-09-22

漫画排序算法Python实现

冒泡排序

冒泡排序的思想,我们要把相邻的元素两两比较,当一个元素大于右侧相邻元素时,

交换它们的位置;当一个元素小于或等于右侧相邻元素时,位置不变。

def bubbleSort(list):

range返回一个序列的数 不指定返回具体值 len值长度

for i in range(len(list) - 1):

Python里true、false赋值首字母大写

isSorted = True

for j in range(len(list) - i - 1 ):

if(float(list[j]) > float(list[j + 1])):

print(list)

fist = list[j]

list[j] = list[j + 1]

list[j + 1] = fist

isSorted = False

当没有发生位置交换时,说明有序跳出大循环

if(isSorted):

break

return list

加上isSorted只是优化了大循环,记录位置优化了比较次数的循环

def optBubbleSort(list):

记录最后一个发生位置交换的位置

lastExchangeIndex = 0

sortBorder = len(list) - 1

for i in range(len(list) - 1):

isSorted = True

for j in range(sortBorder):

if(list[j] > list[j + 1]):

fist = list[j]

list[j] = list[j + 1]

list[j + 1] = fist

isSorted = False

lastExchangeIndex = j#位置数最大的位置变换

sortBorder = lastExchangeIndex

当没有发生位置交换时,说明有序跳出大循环

if(isSorted):

break

return list

冒泡排序测试

text = [5,8,6,3,9,2,1,7]

bubbleSort(text)

[1, 2, 3, 5, 6, 7, 8, 9]

优化冒泡排序测试

text = [4,3,2,1,5,6,7,8]

optBubbleSort(text)

[1, 2, 3, 4, 5, 6, 7, 8]

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253

鸡尾酒排序

鸡尾酒排序的元素比较和交换过程是双向的。它能发挥出优势的场景,是大部分元素已经有序的情况。

def cocktailSort(list):

for i in range(int(len(list) / 2)):

isSorted = True

for j in range(len(list) - i - 1 ):

if(list[j] > list[j + 1]):

fist = list[j]

list[j] = list[j + 1]

list[j + 1] = fist

isSorted = False

当没有发生位置交换时,说明有序跳出大循环

if(isSorted):

break

isSorted = True

wj = len(list) - i - 1

while(wj > i):

if(list[wj] < list[wj-1]):

tmp = list[wj]

list[wj] = list[wj-1]

list[wj-1] = tmp

因为有元素进行交换,所以不是有序的,标记变为false

isSorted = False

wj -= 1

if(isSorted):

break

return list

鸡尾酒排序测试

text = [2,3,4,59,6,7,8,1]

cocktailSort(text)

[1, 2, 3, 4, 6, 7, 8, 59]

1234567891011121314151617181920212223242526272829303132333435363738

快速排序
外汇经纪商对比https://www.fx61.com/brokerlist

from queue import LifoQueue

"""

冒泡排序在每一轮中只把1个元素冒泡到数列的一端,而快速排序则在每一

轮挑选一个基准元素,并让其他比它大的元素移动到数列一边,比它小的

元素移动到数列的另一边,从而把数列拆解成两个部分。

平均时间复杂度是O(nlogn)。

"""

快速排序递归实现

def quickSort(list,startIndex,endIndex):

if(startIndex >= endIndex):

return

pivotIndex = partition(list,startIndex,endIndex)

print(list)

quickSort(list, startIndex, pivotIndex - 1)

quickSort(list, pivotIndex + 1, endIndex)

"""

每一次循环,都会让栈顶元素出栈,通过partition方法进行分治,并且按照基准元素的位

置分成左右两部分,左右两部分再分别入栈。当栈为空时,说明排序已经完毕,退出循环。

"""

快速排序栈实现(绝大多数的递归逻辑,都可以用栈的方式来代替)

def stackQuickSort(list,startIndex,endIndex):

stack = LifoQueue()

param = {"startIndex":startIndex,"endIndex":endIndex}#字典 key value

stack.put(param)

while (not stack.empty()):

p = stack.get()

pivotIndex = partition(list,p["startIndex"],p["endIndex"])

if(p["startIndex"] < pivotIndex - 1):

leftParam = {"startIndex":startIndex,"endIndex":pivotIndex - 1}

stack.put(leftParam)

if(pivotIndex + 1 < p["endIndex"]):

rightParam = {"startIndex":pivotIndex + 1,"endIndex":endIndex}

stack.put(rightParam)

def partition(list,startIndex,endIndex):

pivot = list[startIndex]#把首元素作为基准元素

mark = startIndex

i = startIndex + 1

while(i <= endIndex):

if(list[i] < pivot):

mark += 1#交换位置次数

p = list[mark]

list[mark] = list[i]

list[i] = p

i += 1

list[startIndex] = list[mark]

list[mark] = pivot

return mark

快速排序递归测试

text = [4,7,3,5,6,2,8,1]

quickSort(text,0,len(text) - 1)

print(text)

[1, 3, 2, 4, 6, 7, 8, 5]

[1, 3, 2, 4, 6, 7, 8, 5]

[1, 2, 3, 4, 6, 7, 8, 5]

[1, 2, 3, 4, 5, 6, 8, 7]

[1, 2, 3, 4, 5, 6, 7, 8]

[1, 2, 3, 4, 5, 6, 7, 8]

快速排序栈实现测试

text = [4,7,3,5,6,2,8,1]

stackQuickSort(text,0,len(text) - 1)

print(text)

[1, 2, 3, 4, 5, 6, 7, 8]

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374

堆排序

"""

二叉堆的特性是什么?

  1. 最大堆的堆顶是整个堆中的最大元素。(最大堆的任何一个父节点的值,都大于或等于它左、右孩子节点的值。)
  2. 最小堆的堆顶是整个堆中的最小元素。(最小堆的任何一个父节点的值,都小于或等于它左、右孩子节点的值。)

二叉堆实际存储在数组中,把无序数组构建成二叉堆。需要从小到大排序,则构建成最大堆;需要从大到小

排序,则构建成最小堆。

那么堆排序算法就是循环删除堆顶元素,替换到二叉堆的末尾,调整堆产生新的堆顶。

"""

def heapSort(arr):

无序数组创建最大堆

i = len(arr) / 2

while( i >= 1):

downAdjust(arr,i,len(arr))

i -= 1

print("最大堆:",arr)

排序

j = (len(arr) - 1 )

while(j > 0):

temp1 = arr[j]

arr[j] = arr[0]

arr[0] = temp1

downAdjust(arr, 0, j)

j-=1

def downAdjust(arr,parentIndex,length):

parentIndex = int(parentIndex)

length = int(length)

temp = arr[parentIndex]

childIndex = parentIndex * 2 + 1

while(childIndex < length):

if(childIndex + 1 < length and arr[childIndex] < arr[childIndex + 1]):#改成>号则是最小堆

childIndex += 1

if(temp >= arr[childIndex]):#改成<号则是最小堆

break

arr[parentIndex] = arr[childIndex]

parentIndex = childIndex

childIndex = 2 * childIndex + 1

arr[parentIndex] = temp

堆排序实现测试

text = [4,7,3,5,6,2,1]

heapSort(text)

print(text)

最大堆: [4, 7, 3, 5, 6, 2, 1]

[1, 2, 3, 5, 6, 7, 4]

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253

计数排序

计数排序不用元素之间的比较,以数组index自动排序

def countSort(arr):

找出无序数组的最大的值

arrMax = arr[0]

for a in arr:

if(arrMax < a):

arrMax = a

创建一个以无序数组最大值为长度的数组

countArray = [0 for x in range(0,arrMax + 1)]

遍历无序数组统计值出现的次数

for i in range(len(arr)):

countArray[arr[i]] += 1

此时countArray的值为arr值出现的次数,countArray的index为arr的值

index = 0

sortedArray = [0 for x in range(0,len(arr))]

for c in range(len(countArray)):

for c1 in range(countArray[c]):

sortedArray[index] = c

index+=1

return sortedArray

计数实现测试

text = [4,7,3,5,6,2,1]

countSort(text)

[1, 2, 3, 4, 5, 6, 7]

计数排序的优化(节约空间不再是以最大值创建数组;稳定排序:相同的值下顺序不变)

def countSort(arr):

arrMax = arr[0]

arrMin = arr[0]

for a in arr:

if(arrMax < a):

arrMax = a

if(arrMin > a):

arrMin = a

创建一个以无序数组,长度为最大与最小的差值

countArray = [0 for x in range(0,arrMax - arrMin + 1)]

for i in range(len(arr)):

countArray[arr[i] - arrMin] += 1

统计数组做变形,后面的元素等于前面的元素之和

for j in range(len(countArray) - 1):

countArray[j + 1] += countArray[j]

sortedArray = [0 for x in range(0,len(arr))]

倒序遍历原始数列,从统计数组找到正确位置,输出到结果数组(countArray存的值是顺序)

index = len(arr) - 1

while(index >= 0):

sortedArray[countArray[arr[index] - arrMin] - 1] = arr[index]

countArray[arr[index]-arrMin] -= 1

index -= 1

return sortedArray

text = [4,7,3,5,3,2,1]

countSort(text)

[1, 2, 3, 3, 4, 5, 7]

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566

桶排序

"""

创建的桶数量等于原始数列的元素数量,除最后一个桶只包含数列最大值外,前面各个桶的

区间按照比例来确定。区间跨度 = (最大值-最小值)/ (桶的数量 - 1)

"""

def bucketSort(arr):

arrMax = arr[0]

arrMin = arr[0]

for a in arr:

if(arrMax < a):

arrMax = a

if(arrMin > a):

arrMin = a

d = arrMax - arrMin

bucketNum = len(arr)

初始化桶

blist = {}

for i in range(len(arr)):

bb = []

blist[i] = bb

for a in arr:

num = (int)((a - arrMin) * (bucketNum - 1) / d)

blist[num].append(a)

排序每个桶里的值

for b in blist:

ccc = blist[b]

ccc.sort()

blist[b] = ccc

sortArr = []

for n in blist:

for l in blist[n]:

sortArr.append(l)

return sortArr

text = [4.5,0.84,3.25,2.18,0.5]

bucketSort(text)

[0.5, 0.84, 2.18, 3.25, 4.5]

查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-22

python实现爬取中国商标网信息去天眼查爬取电话

  1. python功能强大非常少的代码轻松实现各种网站资源爬取,如电话信息,vip素材网等

  2. 下面介绍用python爬取中国商标网信息去天眼查爬取法人电话与公司地址提高销售效率

  3. !/usr/bin/env python

  4. -- coding: utf-8 --

  5. from db.name.header_api import Headers, HeadersCookie, sb_num, get_user_agent_pc
  6. num_text = sb_num # 多少期数
  7. rows = [] # 批量信息列表
  8. sb_num_list = [] # 注册号列表换取图片
  9. gs_name_list = [] # 去重后公司列表
  10. gs_name_list1 = [] # 公司列表换取电话与地址
  11. gs_name_list2 = [] # 带公司名,注册号,商标名
  12. gs_name_list3 = []
  13. import requests
  14. import re
  15. import time
  16. from lxml import html
  17. etree =html.etree
  18. import pymysql
  19. import time
  20. import re
  21. import json
  22. import csv
  23. import xlwt # 存入xlsx文件
  24. import xlrd # 获取现有的行数
  25. from xlutils.copy import copy
  26. import os
  27. import requests
  28. from lxml import html # xls
  29. def str_true(str):
  30. a1 =re.search('[A-Z, a-z]', str) # 是否含有大小写字母
  31. if a1 :
  32. return False # 如果有一个存在就不能用为假
  33. else:
  34. return True # 都没有能用为真
  35. 标题写入excel

  36. def write_excel_xls(path, sheet_name, value):
  37. index = len(value) # 获取需要写入数据的行数
  38. workbook = xlwt.Workbook() # 新建一个工作簿
  39. sheet = workbook.add_sheet(sheet_name) # 在工作簿中新建一个表格
  40. for i in range(0, index):
  41. for j in range(0, len(value[i])):
  42. sheet.write(i, j, valuei) # 像表格中写入数据(对应的行和列)
  43. workbook.save(path) # 保存工作簿
  44. print("xls格式表格写入数据成功!")
    外汇代理https://www.kaifx.cn/ib/
  45. 追加

  46. def write_excel_xls_append(path, value):
  47. index = len(value) # 获取需要写入数据的行数
  48. workbook = xlrd.open_workbook(path) # 打开工作簿
  49. sheets = workbook.sheet_names() # 获取工作簿中的所有表格
  50. worksheet = workbook.sheet_by_name(sheets[0]) # 获取工作簿中所有表格中的的第一个表格
  51. rows_old = worksheet.nrows # 获取表格中已存在的数据的行数
  52. new_workbook = copy(workbook) # 将xlrd对象拷贝转化为xlwt对象
  53. new_worksheet = new_workbook.get_sheet(0) # 获取转化后工作簿中的第一个表格
  54. for i in range(0, index):
  55. for j in range(0, len(value[i])):
  56. new_worksheet.write(i + rows_old, j, valuei) # 追加写入数据,注意是从i+rows_old行开始写入
  57. new_workbook.save(path) # 保存工作簿
  58. print("xls格式表格【追加】写入数据成功!")

  59. def sb_cs(pages):
  60. sb_num_list.clear()
  61. gs_name_list.clear()
  62. gs_name_list1.clear()
  63. gs_name_list2.clear()
  64. gs_name_list3.clear()
  65. head2 = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36 QQBrowser/4.4.119.400'
  66. headers2 = {
  67. 'user-agent': head2,

  68. 'Accept': 'application/json, text/javascript, /; q=0.01',
  69. 'Accept-Encoding': 'gzip, deflate',
  70. 'Accept-Language': 'zh-CN,zh;q=0.9',
  71. 'Connection': 'keep-alive',
  72. 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
  73. 'Cookie': 'UM_distinctid=16eac05d31a122-071a188af83977-32365f08-100200-16eac05d3232e2;tmas_cookie=51947.7681.15402.0000',
  74. 'Host': 'wsgg.sbj.cnipa.gov.cn:9080',
  75. 'Origin': 'http://wsgg.sbj.cnipa.gov.cn:9080',
  76. 'Referer': 'http://wsgg.sbj.cnipa.gov.cn:9080/tmann/annInfoView/annSearch.html?annNum=',
  77. 'User-Agent': get_user_agent_pc(), # 随机获取一个
  78. 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36',

  79. 'X-Requested-With': 'XMLHttpRequest',
  80. }
  81. datas = {
  82. "page": pages,
  83. "rows": '100',
  84. "annNum": num_text, # 公告期数
  85. 'annType': 'TMZCSQ',
  86. 'tmType': '',
  87. 'coowner': '',
  88. 'recUserName': '',
  89. 'allowUserName': '',
  90. 'byAllowUserName': '',
  91. 'appId': '',
  92. 'appIdZhiquan': '',
  93. 'bfchangedAgengedName': '',
  94. 'changeLastName': '',
  95. 'transferUserName': '',
  96. 'acceptUserName': '',
  97. 'regNum': '',
  98. 'regName': '',
  99. 'tmName': '',
  100. 'intCls': '',
  101. 'fileType': '',
  102. 'totalYOrN': 'true',
  103. 'appDateBegin': '', # 日期开始
  104. 'appDateEnd': '', # 日期结束
  105. 'agentName': '', # 代理人
  106. }
  107. s = requests.session()
  108. urls1 = 'http://wsgg.sbj.cnipa.gov.cn:9080/tmann/annInfoView/annSearchDG.html' # 信息地址
  109. response = s.post(urls1, data=datas, headers=headers2 ) # post参数
  110. print(response)
  111. jsons = json.loads(response.text)
  112. info = jsons['rows']
  113. print('总条数', len(info))
  114. for i in range(len(info)):
  115. item1 = infoi # 多少期
  116. item2 = infoi # 公布时间
  117. item3 = infoi # 类型
  118. item4 = infoi # 注册号
  119. item5 = infoi # 公司名
  120. item6 = infoi # 商标
  121. item7 = infoi
  122. item8 = infoi # id
  123. print(item7, type(item7), item4, type(item4), type(str(item7)),item7)

  124. 字符串中有点,有数字,有字母的不要

  125. if item3 == '商标初步审定公告' and len(item5) > 11 and str_true(item5): # 过滤
  126. sb_num_list.append(item4)
  127. item_list = [str(item7), item5, item4, item6]
  128. gs_name_list1.append(item5)
  129. gs_name_list2.append(item_list)
  130. print('第', i + 1, '条', item1, item2, item3, item4, item5, item6, str(item7))
  131. print('注册号总共', len(sb_num_list))
  132. print('公司名总共', len(gs_name_list2))
  133. for index, each in enumerate(gs_name_list1):
  134. if each not in gs_name_list3: # 新存入的列表
  135. gs_name_list3.append(each)
  136. gs_name_list.append(gs_name_list2[index])
  137. print(index + 1, each, 'index', 'each', '第', str(pages), '页')
  138. book_name_xls = os.getcwd() + '/text' + '/{}.xls'.format(num_text + '公司名' + str(pages))
  139. value_title = [["图片编号", "公司名", "注册号", "标名"], ]
  140. if os.path.exists(book_name_xls):
  141. write_excel_xls_append(book_name_xls, gs_name_list)
  142. else:
  143. write_excel_xls(book_name_xls, '公司名列表', value_title)
  144. write_excel_xls_append(book_name_xls, gs_name_list)
  145. if name == "__main__":
  146. 执行第1步,获取过滤后的公司信息

  147. for i in range(1, 41): # 1到40,
  148. pages = i
  149. sb_cs(pages) # 一次获以所有的list
  150. print('第', str(pages), '页')
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-17

java敏感词过滤

java敏感词过滤

敏感词:“美元”,“中国”,“北京大学”,“北大”,“南京大学”

DFAUtils

`import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

public class DFAUtils {
    /**
     * 添加敏感词到算法树
     */
    public static void addSensitiveWord(String sensitiveWord) {
        if (null == sensitiveWord || sensitiveWord.length() == 0) {
            return;
        }
        char[] chars = sensitiveWord.toCharArray();
        Map<Character, Map> parentMap = sensitiveWordsMap;
        Map<Character, Map> current = null;
        synchronized (lock) {
            for (int i = 0; i < chars.length; i++) {
                if (i == 0) {
                    if (sensitiveWordsMap.size() == 0) {
                        /* 添加第一个敏感词的第一个字符执行此code */
                        if (chars.length == 1) {
                            Map<Character, Map> endMap = new HashMap<>(1);
                            endMap.put(null, null);
                            sensitiveWordsMap.put(chars[0], endMap);
                        } else {
                            sensitiveWordsMap.put(chars[0], null);
                        }
                    } else {
                        current = parentMap.get(chars[0]);
                        if (null == current) {
                            if (chars.length == 1) {
                                Map<Character, Map> endMap = new HashMap<>(1);
                                endMap.put(null, null);
                                sensitiveWordsMap.put(chars[0], endMap);
                                break;
                            } else {
                                sensitiveWordsMap.put(chars[0], null);
                            }
                        } else {
                            if (chars.length == 1) {
                                current.put(null, null);
                                break;
                            }
                        }
                    }
                } else {
                    if (null == current) {
                        Map<Character, Map> childMap = new HashMap<Character, Map>();
                        if (i == chars.length - 1) {
                            Map<Character, Map> endMap = new HashMap<>(1);
                            endMap.put(null, null);
                            childMap.put(chars[i], endMap);
                            parentMap.put(chars[i - 1], childMap);
                            break;
                        } else {
                            childMap.put(chars[i], null);
                            parentMap.put(chars[i - 1], childMap);
                            parentMap = childMap;
                            current = null;
                        }
                    } else {
                        Map<Character, Map> childMap = current.get(chars[i]);
                        if (null == childMap) {
                            if (i == chars.length - 1) {
                                Map<Character, Map> endMap = new HashMap<>(1);
                                endMap.put(null, null);
                                current.put(chars[i], endMap);
                            } else {
                                current.put(chars[i], null);
                                parentMap = current;
                                current = null;
                            }
                        } else {
                            if (i == chars.length - 1) {
                                childMap.put(null, null);
                            } else {
                                parentMap = current;
                                current = childMap;
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 检查敏感词(找到符合敏感词则返回--单个字符敏感词前后不是中文字符才算敏感词)
     */
    public static String checkSensitiveWord(String content) {
        if (null == content || content.length() == 0 || sensitiveWordsMap.size() == 0) {
            return null;
        }
        char[] chars = content.toCharArray();
        boolean isContain = Boolean.FALSE;
        StringBuilder sbResult = new StringBuilder();
        for (int i = 0; i < chars.length; i++) {
            if (sensitiveWordsMap.containsKey(chars[i])) {
                Map<Character, Map> currentMap = sensitiveWordsMap.get(chars[i]);
                sbResult.append(chars[i]);
                if (null == currentMap) {
                    break;
                } else {
                    if (currentMap.containsKey(null)) {
                        if (sbResult.length() == 1) {
                            /* 前一个字符或后一个字符是否是中文字符 */
                            boolean before = Boolean.FALSE;
                            if (i - 1 < 0) {
                                before = Boolean.TRUE;
                            } else {
                                if (chars[i - 1] < 13312 || chars[i - 1] > 40895) {
                                    before = Boolean.TRUE;
                                }
                            }
                            boolean after = Boolean.FALSE;
                            if (i + 1 >= chars.length) {
                                after = Boolean.TRUE;
                            } else {
                                if (chars[i + 1] < 13312 || chars[i + 1] > 40895) {
                                    after = Boolean.TRUE;
                                }
                            }
                            if (before && after) {
                                isContain = Boolean.TRUE;
                                break;
                            }
                            /* From当前index开始匹配是否存在敏感词 */
                            int j = i + 1;
                            for (; j < chars.length; j++) {
                                if (currentMap.containsKey(chars[j])) {
                                    sbResult.append(chars[j]);
                                    currentMap = currentMap.get(chars[j]);
                                    if (currentMap.containsKey(null)) {
                                        isContain = Boolean.TRUE;
                                        break;
                                    } else {
                                        continue;
                                    }
                                } else {
                                    break;
                                }
                            }
                        } else {
                            isContain = Boolean.TRUE;
                            break;
                        }
                    } else {
                        /* From当前index开始匹配是否存在敏感词 */
                        int j = i + 1;
                        for (; j < chars.length; j++) {
                            if (currentMap.containsKey(chars[j])) {
                                sbResult.append(chars[j]);
                                currentMap = currentMap.get(chars[j]);
                                if (currentMap.containsKey(null)) {
                                    isContain = Boolean.TRUE;
                                    break;
                                } else {
                                    continue;
                                }
                            } else {
                                break;
                            }
                        }
                    }
                    if (isContain) {
                        break;
                    } else {
                        sbResult.setLength(0);
                    }
                }
            }
        }

        if (isContain) {
            return sbResult.toString();
        } else {
            return null;
        }
    }

    /**
     * 删除算法树的敏感词
     */
    public static void delSensitiveWord(String sensitiveWord) {
        if (null == sensitiveWord || sensitiveWord.length() == 0 || sensitiveWordsMap.size() == 0) {
            return;
        }
        int delIndex = 0;
        char[] chars = sensitiveWord.toCharArray();
        Map<Character, Map> current = sensitiveWordsMap;
        synchronized (lock) {
            int i = 0;
            for (; i < chars.length; i++) {
                if (current.containsKey(chars[i])) {
                    if (current.get(chars[i]).size() > 1) {
                        delIndex = i;
                    }

                } else {
                    break;
                }
                current = current.get(chars[i]);
            }
            if (!current.containsKey(null)) {
                return;
            }
            current = sensitiveWordsMap;
            if (i == chars.length) {
                for (i = 0; i < delIndex; i++) {
                    current = current.get(chars[i]);
                }
                if (i == chars.length) {
                    current.remove(chars[i]);
                } else {
                    if (i == 0 && chars.length == 1) {
                        if (current.get(chars[i]).size() == 1) {
                            current.remove(chars[i]);
                        } else {
                            current.get(chars[i]).remove(null);
                        }
                    } else {
                        if (i + 1 == chars.length) {
                            current.get(chars[i]).remove(null);
                        } else {
                            current.get(chars[i]).remove(chars[i + 1]);
                        }
                    }
                }
            }
        }
    }

    /**
     * 获取算法树的敏感词
     */
    public static LinkedList<String> getSevsitiveWords() {
        LinkedList<String> listWords = new LinkedList<String>();
        if (sensitiveWordsMap.size() == 0) {
            return listWords;
        }
        StringBuilder sbWord = new StringBuilder();
        getSevsitiveWords(sensitiveWordsMap, listWords, sbWord);
        return listWords;
    }

    /**
     * 算法树是否包含对应的敏感词
     */
    public static boolean containSensitiveWord(String sensitiveWord) {
        if (null == sensitiveWord || sensitiveWord.length() == 0 || sensitiveWordsMap.size() == 0) {
            return false;
        }
        return sensitiveWord.equals(checkSensitiveWord(sensitiveWord));
    }

    /**
     * 清空算法树
     */
    public static void clearSensitiveWord() {
        synchronized (lock) {
            sensitiveWordsMap = new HashMap<Character, Map>();
        }
    }

    /**
     * 递归获取算法树的敏感词
     */
    private static void getSevsitiveWords(Map<Character, Map> childMap, LinkedList<String> listWords,
                                          StringBuilder sbWord) {
        if (childMap.size() == 1 && childMap.containsKey(null)) {
            listWords.add(sbWord.toString());
            sbWord.setLength(sbWord.length() - 1);
            return;
        }
        for (Map.Entry<Character, Map> entry : childMap.entrySet()) {
            Character keyChar = entry.getKey();
            Map<Character, Map> valueMap = entry.getValue();
            if (null == keyChar) {
                continue;
            }
            sbWord.append(keyChar);
            if (valueMap.containsKey(null)) {
                listWords.add(sbWord.toString());
                if (valueMap.size() == 1) {
                    sbWord.setLength(sbWord.length() - 1);
                } else {
                    getSevsitiveWords(valueMap, listWords, sbWord);
                    sbWord.setLength(sbWord.length() - 1);
                }
            } else {
                getSevsitiveWords(valueMap, listWords, sbWord);
                sbWord.setLength(sbWord.length() - 1);
            }
        }
    }

    private final static Object lock = new Object();
    private static Map<Character, Map> sensitiveWordsMap = new HashMap<Character, Map>();
}` 


DFAUtilsTest

外汇名词解释https://www.fx61.com/definitions

import org.junit.Assert;
import org.junit.Test;

import java.util.LinkedList;

public class DFAUtilsTest {
    /*==========================AddSensitiveWord-start==========================*/
    @Test
    public void testAddSensitiveWord01() {
        DFAUtils.clearSensitiveWord();
        LinkedList<String> listWords = null;
        DFAUtils.addSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.addSensitiveWord("中哈");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.addSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.addSensitiveWord("中哈");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.delSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.addSensitiveWord("中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.addSensitiveWord("中中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(3, listWords.size());
        DFAUtils.addSensitiveWord("人");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(4, listWords.size());
        DFAUtils.addSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(5, listWords.size());
    }

    /*==========================AddSensitiveWord-end============================*/

    /*==========================CheckSensitiveWord-start==========================*/
    @Test
    public void testCheckSensitiveWord01() {
        DFAUtils.clearSensitiveWord();
        String sencitivaWord = null;
        LinkedList<String> listWords = null;
        DFAUtils.addSensitiveWord("大");
        DFAUtils.addSensitiveWord("大学");
        DFAUtils.addSensitiveWord("中中中国中中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(8, listWords.size());
        sencitivaWord = DFAUtils.checkSensitiveWord("滚");
        Assert.assertEquals("滚", sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord("翻滚");
        Assert.assertEquals(null, sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord("滚 ");
        Assert.assertEquals("滚", sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord(" 滚");
        Assert.assertEquals("滚", sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord("体操");
        Assert.assertEquals(null, sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord("你好滚滚");
        Assert.assertEquals("滚滚", sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord("滚你好滚");
        Assert.assertEquals(null, sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord("滚轮胎");
        Assert.assertEquals(null, sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord("你你国国");
        Assert.assertEquals(null, sencitivaWord);

        sencitivaWord = DFAUtils.checkSensitiveWord("中中国中中 中中中中国中中中");
        Assert.assertEquals("中中中国中中中", sencitivaWord);
    }

    /*==========================CheckSensitiveWord-start==========================*/

    /*==========================DelSensitiveWor-start==========================*/
    @Test
    public void testDelSensitiveWord01() {
        DFAUtils.clearSensitiveWord();
        LinkedList<String> listWords = null;
        DFAUtils.addSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("国");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(0, listWords.size());
    }

    @Test
    public void testDelSensitiveWord02() {
        DFAUtils.clearSensitiveWord();
        LinkedList<String> listWords = null;
        DFAUtils.addSensitiveWord("中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("中中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(0, listWords.size());
    }

    @Test
    public void testDelSensitiveWord03() {
        DFAUtils.clearSensitiveWord();
        LinkedList<String> listWords = null;
        DFAUtils.addSensitiveWord("中中");
        DFAUtils.addSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.delSensitiveWord("");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.delSensitiveWord("中中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.delSensitiveWord(" 中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.delSensitiveWord("中中 ");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.delSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(0, listWords.size());
        DFAUtils.addSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("中中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(1, listWords.size());
        DFAUtils.delSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(0, listWords.size());
    }

    @Test
    public void testDelSensitiveWord04() {
        DFAUtils.clearSensitiveWord();
        LinkedList<String> listWords = null;
        DFAUtils.addSensitiveWord("中中中111");
        DFAUtils.addSensitiveWord("中中");
        DFAUtils.addSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(3, listWords.size());
        DFAUtils.delSensitiveWord("");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(3, listWords.size());
        DFAUtils.delSensitiveWord("中中中111");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.addSensitiveWord("中中中111");
        DFAUtils.delSensitiveWord("中中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(3, listWords.size());
        DFAUtils.delSensitiveWord("中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.addSensitiveWord("中中 ");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(3, listWords.size());
        DFAUtils.delSensitiveWord("中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
        DFAUtils.delSensitiveWord("中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(2, listWords.size());
    }
    /*==========================DelSensitiveWor-end============================*/

    /*==========================ContainSensitiveWord-start==========================*/
    @Test
    public void testContainSensitiveWord01() {
        DFAUtils.clearSensitiveWord();
        LinkedList<String> listWords = null;
        DFAUtils.addSensitiveWord("滚");
        DFAUtils.addSensitiveWord("中中中国中中中");
        listWords = DFAUtils.getSevsitiveWords();
        Assert.assertEquals(7, listWords.size());
        Assert.assertEquals(false, DFAUtils.containSensitiveWord(" "));
        Assert.assertEquals(true, DFAUtils.containSensitiveWord("操"));
    }

    /*==========================ContainSensitiveWord-end============================*/
}
查看原文

赞 1 收藏 1 评论 1

zhuanzhudeyipi 发布了文章 · 2020-09-17

JAVA简单模拟DVD功能

建立数组



1.  public class DVD_set {
    
2.      //此处为copy
    
3.      String[] name = new String[50];// 存储DVD的名字
    
4.      String[] date = new String[50];// 当前DVD被借出的时间
    
5.      int[] state = new int[50];// 当前DVD的存取状态
    
6.      int[] count = new int[50];// 当前DVD被借出的次数
    
7.  }
    

基本函数实现
外汇MT4教程https://www.kaifx.cn/mt4.html



1.  import java.util.Scanner;
    

3.  public class DVD_main {
    

5.      DVD_set DVD = new DVD_set();
    
6.      //此处为copy
    
7.      public void initial() {
    
8.          DVD.name[0] = "罗马假日";
    
9.          DVD.state[0] = 0;
    
10.          DVD.count[0] = 30;
    
11.          DVD.date[0] = "2020-11-18";
    

13.          DVD.name[1] = "风声鹤唳";
    
14.          DVD.state[1] = 1;
    

16.          DVD.name[2] = "浪漫满屋";
    
17.          DVD.state[2] = 1;
    
18.          DVD.count[2] = 10;
    
19.      }
    

21.      public void startMenu() {
    

23.          Scanner sc = new Scanner(System.in);
    

25.          System.out.println("---------------------------");
    
26.          System.out.println("| Welcome to my DVD world |");
    
27.          System.out.println("|1----------------查 看DVD|");
    
28.          System.out.println("|2----------------新 增DVD|");
    
29.          System.out.println("|3----------------删 除DVD|");
    
30.          System.out.println("|4----------------借 出DVD|");
    
31.          System.out.println("|5----------------归 还DVD|");
    
32.          System.out.println("|0----------------退 出DVD|");
    
33.          System.out.println("---------------------------");
    

35.          System.out.printf("请选择:");
    

37.          int choose = sc.nextInt();
    

39.          switch (choose) {
    
40.          case 1:
    
41.              DVD_search();
    
42.              returnMenu();
    
43.              break;
    
44.          case 2:
    
45.              DVD_add();
    
46.              returnMenu();
    
47.              break;
    
48.          case 3:
    
49.              DVD_delete();
    
50.              returnMenu();
    
51.              break;
    
52.          case 4:
    
53.              DVD_lend();
    
54.              returnMenu();
    
55.              break;
    
56.          case 5:
    
57.              DVD_return();
    
58.              returnMenu();
    
59.              break;
    
60.          case 0:
    
61.              DVD_out();
    
62.              break;
    
63.          default:
    
64.              System.out.println("输入错误,请输入0返回主界面后重新输入");
    
65.              returnMenu();
    
66.              break;
    
67.          }
    
68.      }
    

70.      // 返回主界面
    
71.      public void returnMenu() {
    
72.          System.out.println("输入0返回主界面");
    
73.          Scanner sc = new Scanner(System.in);
    
74.          if (sc.nextInt() == 0) {
    
75.              startMenu();
    
76.          } else {
    
77.              System.out.println("输入错误,请重新输入");
    
78.              returnMenu();
    
79.          }
    
80.      }
    

82.      // 查看当前所有DVD的基本信息
    
83.      public void DVD_search() {
    
84.          System.out.println("-----------------------------------------------------------------");
    
85.          System.out.println("|" + "序号 t" + "|" + "名称tt" + "|" + "状态t" + "|" + "借出时间t" + "|" + "借出次数t" + "|");
    
86.          for (int i = 0; i < DVD.name.length; i++) {
    
87.              if (DVD.name[i] == null) {
    
88.                  break;
    
89.              } else if (DVD.state[i] == 0) {
    
90.                  System.out.println("|" + i + "t" + "|" + "<<" + DVD.name[i] + ">>t" + "|" + "已借出t" + "|"
    
91.                          + DVD.date[i] + "t" + "|" + DVD.count[i] + "tt" + "|");
    
92.              } else if (DVD.state[i] == 1) {
    
93.                  System.out.println("|" + i + "t" + "|" + "<<" + DVD.name[i] + ">>t" + "|" + "可借t" + "|" + "tt"
    
94.                          + "|" + DVD.count[i] + "tt" + "|");
    
95.              }
    
96.          }
    
97.          System.out.println("-----------------------------------------------------------------");
    
98.      }
    

100.      // 增加DVD
    
101.      public void DVD_add() {
    
102.          System.out.println("请输入您要添加的DVD:");
    
103.          Scanner sc = new Scanner(System.in);
    
104.          String name = sc.next();
    

106.          for (int i = 0; i < DVD.name.length; i++) {
    
107.              // 查找到当前数组中有空位的地方
    
108.              if (DVD.name[i] == null) {
    
109.                  // 将需要添加的DVD内容输入
    
110.                  DVD.name[i] = name;
    
111.                  // 赋初值,因为是刚添加的图书,所以状态为未借出
    
112.                  DVD.state[i] = 1;
    
113.                  System.out.println("《" + name + "》添加成功!");
    
114.                  break;
    
115.              }
    
116.          }
    
117.      }
    

119.      // 删除DVD
    
120.      public void DVD_delete() {
    
121.          System.out.println("请输入您要删除的DVD名称:");
    
122.          Scanner sc = new Scanner(System.in);
    
123.          String name = sc.next();
    

125.          for (int i = 0; i < DVD.name.length; i++) {
    
126.              // 循环查找当前库存中的DVD
    
127.              if (DVD.name[i] != null) {
    
128.                  // 当前库存中DVD不为空,当库存中DVD遍历完之后
    
129.                  if (DVD.name[i].equalsIgnoreCase(name)) {
    
130.                      // equalsIgnoreCase可以进行忽略大小写的字符串比较
    
131.                      // 判断库中所存的name是否和当前输入的name相同
    
132.                      if (DVD.state[i] == 0) {
    
133.                          // 判断DVD是否被借出
    
134.                          System.out.println("《" + name + "》" + "已经被借出!");
    
135.                          // 如果被借出则终止继续查找
    
136.                          break;
    
137.                      } else if (DVD.state[i] == 1) {
    
138.                          // 如果DVD没有被借出
    
139.                          for (int j = i; j < DVD.name.length; j++) {
    
140.                              // 如果被删除的DVD不是菜单中最后一个
    
141.                              if (DVD.name[j + 1] != null) {
    
142.                                  // 则将需要删除的DVD后面的内容挪动到前面
    
143.                                  DVD.name[j] = DVD.name[j + 1];
    
144.                                  DVD.state[j] = DVD.state[j + 1];
    
145.                                  DVD.date[j] = DVD.date[j + 1];
    
146.                                  DVD.count[j] = DVD.count[j + 1];
    
147.                              } else {
    
148.                                  // 如果当前需要删除的DVD是最后一个,则直接进行删除
    
149.                                  DVD.name[j] = null;
    
150.                                  DVD.date[j] = null;
    
151.                                  DVD.count[j] = 0;
    
152.                                  DVD.state[j] = 1;
    
153.                                  // 删除结束后退出循环
    
154.                                  break;
    
155.                              }
    
156.                          }
    
157.                      }
    
158.                      System.out.println("删除" + "《" + name + "》" + "成功");
    
159.                      // 删除成功则结束循环
    
160.                      break;
    
161.                  }
    
162.              } else {
    
163.                  // 遍历完整个库存都没有找到需要删除的DVD
    
164.                  System.out.println("没有找到您选择删除的DVD!");
    
165.              }
    
166.          }
    
167.      }
    

169.      // 借出DVD
    
170.      public void DVD_lend() {
    
171.          System.out.println("请输入您要借出的DVD名称:");
    
172.          Scanner sc = new Scanner(System.in);
    
173.          String name = sc.next();
    

175.          for (int i = 0; i < DVD.name.length; i++) {
    
176.              // 循环查找当前库存中的DVD
    
177.              if (DVD.name[i] != null) {
    
178.                  // 当前库存中DVD不为空,当库存中DVD遍历完之后
    
179.                  if (DVD.name[i].equalsIgnoreCase(name)) {
    
180.                      // equalsIgnoreCase可以进行忽略大小写的字符串比较
    
181.                      // 判断库中所存的name是否和当前输入的name相同
    
182.                      if (DVD.state[i] == 0) {
    
183.                          // 判断DVD是否被借出
    
184.                          System.out.println("《" + name + "》" + "已经被借出!");
    
185.                          // 如果被借出则终止继续查找
    
186.                          break;
    
187.                      } else if (DVD.state[i] == 1) {
    
188.                          // 如果DVD没有被借出
    
189.                          DVD.state[i] = 0;
    

191.                          System.out.println("请输入借阅日期:");
    
192.                          String date = sc.next();
    
193.                          DVD.date[i] = date;
    
194.                          DVD.count[i] += 1;
    
195.                          System.out.println("《" + name + "》" + "已成功借出!");
    
196.                          break;
    
197.                      }
    
198.                  }
    
199.              } else {
    
200.                  // 遍历完整个库存都没有找到需要删除的DVD
    
201.                  System.out.println("没有找到您选择借出的DVD!");
    
202.              }
    
203.          }
    
204.      }
    

206.      // 归还DVD
    
207.      public void DVD_return() {
    
208.          System.out.println("请输入您要归还的DVD名称:");
    
209.          Scanner sc = new Scanner(System.in);
    
210.          String name = sc.next();
    

212.          for (int i = 0; i < DVD.name.length; i++) {
    
213.              // 循环查找当前库存中的DVD
    
214.              if (DVD.name[i] != null) {
    
215.                  // 当前库存中DVD不为空,当库存中DVD遍历完之后
    
216.                  if (DVD.name[i].equalsIgnoreCase(name)) {
    
217.                      // equalsIgnoreCase可以进行忽略大小写的字符串比较
    
218.                      // 判断库中所存的name是否和当前输入的name相同
    
219.                      if (DVD.state[i] == 0) {
    
220.                          // 判断DVD是否被借出
    
221.                          DVD.state[i] = 1;
    
222.                          System.out.println("《" + name + "》" + "已经归还完毕!");
    
223.                          break;
    
224.                      }
    
225.                  }
    
226.              } else {
    
227.                  // 遍历完整个库存都没有找到需要删除的DVD
    
228.                  System.out.println("没有找到您选择归还的DVD!");
    
229.              }
    
230.          }
    
231.      }
    

233.      // 退出DVD管理系统
    
234.      public void DVD_out() {
    
235.          System.out.println("感谢您的使用,欢迎下次光临!");
    
236.      }
    
237.  }
    

程序简单运行



1.  import java.util.*;
    
2.  import java.text.*;
    

4.  public class DVD_demo {
    
5.      public static void main(String[] args) {
    

7.          DVD_main DVD = new DVD_main();
    

9.          DVD.initial();
    
10.          DVD.startMenu();
    
11.      }
    
12.  }
    

查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-15

Python中正则表达式模块详解

正则表达式

用来处理字符串,对字符串进行检索和替换,另外正则在python爬虫的应用也是相当广泛!

特点

  • 灵活性、逻辑性和功能性非常强
  • 可以迅速地用极简单的方式达到字符串的复杂控制

正则语法

`# 1、数字和字母都表示它本身, . 表示匹配除了换行以外的任意字符,    . 表示匹配 .
# 2、很多字母前面添加  会有特殊含义
    - n:换行
    - t:制表符
    - d: 匹配数字,等价[0-9]
    - D:非数字,等价于[^0-9]
    - w:表示数字、字母以及下划线,中文,等价于[0-9a-zA-Z_]
    - W:表示w取反
    - s:表示任意的非打印字符(空格、换行、制表符)
    - S:表示非空白字符
# 3、绝大多数标点都有特殊含义
    - ():用来表示一个分组,如果需要表示括号,需要使用 
    - []: 匹配范围,[0-9] 表示0~9范围中的一个,[0-9a-zA-Z]
    - |: 表示或者的意思 re.search(r'f(x|y|z)m','pdsfxm')   匹配fxm
    - {},{2,},{,3},{1,3}:用来限定前面元素出现的次数  re.search(r'go{2}d','good')
    - *: 表示前面的元素出现的次数为0次及以上,等价于{0,}
    - +: 表示前面的元素出现的次数为1次及以上,等价于{1,}
    - ^:以指定的内容开头,或者取反的意思
    - $:以指定的内容结尾
# 4、 ? 的两种用法
    - 规定前面元素出现的次数最多只能出现1次,等价于{,1}
    - 将贪婪模式转换为非贪婪模式(重点)` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19
*   20
*   21
*   22

re模块的介绍

XM返佣https://www.fx61.com/brokerli...

该模块是python中专门用于处理正则的默认,提供了相关的方法

常用方法

  • match、search 只查询一次
  • finditer 查找到所有的匹配数据放到一个可迭代对象中
  • findall 把查找到的所有字符串结果放到一个列表中
  • fullmatch 完全匹配,字符串需要满足正则表达式

Match类的使用

调用re.match,re.search或者对re.finditer的遍历返回的对象都是re.Match对象

Match类的属性和方法

  • pos、endpos 被查找字符串的起始和终端位置
  • span( ) 匹配到的下标位置(元组)
  • group 分组的概念
`import re

m = re.search(r'c.*z', 'abcdefgz')
print(m.pos)  # 0
print(m.endpos)  # 8
print(m.span())  # (2, 8)
# 使用group获取获取到匹配的字符串
print(m.group()) # cdefgz

# group表示正则表达式的分组
# 1、在正则表达式里使用()表示一个分组
# 2、如果没有分组,默认只有一组
# 3、分组的下标从0开始

# 这里有4个分组 
m1 = re.search(r'(1.*)(2.*)(3.*4)', 'a1bcd2efgh3ij4k')
print(m1.group())  # 默认就是第0组  1bcd2efgh3ij4
print(m1.group(0))  # 第0组就是把整个正则表达式当做一个整体  1bcd2efgh3ij4
print(m1.group(1))  # 1bcd
print(m1.group(2))  # 2efgh
print(m1.group(3))  # 3ij4

#  groups() 将分组以元组的形式返回
print(m1.groups())  # ('1bcd', '2efgh', '3ij4')

# (?P<name> 表达式) 给分组取个名字
m2 = re.search(r'(?P<one>1.*)(?P<two>2.*)(?P<three>3.*4)', 'a1bcd2efgh3ij4k')
print(m2.groupdict())  # {'one': '1bcd', 'two': '2efgh', 'three': '3ij4'}` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19
*   20
*   21
*   22
*   23
*   24
*   25
*   26
*   27
*   28

  • compile

    在re模块,可以使用re.方法调用函数,还可以调用re.compile得到一个对象
`import re

# 这两种写法没有区别
m = re.search(r'm.*a', '111m22222a')
print(m)  # <re.Match object; span=(3, 10), match='m22222a'>

m2 = re.compile(r'm.*a')
result = m2.search('111m22222a')
print(result) # <re.Match object; span=(3, 10), match='m22222a'>` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10

正则修饰符

正则修饰符是对表达式进行修饰
  • re.I 使匹配对大小写不敏感
  • re.M 多行匹配,影响 ^ 和$
  • re.S 使 . 匹配包括换行在内的所有字符
`import re

# . 表示除了换行以外的任意字符
x = re.search(r'm.*a', 'abcdmonxxxa')
print(x)  # None

# re.S 匹配换行
y = re.search(r'm.*a', 'abcdmonxxxa', re.S)  # 让 . 匹配换行
print(y)

a = re.search(r'x', 'helloXyz')
print(a)  # None
# re.I 忽略大小写
b = re.search(r'x', 'helloXyz', re.I)
print(b)  # <re.Match object; span=(5, 6), match='X'>

# re.M 让$ 匹配到换行
m = re.findall(r'w+$', 'i am boyn you are girln he is man')
print(m)  # ['man']
n = re.findall(r'w+$', 'i am boyn you are girln he is man', re.M)
print(n) # ['boy', 'girl', 'man']` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19
*   20
*   21
*   22
*   23

正则替换

sub
`import re

# 把数字替换成x
m = re.sub(r'd', 'x', 'hello123wor123ld')
print(m)  # helloxxxworxxxld

n = re.sub(r'd+', 'x', 'hello123wor123ld')
print(n) # helloxworxld

# 需求:将p中内容的数字乘2
p = 'hello50good34'
def test(x):
    y = int(x.group(0))
    y *= 2
    return str(y)  # 这里只能以字符串的形式返回

print(re.sub(r'd+', test, p)) # hello100good68` 

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19

贪婪模式与非贪婪模式

在正则表达式里,默认采用的是贪婪模式,尽可能匹配多的字符串

在贪婪模式后面添加?,可将贪婪模式转化为非贪婪模式

import re

m = re.search(r'm.*a', 'abcm123a456a')
print(m)  # m123a456a,这里为什么不是m123a呢?因为这里默认使用的贪婪模式
n = re.search(r'm.*?a', 'abcm123a456a')
print(n)  # m123a    使用?将贪婪模式转化为非贪婪模式

# ?
print(re.match(r'aa(d+)', 'aa123bb456').group(1))  # 123
print(re.match(r'aa(d+?)', 'aa123bb456').group(1))  # 1
print(re.match(r'aa(d+?)', 'aa123bb456').group(0))  # aa1

# 虽然说是尽可能少的匹配,但也要满足匹配呀
print(re.match(r'aaa(d+)ddd', 'aaa2333ddd').group(0))  # aaa2333ddd
print(re.match(r'aaa(d+?)ddd', 'aaa2333ddd').group(1))  # 2333

print(re.match(r'aaa(d+).*', 'aaa2333ddd').group(0))  # aaa2333ddd
print(re.match(r'aaa(d+?).*', 'aaa2333ddd').group(1))  # 2
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-15

Python函数

函数

作用:最大化代码重用,最小化代码冗余,过程分解(方便维护)

一、函数的定义

  • 函数定义后不会被执行,只有被调用的函数才会被执行
  • 函数名称只能是由字母、数字、下划线组成,其不能以数字开头
`# 格式:
def 函数名(形参,....):  # 可不设置形式参数
    函数体
    
# 例1:加法函数
def add(a,b):
    c = a+b
    print("加法结果:",c)   # 拓展:print(add) 输出结果为方法 add函数的储存空间位置
    
# 例2:减法函数
def sub(a,b):
    c = a-b
    print("减法结果:",c)` 

二、函数的调用

`# 格式:
函数名(输入实际参数值....)

# 例:调用加法函数
add(2,1)` 

三、函数的返回(return)

`# 格式:
def 函数名():
    函数体
    return  "返回值"

# 例:
def  add(a,b):
    c = a+b
    print(c)
    return   c   # 返回值,哪个调用就给哪个返回c

sum = add(1,2)   # 调用函数
print("sum = " , sum)` 

智汇代理申请https://www.kaifx.cn/broker/thinkmarkets.html
  • 注意:

    • 当函数执行到return的时候,就会马上终止函数执行
    • 函数中可以出现多个return,但有且只有一个return会被执行
    • return 后面可以不跟值,return 单独使用等价于return None

四、变量作用域

  • 作用域范围:Built_in > Global > Enclousure > Local
  • 作用范围采用就近原则

1.python内置函数变量Built_in:

`def len():
    print("我自己定义的方法")
    
len("abcdef")  # 输出结果报错,并不是执行python的内置函数len()计算长度

# 自己定义的len()函数覆盖python的内置函数len()` 

2.全局变量Global:

  • 在函数外部定义的变量,全局指的是该变量在当前python文件范围内是可见的,全局变量可以被当前python文件内所有函数直接使用。
  • 局部变量的优先级大于全局变量(变量就近原则)
`# 例:
a = 10             # 全局变量,全局变量作用域是所有地方
c = 20
def test1():
    a=20           # 函数局部变量只能在自己的函数内使用
    print(a)

test1()       # 输出结果 : 20 
print(a)      # 输出结果 : 10` 


3.封装变量Enclousure:

`def func1():
    x=100
    def nested1():
        x=99
        print(x)
    nested1()
    print(x)
        
func1()
#输出结果:
# 99
# 100

# 修改封装变量:nonlocal
def func2():
    x=100
    def nested2():
        nonlocal x
        x=99
        print(x)
    nested2()
    print(x)
      
func()

#输出结果:
# 99
# 99` 

4.局部变量Local:

  • 在函数内部定义的变量,该变量只能在定义的函数内部使用
  • 全局变量能够同时作用于函数内外,如果想要在函数内部给一个定义在函数外的变量赋值,那么这个变量就不能是局部的,其作用域必须为全局的,可以通过global来定义。
  • 函数内定义全局变量: global 命令
`a=1
def test1():
    global  a       # 定义函数内的全局变量,
    a=10           # 函数内全局变量定义格式:先定义,再赋值,不可写成一行,否则报错
    print(a)
    
#调用函数后,全局变量才能起作用
print(a)
test1()                                    
print("在函数外调用test1函数的全局变量:",a)   # 输出结果:在函数外调用test1函数的全局变量:10

#输出结果:
#1在这里插入代码片
#10
#10` 



  • 一个变量已在函数外定义,如果在函数内需要为这个变量赋值,并要将这个赋值结果反映到函数外,可以在函数内用global声明这个变量,将其定义为全局变量。
  • 在函数内部直接将一个变量声明为全局变量,在函数外没有声明,在调用这个函数之后,将增加为新的全局变量。

五、参数

`def func(a,b,c):  # 形参a、b、c
    print(a,b,c)

func(1,2,3)       # 实参1、2、3` 


1. 必备参数(位置匹配)

  • 必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

    `def sub(a,b):
        c = a-b
        print("减法结果:",c)
    
    sub(1,2)    # 按形参顺序传值   a=1  b=2 输出结果:-1` 
    
    
    
    

2. 关键字参数

  • 关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
  • 使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值

    `def sub(a,b):
        c =a-b
        print(c)
    
    sub(b=2,a=1)    # 输出结果:-1 
    #b=2,a=1  关键字参数
    #关键字传值与顺序无关` 
    
    
    
    
  • 注意:调用函数时既传递位置参数又传递关键字参数时,位置参数要在关键字参数前面如: add(200,300,400,num5=100)

3. 默认参数(调用时省略传值)

  • 调用函数时,默认参数的值如果没有传入,则被认为是默认值
  • 格式:

    `def 函数名(... , ... , 形参名=默认值):
        函数体` 
    
    
    
  • 注意:默认值参数必须出现在函数参数列表最右端,且任何一个默认参数右边不能有非默认参数
  • 例:

    `def func2(a,b=2,c=3):
        print(a,b,c)
    
    func(1)      #输出结果:1 2 3
    func(1,2)    #输出结果:1 2 3
    func(1,c=5)  #输出结果:1 2 5` 
    
    

默认值参数必须出现在函数参数列表的最右端,如果某一个位置的形参设置了默认参数,那么该位置之后的所有参数都必须设置为默认参数

4. 不定长参数(定义函数时,定义可接收多实参数据的形参)

需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数

定义一个可以接收任意数量参数的函数时需使用不定长参数: *args**kwargs

4.1 *args

  • *args用来接收多个实参并将其放在一个元组中;
  • *args表示多参数传值,*号为关键格式,后面名称可随意改

    `# 例1:
    # 定义计算2门学科求平均成绩的方法
    def avg(score1,score2):
        return(score1+score2)/2
    
    # 定义计算n门学科求平均成绩的方法
    def avg(*scores): #定义形参时,形参前加*号,表示可接收任意数量实参并将其置于一个元组中
        return sum(scores)/len(scores)  # 使用该形参时前面不需要加*号
    
    result = avg(98.2,88.1,70,65)
    print(result)    # 输出80.325
    
    scores=(88,89,90)
    result2 = avg(*scores)  # scores变量前必须加*解包,表示将元组各个元素分离出来,不然报错
    print(result2)
    
    # 例2:
    def test1(*args):       # 形参格式为:* + 形参名
        print(args)         # 输出多个参数的元组数据类型
    
    # 调用函数,不能关键字传值:
    test1(1,2,3,"xzh",18)     
    # 输出元组数据类型: 
    (1,2,3,"xzh",18)` 
    
    
    
    

4.2 **kwargs

  • **kwargs接收类似关键参数一样显示赋值形式的多个实参并将其放入字典
  • **kwargs 表示多参数传值,**号为关键格式,后面名称可随意改

    `# 例1:
    def display(**employee):
        print(employee)
        
    emp={'name':'Tom','age':22,'job':'dev'}
    
    display(name='Tom', age=22, job='dev')  
    #输出结果:{name:'Tom',age:22, job:'dev'}
    
    display(**emp)   #输出结果:{'job':'dev','name':'Tom','age':22}   必须加**解包
    
    # 例2:
    def test2(**kwargs):    # 形参格式为:** + 形参名
        print(kwargs)       # 输出多个参数的字典数据类型
    
    # 调用函数,只能关键字传值:
    test2(name="Tom" , age=18 ,height=188.8)
    # 输出字典数据类型:
    {"name" : "Tom" ,  "age" : 18 , "height" : 188.8}` 
    
    
    
    

总结:

  • 单个*号表示使用元组传值,以元组形式传入的实参数不定
  • **号表示使用字典传值,以字典形式传入的实参数不定

5、普通参数和不定长数参的混合使用

`# 例:
def test3(a,b,*args):
    print("输出a和b:" ,a,b)
    print("输出可变长度参数:" , args)

# 调用函数:
test3(1,2,3,4)

# 输出结果:
输出a和b:1 2
输出可变长度参数:(3,4)` 


六、lambda表达式(匿名函数)

主要用于编写简单逻辑的函数

  • lambda表达式可以用来声明匿名函数,即没有函数名字的临时使用的小函数。
  • lambda是一种以表达式形式生成函数的方法,和def语句类似用于创建一个函数。
  • def常用来设计功能复杂的一般性函数,而lambda用于简单的函数,以适应更灵活的应用,也被称为函数功能速写。
  • lambda定义的函数没有函数名,生成的是一个表达式形式的无名函数,表达式的结果是lambda的返回值。
  • lambda函数要传递给一个变量才可使用。

基本格式:

`lambda 参数1,…,参数n : 函数体 
# 例: 
add = lambda  a,b,c:a+b+c 
add(1,2,3)
# 若不需传参
f=lambda :pritn('hello')
f()` 


例:

`def hello(name):    
    prtin(name) 
    
def add(x,y):    
    return x+y               

f= lambda name: print(name)     # 等价于没有函数名的hello()函数 
f2=lambda x,y : x+y             # 等价于没有函数名的add()函数 
f('Tom')   # 输出结果:打印出Tom 
print(f2(5,3))  # 输出结果:8` 



七、函数的委托(函数别名)

`def add(x,y):
    return x+y

a = add  # 把函数当作对象传递给变量时注意不要加(),因为“函数名后+()”表示调用该函数

print(a(2,3))  # 该委托函数执行方法:a(),也就是a()相当于add()这个函数

#输出结果:5

def hello_chinese(name):
    print('你好',name)
    
hello = hello_chinese
hello('Tom')

hello = lanbda name:pritn('こんにちは', name)
hello('Tom')` 


*   17

八、将函数作为另一函数的参数进行传递

`#例1
def hello_chinese(name):
    print('您好:', name)

def hello_english(name):
    print('Hello', name)
    
def hello_japanese(name):
    print('こんにちは', name)
    
def hello(action,name):
    action(name)
    
hello(hello_chinese,"Tom")
hello(lambda name : print('Прывітанне!',name),"Tom")

#例2
l = list(range(1,21))
def add(x):
    return x+5
#将列表l中所有元素加5
result = list(map(add,l))
result = list(lambda x:x=5,l)` 



九、实际应用

例:实现选择不同语言打招呼

`# def hello_chinese(name):
#     print('您好:', name)

# def hello_english(name):
#     print('Hello', name)
    
# 初级写法 
# while True:
#     name = input("请输入名称:n")
#     if name == 'stop':
#         break
#     language = input('请选择语言:n  c=> 中文版n e=>英文版n j=>日文版n')
# 
#     if language == 'c':
#         hello_chinese(name)
#     elif language == 'e':
#         hello_english(name)
#     elif language == 'j':
#         (lambda name: print('こんにちは', name))(name)

# 中级写法 
# while True:
#     name = input("请输入名称:n")
#     if name == 'stop':
#         break
#     language = input('请选择语言:n  c=> 中文版n e=>英文版n j=>日文版n')
# 
#     if language == 'c':
#         action = hello_chinese
#     elif language == 'e':
#         action = hello_english
#     elif language == 'j':
#         action = lambda name: print('こんにちは', name)
#     action(name)  # 实现选择不同语言换对应的函数

#大神级写法
def hello_chinese(name):
    print('您好:', name)

def hello_english(name):
    print('Hello', name)
    
def hello_japanese(name):
    print('こんにちは', name)
       
operation{
    'e':hello_english,
    'c':hello_chinese,
    'j':hello_japanese,
    'r':lambda name : print('Прывітанне!',name)
}
    
while True:
    name = input("请输入名称:n")
    if name == 'stop':
        break
    language = input('请选择语言:n c=>中文版n e=>英文版n j=>日文版n r=>俄语版n')
    #operation.get(language)(name)  #若找不到key值则返回None,相当于None(name)会报错
    operation.get(language,hello_chinese)(name)  # 设默认值为hello_chinese 防止报错` 



十、函数的高级工具

1、map()函数

格式:

`map(函数,可迭代的对象)
# map()返回的结果是一个map类型` 

*   1
*   2

  • map()函数,顾名思义,用于映射,把一个序列的每一个元素映射到函数中,然后返回一个迭代对象。

例:

`l = list(range(1,21))  # 生成1到20的列表l

result = []

# 将列表l中所有偶数放入列表result中
#方法1:使用循环
for n in l:
    if n % 2 == 0:
        result.append(n)
pritn(result)

#方法2:使用推导(实际开发过程中建议使用推导)
result = [x for x in l if x % 2 == 0]
pritn(result)

#将列表l中所有元素加5
#方法1:使用循环
for n in l:
    result.append(n+5)
pritn(result)

#方法2:使用推导
result =[x+5 for x in l]

#方法3:map()
def add(x):
    return x+5

result = list(map(add,l))
#或写成如下:
result = list(map(lambda n:n+5, l))` 



2、filter()函数

格式:

`filter(函数,可迭代对象)` 

*   1

  • filter()函数,顾名思义,用于过滤,把一个序列的每个元素映射到函数中,返回结果为True的元素。

例:

l = list(range(1,11))

def even_number(x):
    return x%2 == 0

res = list(filter(even_number,l))
# 或写成
res = list(filter(lambda x: x % 2== 0, l)) # 只留下能被2整除的元素
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-10

java 身份证合法性校验工具类

1.身份证规则

计算方法(来源百度)

  1. 将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为:7-9-10-5-8-4-2-1-6-3-7-9-10-5-8-4-2。
  2. 将这17位数字和系数相乘的结果相加。
  3. 用加出来和除以11,看余数是多少?
  4. 余数只可能有0-1-2-3-4-5-6-7-8-9-10这11个数字。其分别对应的最后一位身份证的号码为1-0-X -9-8-7-6-5-4-3-2。(即余数0对应1,余数1对应0,余数2对应X…)
  5. 通过上面得知如果余数是3,就会在身份证的第18位数字上出现的是9。如果对应的数字是2,身份证的最后一位号码就是罗马数字x。

例如: 某男性的身份证号码为【53010219200508011x】, 我们看看这个身份证是不是合法的身份证。

首先我们得出前17位的乘积和【(5_7)+(3_9)+(0_10)+(1_5)+(0_8)+(2_4)+(1_2)+(9_1)+(2_6)+(0_3)+(0_7)+(5_9)+(0_10)+(8_5)+(0_8)+(1_4)+(1*2)】是189,然后用189除以11得出的结果是189/11=17----2,也就是说其余数是2。最后通过对应规则就可以知道余数2对应的检验码是X。所以,可以判定这是一个正确的身份证号码。

  1. 代码逻辑

本工具类提供了3种类型校验:

  1. 18位身份证号码校验
  2. 15位身份证号码校验(方法验证不准确)
  3. 15位转18位 身份证号码校验

18位身份证号合法性:

  • 根据〖中华人民共和国国家标准GB11643-1999〗中有关公民身份号码的规定,公民身份号码是特征组合码,由十七位数字本体码和一位数字校验码组成。
  • 排列顺序从左至右依次为:六位数字地址码,八位数字出生日期码,三位数字顺序码和一位数字校验码。
  • 顺序码: 表示在同一地址码所标识的区域范围内,对同年、同月、同 日出生的人编定的顺序号,顺序码的奇数分配给男性,偶数分配 给女性。
  • 前1、2位数字表示:所在省份的代码; 2.第3、4位数字表示:所在城市的代码; 3.第5、6位数字表示:所在区县的代码;
  • 第7~14位数字表示:出生年、月、日; 5.第15、16位数字表示:所在地的派出所的代码;
  • 第17位数字表示性别:奇数表示男性,偶数表示女性;
  • 第18位数字是校检码:也有的说是个人信息码,一般是随计算机的随机产生,用来检验身份证的正确性。校检码可以是0~9的数字,有时也用x表示。

外汇IB https://www.fx61.com/ib.html

3.代码

此工具类可以直接拷贝使用 并且提供了 main方法进行测试
/**  
 *         <p>  
 *         类说明:身份证合法性校验  
 *         </p>  
 *         <p>  
 *         --15位身份证号码:第7、8位为出生年份(两位数),第9、10位为出生月份,第11、12位代表出生日期,第15位代表性别,奇数为男,偶数为女。  
 *         --18位身份证号码:第7、8、9、10位为出生年份(四位数),第11、第12位为出生月份,第13、14位代表出生日期,第17位代表性别,奇数为男,偶数为女。  
 *         </p>  
 */  
 /**
 * @Description:   身份证校验工具类
 * @author: xuxinku
 * @Date: 2020/9/07 10:55
 * @ModifiedDate:
 * @Copyright:xx保险股份有限公司
 */
@SuppressWarnings({"unchecked","unused","all"})   
public class IdcardValidator {   
  
    /**  
     * 省,直辖市代码表: { 11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",  
     * 21:"辽宁",22:"吉林",23:"黑龙江",31:"上海",32:"江苏",  
     * 33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",  
     * 42:"湖北",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",  
     * 51:"四川",52:"贵州",53:"云南",54:"西藏",61:"陕西",62:"甘肃",  
     * 63:"青海",64:"宁夏",65:"新疆",71:"台湾",81:"香港",82:"澳门",91:"国外"}  
     */  
    protected String codeAndCity[][] = { { "11", "北京" }, { "12", "天津" },   
            { "13", "河北" }, { "14", "山西" }, { "15", "内蒙古" }, { "21", "辽宁" },   
            { "22", "吉林" }, { "23", "黑龙江" }, { "31", "上海" }, { "32", "江苏" },   
            { "33", "浙江" }, { "34", "安徽" }, { "35", "福建" }, { "36", "江西" },   
            { "37", "山东" }, { "41", "河南" }, { "42", "湖北" }, { "43", "湖南" },   
            { "44", "广东" }, { "45", "广西" }, { "46", "海南" }, { "50", "重庆" },   
            { "51", "四川" }, { "52", "贵州" }, { "53", "云南" }, { "54", "西藏" },   
            { "61", "陕西" }, { "62", "甘肃" }, { "63", "青海" }, { "64", "宁夏" },   
            { "65", "新疆" }, { "71", "台湾" }, { "81", "香港" }, { "82", "澳门" },   
            { "91", "国外" } };   
  
        private String cityCode[] = { "11", "12", "13", "14", "15", "21", "22",   
            "23", "31", "32", "33", "34", "35", "36", "37", "41", "42", "43",   
            "44", "45", "46", "50", "51", "52", "53", "54", "61", "62", "63",   
            "64", "65", "71", "81", "82", "91" };   
  
    // 每位加权因子 
    private int power[] = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };   
  
    // 第18位校检码 
    private String verifyCode[] = { "1", "0", "X", "9", "8", "7", "6", "5",   
            "4", "3", "2" };   
  
       
    /**  
     * 验证所有的身份证的合法性  
     * @param idcard  
     * @return  
     */  
    public boolean isValidatedAllIdcard(String idcard) {   
        if (idcard.length() == 15) {   
            idcard = this.convertIdcarBy15bit(idcard);   
        }   
        return this.isValidate18Idcard(idcard);   
    }   
  
    /**  
     * <p>  
     * 判断18位身份证的合法性  
     * </p>  
     * 根据〖中华人民共和国国家标准GB11643-1999〗中有关公民身份号码的规定,公民身份号码是特征组合码,由十七位数字本体码和一位数字校验码组成。  
     * 排列顺序从左至右依次为:六位数字地址码,八位数字出生日期码,三位数字顺序码和一位数字校验码。  
     * <p>  
     * 顺序码: 表示在同一地址码所标识的区域范围内,对同年、同月、同 日出生的人编定的顺序号,顺序码的奇数分配给男性,偶数分配 给女性。  
     * </p>  
     * <p>  
     * 1.前1、2位数字表示:所在省份的代码; 2.第3、4位数字表示:所在城市的代码; 3.第5、6位数字表示:所在区县的代码;  
     * 4.第7~14位数字表示:出生年、月、日; 5.第15、16位数字表示:所在地的派出所的代码;  
     * 6.第17位数字表示性别:奇数表示男性,偶数表示女性;  
     * 7.第18位数字是校检码:也有的说是个人信息码,一般是随计算机的随机产生,用来检验身份证的正确性。校检码可以是0~9的数字,有时也用x表示。  
     * </p>  
     * <p>  
     * 第十八位数字(校验码)的计算方法为: 1.将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为:7 9 10 5 8 4  
     * 2 1 6 3 7 9 10 5 8 4 2  
     * </p>  
     * <p>  
     * 2.将这17位数字和系数相乘的结果相加。  
     * </p>  
     * <p>  
     * 3.用加出来和除以11,看余数是多少?  
     * </p>  
     * 4.余数只可能有0 1 2 3 4 5 6 7 8 9 10这11个数字。其分别对应的最后一位身份证的号码为1 0 X 9 8 7 6 5 4 3  
     * 2。  
     * <p>  
     * 5.通过上面得知如果余数是2,就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10,身份证的最后一位号码就是2。  
     * </p>  
     *   
     * @param idcard  
     * @return  
     */  
    public boolean isValidate18Idcard(String idcard) {   
        // 非18位为假 
        if (idcard.length() != 18) {   
            return false;   
        }   
        // 获取前17位 
        String idcard17 = idcard.substring(0, 17);   
        // 获取第18位 
        String idcard18Code = idcard.substring(17, 18);   
        char c[] = null;   
        String checkCode = "";   
        // 是否都为数字 
        if (isDigital(idcard17)) {   
            c = idcard17.toCharArray();   
        } else {   
            return false;   
        }   
  
        if (null != c) {   
            int bit[] = new int[idcard17.length()];   
  
            bit = converCharToInt(c);   
  
            int sum17 = 0;   
  
            sum17 = getPowerSum(bit);   
  
            // 将和值与11取模得到余数进行校验码判断 
            checkCode = getCheckCodeBySum(sum17);   
            if (null == checkCode) {   
                return false;   
            }   
            // 将身份证的第18位与算出来的校码进行匹配,不相等就为假 
            if (!idcard18Code.equalsIgnoreCase(checkCode)) {   
                return false;   
            }   
        }   
        return true;   
    }   
  
    /**  
     * 验证15位身份证的合法性,该方法验证不准确,最好是将15转为18位后再判断,该类中已提供。  
     *   
     * @param idcard  
     * @return  
     */  
    public boolean isValidate15Idcard(String idcard) {   
        // 非15位为假 
        if (idcard.length() != 15) {   
            return false;   
        }   
  
        // 是否全都为数字 
        if (isDigital(idcard)) {   
            String provinceid = idcard.substring(0, 2);   
            String birthday = idcard.substring(6, 12);   
            int year = Integer.parseInt(idcard.substring(6, 8));   
            int month = Integer.parseInt(idcard.substring(8, 10));   
            int day = Integer.parseInt(idcard.substring(10, 12));   
  
            // 判断是否为合法的省份 
            boolean flag = false;   
            for (String id : cityCode) {   
                if (id.equals(provinceid)) {   
                    flag = true;   
                    break;   
                }   
            }   
            if (!flag) {   
                return false;   
            }   
            // 该身份证生出日期在当前日期之后时为假 
            Date birthdate = null;   
            try {   
                birthdate = new SimpleDateFormat("yyMMdd").parse(birthday);   
            } catch (ParseException e) {   
                e.printStackTrace();   
            }   
            if (birthdate == null || new Date().before(birthdate)) {   
                return false;   
            }   
  
            // 判断是否为合法的年份 
            GregorianCalendar curDay = new GregorianCalendar();   
            int curYear = curDay.get(Calendar.YEAR);   
            int year2bit = Integer.parseInt(String.valueOf(curYear)   
                    .substring(2));   
  
            // 判断该年份的两位表示法,小于50的和大于当前年份的,为假 
            if ((year < 50 && year > year2bit)) {   
                return false;   
            }   
  
            // 判断是否为合法的月份 
            if (month < 1 || month > 12) {   
                return false;   
            }   
  
            // 判断是否为合法的日期 
            boolean mflag = false;   
            curDay.setTime(birthdate);  //将该身份证的出生日期赋于对象curDay 
            switch (month) {   
            case 1:   
            case 3:   
            case 5:   
            case 7:   
            case 8:   
            case 10:   
            case 12:   
                mflag = (day >= 1 && day <= 31);   
                break;   
            case 2: //公历的2月非闰年有28天,闰年的2月是29天。 
                if (curDay.isLeapYear(curDay.get(Calendar.YEAR))) {   
                    mflag = (day >= 1 && day <= 29);   
                } else {   
                    mflag = (day >= 1 && day <= 28);   
                }   
                break;   
            case 4:   
            case 6:   
            case 9:   
            case 11:   
                mflag = (day >= 1 && day <= 30);   
                break;   
            }   
            if (!mflag) {   
                return false;   
            }   
        } else {   
            return false;   
        }   
        return true;   
    }   
  
    /**  
     * 将15位的身份证转成18位身份证  
     *   
     * @param idcard  
     * @return  
     */  
    public String convertIdcarBy15bit(String idcard) {   
        String idcard17 = null;   
        // 非15位身份证 
        if (idcard.length() != 15) {   
            return null;   
        }   
  
        if (isDigital(idcard)) {   
            // 获取出生年月日 
            String birthday = idcard.substring(6, 12);   
            Date birthdate = null;   
            try {   
                birthdate = new SimpleDateFormat("yyMMdd").parse(birthday);   
            } catch (ParseException e) {   
                e.printStackTrace();   
            }   
            Calendar cday = Calendar.getInstance();   
            cday.setTime(birthdate);   
            String year = String.valueOf(cday.get(Calendar.YEAR));   
  
            idcard17 = idcard.substring(0, 6) + year + idcard.substring(8);   
  
            char c[] = idcard17.toCharArray();   
            String checkCode = "";   
  
            if (null != c) {   
                int bit[] = new int[idcard17.length()];   
  
                // 将字符数组转为整型数组 
                bit = converCharToInt(c);   
                int sum17 = 0;   
                sum17 = getPowerSum(bit);   
  
                // 获取和值与11取模得到余数进行校验码 
                checkCode = getCheckCodeBySum(sum17);   
                // 获取不到校验位 
                if (null == checkCode) {   
                    return null;   
                }   
  
                // 将前17位与第18位校验码拼接 
                idcard17 += checkCode;   
            }   
        } else { // 身份证包含数字 
            return null;   
        }   
        return idcard17;   
    }   
  
    /**  
     * 15位和18位身份证号码的基本数字和位数验校  
     *   
     * @param idcard  
     * @return  
     */  
    public boolean isIdcard(String idcard) {   
        return idcard == null || "".equals(idcard) ? false : Pattern.matches(   
                "(^d{15}$)|(d{17}(?:d|x|X)$)", idcard);   
    }   
  
    /**  
     * 15位身份证号码的基本数字和位数验校  
     *   
     * @param idcard  
     * @return  
     */  
    public boolean is15Idcard(String idcard) {   
        return idcard == null || "".equals(idcard) ? false : Pattern.matches(   
                "^[1-9]d{7}((0d)|(1[0-2]))(([0|1|2]d)|3[0-1])d{3}$",   
                idcard);   
    }   
  
    /**  
     * 18位身份证号码的基本数字和位数验校  
     *   
     * @param idcard  
     * @return  
     */  
    public boolean is18Idcard(String idcard) {   
        return Pattern   
                .matches(   
                        "^[1-9]d{5}[1-9]d{3}((0d)|(1[0-2]))(([0|1|2]d)|3[0-1])d{3}([d|x|X]{1})$",   
                        idcard);   
    }   
  
    /**  
     * 数字验证  
     *   
     * @param str  
     * @return  
     */  
    public boolean isDigital(String str) {   
        return str == null || "".equals(str) ? false : str.matches("^[0-9]*$");   
    }   
  
    /**  
     * 将身份证的每位和对应位的加权因子相乘之后,再得到和值  
     *   
     * @param bit  
     * @return  
     */  
    public int getPowerSum(int[] bit) {   
  
        int sum = 0;   
  
        if (power.length != bit.length) {   
            return sum;   
        }   
  
        for (int i = 0; i < bit.length; i++) {   
            for (int j = 0; j < power.length; j++) {   
                if (i == j) {   
                    sum = sum + bit[i] * power[j];   
                }   
            }   
        }   
        return sum;   
    }   
  
    /**  
     * 将和值与11取模得到余数进行校验码判断  
     *   
     * @param checkCode  
     * @param sum17  
     * @return 校验位  
     */  
    public String getCheckCodeBySum(int sum17) {   
        String checkCode = null;   
        switch (sum17 % 11) {   
        case 10:   
            checkCode = "2";   
            break;   
        case 9:   
            checkCode = "3";   
            break;   
        case 8:   
            checkCode = "4";   
            break;   
        case 7:   
            checkCode = "5";   
            break;   
        case 6:   
            checkCode = "6";   
            break;   
        case 5:   
            checkCode = "7";   
            break;   
        case 4:   
            checkCode = "8";   
            break;   
        case 3:   
            checkCode = "9";   
            break;   
        case 2:   
            checkCode = "x";   
            break;   
        case 1:   
            checkCode = "0";   
            break;   
        case 0:   
            checkCode = "1";   
            break;   
        }   
        return checkCode;   
    }   
  
    /**  
     * 将字符数组转为整型数组  
     *   
     * @param c  
     * @return  
     * @throws NumberFormatException  
     */  
    public int[] converCharToInt(char[] c) throws NumberFormatException {   
        int[] a = new int[c.length];   
        int k = 0;   
        for (char temp : c) {   
            a[k++] = Integer.parseInt(String.valueOf(temp));   
        }   
        return a;   
    }   
  
    public static void main(String[] args) throws Exception {   
                  String idcard15 = "130503670401001";
                  String idcard18 = "321321198810113333";
                  String idcard = "130503670401001";
        IdcardValidator iv = new IdcardValidator();   
        boolean flag = false;   
        flag = iv.isValidate18Idcard(idcard18);   
        System.out.println("18位身份证号校验"+flag);
  
        flag = iv.isValidate15Idcard(idcard15);
        System.out.println("15位身份证号校验"+ flag);

        System.out.println("15位转18位身份证号" + iv.convertIdcarBy15bit(idcard15));
        flag = iv.isValidate18Idcard(iv.convertIdcarBy15bit(idcard15));
        System.out.println("15位转18位身份证号校验" + flag);
  
        System.out.println(" 验证所有的身份证的合法性" + iv.isValidatedAllIdcard(idcard));
           
        }   
} 
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-10

QQ登录界面实现

Java实现QQ登录界面
QQ登录界面也是界面的一种,在实现界面时我们需要一些界面开发包,如:
package – 一个项目中给代码分类
系统库:
java.awt – 早期的界面开发包 保留使用元素类
javax.swing – 升级之后的界面开发包 – 可视化组件
那么在设置界面的时候我们需要有以下步骤

  1. 创建一个窗体对象
  2. 设置属性
  3. 设置组件摆放的布局管理器
  4. 加组件

亨达返佣https://www.fx61.com/brokerli...

`public class LoginUI {
    
    public static void main (String[] args) {
        LoginUI loginui=new LoginUI();
        loginui.initUI();
    
    }

     //创建一个窗体类对象
     public void initUI() {
     JFrame jf = new JFrame();
     //设置窗体属性
     jf.setTitle("QQ登录");
     jf.setSize(500,500);// 宽 高   单位:像素 
     jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 关闭时退出程序
     jf.setLocationRelativeTo(null);// 居中显示 
       // 设置布局管理器(流式布局) 
            FlowLayout fl = new FlowLayout();
            jf.setLayout(fl);
        //加组件 
            // 图片 - 标签 
            ImageIcon img = new ImageIcon("C:Users86189PicturesSaved PicturesQQ音乐1.jpg");
            JLabel imgjla = new JLabel(img);
            
            
            //文字 标签
            JLabel namejla = new JLabel("账号:");
            JLabel pwdjla = new JLabel("密码:");
            
            // 输入框 
            JTextField nameField = new JTextField();
            JPasswordField pwdField = new JPasswordField();
            
            // 按钮 
            JButton btn = new JButton("登录");
            JButton btn1 = new JButton("注册");
            //设置组件对象的属性
            btn.setBackground(Color.white);
            // 尺寸
            Dimension dim = new Dimension(400,30);
            nameField.setPreferredSize(dim);
            pwdField.setPreferredSize(dim);
            
            //加载到窗体上
            
            
            jf.add(imgjla);
            jf.add(namejla);
            jf.add(nameField);
            jf.add(pwdjla);
            jf.add(pwdField);
            
            jf.add(btn);
            jf.add(btn1);
            
            jf.setVisible(true);// 可视化 将窗体显示在屏幕上  需要放在所有组件加载之后 
}
}` 



根据图中的代码我们的简单QQ界面登录就完成了,之后我们可以考虑在啊账号密码的输入框中填写信息,然后验证,这时我们需要用到监听器,接口  
接口 关键字:erface - - 方法的抽象

`1、接口中不能创建带方法体的方法
2、接口中不能创建变量 -- 可以声明常量

3、实现接口 
    创建一个类来实现接口 
    格式: public class 类名 implements 接口名{   }
    必须在类中实现接口里所有的抽象方法  
    这个类的对象也可以作为接口类型的参数来使用 
    并且调用的是实现之后的方法` 


了解接口之后,我们只需要在btn按钮处加入监听器即可

 `//创建实现了监听器接口的类的对象 
            
            LoginUIListener loginlistener = new LoginUIListener();
            // 按钮添加监听器
            btn.addActionListener(loginlistener);
            btn1.addActionListener(loginlistener);
            // 将输入框对象 传入监听器中
            loginlistener.nameField = nameField;
            loginlistener.pwdField = pwdField;` 



加入监听器我们需要创建另外一个类来实现我们所需要的接口

`public class LoginUIListener implements ActionListener{

JTextField nameField=null;
JPasswordField pwdField=null;


// 实现接口中的抽象方法 
 public void actionPerformed(ActionEvent e) {
     // 获取按钮上的字 
     
    String btnstr =  e.getActionCommand();
     
    if(btnstr.equals("登录")) {
        System.out.println("nameF="+nameField);
    String namestr =     nameField.getText();
    String pwdstr =     pwdField.getText();
    
    if(namestr.equals("admin") && pwdstr.equals("123")) {
        System.out.println("登录成功!!");
    }else {
        System.out.println("请重试!!");
    }
        
        
    }else if(btnstr.equals("注册")) {
        
        
    }
       
    System.out.println(btnstr + "  = 按钮被点击了");
 }    

}`

在这里我们需要注意一点,在调用接口时,接口函数里面的分号我们在类里面用{}代替
到现在一个QQ的登录界面也就完成了。

查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-08

python-酷我音乐

完整代码

import requests
import json
import os
外汇出入金流程https://www.fx61.com/support

def music_download():
    kw = input("请输入音乐名称:")
    # 请求头
    headers = {
        "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36 Edg/84.0.522.63",
        "Cookie":"_ga=GA1.2.1083049585.1590317697; _gid=GA1.2.2053211683.1598526974; _gat=1; Hm_lvt_cdb524f42f0ce19b169a8071123a4797=1597491567,1598094297,1598096480,1598526974; Hm_lpvt_cdb524f42f0ce19b169a8071123a4797=1598526974; kw_token=HYZQI4KPK3P",
        "Referer": "http://www.kuwo.cn/search/list?key=%E5%91%A8%E6%9D%B0%E4%BC%A6",
        "csrf": "HYZQI4KPK3P",
    }
    # 参数列表
    params = {
        "key": kw,
        # 页数
        "pn": "1",
        # 音乐数
        "rn": "10",
        "httpsStatus": "1",
        "reqId": "cc337fa0-e856-11ea-8e2d-ab61b365fb50",
    }
    # 创建列表,后面下载需要
    music_list = []
    url = "http://www.kuwo.cn/api/www/search/searchMusicBykeyWord?"
    res = requests.get(url = url,headers = headers,params = params)
    res.encoding = "utf-8"
    text = res.text
    # 转成json数据
    json_list = json.loads(text)
    # 发现data中list是存主要数据的地方
    datapack = json_list["data"]["list"]
    # 遍历拿到所需要的数据,音乐名称,歌手,id...
    for i in datapack:
        # 音乐名
        music_name = i["name"]
        # 歌手
        music_singer = i["artist"]
        # 待会需要的id先拿到
        rid = i["rid"]
        # 随便试听拿到一个音乐的接口,这是的rid就用得上了
        api_music = "http://www.kuwo.cn/url?format=mp3&rid={}&response=url&type=convert_url3" 
                    "&br=128kmp3&from=web&t=1598528574799&httpsStatus=1" 
                    "&reqId=72259df1-e85a-11ea-a367-b5a64c5660e5".format(rid)
        api_res = requests.get(url = api_music)
        # 打印发现真实的url确实在里面
        # print(api_res.text)
        music_url = json.loads(api_res.text)["url"]
        # 大功告成,试试效果
        print(music_name)
        print(music_singer)
        print(music_url)
        # 把数据存到字典方便下载时查找
        music_dict = {}
        music_dict["name"] = music_name
        music_dict["url"] = music_url
        music_dict["singer"] = music_singer
        music_list.append(music_dict)
    # 看看真实数据数量
    print(len(music_list))
    # 下载
    xiazai = input("输入音乐名称:")
    # 下载位置
    root = 'E://下载的music//'
    for i in range(len(music_list)):
        try:
            if xiazai == music_list[i]["name"]:
                # 创建文件夹
                if not os.path.exists(root):
                    os.mkdir(root)
                # 拿到字典中对应的音乐url数据
                music_content = requests.get(url = music_list[i]["url"]).content
                with open(root + "{}({}).mp3".format(music_list[i]['name'],music_list[i]['singer']),"wb") as f:
                    f.write(music_content)
                    print("下载成功")
            else:
                print("此歌名不在你所搜索的音乐里!")
                continue
        except:
            print("下载失败")
if __name__ == "__main__":
    music_download()
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-08

python爬虫爬取拉勾招聘网

  • 搭配好环境
  • 复制以下代码
# -*- coding: utf-8 -*-
"""
Created on Mon Sep  7 21:44:39 2020

@author: ASUS
"""
外汇常见问题https://www.kaifx.cn/lists/question/

import requests
import time
import json
import xlwt

workbook = xlwt.Workbook(encoding=' utf-8')
mysheet = workbook.add_sheet('mysheet')

mysheet.write(0, 0, 'positionId')
mysheet.write(0, 1, 'positionName')
mysheet.write(0, 2, 'companyId')
mysheet.write(0, 3, 'companyFullName')
mysheet.write(0, 4, 'city')
mysheet.write(0, 5, 'companyLabelList')
mysheet.write(0, 6, 'companyLogo')
mysheet.write(0, 7, 'companyShortName')
mysheet.write(0, 8, 'companySize')
mysheet.write(0, 9, 'createTime')
mysheet.write(0, 10, 'district')
mysheet.write(0, 11, 'education')
mysheet.write(0, 12, 'financeStage')
mysheet.write(0, 13, 'firstType')
mysheet.write(0, 14, 'formatCreateTime')
mysheet.write(0, 15, 'industryField')
mysheet.write(0, 16, 'jobNature')
mysheet.write(0, 17, 'lastLogin')
mysheet.write(0, 18, 'latitude')
mysheet.write(0, 19, 'linestaion')
mysheet.write(0, 20, 'longitude')
mysheet.write(0, 21, 'matchScore')


mysheet.write(0, 22, 'positionAdvantage')
mysheet.write(0, 23, 'positionId')
mysheet.write(0, 24, 'positionLables')
mysheet.write(0, 25, 'positionName')
mysheet.write(0, 26, 'secondType')
mysheet.write(0, 27, 'skillLables')
mysheet.write(0, 28, 'stationname')
mysheet.write(0, 29, 'subwayline')
mysheet.write(0, 30, 'thirdType')
mysheet.write(0, 31, 'workYear')

def main(kd,pages,row):
    # 通过访问主网页获取cookies和session
    url1 = 'https://www.lagou.com/jobs/list_python?city=%E5%85%A8%E5%9B%BD&cl=false&fromSearch=true&labelWords=&suginput='
    # 提交ajax请求,获取json数据
    url = "https://www.lagou.com/jobs/positionAjax.json?px=default&needAddtionalResult=false"
    # 请求头
    headers = {
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
        'Referer': 'https://www.lagou.com/jobs/list_python?px=default&city=%E5%85%A8%E5%9B%BD',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36',
        'Host': 'www.lagou.com'
    }

    # 使用data来决定获取多少页的json数据
    for page in range(1, pages):
        data = {
            'first': 'false',
            'pn': page,
            'kd': 'python'
        }
        data['kd']=kd
        s = requests.Session()  # 建立session
        s.get(url=url1, headers=headers, timeout=1)
        cookie = s.cookies  # 获取cookie
        respon = s.post(url=url, headers=headers, data=data, cookies=cookie, timeout=3)
        time.sleep(1)
        #print(respon.text)
        result = json.loads(respon.text)
        info = result["content"]["positionResult"]["result"]
        print(len(info))
        for j in info:
        
            mysheet.write(row, 0, j['positionId'])
            mysheet.write(row, 1, j['positionName'])
            mysheet.write(row, 2, j['companyId'])
            mysheet.write(row, 3, j['companyFullName'])
            mysheet.write(row, 4, j['city'])
            mysheet.write(row, 5, j['companyLabelList'])
            mysheet.write(row, 6, j['companyLogo'])
            mysheet.write(row, 7, j['companyShortName'])
            mysheet.write(row, 8, j['companySize'])
            mysheet.write(row, 9, j['createTime'])
            mysheet.write(row, 10, j['district'])
            mysheet.write(row, 11, j['education'])
            mysheet.write(row, 12, j['financeStage'])
            mysheet.write(row, 13, j['firstType'])
            mysheet.write(row, 14, j['formatCreateTime'])
            mysheet.write(row, 15, j['industryField'])
            mysheet.write(row, 16, j['jobNature'])
            mysheet.write(row, 17, j['lastLogin'])
            mysheet.write(row, 18, j['latitude'])
            mysheet.write(row, 19, j['linestaion'])
            mysheet.write(row, 20, j['longitude'])
            mysheet.write(row, 21, j['matchScore'])
    
            mysheet.write(row, 22, j['positionAdvantage'])
            mysheet.write(row, 23, j['positionId'])
            mysheet.write(row, 24, j['positionLables'])
            mysheet.write(row, 25, j['positionName'])
            mysheet.write(row, 26, j['secondType'])
            mysheet.write(row, 27, j['skillLables'])
            mysheet.write(row, 28, j['stationname'])
            mysheet.write(row, 29, j['subwayline'])
            mysheet.write(row, 30, j['thirdType'])
            mysheet.write(row, 31, j['workYear'])
            row=row+1
    workbook.save('py3.xls')
# 获取前两页的职位json信息
kd=input('输入关键字:')
pages=int(input('输入要爬取多少页:'))
main(kd,pages,1)
# 结果如下:
# {"resubmitToken":null,"requestId":null,"msg":null,"success":true,"content":{"hrInfoMap":{"6187967":{"userId":11765418,"phone":null,"positionName":"招聘经理",........."pageSize":15},"code":0}
查看原文

赞 1 收藏 1 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-04

JAVA代码实现扫码购带圆图二维码生成

需求背景

针对常规的新媒体运营渠道,经常要推出一些福利商品,只能通过自媒体的渠道进行购买,因为在当前商城中商品一旦上架,所有的用户都可进行购买,所以需要控制商品购买入口,提供新的商品购买入口。

技术方案

针对以上的需求,开发侧和产品侧讨论之后确定使用扫码购的方式来实现这一需求。

程序设计

  • 商品信息添加购买渠道标识
  • 因为商品的购买一般是经过商品详情页进行加车的,所以直接提供特殊通道让用户可以跳转到详情页,而正常购买渠道无法进入此详情页,通过商品详情页路径生成商品二维码
  • 为了提升品牌形象,在商品二维码中间添加商品logo或者品牌logo

代码实现

外汇经纪商动态https://www.fx61.com/news

代码入口Controller

 @ApiOperation(value = "获取商品二维码", notes = "获取商品二维码", httpMethod = "GET")
    @RequestMapping(value = "/qrcode/get", method = RequestMethod.GET)
    @ResponseBody
    public void getQrCode(Long itemNo, HttpServletResponse response) {
        try{
            // 定义商品详情路径
            String detailUrl = "https://www.xxx.com/details?itemNo=123456";
            // 获取二维码中心商品图,此处我设置的是固定的公司logo图,建议可以换成商品的缩略图
            // 这个logo图是放在项目的resource目录下的
             ClassPathResource resource = new ClassPathResource("logo.png");
            InputStream inputStream = resource.getInputStream();
            File file = new File("./logo.png");
            FileUtils.copyInputStreamToFile(inputStream,file);
            // 创建用来接收二维码的图片
            String rootPath = "./"+itemNo+".png";
            // 用商品详情信息和图片地址生成二维码,350为二维码尺寸
            File qrCodeImge = ZxingUtils.getQRCodeImge(detailUrl, 350, rootPath);
            // 将二维码图片与logo图片进行叠合
            BufferedImage bufferedImage = ZxingUtils.encodeImgLogo(qrCodeImge, file);
            ImageIO.write(bufferedImage,"png",qrCodeImge);
            // 通过流将图片写回到前端
            InputStream in = new FileInputStream(qrCodeImge);
            response.setContentType("image/png");
            OutputStream outputStream = new BufferedOutputStream(response.getOutputStream());
            //创建存放文件内容的数组
            byte[] buff =new byte[1024];
            //所读取的内容使用n来接收
            int n;
            //当没有读取完时,继续读取,循环
            while((n=in.read(buff))!=-1){
                //将字节数组的数据全部写入到输出流中
                outputStream.write(buff,0,n);
            }
            //强制将缓存区的数据进行输出
            outputStream.flush();
            //关流
            outputStream.close();
            in.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

生成二维码工具类

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Map;

/**
 * @author huachao 
 * @生二维码工具类 2020年9月3日
 */
public class ZxingUtils {
    private static Log log = LogFactory.getLog(ZxingUtils.class);

    private static final int BLACK = 0xFF000000;
    private static final int WHITE = 0xFFFFFFFF;

    private static BufferedImage toBufferedImage(BitMatrix matrix) {
        int width = matrix.getWidth();
        int height = matrix.getHeight();
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                image.setRGB(x, y, matrix.get(x, y) ? BLACK : WHITE);
            }
        }
        return image;
    }

    private static void writeToFile(BitMatrix matrix, String format, File file) throws IOException {
        BufferedImage image = toBufferedImage(matrix);
        if (!ImageIO.write(image, format, file)) {
            throw new IOException("Could not write an image of format " + format + " to " + file);
        }
    }

    /**
     * 将内容contents生成长宽均为width的图片,图片路径由imgPath指定
     */
    public static File getQRCodeImge(String contents, int width, String imgPath) {
        return getQRCodeImge(contents, width, width, imgPath);
    }

    /**
     * 将内容contents生成长为width,宽为width的图片,图片路径由imgPath指定
     */
    public static File getQRCodeImge(String contents, int width, int height, String imgPath) {
        try {
            Map<EncodeHintType, Object> hints = new Hashtable<EncodeHintType, Object>();
            hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.M);
            hints.put(EncodeHintType.CHARACTER_SET, "UTF8");

            BitMatrix bitMatrix = new MultiFormatWriter().encode(contents, BarcodeFormat.QR_CODE, width, height, hints);

            File imageFile = new File(imgPath);
            writeToFile(bitMatrix, "png", imageFile);

            return imageFile;

        } catch (Exception e) {
            log.error("create QR code error!", e);
            return null;
        }
    }

    /**
     * 在已有的二维码图片加上logo图片
     *
     * @param twodimensioncodeImg 二维码图片文件
     * @param logoImg             logo图片文件
     * @return
     */
    public static BufferedImage encodeImgLogo(File twodimensioncodeImg, File logoImg) {
        BufferedImage twodimensioncode = null;
        try {
            if (!twodimensioncodeImg.isFile() || !logoImg.isFile()) {
                System.out.println("输入非图片");
                return null;
            }
            //读取二维码图片
            twodimensioncode = ImageIO.read(twodimensioncodeImg);
            //获取画笔
            Graphics2D g = twodimensioncode.createGraphics();
            //读取logo图片
            BufferedImage logo = ImageIO.read(logoImg);

            //透明底的图片
            BufferedImage bi2 = new BufferedImage(logo.getWidth(),logo.getHeight(),BufferedImage.TYPE_4BYTE_ABGR);
            Ellipse2D.Double shape = new Ellipse2D.Double(0,0,logo.getWidth(),logo.getHeight());
            Graphics2D g2 = bi2.createGraphics();
            g2.setClip(shape);
            // 使用 setRenderingHint 设置抗锯齿
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2.drawImage(logo,0,0,null);
            //设置颜色
            g2.setBackground(Color.green);
            g2.dispose();
            //设置二维码大小,太大,会覆盖二维码,此处20%
            int logoWidth = bi2.getWidth(null) > twodimensioncode.getWidth() * 3 / 10 ? (twodimensioncode.getWidth() * 3 / 10) : logo.getWidth(null);
            int logoHeight = bi2.getHeight(null) > twodimensioncode.getHeight() * 3 / 10 ? (twodimensioncode.getHeight() * 3 / 10) : logo.getHeight(null);
            // 确定二维码的中心位置坐标,设置logo图片放置的位置
            int x = (twodimensioncode.getWidth() - logoWidth) / 2;
            int y = (twodimensioncode.getHeight() - logoHeight) / 2;
            g.drawOval(x, y, logoWidth, logoHeight);
            //开始合并绘制图片
            g.drawImage(bi2, x, y, logoWidth, logoHeight, null);
            // 此处是划圆形,如果需要方形注释掉即可
            g.drawRoundRect(x, y, logoWidth, logoHeight, logoWidth, logoHeight);
            g.dispose();
            logo.flush();
            twodimensioncode.flush();
        } catch (Exception e) {
            System.out.println("二维码绘制logo失败");
        }
        return twodimensioncode;
    }
}
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-04

Java实现PDF文件转换为图片

引入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.4.RELEASE</version>
    <relativePath/>
</parent>

<dependencies>
    <!--SpringMVC的依赖,方便我们可以获取前端传递过来的文件信息-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--icepdf,用来将pdf文件转换为图片的依赖-->
    <dependency>
        <groupId>org.icepdf.os</groupId>
        <artifactId>icepdf-core</artifactId>
        <version>6.2.2</version>
    </dependency>
</dependencies>

前端页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>PDf转换图片</title>
    <style>
        .submitButton {
            margin-top: 20px;
            margin-left: 150px;
            background-color: #e37e10;
            border-radius: 10px;
            border: 1px solid #ff8300;
        }
    </style>
</head>
<body>
<div style="text-align: center">
    <h1>PDF转换图片工具</h1>
    <form action="/pdf/to/image" enctype="multipart/form-data" method="post" onsubmit="return allowFileType()">
        <input type="file" id="file" name="file" placeholder="请选择PDF文件" onchange="allowFileType()" style="border: 1px solid black;"><br>
        <input type="submit" value="一键转换图片" class="submitButton">
    </form>
</div>
</body>
<script>
    function allowFileType() {
        let file = document.getElementById("file").files[0];
        let fileName = file.name;
        let suffix = fileName.substring(fileName.lastIndexOf("."),fileName.length).toLowerCase();
        if('.pdf' != suffix) {
            alert("只允许传入PDF格式的文件!");
            return false;
        }
        return true;
    }
</script>
</html>

控制层接口

外汇MT4教程https://www.kaifx.cn/mt4.html

package com.hrp.controller;

import com.hrp.util.ImageUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;

/**
 * @description: 用于处理Pdf相关的请求
 */
@Controller
@RequestMapping("pdf")
public class PdfController {

    @PostMapping("to/image")
    public void pdfToImage(@RequestParam("file") MultipartFile file,HttpServletResponse response) throws Exception{
        ImageUtils.pdfToImage(file,response);
    }

}

Image工具类

package com.hrp.util;

import org.icepdf.core.pobjects.Document;
import org.icepdf.core.pobjects.Page;
import org.icepdf.core.util.GraphicsRenderingHints;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * @description: PDF转换为图片的工具类
 */
@Component
public class ImageUtils {

    /**
     * 图片文件格式
     */
    public static final String FORMAT_NAME = "png";
    /**
     * 图片文件后缀名
     */
    public static final String PNG_SUFFIX = ".png";
    /**
     * 压缩文件后缀名
     */
    public static final String ZIP_SUFFIX = ".zip";

    /**
     * 对外的开放接口,用于将PDF文件转换为图片文件压缩包进行下载
     *
     * @param file SpringMVC获取的图片文件
     * @param response
     * @throws Exception
     */
    public static void pdfToImage(MultipartFile file, HttpServletResponse response) throws Exception {
        File zipFile = generateImageFile(file);
        downloadZipFile(zipFile, response);
    }


    /**
     * 将PDF文件转换为多张图片并放入一个压缩包中
     *
     * @param file SpringMVC获取的图片文件
     * @return 图片文件压缩包
     * @throws Exception 抛出异常
     */
    private static File generateImageFile(MultipartFile file) throws Exception {
        String fileName = file.getOriginalFilename();
        Document document = new Document();
        document.setByteArray(file.getBytes(), 0, file.getBytes().length, fileName);

        List<File> fileList = new ArrayList<>();
        for (int i = 0; i < document.getNumberOfPages(); i++) {
            BufferedImage image = (BufferedImage) document.getPageImage(i, GraphicsRenderingHints.SCREEN,
                    Page.BOUNDARY_CROPBOX, 0F, 2.5F);
            File imageFile = new File((i + 1) + PNG_SUFFIX);
            ImageIO.write(image, FORMAT_NAME, imageFile);
            image.flush();
            fileList.add(imageFile);
        }
        document.dispose();

        String directoryName = fileName.substring(0, fileName.lastIndexOf("."));
        File zipFile = new File(directoryName + ZIP_SUFFIX);
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile));
        zipFile(fileList, zos);
        zos.close();
        return zipFile;
    }

    /**
     * 下载zip文件
     *
     * @param zipFile  zip压缩文件
     * @param response HttpServletResponse
     * @throws IOException IO异常
     */
    private static void downloadZipFile(File zipFile, HttpServletResponse response) throws IOException {
        FileInputStream fis = new FileInputStream(zipFile);
        byte[] bytes = new byte[fis.available()];
        fis.read(bytes);
        fis.close();

        response.reset();
        response.setCharacterEncoding("UTF-8");
        response.setHeader("Content-Type", "application/x-msdownload");
        response.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(zipFile.getName(), "UTF-8"));
        OutputStream out = response.getOutputStream();
        out.write(bytes);
        out.flush();
        out.close();
        zipFile.delete();
    }

    /**
     * 压缩文件
     *
     * @param inputFiles 具体需要压缩的文件集合
     * @param zos        ZipOutputStream对象
     * @throws IOException IO异常
     */
    private static void zipFile(List<File> inputFiles, ZipOutputStream zos) throws IOException {
        byte[] buffer = new byte[1024];
        for (File file : inputFiles) {
            if (file.exists()) {
                if (file.isFile()) {
                    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
                    zos.putNextEntry(new ZipEntry(file.getName()));
                    int size = 0;
                    while ((size = bis.read(buffer)) > 0) {
                        zos.write(buffer, 0, size);
                    }
                    zos.closeEntry();
                    bis.close();
                    file.delete();
                } else {
                    File[] files = file.listFiles();
                    List<File> childrenFileList = Arrays.asList(files);
                    zipFile(childrenFileList, zos);
                }
            }
        }
    }

}
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-02

Opencv python之车辆识别项目

图片车辆识别

根据文章搭建好环境后开始进行做项目link

import sys
import cv2
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QIcon, QPalette, QPixmap, QBrush, QRegExpValidator




class mainWin(QWidget):
    def __init__(self):
        """
        构造函数
        """
        super().__init__()
        self.initUI()
        self.openBtn.clicked.connect(self.openFile)  # 信号和槽
        self.grayBtn.clicked.connect(self.imgGray)  # 信号和槽
        self.carCheckBtn.clicked.connect(self.carCheck)

    def initUI(self):
        # 设置窗口得大小
        self.setFixedSize(860, 600)
        # 图标和背景
        self.setWindowTitle("车辆检测")
        self.setWindowIcon(QIcon("img/icon.jpg"))  # 图标

        # 标签
        self.leftLab = QLabel("原图:", self)
        self.leftLab.setGeometry(10, 50, 400, 400)  # 设置绝对位置
        self.leftLab.setStyleSheet("background:white")

        self.newLab = QLabel("新图:", self)
        self.newLab.setGeometry(420, 50, 400, 400)  # 设置绝对位置
        self.newLab.setStyleSheet("background-color:white")

        # 按钮
        self.openBtn = QPushButton(" 打开文件", self)
        self.openBtn.setGeometry(10, 10, 80, 30)


        self.grayBtn = QPushButton(" 灰度处理", self)
        self.grayBtn.setGeometry(100, 10, 80, 30)

        self.carCheckBtn = QPushButton(" 视频检测", self)
        self.carCheckBtn.setGeometry(200, 10, 80, 30)

打开文件方法

 def openFile(self):
        """
        打开文件的处理函数
        :return;
        :return:
        """

        print("打开图片")

        self.img,imgType = QFileDialog.getOpenFileName(self, "打开图片", "", "*.jpg;;*.png;;ALL FILES(*)")
        print(self.img)

        #jpg = QPixmap(self.img)
        self.leftLab.setPixmap(QPixmap(self.img))
        self.leftLab.setScaledContents(True)

图像变灰度并车辆识别方法
外汇专业术语https://www.fx61.com/definitions

    def imgGray(self):
        print("灰度")
        img1 = cv2.imread(self.img)
        #1. 灰度化处理
        img_gray = cv2.cvtColor(img1, cv2.COLOR_RGB2GRAY)
        # BGR = cv2.cvtColor(module,cv2.COLOR_BGR2RGB)# 转化为RGB格式
        # ret,thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)#二值化


        #2. 加载级联分类器
        car_detector = cv2.CascadeClassifier("./cars.xml")

        """
        image--图片像素数据
        scaleFactor=None,缩放比例
        minNeighbors=None,2  写2就是3
        flags =None, 标志位 用什么来进行检测
        minSize=None,最小的尺寸
        maxSize=None,最大的尺寸
        self, image, scaleFactor=None, minNeighbors=None, flags=None, minSize=None, maxSize=None
        """
        #3. 检测车辆  多尺度检测,得到车辆的坐标定位
        cars = car_detector.detectMultiScale(img_gray, 1.05, 2, cv2.CASCADE_SCALE_IMAGE, (20,20), (100,100))
        print(cars)
        #(274  46  28  28) --(x,y,w,h)

        #4. 在车的定位上画图
        for(x, y, w, h) in cars:
            print(x, y, w, h)
            #img, pt1, pt2, color, thickness = None, lineType = None, shift = None
            cv2.rectangle(img1,(x,y), (x+w, y+h), (255, 255, 255), 1, cv2.LINE_AA)

        # 保存图片
        img_gray_name = "3.png"  # 文件名
        cv2.imwrite(img_gray_name, img1)  # 保存

        # 显示再控件上面
        self.newLab.setPixmap(QPixmap(img_gray_name))
        self.newLab.setScaledContents(True)

视频车辆识别

视频打开且识别方法

    def carCheck(self):
        print("车流检测")
        # parent: QWidget = None, caption: str = '', directory: str = '', filter:
        #1. 选择视频
        video, videoType = QFileDialog.getOpenFileName(self, "打开视频", "", "*.mp4")
        print(video, videoType)

        # video --打开的视频filename
        #2. 读取加载视频
        cap = cv2.VideoCapture(video)

        #3.读取一帧图片
        while True:
            status,img = cap.read()
            if status:
                # 灰度
                gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
                # 2. 加载级联分类器
                car_detector = cv2.CascadeClassifier("./cars.xml")

                cars = car_detector.detectMultiScale(gray, 1.2, 2, cv2.CASCADE_SCALE_IMAGE, (25, 25), (200, 200))
                # 画框框
                for (x, y, w, h) in cars:
                    print(x, y, w, h)
                    # img, pt1, pt2, color, thickness = None, lineType = None, shift = None
                    cv2.rectangle(img, (x, y), (x + w, y + h), (255, 255, 255), 1, cv2.LINE_AA)

                print("实时车流量", len(cars))
                text = 'car number: '+str(len(cars))
                # 添加文字
                cv2.putText(img, text, (350, 100), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (255, 255, 0), 2)
                cv2.imshow("opencv", img)
                key = cv2.waitKey(10)  # 延时并且监听按键
                if key == 27:
                    break
            else:
                break

        # 释放资源
        cap.release()
        cv2.destroyAllWindows()

主函数

if __name__ == "__main__":
    app = QApplication(sys.argv)  #创建一个应用程序
    win = mainWin()  #实例化对象
    win.show()  #显示窗口
    sys.exit(app.exec_())
查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-09-02

Python网易云音乐自动化下载

使用以下脚本打印歌单信息:

encoding=utf8

import requests

from bs4 import BeautifulSoup

import urllib.request

headers = {

'Referer':'http://music.163.com/',

'Host':'music.163.com',

'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',

'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',

}

play_url = 'http://music.163.com/playlist...'

s = requests.session()

response=s.get(play_url,headers = headers).content

s = BeautifulSoup(response,'lxml')

main = s.find('ul',{'class':'f-hide'})

for music in main.find_all('a'):

print('{} : {}'.format(music.text, music['href']))

完整代码

encoding=utf8

import requests

from bs4 import BeautifulSoup

import urllib.request

headers = {

'Referer':'http://music.163.com/',

'Host':'music.163.com',

'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',

'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',

}

# 歌单的url地址

play_url = 'http://music.163.com/playlist...'

# 获取页面内容

s = requests.session()

response=s.get(play_url,headers = headers).content

使用bs4匹配出对应的歌曲名称和地址

s = BeautifulSoup(response,'lxml')

main = s.find('ul',{'class':'f-hide'})

lists=[]

for music in main.find_all('a'):

list=[]

# print('{} : {}'.format(music.text, music['href']))

musicUrl='http://music.163.com/song/med...'+music['href'][5:]+'.mp3'

musicName=music.text

# 单首歌曲的名字和地址放在list列表中

list.append(musicName)

list.append(musicUrl)

# 全部歌曲信息放在lists列表中

lists.append(list)

print(lists)

# 下载列表中的全部歌曲,并以歌曲名命名下载后的文件,文件位置为当前文件夹
外汇MT4教程https://www.kaifx.cn/mt4.html

for i in lists:

url=i[1]

name=i[0]

try:

print('正在下载',name)

urllib.request.urlretrieve(url,'./music/%s.mp3'% name)

print('下载成功')

except:

print('下载失败')

拓展代码

附上一位大佬另外的一种实现爬取网易云歌单音乐的代码:

导入库

import requests

from fake_useragent import UserAgent

from lxml import etree

import re

网易云官网 搜索薛之谦跳转网页后 检查 network doc 找到该网页的

Request URL: https://music.163.com/artist?...

1、确定url地址(薛之谦的歌单)

url = 'https://music.163.com/artist?...'

网易云音乐的外链地址

base_url = 'https://link.hhtjim.com/163/'

2、请求

headers= {

"User-Agent": UserAgent().chrome

}

result = requests.get(url, headers=headers).text

# print(result)

3、删选数据 拿到列表中的歌曲id 为一个字典 里面有每首个的id

dom =etree.HTML(result)

# 通过审查元素发现每首歌在 中通过xpath分析得获取所有歌曲id的xpath语句为'//a[contains(@href,"/song?")]/@href'

ids = dom.xpath('//ul[@class="f-hide"]//li/a/@href')

将数据切片只需要id数值

正则表达式

for i in range(len(ids)):

ids[i] = re.sub('\D', '', ids[i])

print(ids)

for i in range(len(ids)):

每一首歌的地址

M_url = f'https://music.163.com/song?id={ids[i]}'

response = requests.get(M_url, headers=headers)

html = etree.HTML(response.text)

music_info = html.xpath('//title/text()')

print(music_info) #['我好像在哪见过你(电影《精灵王座》主题曲) - 薛之谦 - 单曲 - 网易云音乐']

music_name = music_info[0].split('-')[0]

singer = music_info[0].split('-')[1]

print(music_name, singer) #我好像在哪见过你(电影《精灵王座》主题曲) 薛之谦

获取歌源

music_url = base_url + str(ids[i]) + '.mp3'

print(music_url) #打印出每首歌的外链网址

music = requests.get(music_url).content

4、保存

with open('./music/'+music_name+'.mp3', 'wb') as file:

file.write(music)

print("正在下载第"+str(i+1)+"首: "+music_name+singer)

查看原文

赞 0 收藏 0 评论 0

zhuanzhudeyipi 发布了文章 · 2020-08-28

java之树结构得实现

实体类:

package com.gsl.node.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

/**

  • @Author :Guo Shi Lin
  • @date : 2020/8/18 13:57
  • @description:菜单树
  • @modified By:
  • @version: 1.0

*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tree")
public class Tree {

@TableId(value = "id", type = IdType.AUTO)
private Integer id;
private String name;
private Integer parentId;
@TableField(exist = false)
private List<Tree> children;

}
数据访问层接口dao:

package com.gsl.node.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.gsl.node.entity.Tree;
import org.apache.ibatis.annotations.Mapper;

/**

  • @Author :Guo Shi Lin
  • @date : 2020/8/18 13:58
  • @description:
  • @modified By:
  • @version: 1.0

*/
@Mapper
public interface TreeDao extends BaseMapper<Tree> {

}

业务逻辑层接口service:

package com.gsl.node.service;

import com.gsl.node.entity.Tree;

import java.util.List;

/**

  • @Author :Guo Shi Lin
  • @date : 2020/8/18 13:58
  • @description:
  • @modified By:
  • @version: 1.0

*/
public interface TreeService {

/**
 * 查找树
 * @return
 */
List<Tree> findList();

}
业务逻辑层实现类impl:
外汇经纪商对比https://www.fx61.com/brokerlist

package com.gsl.node.service.impl;

import com.gsl.node.dao.TreeDao;
import com.gsl.node.entity.Tree;
import com.gsl.node.service.TreeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**

  • @Author :Guo Shi Lin
  • @date : 2020/8/18 14:00
  • @description:用的递归实现
  • @modified By:
  • @version: 1.0

*/
@Service
public class TreeServiceImpl implements TreeService {

@Autowired
private TreeDao treeDao;

@Override
public List<Tree> findList() {
    return treeDao.selectList(null);
}

public List<Tree> handleTree() {
    //根节点list
    List<Tree> treeList = new ArrayList<>();
    //从数据库获取所有得数据
    List<Tree> allTree = treeDao.selectList(null);
    if (null != allTree && allTree.size() > 0) {
        allTree.forEach(tree -> {
            if (tree.getParentId() == 0) {
                treeList.add(tree);
            }
        });

        if (null != treeList && treeList.size() > 0) {
            treeList.forEach(tree -> {
                //使用递归获取孩子
                List<Tree> childrenList = getChildren(tree.getId(), allTree);
                tree.setChildren(childrenList);
            });
        }
    }
    return treeList;
}

/**
 * 使用递归获取根节点下面得孩子
 * @param id
 * @param allTree
 * @return
 */
public List<Tree> getChildren(Integer id, List<Tree> allTree) {
    List<Tree> childrenList = new ArrayList<>();
    allTree.forEach(tree -> {
        if (tree.getParentId().equals(id)) {
            childrenList.add(tree);
        }
    });

    if (null != childrenList && childrenList.size() > 0) {
        childrenList.forEach(tree -> {
            tree.setChildren(getChildren(tree.getId(), allTree));
        });

    } else {
        return null;
    }
    return childrenList;
}

}
控制层controller:

package com.gsl.node.controller;

import com.gsl.node.entity.Tree;
import com.gsl.node.service.TreeService;
import com.gsl.node.service.impl.TreeServiceImpl;
import com.gsl.result.ResponseResult;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**

  • @Author :Guo Shi Lin
  • @date : 2020/8/19 9:37
  • @description:
  • @modified By:
  • @version: 1.0

*/
@RestController
@Api(tags = "树")
public class TreeController {

@Autowired
private TreeServiceImpl treeService;

@GetMapping("tree")
public ResponseResult<Tree> tree() {
    return new ResponseResult(200, "成功", treeService.handleTree());
}

}
3.测试结果
{

"code": 200,
"msg": "成功",
"data": [
    {
        "id": 1,
        "name": "根节点",
        "parentId": 0,
        "children": [
            {
                "id": 2,
                "name": "父节点",
                "parentId": 1,
                "children": [
                    {
                        "id": 3,
                        "name": "子节点",
                        "parentId": 2,
                        "children": null
                    },
                    {
                        "id": 4,
                        "name": "子节点-1",
                        "parentId": 2,
                        "children": null
                    }
                ]
            },
            {
                "id": 5,
                "name": "父节点-1",
                "parentId": 1,
                "children": null
            }
        ]
    },
    {
        "id": 6,
        "name": "根节点-1",
        "parentId": 0,
        "children": null
    }
]

}

查看原文

赞 1 收藏 1 评论 0

zhuanzhudeyipi 发布了文章 · 2020-08-28

java 获取某月、某周的第一天、最后一天

java 获取某月、某周的第一天、最后一天

/**
 * 日期格式化
 */
public static String format(Calendar c, String pattern) {
    Calendar calendar = null;
    if (c != null) {
        calendar = c;
    } else {
        calendar = Calendar.getInstance();
    }
    if (pattern == null || pattern.equals("")) {
        pattern = DATETIME_FORMAT;
    }
    SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    return sdf.format(calendar.getTime());
}
  1. 获取某月的第一天/最后一天
/**
 * 获得某月第一天
 * @param count (0:本月,-1:上一个月,1:下一个月)
 * @return    yyyy-MM-dd
 */
public static String getNextMonthFirst(int count) {
     Calendar strDate = Calendar.getInstance();
     int day = getDate(strDate);
     strDate.add(Calendar.DATE,-(day-1));
     strDate.add(Calendar.MONTH,count);
     return format(strDate,"yyyy-MM-dd");
 }
/**
 * 获得下月最后一天
 * @param count (0:本月,-1:上一个月,1:下一个月)
 * @return    yyyy-MM-dd
 */
public static String getNextMonthEnd(int count) {
     Calendar strDate = Calendar.getInstance();
     int day = getDate(strDate);
     strDate.add(Calendar.DATE,-day);
     strDate.add(Calendar.MONTH,count+1);
     return format(strDate,"yyyy-MM-dd");
 }

测试:

System.out.println("当前时间点是:"+DateUtil.getDataFormat(new Date()));
System.out.println("上月第一天是:"+DateUtil.getNextMonthFirst(-1));
System.out.println("本月第一天是:"+DateUtil.getNextMonthFirst(0));
System.out.println("下月第一天是:"+DateUtil.getNextMonthFirst(1));
System.out.println("上月最后一天是:"+DateUtil.getNextMonthEnd(-1));
System.out.println("本月最后一天是:"+DateUtil.getNextMonthEnd(0));
System.out.println("下月最后一天是:"+DateUtil.getNextMonthEnd(1));

结果展示:

当前时间点是:2020-08-27 19:27:52
上月第一天是:2020-07-01
本月第一天是:2020-08-01
下月第一天是:2020-09-01
上月最后一天是:2020-07-31
本月最后一天是:2020-08-31
下月最后一天是:2020-09-30

2. 获取某周的第一天/最后一天

 /**
 * 获得某周星期一的日期
 * @param count (0:本月,-1:上一个月,1:下一个月)
 * @return    yyyy-MM-dd
 */
public static String getNextMonday(int count) {
    Calendar strDate = Calendar.getInstance();
    int day = getDay(strDate);
    strDate.add(Calendar.DATE,-(day-2));
    strDate.add(Calendar.WEEK_OF_YEAR,count);
    return format(strDate,"yyyy-MM-dd");
}

/**
 * 获得某周星期日的日期
 * @param count (0:本月,-1:上一个月,1:下一个月)
 * @return    yyyy-MM-dd
 */
public static String getNextSunday(int count) {
    Calendar strDate = Calendar.getInstance();
    int day = getDay(strDate);
    strDate.add(Calendar.DATE,8-day);
    strDate.add(Calendar.WEEK_OF_YEAR,count);
    return format(strDate,"yyyy-MM-dd");
 }

测试:

System.out.println("当前时间点是:"+DateUtil.getDataFormat(new Date()));
System.out.println("上周第一天是:"+DateUtil.getNextMonday(-1));
System.out.println("本周第一天是:"+DateUtil.getNextMonday(0));
System.out.println("下周第一天是:"+DateUtil.getNextMonday(1));
System.out.println("上周最后一天是:"+DateUtil.getNextSunday(-1));
System.out.println("本周最后一天是:"+DateUtil.getNextSunday(0));
System.out.println("下周最后一天是:"+DateUtil.getNextSunday(1));

结果展示:
亨达返佣https://www.fx61.com/brokerli...

当前时间点是:2020-08-27 19:32:58
上周第一天是:2020-08-17
本周第一天是:2020-08-24
下周第一天是:2020-08-31
上周最后一天是:2020-08-23
本周最后一天是:2020-08-30
下周最后一天是:2020-09-06
查看原文

赞 1 收藏 1 评论 0

zhuanzhudeyipi 发布了文章 · 2020-08-26

python 数字转换为大写

在会计的时候,用到将数字转换为大写,也就是讲数字转为汉字
外汇出入金流程https://www.fx61.com/support

class cnumber:
    cdict = {}
    gdict = {}
    xdict = {}

    def __init__(self):
        self.cdict = {1: u'', 2: u'拾', 3: u'佰', 4: u'仟'}
        self.xdict = {1: u'元', 2: u'万', 3: u'亿', 4: u'兆'}  # 数字标识符
        self.gdict = {0: u'零', 1: u'壹', 2: u'贰', 3: u'叁', 4: u'肆', 5: u'伍', 6: u'陆', 7: u'柒', 8: u'捌', 9: u'玖'}

    def csplit(self, cdata):  # 拆分函数,将整数字符串拆分成[亿,万,仟]的list
        g = len(cdata) % 4
        csdata = []
        lx = len(cdata) - 1
        if g > 0:
            csdata.append(cdata[0:g])
        k = g
        while k <= lx:
            csdata.append(cdata[k:k + 4])
            k += 4
        return csdata

    def cschange(self, cki):  # 对[亿,万,仟]的list中每个字符串分组进行大写化再合并
        lenki = len(cki)
        i = 0
        lk = lenki
        chk = u''
        for i in range(lenki):
            if int(cki[i]) == 0:
                if i < lenki - 1:
                    if int(cki[i + 1]) != 0:
                        chk = chk + self.gdict[int(cki[i])]
            else:
                chk = chk + self.gdict[int(cki[i])] + self.cdict[lk]
            lk -= 1
        return chk

    def cwchange(self, data):
        cdata = str(data).split('.')
        cki = cdata[0]
        if len(cdata) == 1:
            i = 0
            chk = u''
            cski = self.csplit(cki)  # 分解字符数组[亿,万,仟]三组List:['0000','0000','0000']
            ikl = len(cski)  # 获取拆分后的List长度
            # 大写合并
            for i in range(ikl):
                if self.cschange(cski[i]) == '':  # 有可能一个字符串全是0的情况
                    chk = chk + self.cschange(cski[i])  # 此时不需要将数字标识符引入
                else:
                    chk = chk + self.cschange(cski[i]) + self.xdict[ikl - i]  # 合并:前字符串大写+当前字符串大写+标识符
            chk = chk + u'整'
        else:
            i = 0
            chk = u''
            cski = self.csplit(cki)  # 分解字符数组[亿,万,仟]三组List:['0000','0000','0000']
            ikl = len(cski)  # 获取拆分后的List长度
            # 大写合并
            for i in range(ikl):
                if self.cschange(cski[i]) == '':  # 有可能一个字符串全是0的情况
                    chk = chk + self.cschange(cski[i])  # 此时不需要将数字标识符引入
                else:
                    chk = chk + self.cschange(cski[i]) + self.xdict[ikl - i]  # 合并:前字符串大写+当前字符串大写+标识符
            # 处理小数部分
            ckj = cdata[1]
            lenkj = len(ckj)
            if lenkj == 1:  # 若小数只有1位
                if int(ckj[0]) == 0:
                    chk = chk + u'整'
                else:
                    chk = chk + self.gdict[int(ckj[0])] + u'角整'
            else:  # 若小数有两位的四种情况
                if int(ckj[0]) == 0 and int(ckj[1]) != 0:
                    chk = chk + u'零' + self.gdict[int(ckj[1])] + u'分'
                elif int(ckj[0]) == 0 and int(ckj[1]) == 0:
                    chk = chk + u'整'
                elif int(ckj[0]) != 0 and int(ckj[1]) != 0:
                    chk = chk + self.gdict[int(ckj[0])] + u'角' + self.gdict[int(ckj[1])] + u'分'
                else:
                    chk = chk + self.gdict[int(ckj[0])] + u'角整'
        return chk

if __name__ == '__main__':
    pt = cnumber()
    print(pt.cwchange('14524'))  # 壹万肆仟伍佰贰拾肆元整
查看原文

赞 0 收藏 0 评论 0