精华内容
下载资源
问答
  • 企业编码生成系统智能批量生成数据分析功能的防伪码.pdf
  • 增值税发票系统升级版与电子发票系统 数据接口规范,以及电子票,纸质票批量导入XML生成DEMO源码
  • shell脚本批量生成测试用数据文件

    千次阅读 2020-11-10 12:09:51
    为了测试hadoop对小文件的性能,所以用shell脚本生成了一千万个小文件用于测试. 一共生成了一千万个小文件,采用%的方式分散在1000个文件夹里面,然后每个文件夹里有一万个小文件. 文件里面我就存放了一个数字,如果需要...

    为了测试hadoop对小文件的性能,所以用shell脚本生成了一千万个小文件用于测试.

    一共生成了一千万个小文件,采用/的方式顺序写入1000个文件夹里面,然后每个文件夹里有一万个小文件.

    文件里面我就存放了一个数字,如果需要的话,可以改成自己想要的

    生成的脚本如下:

    #!/bin/sh
    source /etc/profile
    
    #程序的最终输出目录
    path="/a/zl/tmp"
    
    if [ ! -d path ];
    	then
    		mkdir -p $path
    fi
    
    #生成多少个文件
    for  index in {0..10000000}
    do
        #确定最终输出目录里面有多少个子目录, 
        #这里是放到1000个文件夹里面了, 每个文件里面有1万个小文件
        #单个目录里面的文件数量不推荐超过100万,不然操作系统会很卡
        num=`expr $index / 10000`
        tmpPath="${path}/data_${num}"
        if [ ! -d $tmpPath ];
            then
                mkdir -p $tmpPath
        fi
         #输出一个数字到目标文件
        echo "${index}" > $tmpPath/bk-${index}.txt
    done
    
    
    
    
    展开全文
  • Python循环产生批量数据batch

    万次阅读 2018-10-28 11:49:33
    Python循环产生批量数据batch 目录 Python循环产生批量数据batch 一、Python循环产生批量数据batch 二、TensorFlow循环产生批量数据batch (1)tf.train.slice_input_producer (2)tf.train.batch和tf.train....

    Python循环产生批量数据batch

     

    目录

    Python循环产生批量数据batch

    一、Python循环产生批量数据batch

    二、TensorFlow循环产生批量数据batch 

    (1) tf.train.slice_input_producer

    (2) tf.train.batch和tf.train.shuffle_batch

    (3) TF循环产生批量数据batch 的完整例子

    三、更加实用的方法:数据巨大的情况


    一、Python循环产生批量数据batch

       在机器学习中,经常需要产生一个batch的数据用于训练模型,比如tensorflow的接口tf.train.batch就可以实现数据批量读取的操作。本博客将不依赖TensorFlow,实现一个类似于tensorflow接口tf.train.batch的方法,循环产生批量数据batch。实现的代码和测试的代码如下:

       TXT文本如下,格式:图片名 label1 label2 ,注意label可以多个

    1.jpg 1 11
    2.jpg 2 12
    3.jpg 3 13
    4.jpg 4 14
    5.jpg 5 15
    6.jpg 6 16
    7.jpg 7 17
    8.jpg 8 18

        要想产生batch数据,关键是要用到Python的关键字yield,实现一个batch一个batch的返回数据,代码实现主要有两个方法:

    def get_data_batch(inputs, batch_size=None, shuffle=False):
        '''
        循环产生批量数据batch
        :param inputs: list数据
        :param batch_size: batch大小
        :param shuffle: 是否打乱inputs数据
        :return: 返回一个batch数据
        '''
    def get_next_batch(batch):
        return batch.__next__()

        使用时,将数据传到 get_data_batch( )方法,然后使用get_next_batch( )获得一个batch数据,完整的Python代码如下:

    # -*-coding: utf-8 -*-
    """
        @Project: create_batch_data
        @File   : create_batch_data.py
        @Author : panjq
        @E-mail : pan_jinquan@163.com
        @Date   : 2017-10-27 18:20:15
    """
    import math
    import random
    import os
    import glob
    import numpy as np
    
    
    def get_data_batch(inputs, batch_size=None, shuffle=False):
        '''
        循环产生批量数据batch
        :param inputs: list类型数据,多个list,请[list0,list1,...]
        :param batch_size: batch大小
        :param shuffle: 是否打乱inputs数据
        :return: 返回一个batch数据
        '''
        rows = len(inputs[0])
        indices = list(range(rows))
        # 如果输入是list,则需要转为list
        if shuffle:
            random.seed(100)
            random.shuffle(indices)
        while True:
            batch_indices = np.asarray(indices[0:batch_size])  # 产生一个batch的index
            indices = indices[batch_size:] + indices[:batch_size]  # 循环移位,以便产生下一个batch
            batch_data = []
            for data in inputs:
                data = np.asarray(data)
                temp_data=data[batch_indices] #使用下标查找,必须是ndarray类型类型
                batch_data.append(temp_data.tolist())
            yield batch_data
    
    def get_data_batch2(inputs, batch_size=None, shuffle=False):
        '''
        循环产生批量数据batch
        :param inputs: list类型数据,多个list,请[list0,list1,...]
        :param batch_size: batch大小
        :param shuffle: 是否打乱inputs数据
        :return: 返回一个batch数据
        '''
        # rows,cols=inputs.shape
        rows = len(inputs[0])
        indices = list(range(rows))
        if shuffle:
            random.seed(100)
            random.shuffle(indices)
        while True:
            batch_indices = indices[0:batch_size]  # 产生一个batch的index
            indices = indices[batch_size:] + indices[:batch_size]  # 循环移位,以便产生下一个batch
            batch_data = []
            for data in inputs:
                temp_data = find_list(batch_indices, data)
                batch_data.append(temp_data)
            yield batch_data
    
    
    
    def get_data_batch_one(inputs, batch_size=None, shuffle=False):
        '''
        产生批量数据batch,非循环迭代
        迭代次数由:iter_nums= math.ceil(sample_nums / batch_size)
        :param inputs: list类型数据,多个list,请[list0,list1,...]
        :param batch_size: batch大小
        :param shuffle: 是否打乱inputs数据
        :return: 返回一个batch数据
        '''
        # rows,cols=inputs.shape
        rows = len(inputs[0])
        indices = list(range(rows))
        if shuffle:
            random.seed(100)
            random.shuffle(indices)
        while True:
            batch_data = []
            cur_nums = len(indices)
            batch_size = np.where(cur_nums > batch_size, batch_size, cur_nums)
            batch_indices = indices[0:batch_size]  # 产生一个batch的index
            indices = indices[batch_size:]
            # indices = indices[batch_size:] + indices[:batch_size]  # 循环移位,以便产生下一个batch
            for data in inputs:
                temp_data = find_list(batch_indices, data)
                batch_data.append(temp_data)
            yield batch_data
    
    
    def find_list(indices, data):
        out = []
        for i in indices:
            out = out + [data[i]]
        return out
    
    
    def get_list_batch(inputs, batch_size=None, shuffle=False):
        '''
        循环产生batch数据
        :param inputs: list数据
        :param batch_size: batch大小
        :param shuffle: 是否打乱inputs数据
        :return: 返回一个batch数据
        '''
        if shuffle:
            random.shuffle(inputs)
        while True:
            batch_inouts = inputs[0:batch_size]
            inputs = inputs[batch_size:] + inputs[:batch_size]  # 循环移位,以便产生下一个batch
            yield batch_inouts
    
    
    def load_file_list(text_dir):
        text_dir = os.path.join(text_dir, '*.txt')
        text_list = glob.glob(text_dir)
        return text_list
    
    
    def get_next_batch(batch):
        return batch.__next__()
    
    
    def load_image_labels(finename):
        '''
        载图txt文件,文件中每行为一个图片信息,且以空格隔开:图像路径 标签1 标签1,如:test_image/1.jpg 0 2
        :param test_files:
        :return:
        '''
        images_list = []
        labels_list = []
        with open(finename) as f:
            lines = f.readlines()
            for line in lines:
                # rstrip:用来去除结尾字符、空白符(包括\n、\r、\t、' ',即:换行、回车、制表符、空格)
                content = line.rstrip().split(' ')
                name = content[0]
                labels = []
                for value in content[1:]:
                    labels.append(float(value))
                images_list.append(name)
                labels_list.append(labels)
        return images_list, labels_list
    
    
    if __name__ == '__main__':
        filename = './training_data/test.txt'
        images_list, labels_list = load_image_labels(filename)
    
        # 若输入为np.arange数组,则需要tolist()为list类型,如:
        # images_list = np.reshape(np.arange(8*3), (8,3))
        # labels_list = np.reshape(np.arange(8*3), (8,3))
        # images_list=images_list.tolist()
        # labels_list=labels_list.tolist()
    
        iter = 5  # 迭代3次,每次输出一个batch个
        # batch = get_data_batch([images_list, labels_list], batch_size=3, shuffle=False)
        batch = get_data_batch2(inputs=[images_list,labels_list], batch_size=5, shuffle=True)
    
        for i in range(iter):
            print('**************************')
            batch_images, batch_labels = get_next_batch(batch)
            print('batch_images:{}'.format(batch_images))
            print('batch_labels:{}'.format(batch_labels))
    
    
    

       运行输出结果为:

    **************************
    batch_images:['1.jpg', '2.jpg', '3.jpg']
    batch_labels:[[1.0, 11.0], [2.0, 12.0], [3.0, 13.0]]
    **************************
    batch_images:['4.jpg', '5.jpg', '6.jpg']
    batch_labels:[[4.0, 14.0], [5.0, 15.0], [6.0, 16.0]]
    **************************
    batch_images:['7.jpg', '8.jpg', '1.jpg']
    batch_labels:[[7.0, 17.0], [8.0, 18.0], [1.0, 11.0]]
    **************************
    batch_images:['2.jpg', '3.jpg', '4.jpg']
    batch_labels:[[2.0, 12.0], [3.0, 13.0], [4.0, 14.0]]
    **************************
    batch_images:['5.jpg', '6.jpg', '7.jpg']
    batch_labels:[[5.0, 15.0], [6.0, 16.0], [7.0, 17.0]]

    Process finished with exit code 0

    二、TensorFlow循环产生批量数据batch 

        使用TensorFlow实现产生批量数据batch,需要几个接口,

    (1) tf.train.slice_input_producer

    tf.train.slice_input_producer是一个tensor生成器,作用是按照设定,每次从一个tensor列表中按顺序或者随机抽取出一个tensor放入文件名队列。

    slice_input_producer(tensor_list,
                         num_epochs=None,
                         shuffle=True,
                         seed=None,
                         capacity=32,
                         shared_name=None,
                         name=None)
    # 第一个参数
    #           tensor_list:包含一系列tensor的列表,表中tensor的第一维度的值必须相等,即个数必须相等,有多少个图像,就应该有多少个对应的标签。
    # 第二个参数num_epochs: 可选参数,是一个整数值,代表迭代的次数,如果设置
    #           num_epochs = None, 生成器可以无限次遍历tensor列表,如果设置为
    #           num_epochs = N,生成器只能遍历tensor列表N次。
    # 第三个参数shuffle: bool类型,设置是否打乱样本的顺序。一般情况下,如果shuffle = True,生成的样本顺序就被打乱了,在批处理的时候不需要再次打乱样本,使用
    #           tf.train.batch函数就可以了;
    #           如果shuffle = False, 就需要在批处理时候使用
    #           tf.train.shuffle_batch函数打乱样本。
    # 第四个参数seed: 可选的整数,是生成随机数的种子,在第三个参数设置为shuffle = True的情况下才有用。
    # 第五个参数capacity:设置tensor列表的容量。
    # 第六个参数shared_name:可选参数,如果设置一个‘shared_name’,则在不同的上下文环境(Session)中可以通过这个名字共享生成的tensor。
    # 第七个参数name:可选,设置操作的名称
    

        tf.train.slice_input_producer定义了样本放入文件名队列的方式,包括迭代次数,是否乱序等,要真正将文件放入文件名队列,还需要调用tf.train.start_queue_runners 函数来启动执行文件名队列填充的线程,之后计算单元才可以把数据读出来,否则文件名队列为空的,计算单元就会处于一直等待状态,导致系统阻塞。

        例子:

    import tensorflow as tf
     
    images = ['img1', 'img2', 'img3', 'img4', 'img5']
    labels= [1,2,3,4,5]
     
    epoch_num=8
     
    f = tf.train.slice_input_producer([images, labels],num_epochs=None,shuffle=False)
     
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        for i in range(epoch_num):
            k = sess.run(f)
            print '************************'
            print (i,k)
     
        coord.request_stop()
        coord.join(threads)
    

    (2) tf.train.batch和tf.train.shuffle_batch

        tf.train.batch是一个tensor队列生成器,作用是按照给定的tensor顺序,把batch_size个tensor推送到文件队列,作为训练一个batch的数据,等待tensor出队执行计算。

    tf.train.batch(tensors, 
                   batch_size, 
                   num_threads=1, 
                   capacity=32,
                   enqueue_many=False, 
                   shapes=None, 
                   dynamic_pad=False,
                   allow_smaller_final_batch=False, 
                   shared_name=None, 
                   name=None)
    # 第一个参数tensors:tensor序列或tensor字典,可以是含有单个样本的序列;
    # 第二个参数batch_size: 生成的batch的大小;
    # 第三个参数num_threads:执行tensor入队操作的线程数量,可以设置使用多个线程同时并行执行,提高运行效率,但也不是数量越多越好;
    # 第四个参数capacity: 定义生成的tensor序列的最大容量;
    # 第五个参数enqueue_many: 定义第一个传入参数tensors是多个tensor组成的序列,还是单个tensor;
    # 第六个参数shapes: 可选参数,默认是推测出的传入的tensor的形状;
    # 第七个参数dynamic_pad: 定义是否允许输入的tensors具有不同的形状,设置为True,会把输入的具有不同形状的tensor归一化到相同的形状;
    # 第八个参数allow_smaller_final_batch: 设置为True,表示在tensor队列中剩下的tensor数量不够一个batch_size的情况下,允许最后一个batch的数量少于batch_size, 设置为False,则不管什么情况下,生成的batch都拥有batch_size个样本;
    # 第九个参数shared_name: 可选参数,设置生成的tensor序列在不同的Session中的共享名称;
    # 第十个参数name: 操作的名称;

        如果tf.train.batch的第一个参数 tensors 传入的是tenor列表或者字典,返回的是tensor列表或字典,如果传入的是只含有一个元素的列表,返回的是单个的tensor,而不是一个列表。

        与tf.train.batch函数相对的还有一个tf.train.shuffle_batch函数,两个函数作用一样,都是生成一定数量的tensor,组成训练一个batch需要的数据集,区别是tf.train.shuffle_batch会打乱样本顺序。

    (3) TF循环产生批量数据batch 的完整例子

    # -*-coding: utf-8 -*-
    """
        @Project: LSTM
        @File   : tf_create_batch_data.py
        @Author : panjq
        @E-mail : pan_jinquan@163.com
        @Date   : 2018-10-28 17:50:24
    """
    import tensorflow as tf
    
    
    def get_data_batch(inputs,batch_size,labels_nums,one_hot=False,shuffle=False,num_threads=1):
        '''
        :param inputs: 输入数据,可以是多个list
        :param batch_size:
        :param labels_nums:标签个数
        :param one_hot:是否将labels转为one_hot的形式
        :param shuffle:是否打乱顺序,一般train时shuffle=True,验证时shuffle=False
        :return:返回batch的images和labels
        '''
        # 生成队列
        inputs_que= tf.train.slice_input_producer(inputs, shuffle=shuffle)
        min_after_dequeue = 200
        capacity = min_after_dequeue + 3 * batch_size  # 保证capacity必须大于min_after_dequeue参数值
        if shuffle:
            out_batch = tf.train.shuffle_batch(inputs_que,
                                                batch_size=batch_size,
                                                capacity=capacity,
                                                min_after_dequeue=min_after_dequeue,
                                                num_threads=num_threads)
        else:
            out_batch = tf.train.batch(inputs_que,
                                        batch_size=batch_size,
                                        capacity=capacity,
                                        num_threads=num_threads)
        return out_batch
    
    def get_batch_images(images,labels,batch_size,labels_nums,one_hot=False,shuffle=False):
        '''
        :param images:图像
        :param labels:标签
        :param batch_size:
        :param labels_nums:标签个数
        :param one_hot:是否将labels转为one_hot的形式
        :param shuffle:是否打乱顺序,一般train时shuffle=True,验证时shuffle=False
        :return:返回batch的images和labels
        '''
        images_que, labels_que= tf.train.slice_input_producer([images,labels], shuffle=shuffle)
        min_after_dequeue = 200
        capacity = min_after_dequeue + 3 * batch_size  # 保证capacity必须大于min_after_dequeue参数值
        if shuffle:
            images_batch, labels_batch = tf.train.shuffle_batch([images_que, labels_que],
                                                                batch_size=batch_size,
                                                                capacity=capacity,
                                                                min_after_dequeue=min_after_dequeue)
        else:
            images_batch, labels_batch = tf.train.batch([images_que, labels_que],
                                                        batch_size=batch_size,
                                                        capacity=capacity)
        if one_hot:
            labels_batch = tf.one_hot(labels_batch, labels_nums, 1, 0)
        return images_batch,labels_batch
    
    def load_image_labels(finename):
        '''
        载图txt文件,文件中每行为一个图片信息,且以空格隔开:图像路径 标签1 标签1,如:test_image/1.jpg 0 2
        :param test_files:
        :return:
        '''
        images_list=[]
        labels_list=[]
        with open(finename) as f:
            lines = f.readlines()
            for line in lines:
                #rstrip:用来去除结尾字符、空白符(包括\n、\r、\t、' ',即:换行、回车、制表符、空格)
                content=line.rstrip().split(' ')
                name=content[0]
                labels=[]
                for value in content[1:]:
                    labels.append(float(value))
                images_list.append(name)
                labels_list.append(labels)
        return images_list,labels_list
    
    if __name__ == '__main__':
        filename='./training_data/train.txt'
        # 输入数据可以是list,也可以是np.array
        images_list, labels_list=load_image_labels(filename)
        # np.arange数组如:
        # images_list = np.reshape(np.arange(8*3), (8,3))
        # labels_list = np.reshape(np.arange(8*3), (8,3))
    
        iter = 5  # 迭代5次,每次输出一个batch个
        # batch_images, batch_labels = get_data_batch( inputs=[images_list, labels_list],batch_size=3,labels_nums=2,one_hot=False,shuffle=False,num_threads=1)
        # 或者
        batch_images, batch_labels = get_batch_images(images_list,labels_list,batch_size=3,labels_nums=2,one_hot=False,shuffle=False)
        with tf.Session() as sess:  # 开始一个会话
            sess.run(tf.global_variables_initializer())
            coord = tf.train.Coordinator()
            threads = tf.train.start_queue_runners(coord=coord)
            for i in range(iter):
                # 在会话中取出images和labels
                images, labels = sess.run([batch_images, batch_labels] )
                print('**************************')
                print('batch_images:{}'.format(images ))
                print('batch_labels:{}'.format(labels))
    
            # 停止所有线程
            coord.request_stop()
            coord.join(threads)
    
    

        运行输出结果:

    **************************
    batch_images:[b'1.jpg' b'2.jpg' b'3.jpg']
    batch_labels:[[ 1. 11.] [ 2. 12.][ 3. 13.]]
    **************************
    batch_images:[b'4.jpg' b'5.jpg' b'6.jpg']
    batch_labels:[[ 4. 14.] [ 5. 15.][ 6. 16.]]
    **************************
    batch_images:[b'7.jpg' b'8.jpg' b'1.jpg']
    batch_labels:[[ 7. 17.][ 8. 18.][ 1. 11.]]
    **************************
    batch_images:[b'2.jpg' b'3.jpg' b'4.jpg']
    batch_labels:[[ 2. 12.] [ 3. 13.][ 4. 14.]]
    **************************
    batch_images:[b'5.jpg' b'6.jpg' b'7.jpg']
    batch_labels:[[ 5. 15.][ 6. 16.][ 7. 17.]]

    三、更加实用的方法:数据巨大的情况

        当数据量很大很大时,超过2T的数据时,我们不可能把所以数据都保存为一个文件,也不可能把数据都加载到内存。为了避免内存耗尽的情况,最简单的思路是:把数据分割成多个文件保存到硬盘(每个文件不超过2G),训练时,按batch大小逐个加载文件,再获取一个batch的训练数据。这种方法,也可以用TensorFlow TFRecord格式,利用队列方法读取文件,然后再产生一个batch数据,可以参考:《Tensorflow生成自己的图片数据集TFrecords》:https://blog.csdn.net/guyuealian/article/details/80857228

       但TensorFlow TFRecord格式存储的内容,有很多限制, 这里将实现一种类似于TensorFlow TFRecord的方法,但存储的内容没有限制,你可稍微修改保存不同的数据,基本思路是:

    1. 数据产生:利用numpy,把数据分割成多个*.npy文件保存到硬盘(每个文件不超过1G),当然你可以用其他Python工具保存其他文件格式,只要你能读取文件即可
    2. 获得训练数据:获取所有文件*.npy的列表,逐个读取文件的数据,并根据batch的大小,循环返回数据

         完整代码如下:

        这里将数据保存为data1.npy,data2.npy,data3.npy,其中*.npy文件的数据保存是二维矩阵Mat:第一列为样本的labels,剩余的列为样本的数据,

    indexMat1:
    [[0 0 5]
     [1 1 6]
     [2 2 7]
     [3 3 8]
     [4 4 9]]
    indexMat2:
    [[ 5 15 20]
     [ 6 16 21]
     [ 7 17 22]
     [ 8 18 23]
     [ 9 19 24]]
    indexMat3:
    [[10 30 35]
     [11 31 36]
     [12 32 37]
     [13 33 38]
     [14 34 39]]
    
    # -*-coding: utf-8 -*-
    """
        @Project: nlp-learning-tutorials
        @File   : create_batch_data.py
        @Author : panjq
        @E-mail : pan_jinquan@163.com
        @Date   : 2018-11-08 09:29:19
    """
    
    import math
    import random
    import os
    import glob
    import numpy as np
    from sklearn import preprocessing
    
    
    def get_data_batch(file_list,labels_nums,batch_size=None, shuffle=False,one_hot=False):
        '''
        加载*.npy文件的数据,循环产生批量数据batch,其中*.npy文件的数据保存是二维矩阵Mat:
        二维矩阵Mat:第一列为样本的labels,剩余的列为样本的数据,
        np.concatenate([label,data], axis=1)
        :param file_list: *.npy文件路径,type->list->[file0.npy,file1.npy,....]
        :param labels_nums: labels种类数
        :param batch_size: batch大小
        :param shuffle: 是否打乱数据,PS:只能打乱一个batch的数据,不同batch的数据不会干扰
        :param one_hot: 是否独热编码
        :return: 返回一个batch数据
        '''
        height = 0
        indexMat_labels = None
        i = 0
        while True:
            while height < batch_size:
                i = i%len(file_list)
                tempFile = file_list[i]
                tempMat_labels = np.load(tempFile)
                if indexMat_labels is None:
                    indexMat_labels = tempMat_labels
                else:
                    indexMat_labels = np.concatenate([indexMat_labels, tempMat_labels], 0)
                i=i+1
                height = indexMat_labels.shape[0]
    
            indices = list(range(height))
            batch_indices = np.asarray(indices[0:batch_size])  # 产生一个batch的index
            if shuffle:
                random.seed(100)
                random.shuffle(batch_indices)
    
            batch_indexMat_labels = indexMat_labels[batch_indices] # 使用下标查找,必须是ndarray类型类型
            indexMat_labels=np.delete(indexMat_labels,batch_indices,axis=0)
            height = indexMat_labels.shape[0]
    
            # 将数据分割成indexMat和labels
            batch_labels=batch_indexMat_labels[:,0]     # 第一列是labels
            batch_indexMat=batch_indexMat_labels[:,1:]  # 其余是indexMat
    
            # 是否进行独热编码
            if one_hot:
                batch_labels = batch_labels.reshape(len(batch_labels), 1)
                onehot_encoder = preprocessing.OneHotEncoder(sparse=False,categories=[range(labels_nums)])
                batch_labels = onehot_encoder.fit_transform(batch_labels)
            yield batch_indexMat,batch_labels
    
    
    def get_next_batch(batch):
        return batch.__next__()
    
    def get_file_list(file_dir,postfix):
        '''
        获得后缀名为postfix所有文件列表
        :param file_dir:
        :param postfix:
        :return:
        '''
        file_dir=os.path.join(file_dir,postfix)
        file_list=glob.glob(file_dir)
        return file_list
    
    
    def create_test_data(out_dir):
        '''
        产生测试数据
        :return:
        '''
        data1 = np.arange(0, 10)
        data1 = np.transpose(data1.reshape([2, 5]))
        label1 = np.arange(0, 5)
        label1 = label1.reshape([5, 1])
    
        path1 = os.path.join(out_dir,'data1.npy')
        indexMat1 = np.concatenate([label1, data1], axis=1)  # 矩阵拼接,第一列为labels
        np.save(path1, indexMat1)
    
        data2 = np.arange(15, 25)
        data2 = np.transpose(data2.reshape([2, 5]))
        label2 = np.arange(5, 10)
        label2 = label2.reshape([5, 1])
    
        path2 = os.path.join(out_dir,'data2.npy')
        indexMat2 = np.concatenate([label2, data2], axis=1)
        np.save(path2, indexMat2)
    
        data3 = np.arange(30, 40)
        data3 = np.transpose(data3.reshape([2, 5]))
        label3 = np.arange(10, 15)
        label3 = label3.reshape([5, 1])
    
        path3 = os.path.join(out_dir,'data3.npy')
        indexMat3 = np.concatenate([label3, data3], axis=1)
        np.save(path3, indexMat3)
    
        print('indexMat1:\n{}'.format(indexMat1))
        print('indexMat2:\n{}'.format(indexMat2))
        print('indexMat3:\n{}'.format(indexMat3))
    
    
    if __name__ == '__main__':
        out_dir='./output'
        create_test_data(out_dir)
        file_list=get_file_list(file_dir=out_dir, postfix='*.npy')
        iter = 3  # 迭代3次,每次输出一个batch个
        batch = get_data_batch(file_list, labels_nums=15,batch_size=8, shuffle=False,one_hot=False)
        for i in range(iter):
            print('**************************')
            batch_data, batch_label = get_next_batch(batch)
            print('batch_images:\n{}'.format(batch_data))
            print('batch_labels:\n{}'.format(batch_label))
    
    

    运行结果: 

    **************************
    batch_images:
    [[ 0  5]
     [ 1  6]
     [ 2  7]
     [ 3  8]
     [ 4  9]
     [15 20]
     [16 21]
     [17 22]]
    batch_labels:
    [0 1 2 3 4 5 6 7]
    **************************
    batch_images:
    [[18 23]
     [19 24]
     [30 35]
     [31 36]
     [32 37]
     [33 38]
     [34 39]
     [ 0  5]]
    batch_labels:
    [ 8  9 10 11 12 13 14  0]
    **************************
    batch_images:
    [[ 1  6]
     [ 2  7]
     [ 3  8]
     [ 4  9]
     [15 20]
     [16 21]
     [17 22]
     [18 23]]
    batch_labels:
    [1 2 3 4 5 6 7 8]
    

     

    展开全文
  • 汉字字模点阵数据批量生成工具支持 1024x1024以内的任意点阵汉字支持 所有Windows汉字字体设置支持 汉字大小调整 支持 汉字位置调整 支持 单个汉字字模生成 支持 海量汉字批量字模生成 支持 按汉语拼音排序 支持 ...
  • 在做系统或者做项目的时候,经常会遇到这样的要求:用户给我们发过来一些数据,要求我们把这些数据导入到数 据库中,对于少量的数据来说,用最原始的方法就可以解决,直接在SQL里面用语句来实现,但是如果有成千上万...

         在做系统或者做项目的时候,经常会遇到这样的要求:用户给我们发过来一些数据,要求我们把这些数据导入到数

    据库中,对于少量的数据来说,用最原始的方法就可以解决,直接在SQL里面用语句来实现,但是如果有成千上万条的

    数据呢?如果你还继续单独写SQL语句,估计写个几十条你就会有跳楼的冲动,其实有两种简单的方法:

       1、将Excel的数据整理好,通过SQL的导入功能直接导入到数据库中,但是要保证数据库的字段和Excel的字段一致。

       2、通过Excel生成相应的SQL语句,然后,放到SQL的新建查询中,执行。下面就来说一说该方法怎么用:

       我们要把下面的20条数据导入到数据库中去,一条一条的Insert,太慢,咱是个懒人,想偷懒,只能想别的法儿。

       


       在Excel的E1单元格中,写一段SQL语句,只需要写这一句就可以:

    INSERT INTO TableName(Column1,Column2,Column3) VALUES('Value1','Value2','Value3')
       


      然后直接从头拉到尾,你会发现所有的数据都有对应的脚本,然后直接复制相关的SQL语句,到分析器中,F5,OK,任务完成!

      一点小经验,和大家分享,这是一个分享的时代,相互分享,相互帮助,共同提高。

       


         

    展开全文
  • 作为测试开发工程师,在测试的时候免不了需要用到数据来进行测试,有时需要批量生成一定量的假数据来就进行测试,自己构造确实太麻烦,今天我来讲一下构造假数据的一个非常优秀的框架。在 Python 中有一个非常厉害的...

    前言:

    简略版本可以查看本人的上一篇博客。

    作为测试开发工程师,在测试的时候免不了需要用到数据来进行测试,有时需要批量生成一定量的假数据来就进行测试,自己构造确实太麻烦,今天我来讲一下构造假数据的一个非常优秀的框架。在 Python 中有一个非常厉害的程序库叫做 Faker,它可以自动帮我们来生成各种各样的看起来很真的”假“数据,让我们来一起学习学习这个Faker库吧。

    相信大家都学过Python,这里我就不多说了。

    安装Faker库

    pip3 install faker

    导入Faker库调用

    # coding:utf8
    from faker import Faker
     
    # 中文数据
    faker = Faker('zh_CN')

    Faker 各个类型数据构造的清晰版

    1、Address 地址

    faker.address()
    # '新疆维吾尔自治区杰县南湖武汉街D座 253105'
    faker.building_number()
    # 'B座'
    faker.city()
    # '璐县'
    faker.city_name()
    # '贵阳'
    faker.city_suffix()
    # '县'
    faker.country()
    # '阿拉斯加'
    faker.country_code(representation="alpha-2")
    # 'CR'
    faker.district()
    # '西峰'
    faker.postcode()
    # '726749'
    faker.province()
    # '福建省'
    faker.street_address()
    # '余路N座'
    faker.street_name()
    # '李路'
    faker.street_suffix()
    # '路'
    

    2、Color 颜色

    faker.color_name()
    # 'DarkKhaki'
    faker.hex_color()
    # '#97d14e'
    faker.rgb_color()
    # '107,179,51'
    faker.rgb_css_color()
    # 'rgb(20,46,70)'
    faker.safe_color_name()
    # 'navy'
    faker.safe_hex_color()
    # '#dd2200'
    

    3、Company 公司

    faker.bs()
    # 'grow rich initiatives'
    faker.catch_phrase()
    # 'Self-enabling encompassing function'
    faker.company()
    # '恒聪百汇网络有限公司'
    faker.company_prefix()
    # '晖来计算机'
    faker.company_suffix()
    # '信息有限公司'
    Credit Card
    
    Credit Card,用于生成信用卡相关数据,如过期时间、银行卡号、安全码等内容,用法如下:
    
    faker.credit_card_expire(start="now", end="+10y", date_format="%m/%y")
    # '08/20'
    faker.credit_card_full(card_type=None)
    # 'Mastercard\n玉兰 范\n5183689713096897 01/25\nCVV: 012\n'
    faker.credit_card_number(card_type=None)
    # '4009911097184929918'
    faker.credit_card_provider(card_type=None)
    # 'JCB 15 digit'
    faker.credit_card_security_code(card_type=None)
    # '259'
    

    4、Date Time 时间

    faker.am_pm()
    # 'AM'
    faker.century()
    # 'X'
    faker.date(pattern="%Y-%m-%d", end_datetime=None)
    # '1997-06-16'
    faker.date_between(start_date="-30y", end_date="today")
    # datetime.date(2000, 8, 30)
    faker.date_between_dates(date_start=None, date_end=None)
    # datetime.date(2019, 7, 30)
    faker.date_object(end_datetime=None)
    # datetime.date(1978, 3, 12)
    faker.date_of_birth(tzinfo=None, minimum_age=0, maximum_age=115)
    # datetime.date(2012, 6, 3)
    faker.date_this_century(before_today=True, after_today=False)
    # datetime.date(2011, 6, 12)
    faker.date_this_decade(before_today=True, after_today=False)
    # datetime.date(2011, 8, 22)
    faker.date_this_month(before_today=True, after_today=False)
    # datetime.date(2019, 7, 25)
    faker.date_this_year(before_today=True, after_today=False)
    # datetime.date(2019, 7, 22)
    faker.date_time(tzinfo=None, end_datetime=None)
    # datetime.datetime(2018, 8, 11, 22, 3, 34)
    faker.date_time_ad(tzinfo=None, end_datetime=None, start_datetime=None)
    # datetime.datetime(1566, 8, 26, 16, 25, 30)
    faker.date_time_between(start_date="-30y", end_date="now", tzinfo=None)
    # datetime.datetime(2015, 1, 31, 4, 14, 10)
    faker.date_time_between_dates(datetime_start=None, datetime_end=None, tzinfo=None)
    # datetime.datetime(2019, 7, 30, 17, 51, 44)
    faker.date_time_this_century(before_now=True, after_now=False, tzinfo=None)
    # datetime.datetime(2002, 9, 25, 23, 59, 49)
    faker.date_time_this_decade(before_now=True, after_now=False, tzinfo=None)
    # datetime.datetime(2010, 5, 25, 20, 20, 52)
    faker.date_time_this_month(before_now=True, after_now=False, tzinfo=None)
    # datetime.datetime(2019, 7, 19, 18, 4, 6)
    faker.date_time_this_year(before_now=True, after_now=False, tzinfo=None)
    # datetime.datetime(2019, 3, 15, 11, 4, 18)
    faker.day_of_month()
    # '04'
    faker.day_of_week()
    # 'Monday'
    faker.future_date(end_date="+30d", tzinfo=None)
    # datetime.date(2019, 8, 12)
    faker.future_datetime(end_date="+30d", tzinfo=None)
    # datetime.datetime(2019, 8, 24, 2, 59, 4)
    faker.iso8601(tzinfo=None, end_datetime=None)
    # '1987-07-01T18:33:56'
    faker.month()
    # '11'
    faker.month_name()
    # 'August'
    faker.past_date(start_date="-30d", tzinfo=None)
    # datetime.date(2019, 7, 25)
    faker.past_datetime(start_date="-30d", tzinfo=None)
    # datetime.datetime(2019, 7, 18, 22, 46, 51)
    faker.time(pattern="%H:%M:%S", end_datetime=None)
    # '16:22:30'
    faker.time_delta(end_datetime=None)
    # datetime.timedelta(0)
    faker.time_object(end_datetime=None)
    # datetime.time(22, 12, 15)
    faker.time_series(start_date="-30d", end_date="now", precision=None, distrib=None, tzinfo=None)
    # <generator object Provider.time_series at 0x7fcbce0604f8>
    faker.timezone()
    # 'Indian/Comoro'
    faker.unix_time(end_datetime=None, start_datetime=None)
    # 1182857626
    faker.year()
    # '1970'
    

    5、File 文件

    faker.file_extension(category=None)
    # 'flac'
    faker.file_name(category=None, extension=None)
    # '然后.numbers'
    faker.file_path(depth=1, category=None, extension=None)
    # '/关系/科技.mov'
    faker.mime_type(category=None)
    # 'video/ogg'
    faker.unix_device(prefix=None)
    # '/dev/sdd'
    faker.unix_partition(prefix=None)
    # '/dev/xvds3'
    

    6、Geo 地理位置数据

    faker.coordinate(center=None, radius=0.001)
    # Decimal('-114.420686')
    faker.latitude()
    # Decimal('-9.772541')
    faker.latlng()
    # (Decimal('-27.0730915'), Decimal('-5.919460'))
    faker.local_latlng(country_code="US", coords_only=False)
    # ('41.47892', '-87.45476', 'Schererville', 'US', 'America/Chicago')
    faker.location_on_land(coords_only=False)
    # ('12.74482', '4.52514', 'Argungu', 'NG', 'Africa/Lagos')
    faker.longitude()
    # Decimal('40.885895')
    

    7、Internet 互联网数据

    faker.ascii_company_email(*args, **kwargs)
    # 'xuna@xiaqian.cn'
    faker.ascii_email(*args, **kwargs)
    # 'min59@60.cn'
    faker.ascii_free_email(*args, **kwargs)
    # 'min75@gmail.com'
    faker.ascii_safe_email(*args, **kwargs)
    # 'cliu@example.com'
    faker.company_email(*args, **kwargs)
    # 'ilong@99.cn'
    faker.domain_name(levels=1)
    # 'xiulan.cn'
    faker.domain_word(*args, **kwargs)
    # 'luo'
    faker.email(*args, **kwargs)
    # 'maoxiulan@hotmail.com'
    faker.free_email(*args, **kwargs)
    # 'yanshen@gmail.com'
    faker.free_email_domain(*args, **kwargs)
    # 'yahoo.com'
    faker.hostname(*args, **kwargs)
    # 'lt-18.pan.cn'
    faker.image_url(width=None, height=None)
    # 'https://placekitten.com/51/201'
    faker.ipv4(network=False, address_class=None, private=None)
    # '192.233.68.5'
    faker.ipv4_network_class()
    # 'a'
    faker.ipv4_private(network=False, address_class=None)
    # '10.9.97.93'
    faker.ipv4_public(network=False, address_class=None)
    # '192.51.22.7'
    faker.ipv6(network=False)
    # 'de57:9c6f:a38c:9864:10ec:6442:775d:5f02'
    faker.mac_address()
    # '99:80:5c:ab:8c:a9'
    faker.safe_email(*args, **kwargs)
    # 'tangjuan@example.net'
    faker.slug(*args, **kwargs)
    # ''
    faker.tld()
    # 'cn'
    faker.uri()
    # 'http://fangfan.org/app/tag/post/'
    faker.uri_extension()
    # '.php'
    faker.uri_page()
    # 'about'
    faker.uri_path(deep=None)
    # 'app'
    faker.url(schemes=None)
    # 'http://mingli.cn/'
    faker.user_name(*args, **kwargs)
    # 'jie54'
    Job
    
    Job,用于生成和职业相关的数据,用法如下:
    
    faker.job()
    # '烫工'
    

    8、 Lorem 假文字数据

    faker.paragraph(nb_sentences=3, variable_nb_sentences=True, ext_word_list=None)
    # '包括的是报告那些一点.图片地址基本全部.'
    faker.paragraphs(nb=3, ext_word_list=None)
    # [   '计划规定这样所以组织商品其中.参加成为不同发表地区.精华科技谢谢大家需要.一下手机上海中文工程.',
    #     '非常相关是一就是一个一种文章发生.增加那些以及之后以下你的.',
    #     '学生应该出来分析增加关系组织.评论来源朋友注册应该需要单位.感觉最后无法发现选择人民.']
    faker.sentence(nb_words=6, variable_nb_words=True, ext_word_list=None)
    # '介绍结果自己解决处理.'
    faker.sentences(nb=3, ext_word_list=None)
    # ['查看其实一次学习登录浏览是一他们.', '而且资源的人事情.', '科技价格免费大学教育.']
    faker.text(max_nb_chars=200, ext_word_list=None)
    # ('只是当前国内中文所以.威望系统在线虽然.\n'
    #  '图片人民非常合作这种谢谢更新.名称详细直接社会一直首页完全.\n'
    #  '重要更多只要市场.必须只是学生音乐.系统美国类别这些一切环境.\n'
    #  '但是的话人民美国关于.\n'
    #  '情况专业国际看到研究.音乐环境市场搜索发现.\n'
    #  '工具还是到了今天位置人民.留言作者品牌工程项目必须.上海精华现在我们新闻应该关系.\n'
    #  '更新经济能力全部资源如果.手机能够登录国内.')
    faker.texts(nb_texts=3, max_nb_chars=200, ext_word_list=None)
    # [   '成功可能推荐你的行业.地区而且推荐.\n'
    #     '网络不断是一主要必须.开始安全服务.\n'
    #     '应该网上通过以后通过大学.管理要求有关国际阅读当前.为了应该结果点击公司开始怎么.\n'
    #     '成功一次最大生产网站.这种加入她的地址有限.\n'
    #     '根据新闻汽车起来非常主题显示必须.有些建设来自作者电话支持.\n'
    #     '只是资源还是由于经济事情喜欢.为什中文大小得到服务.网络密码是否免费参加一次社区欢迎.',
    #     '部门活动技术.商品影响发生行业密码完成.就是部门结果资料学习当然.或者帮助城市要求首页市场教育你们.\n'
    #     '专业完全分析处理城市大学什么.\n'
    #     '文件非常国际全部起来积分公司.资料的是电影没有.这是本站需要.\n'
    #     '合作重要没有现在市场开发空间.您的会员推荐成功教育进行中国.\n'
    #     '文件不是如果评论.因为经验设备规定.\n'
    #     '加入一起影响网上大家运行在线如果.工程企业这种以后.',
    #     '空间市场出现必须基本电话.显示一个标准其他设计作品.工程不断新闻问题更多更新这么.\n'
    #     '一起简介网上内容不会.任何知道各种两个.类别事情经营那么投资市场.\n'
    #     '那些使用介绍公司朋友人民你们浏览.应该表示一点一般说明主要谢谢.电话回复起来经验一个来源加入.\n'
    #     '地区法律其他表示虽然.参加社会喜欢有限论坛一般发布.类别目前文化可以.\n'
    #     '报告质量工作主要.企业发布完全.得到名称作者等级两个论坛只要电话.']
    faker.word(ext_word_list=None)
    # '注意'
    faker.words(nb=3, ext_word_list=None, unique=False)
    # ['责任', '组织', '以后']
    

    9、Misc,混淆数据,比如密码、sha1、sha256、md5 等加密后的内容

    faker.boolean(chance_of_getting_true=50)
    # True
    faker.md5(raw_output=False)
    # '3166fa26ffd3f2a33e020dfe11191ac6'
    faker.null_boolean()
    # False
    faker.password(length=10, special_chars=True, digits=True, upper_case=True, lower_case=True)
    # 'W7Ln8La@%O'
    faker.sha1(raw_output=False)
    # 'c8301a2a79445439ee5287f38053e4b3a05eac79'
    faker.sha256(raw_output=False)
    # '1e909d331e20cf241aaa2da894deae5a3a75e5cdc35c053422d9b8e7ccfa0402'
    faker.uuid4(cast_to=<class 'str'>)
    # '6e6fe387-6877-48d9-94ea-4263c4c71aa5'
    

    10、Person 和人相关的

    faker.first_name()
    # '颖'
    faker.first_name_female()
    # '芳'
    faker.first_name_male()
    # '利'
    faker.first_romanized_name()
    # 'Jing'
    faker.last_name()
    # '温'
    faker.last_name_female()
    # '寇'
    faker.last_name_male()
    # '陈'
    faker.last_romanized_name()
    # 'Lei'
    faker.name()
    # '黄明'
    faker.name_female()
    # '张凯'
    faker.name_male()
    # '黄鹏'
    
    
    print(faker.name()) # 姓名
    print(faker.ssn()) #身份证号
    print(faker.country()) # 国家
    print(faker.postcode()) # 邮编
    print(faker.credit_card_number()) # 信用卡号
    print(faker.city_suffix()) #
    print(faker.file_name()) #文件名带后缀
    print(faker.file_path()) #路径带文件
    print(faker.domain_name())#域名

     

    11、User-Agent 浏览器 User-Agent 相关的内容,

    faker.chrome(version_from=13, version_to=63, build_from=800, build_to=899)
    # ('Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/5332 (KHTML, like Gecko) '
    #  'Chrome/40.0.837.0 Safari/5332')
    faker.firefox()
    # ('Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_8_9; rv:1.9.4.20) '
    #  'Gecko/2019-05-02 05:58:44 Firefox/3.6.19')
    faker.internet_explorer()
    # 'Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/3.0)'
    faker.linux_platform_token()
    # 'X11; Linux i686'
    faker.linux_processor()
    # 'x86_64'
    faker.mac_platform_token()
    # 'Macintosh; U; PPC Mac OS X 10_12_5'
    faker.mac_processor()
    # 'U; Intel'
    faker.opera()
    # 'Opera/9.77.(Windows NT 4.0; vi-VN) Presto/2.9.182 Version/11.00'
    faker.safari()
    # ('Mozilla/5.0 (Macintosh; PPC Mac OS X 10_7_1 rv:5.0; or-IN) '
    #  'AppleWebKit/535.9.4 (KHTML, like Gecko) Version/5.0.2 Safari/535.9.4')
    faker.user_agent()
    # 'Opera/8.69.(X11; Linux i686; ml-IN) Presto/2.9.170 Version/11.00'
    faker.windows_platform_token()
    # 'Windows NT 6.1'
    

    本博客参考了博客:https://blog.csdn.net/qq_42692386/article/details/107359656

    Faker的官网,官方文档链接 https://faker.readthedocs.io/en/master/locales/zh_CN.html

    12、补充faker函数

    Python Faker库常用操作 函数(自用)
    country():国家
    province():省份
    city_suffix():市,县
    district():区
    street_address():街道地址
    street_name():街道名
    street_suffix():街、路
    country_code():国家编码
    postcode():邮编
    geo_coordinate():地理坐标
    longitude():经度
    latitude():纬度
    lexify():替换所有问号?带有随机事件
    numerify():生成三位随机数
    random_digit():生成0~9随机数
    random_digit_not_null():生成1~9的随机数
    random_element():生成随机字母
    random_int():随机数字,默认0~9999,可通过min,max参数修改
    random_letter():随机字母
    random_number():随机数字,参数digits设置生成的数字位数
    color_name():随机颜色名
    hex_color():随机HEX颜色
    rgb_color():随机RGB颜色
    safe_color_name():随机安全色名
    safe_hex_color():随机安全HEX颜色
    bs():随机公司服务名
    company():随机公司名(长)
    company_prefix():随机公司名(短)
    company_suffix():公司性质
    credit_card_expire():随机信用卡到期日
    credit_card_full():生成完整信用卡信息
    credit_card_number():信用卡号
    credit_card_provider():信用卡类型
    credit_card_security_code():信用卡安全码
    currency_code():货币编码
    am_pm():AM/PM
    century():随机世纪
    date():随机日期
    date_between():随机生成指定范围内日期,参数:start_date,end_date
    date_between_dates():随机生成指定范围内日期,用法同上
    date_object():随机生产从1970-1-1到指定日期的随机日期。
    date_this_month():
    date_this_year():
    date_time():随机生成指定时间(1970年1月1日至今)
    date_time_ad():生成公元1年到现在的随机时间
    date_time_between():用法同dates
    future_date():未来日期
    future_datetime():未来时间
    month():随机月份
    month_name():随机月份(英文)
    past_date():随机生成已经过去的日期
    past_datetime():随机生成已经过去的时间
    time():随机24小时时间
    timedelta():随机获取时间差
    time_object():随机24小时时间,time对象
    time_series():随机TimeSeries对象
    timezone():随机时区
    unix_time():随机Unix时间
    year():随机年份
    file_extension():随机文件扩展名
    file_name():随机文件名(包含扩展名,不包含路径)
    file_path():随机文件路径(包含文件名,扩展名)
    mime_type():随机mime Type
    ascii_company_email():随机ASCII公司邮箱名
    ascii_email():随机ASCII邮箱
    ascii_free_email():
    ascii_safe_email():
    company_email():
    domain_name():生成域名
    domain_word():域词(即,不包含后缀)
    email():
    free_email():
    free_email_domain():
    f.safe_email():安全邮箱
    f.image_url():随机URL地址
    ipv4():随机IP4地址
    ipv6():随机IP6地址
    mac_address():随机MAC地址
    tld():网址域名后缀
    uri():随机URI地址
    uri_extension():网址文件后缀
    uri_page():网址文件(不包含后缀)
    uri_path():网址文件路径(不包含文件名)
    url():随机URL地址
    user_name():随机用户名
    isbn10():随机ISBN(10位)
    isbn13():随机ISBN(13位)
    job():随机职位
    paragraph():随机生成一个段落
    paragraphs():随机生成多个段落,通过参数nb来控制段落数,返回数组
    sentence():随机生成一句话
    sentences():随机生成多句话,与段落类似
    text():随机生成一篇文章
    word():随机生成词语
    words():随机生成多个词语,用法与段落,句子,类似
    binary():随机生成二进制编码
    boolean():True/False
    language_code():随机生成两位语言编码
    locale():随机生成语言/国际 信息
    md5():随机生成MD5
    null_boolean():NULL/True/False
    password():随机生成密码,可选参数:length:密码长度;special_chars:是否能使用特殊字符;digits:是否包含数字;upper_case:是否包含大写字母;lower_case:是否包含小写字母
    sha1():随机SHA1
    sha256():随机SHA256
    uuid4():随机UUID
    first_name():
    first_name_female():女性名
    first_name_male():男性名
    first_romanized_name():罗马名
    last_name():
    last_name_female():女
    last_name_male():男
    last_romanized_name():
    name():随机生成姓名
    name_female():男性姓名
    name_male():女性姓名
    romanized_name():罗马名
    msisdn():移动台国际用户识别码,即移动用户的ISDN号码
    phone_number():随机生成手机号
    phonenumber_prefix():随机生成手机号段
    profile():随机生成档案信息
    simple_profile():随机生成简单档案信息

    随机生成指定类型数据:
    pybool():
    pydecimal():
    pydict():
    pyfloat():left_digits=2 #生成的整数位数,
    right_digits=1 #生成的小数位数,
    positive=True #是否只有正数
    pyint():
    pyiterable()
    pylist()
    pyset()
    pystr()
    pystruct()
    pytuple()
    ssn():生成身份证号
    chrome():随机生成Chrome的浏览器user_agent信息
    firefox():随机生成FireFox的浏览器user_agent信息
    internet_explorer():随机生成IE的浏览器user_agent信息
    opera():随机生成Opera的浏览器user_agent信息
    safari():随机生成Safari的浏览器user_agent信息
    linux_platform_token():随机Linux信息
    user_agent():随机user_agent信息

    展开全文
  • 生成合成时间序列和顺序数据要比表格数据更具挑战性,在表格数据中,通常将与一个人有关的所有信息存储在一行中。 在顺序数据中,信息可以分布在许多行中,例如信用卡交易,并且保留行(事件)和列之间的相关性...
  • 使用Excel批量生成SQL脚本(小技巧)

    千次阅读 2015-08-20 18:08:31
     我们需要把Excel中的一些资料更新到数据库中,比如学生的考试系统,在数据中已经有了考生的ID,这里有一份考生ID和考生成绩的Excel,我们如何把考生成绩更新到数据库中呢?   方案: 我们最常使用...
  • sqlldr 批量生成CTL文件

    千次阅读 2019-04-12 15:40:34
    用sqlldr导进数据时,需要编写CTL文件,如果有多个数据文件,我们手动去编写CTL文件,就很费事,那么我们可以通过数据动态生成CTL文件。 1、 ----创建目录 ---创建目录需要用管理员的权限,用sys用户 create or ...
  • (通过foreach,生成很长的SQL)ExecutorType.BATCH方式执行批量操作在这里简单介绍一下,自动生成工具的使用方法 常规批量插入。(通过foreach,生成很长的SQL) 第一先建实体类 package com.lanou.spring.bean; ...
  • 我们工作中,经常需要获取服务器的一些信息,包括...基于以上这些需求,我写了一个脚本,用shell批量获取远程服务器的信息保存到一个结果,然后用python进行解析,生成excel。以下是具体步骤: 配置ssh免密码登录,或
  • 批量导入数据到Redis

    千次阅读 2019-01-23 11:06:33
    推荐系统实战过程中,需要将生成的item-item:score数据导入到redis数据库中,便于之后的在线查询 方法: Redis2.6之后,redis-cli支持pipe模式进行批量插入数据 我们只需要将数据格式化为: SET key value(空格隔开...
  • Word/WPS 利用邮件合并批量生成文档

    千次阅读 2021-06-16 10:25:26
    准备用于批量生成数据3. 插入数据批量生成文档4. 批量生成文档参考资料 WPS 准备一个模板文档、一组数据。通过邮件合并功能,将每行数据填入模板文档指定位置,最终将生成一个文档。 1. 先找到功能所有位置 先...
  • 如何使用Excel表格导入数据批量开票

    千次阅读 2017-10-28 20:01:50
    首先我来说一下它是做什么用的,它的主要作用是把用户的开票数据,Excel数据、ERP 系统导入到税控盘开票软件中。 解决企业开票明细多、开票数据量大、手工输入明细慢、开票赋码不方便等问题,通过使用开票助手...
  • hibernate注解自动生成数据表

    万次阅读 2011-12-17 14:39:43
    按习惯来说,一般系统开发都是从数据库开始设计的。但从面向对象开发的角度,系统...另外,使用注解也省却了很多繁杂的配置工作,下面对hibernate注解自动生成数据表的过程做一个详细描述。  一、环境搭载  下载了
  • 使用 BulkLoad 向 HBase 中批量导入数据

    千次阅读 2020-06-16 08:56:33
    一、背景介绍1.1 概述我们经常面临向 HBase 中导入大量数据的情景。往 HBase 中批量加载数据的方式有很多种,最直接方式是调用 HBase 的 API 用 put 方法插入数据...
  • 有时候我们在做项目时,有些项目需要生成Microsoft Excel...例如,本次利用 POI 技术实现使用模板批量添加数据。 下载上传模板1.编写页面function downloadTemplate(){ window.open('template/userExporTemplate.xls'
  • 溯源二维码标签是指以二维码为信息...首先,需要通过溯源管理系统数据导出为数据源文档,然后将数据文档导入二维码生成器中来制作溯源二维码。下面来看一下具体的操作方法: 一、打开二维码生成器,设置合适的标...
  • SQL SERVER存储过程批量插入数据库表数据 这是个简单的例子,向岗位中插入数据。要求编号名称全部是以GSPOS_为前缀的,如POS_1,一直到POS_1000,备注里内容如批量加的GSPOS_1,批量加的GSPOS_2...... Declare @td ...
  • 批量处理NC数据

    千次阅读 2017-06-05 23:24:31
    NetCDF全称为network Common Data Format,中文译法为“网络通用... ,分别使用Arcgis、IDL批量处理。基础了解见http://blog.renren.com/share/242186498/4248540111 1、将NetCDF文件批量导出为tiff文件: 打开Arcmap—
  • 设计了一个Word文档批量生成小工具软件

    万次阅读 多人点赞 2018-08-25 10:44:45
    最近,因工作需要开发了一个文档自动生成的小工具软件,即批量替换Word文档模板中设定标签为指定的内容。Word文档模板为事先已经排版好的报表、公文等文件,但留下部分内容需要更改,将该内容设定为一个标签(如...
  • Hive 批量数据迁移

    千次阅读 2017-12-18 10:55:53
    验证hive export/import 数据迁移工具
  • Conceptual Data Model 概念数据模型(CDM)帮助您分析信息系统的概念结构,以识别要表示的主要实体、它们的属性以及它们之间的关系。 CDM比逻辑(LDM)或物理(PDM)数据模型更抽象。 1.新建概念数据模型 2.创建域...
  • MySQL 测试数据快速生成

    万次阅读 2019-04-21 15:58:01
    在我们进行大数据量的报表测试以及性能测试时,需要数据库中存在大量的基础测试数据,但是依赖于系统本身大多数情况下都无法快速产生大量适合的测试数据,这就需要我们手动生成一些测试数据。 目前生成数据的方式...
  • 一次性保存多条数据(批量保存)比较简单方便的做法就是使用json格式,具体看我的这篇文章,批量保存数据(json版),该篇文章详细的介绍了使用json来做批量保存!有图有代码有步骤! 但是我本篇文章并没有使用json,我...
  • Laravel批量更新多条数据

    千次阅读 2019-09-04 11:01:58
    近期在刷新生产环境数据库的时候,需要更新中的字段,如果对每条数据结果都执行一次update语句,占用的数据库资源就会很多,而且速度慢,显得也不高大上。 因为项目是Laravel框架,Laravel有批量插入的方法,却...
  • 使用Kettle批量同步数据库

    千次阅读 2018-08-14 12:27:16
    从源库中同步若干张数据表至目标库或目标文件中 (鉴于Kettle工具对数据库连接的插件支持不是太好,最好是在源库与目标库类型相同的情况下使用,如:都是Oracle或都是Mysql等,当然不同的数据库也是可以的) 直接点:...
  • 近期用到同步数据的工具,就是将一个网站的订单信息同步到另一个后台订单系统中,由于订单数据量较大,所以就用到了"批量" --- 批量获取 批量插入

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 123,741
精华内容 49,496
关键字:

使用系统表生成批量数据