class mockDataGenerator():
def __init__(self, language):
self.fake = Factory().create(language)
def random_phone_number(self):
return self.fake.phone_number()
def random_name(self):
return self.fake.name()
def random_address(self):
return self.fake.addres()
def random_email(self):
return self.fake.email()
def random_ipv4(self):
return self.fake.ipv4()
def random_str(self, min_chars=0, max_chars=8):
return self.fake.pystr(min_chars=min_chars, max_chars=max_chars)
def random_text(self):
return self.fake.text()
def random_timestamp(self):
return self.fake.unix_time(end_datetime=None)
def random_int(self):
return self.fake.pyint()
def random_bool(self):
return self.fake.pybool()
def random_description(self):
return self.fake.paragraph(nb_sentences=3,
variable_nb_sentences=True,
ext_word_list=None)
def random_title(self):
return self.fake.sentence(nb_words=6,
variable_nb_words=True,
ext_word_list=None)
def random_type(self):
i = random.randint(0, 10)
if i == 0:
type_ = '前端'
else:
type_ = '后端'
return type_
class Generator:
def __init__(self):
self.fake = Factory().create('zh_CN')
def random_phone_number(self):
"""随机手机号"""
return self.fake.phone_number()
def random_name(self):
"""随机姓名"""
return self.fake.name()
def random_address(self):
"""随机地址"""
return self.fake.address()
def random_email(self):
"""随机email"""
return self.fake.email()
def random_ipv4(self):
"""随机IPV4地址"""
return self.fake.ipv4()
def random_str(self, min_chars=0, max_chars=8):
"""长度在最大值与最小值之间的随机字符串"""
return self.fake.pystr(min_chars=min_chars, max_chars=max_chars)
def factory_generate_ids(self, starting_id=1, increment=1):
""" 返回一个生成器函数，调用这个函数产生生成器，从starting_id开始，步长为increment。 """
def generate_started_ids():
val = starting_id
local_increment = increment
while True:
yield val
val += local_increment
return generate_started_ids
def factory_choice_generator(self, values):
""" 返回一个生成器函数，调用这个函数产生生成器，从给定的list中随机取一项。 """
def choice_generator():
my_list = list(values)
# rand = random.Random()
while True:
yield random.choice(my_list)
return choice_generator
# 导入faker模块
from faker import Factory
fake = Factory().create(locale="zh_CN")
# print(dir(fake))
for i in range(1, 11):
print("第{0}次随机产生的数据:".format(i))
print("用户姓名:{0}".format(fake.name()))
print("用户名:{0}".format(fake.user_name()))
print("密码:{0}".format(fake.password()))
print("电子信箱:{0}".format(fake.email()))
print("电话号码:{0}".format(fake.phone_number()))
print("住址:{0}".format(fake.address()))
print("所在城市:{0}".format(fake.city()))
print("段落:{0}".format(fake.paragraph()))
print("文本:{0}".format(fake.text()))
print("IPv4:{0}".format(fake.ipv4()))
print("网址:{0}".format(fake.url()))
print("指定长度的字符串:{0}".format(fake.pystr(min_chars=6, max_chars=12)))
class FackData(object):
def __init__(self, locale):
self.faker = Factory().create(locale)
self.faker_funcs = dir(self.faker)
self.lock = compat.Lock()
self.auto_inc = Dict()
self.current_num = 0
######## mysql 数值类型 #############
def fake_tinyint(self, digits=None, unsigned=False):
return self.faker.random_int(
0, 255) if unsigned else self.faker.random_int(-128, 127)
def fake_smallint(self, digits=None, unsigned=False):
return self.faker.random_int(
0, 65535) if unsigned else self.faker.random_int(-32768, 32767)
def fake_mediumint(self, digits=None, unsigned=False):
return self.faker.random_int(
0, 16777215) if unsigned else self.faker.random_int(
-8388608, 8388607)
def fake_int(self, min=None, max=None, unsigned=False):
if min or max:
return self.faker.random_int(min, max)
return self.faker.random_int(
0, 4294967295) if unsigned else self.faker.random_int(
-2147483648, 2147483647)
def fake_integer(self, *args):
return self.fake_int(*args)
def fake_bigint(self, *args):
return self.faker.random_int(0, 18446744073709551615) if len(args) > 0 \
else self.faker.random_int(-9223372036854775808, 9223372036854775807)
def fake_float(self, *args):
return self.faker.pyfloat()
def fake_double(self, *args):
return self.fake_float()
def fake_decimal(self,
digits,
right_digits,
flag=None,
min_value=None,
max_value=None):
"""
mysql中DECIMAL(6,2);
最多可以存储6位数字，小数位数为2位; 因此范围是从-9999.99到9999.99
而pyfloat left_digits, right_digits 表示小数点左右数字位数
:param args:
:return:
"""
if flag is None:
flag = random.randint(0, 1)
number = self.faker.pyfloat(left_digits=(digits - right_digits),
right_digits=right_digits,
positive=True,
min_value=min_value,
max_value=max_value)
return number if flag == 1 else -number
############ mysql 日期和时间类型 ###################
def fake_date(self,
start_date='-30y',
end_date='today',
format='%Y-%m-%d'):
"""
以今天为基点，start_day, end_day两个参数，往前后推的天数
end_day默认今天
format为输出格式
:param args:
:return:
"""
thedate = self.faker.date_between(start_date, end_date)
return thedate.strftime(format)
def fake_datetime_between(self, sdt, edt, foramt='%Y-%m-%d %H:%M:%S'):
sdatetime = datetime.datetime.strptime(sdt, '%Y-%m-%d %H:%M:%S')
stimestamp = time.mktime(sdatetime.timetuple())
edatetime = datetime.datetime.strptime(edt, '%Y-%m-%d %H:%M:%S')
etimestamp = time.mktime(edatetime.timetuple())
timestamp = random.randint(stimestamp, etimestamp)
ltime = time.localtime(timestamp)
return time.strftime(foramt, ltime)
def fake_date_between(self, start_date, end_date, format='%Y-%m-%d'):
# 去掉时分秒，不然后续计算天差值会出错
start_date_time = '{0} 00:00:00'.format(start_date)
end_date_time = '{0} 23:59:59'.format(end_date)
random_datetime = self.fake_datetime_between(start_date_time,
end_date_time)
random_date = datetime.datetime.strptime(random_datetime.split()[0],
'%Y-%m-%d').date()
return datetime.datetime.strftime(random_date, format)
def fake_time(self, *args):
return self.faker.time()
def fake_year(self, *args):
return self.faker.year()
def fake_datetime(self, now=0, format='%Y-%m-%d %H:%M:%S'):
dt = datetime.datetime.now() if now else self.faker.date_time()
return dt.strftime(format)
def fake_timestamp(self, now=0):
timestamp = int(time.time()) if now else self.faker.unix_time()
return timestamp
########### mysql 字符串类型##############
def fake_char(self, *args):
return self.faker.pystr(min_chars=1, max_chars=255)
def fake_varchar(self, max_chars=255):
return self.faker.pystr(min_chars=1, max_chars=max_chars)
def fake_tinyblob(self, *args):
# TODO 待实现
return None
def fake_tinytext(self, *args):
max_nb_chars = args[0] if len(args) else 255
return self.faker.text(max_nb_chars=max_nb_chars)
def fake_text(self, *args):
max_nb_chars = args[0] if len(args) else 65535
return self.faker.text(max_nb_chars=max_nb_chars)
def fake_mediumtext(self, *args):
# TODO 待实现
return None
def fake_longtext(self, *args):
# TODO 待实现
return None
############ hive 基本数据类型 #############
def fake_number(self, digits=None, fix_len=0, positive=0):
"""
digits=None, fix_len=0, positive=0
:param digits:
:param fix_len:
:param positive:
:return:
"""
fixlen = (fix_len == 1)
val = self.faker.random_number(digits=digits, fix_len=fixlen)
if positive > 0:
val = val if val >= 0 else -val
if positive < 0:
val = val if val <= 0 else -val
return val
def fake_string(self, *args):
return self.faker.pystr(*args)
####### 定制函数 ##########
def fake_age(self, *args):
if not args:
args = [0, 100]
return self.faker.random_int(*args)
def fake_inc(self, mark, start=0, step=1):
"""
用于实现整型变量自增
:param args:
:return:
"""
with self.lock:
if mark not in self.auto_inc:
self.auto_inc[mark] = int(start)
ret = self.auto_inc[mark]
self.auto_inc[mark] += int(step)
return ret
def fake_enum(self, *args):
"""
实现枚举类型，随机返回一个列表中值
:param args: 枚举数组
:return:
"""
return random.choice(list(args))
def fake_order_enum(self, *args):
"""
用于循环顺序产生枚举值。常用于多列关联产生值
:param args: 数组值
:return:
"""
datas = list(args)
num = len(datas)
idx = (self.current_num % num) - 1
return datas[idx]
def fake_op(self, *args):
"""
实现多字段四项运算
:param args:
:return:
"""
return None
######## 执行主函数 #########
def do_fake(self, keyword, args, current_num):
"""
首先查看是否在faker类的成员函数内，如果在则调用；
否者调用FakeData类中自定义的成员函数
:param keyword:
:param args:
:return:
"""
self.current_num = current_num
method = getattr(self, 'fake_' + keyword, None)
if callable(method):
return method(*args)
if keyword in self.faker_funcs:
method = getattr(self.faker, keyword, None)
if callable(method):
return method(*args)
return None
class TestdataGenerator(object):
"""一些生成器方法，生成随机数，手机号，以及连续数字等"""
def __init__(self):
self.fake = Factory().create('zh_CN')
def random_phone_number(self):
"""随机手机号"""
return self.fake.phone_number()
def random_name(self):
"""随机姓名"""
return self.fake.name()
def random_address(self):
"""随机地址"""
return self.fake.address()
def random_email(self):
"""随机email"""
return self.fake.email()
def random_ipv4(self):
"""随机IPV4地址"""
return self.fake.ipv4()
def random_str(self, min_chars=0, max_chars=8):
"""长度在最大值与最小值之间的随机字符串，只包含a-zA-Z字母"""
return self.fake.pystr(min_chars=min_chars, max_chars=max_chars)
def random_int(self, min_value=0, max_value=9999, exclude=None):
"""返回[min_value, max_value]范围内的一随机数，可排除范围内任意数"""
if exclude is not None:
if not isinstance(exclude, list):
return "exclude must a list"
else:
exclude = list()
while True:
value = self.fake.pyint(min_value=min_value, max_value=max_value)
if value not in exclude:
return value
def random_letter_digit_str(self, min_chars=0, max_chars=8):
"""长度在最大值与最小值之间的随机字符串，只包含a-zA-Z字母和0-9数字"""
if min_chars is None:
return "".join(self.random_letters_digits(length=max_chars))
else:
assert (
max_chars >= min_chars
), "Maximum length must be greater than or equal to minium length"
return "".join(
self.random_letters_digits(length=random.randint(
min_chars, max_chars), ), )
def random_letters_digits(self, length=16):
"""返回一随机字母、数字字符串(a-z 、A-Z 、0-9)."""
return self.fake.random_choices(
getattr(string, 'letters', string.ascii_letters + string.digits),
length=length,
)
def random_punctuation_str(self, min_chars=0, max_chars=8):
"""返回长度在最大值与最小值之间的随机字符串，只包含英文标点符号"""
if min_chars is None:
return "".join(self.random_punctuation(length=max_chars))
else:
assert (
max_chars >= min_chars
), "Maximum length must be greater than or equal to minium length"
return "".join(
self.random_punctuation(length=random.randint(
min_chars, max_chars), ), )
def random_punctuation(self, length=16):
"""返回一随机英文标点符号"""
return self.fake.random_choices(
getattr(string, 'letters', string.punctuation),
length=length,
)
@classmethod
def factory_generate_ids(cls, starting_id=1, increment=1):
""" 返回一个生成器函数，调用这个函数产生生成器，从starting_id开始，步长为increment。 """
def generate_started_ids():
val = starting_id
local_increment = increment
while True:
yield val
val += local_increment
return generate_started_ids
@classmethod
def factory_choice_generator(cls, values):
""" 返回一个生成器函数，调用这个函数产生生成器，从给定的list中随机取一项。 """
def choice_generator():
my_list = list(values)
while True:
yield random.choice(my_list)
return choice_generator
class DataGenerator(object):
"""随机数据生成器"""
def __init__(self):
self.fake = Factory().create('zh_CN')
def random_phone_number(self):
"""
随机手机号码
:return:
"""
return self.fake.phone_number()
def random_name(self):
"""
随机姓名
:return:
"""
return self.fake.name()
def random_address(self):
"""
随机地址
:return:
"""
return self.fake.address()
def random_email(self):
"""
随机email
:return:
"""
return self.fake.email()
def random_ipv4(self):
"""
随机ip地址
:return:
"""
return self.fake.ipv4()
def random_str(self, min_char=0, max_char=8):
"""
随机字符,默认8个
:return:
"""
return self.fake.pystr(min_chars=min_char, max_chars=max_char)
@staticmethod
def random_chinese_characters(i=1):
"""随机中文汉字"""
s = ""
if i < 11:
s = xeger.xeger(u"[\\u4e00-\\u9fa5]{}".format("{" + str(i) + "}"))
else:
j = i // 10
k = i % 10
while j > 0:
a = xeger.xeger(u"[\\u4e00-\\u9fa5]{10}")
s = s + a
j -= 1
if j == 0:
a = xeger.xeger(
u"[\\u4e00-\\u9fa5]{}".format("{" + str(k) + "}"))
s = s + a
return s
