zhuanzhudeyipi

zhuanzhudeyipi 查看完整档案

填写现居城市  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 该用户太懒什么也没留下

个人动态

zhuanzhudeyipi 发布了文章 · 9月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 发布了文章 · 9月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 评论 0

zhuanzhudeyipi 发布了文章 · 9月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 发布了文章 · 9月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 发布了文章 · 9月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 评论 0

zhuanzhudeyipi 发布了文章 · 9月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 发布了文章 · 9月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 发布了文章 · 9月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 发布了文章 · 9月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 发布了文章 · 9月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

认证与成就

  • 获得 10 次点赞
  • 获得 2 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 2 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2019-12-16
个人主页被 305 人浏览