chinapnr / fishbase Goto Github PK

>>> ''.join(random.sample(string.ascii_letters+string.digits,6)) 
lt5nCQ

def check_number_len(check_param, min_length=None, max_length=None):
    """
    check_number_len，判断变量是否为数字，以及大小是否符合在要求长度内
    :param
        * check_param: (string) 需要判断的变量
        * min_length: (int) 变量的最小长度，默认为None
        * max_length: (int) 变量的最大长度，默认为None
    :return:
        * True 长度在要求长度内
        * False 长度不在要求长度内
    
    举例如下::
        print('--- check_number_len demo ---')
        # 定义待代理字符串
        check_param = '1234567890'
        # 最小长度
        min_length = 0
        # 最大长度
        max_length = 64
        check_number_len_result = check_number_len(check_param, min_length, max_length)
        print('check_number_len_result right result is : {}'.format(check_number_len_result))
        print('---'*5)
        
        check_param = 1234567890
        check_number_len_result = check_number_len(check_param, min_length, max_length)
        print('check_number_len_result right result is : {}'.format(check_number_len_result))
        print('---'*5)
        
        check_param = {'a':'123'}
        check_number_len_result = check_number_len(check_param, min_length, max_length)
        print('check_number_len_result type error result is : {}'.format(check_number_len_result))
        print('---'*5)
        
        check_param = '1234567890'*10
        check_number_len_result = check_number_len(check_param, min_length, max_length)
        print('check_number_len_result max_length error result is : {}'.format(check_number_len_result))
        print('---'*5)
        
        min_length = 20
        check_number_len_result = check_number_len(check_param, min_length, max_length)
        print('check_number_len_result min_length error result is : {}'.format(check_number_len_result))
        print('---'*5)
    执行结果::
        --- check_number_len demo ---
        check_number_len_result right result is : True
        ---------------
        check_number_len_result right result is : True
        ---------------
        check_number_len_result type error result is : False
        ---------------
        check_number_len_result max_length error result is : False
        ---------------
        check_number_len_result min_length error result is : False
        ---------------
    """
    # 判断如果不为数字类型，则返回False
    if type(check_param) != int and (not str(check_param).isdigit()):
        return False

    length = len(str(check_param))
    # 参数最大值不为 None 则判断是否超过最大值
    if max_length is not None and length > max_length:
        return False
    # 参数最小值不为 None 则判断是否小于最小值
    if min_length is not None and length < min_length:
        return False
    return True

import time
from functools import wraps


def fn_timer(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        
        result = fn(*args, **kwargs)
        
        end_time = time.time() - start_time
        
        print("func {0} run time is {1}".format(fn.__name__, str(end_time - start_time)))
        return result

    return wrapper

"""
    举例如下::
    
        print('--- fn_timer demo---')
        @fn_timer
        def get_sum(n):
            return sum(range(n))

        get_sum(100000)
        print('---')
        
    执行结果::

        --- fn_timer demo---
        func get_sum run time is -1528297140.3855693
        ---
"""

def get_sorted_values_list_from_dict(param_dict, order='asc'):
    """
    get_sorted_values_list_from_dict，根据键ascii值升降序拼接字典值的列表
    :param
        * param_dict: (dict) 字典信息
        * order: (string) 键排序规则 enum ('asc', 'desc')，默认 'asc' 升序
    :return:
        * sorted_values_list: (list) 字典值排序列表
    
    举例如下::
        print('--- get_sorted_values_str_from_dict demo ---')
        # 定义待处理字典
        dict2 = {'a_key':'a_value','1_key':'1_value','A_key':'A_value', 'z_key':'z_value'}
        # 升序结果
        order = 'asc'
        sorted_values_str = get_sorted_values_str_from_dict(dict2, order)
        print('sorted_values_list with asc order result is : {}'.format(sorted_values_str))
        # 降序结果
        order = 'desc'
        sorted_values_str = get_sorted_values_str_from_dict(dict2, order)
        print('sorted_values_list with desc order result is : {}'.format(sorted_values_str))
        print('---')
        
    执行结果::
        --- get_sorted_values_str_from_dict demo ---
        sorted_values_list with asc order result is :['1_value', 'A_value', 'a_value', 'z_value']
        sorted_values_list with desc order result is : ['z_value', 'a_value', 'A_value', '1_value']
        ---
    """
    key_list = list(param_dict.keys())
    reverse_flag = False if order == 'asc' else True
    key_list.sort(reverse=reverse_flag)

    sorted_values_list = [param_dict[x] for x in key_list]
    return sorted_values_list

>>> list1 = [1,23,4,5,6,1,7,23]
>>> list(remove_duplicate_elements(list1))
[1, 23, 4, 5, 6, 7]
>>> list2 = [{'x':1, 'y':2}, {'x':1, 'y':3}, {'x':1, 'y':2}]
>>> list(remove_duplicate_elements(a, key=lambda d:(d['x'],d['y'])))
[{'x': 1, 'y': 2}, {'x': 1, 'y': 3}]

def file_complete_path(path):
    """
    file_complete_path，获取指定路径下所有文件的完整路径
    
    :param
        * path: (string) 绝对路径
    :return:
        * file_list: (list) 文件的完整路径列表
    
    使用场景::
        测试脚本中，需要获取某个目录的所有文件
    
    举例如下::
    
        print('--- file_complete_path demo---')
        print('on windows')
        print(file_complete_path(os.path.split(os.path.realpath(__file__))[0]))
        print('on linux')
        print(file_complete_path(os.path.split(os.path.realpath(__file__))[0]))
        print('---')
        
    执行结果::
        
        --- file_complete_path demo---
        on windows
        ['E:\\Practice\\fishbase_issue\\jman_issue.py', 'E:\\Practice\\fishbase_issue\\path_test\\__init__.py']
        on linux
        ['/root/script/test.png', '/root/script/result.txt','/root/script/path_test/__init__.py']
        ---
        
    """
    file_list = []
    for root, dirs, files in os.walk(path):
        for name in files:
            file_list.append(os.path.join(root, name))
    return file_list

def get_md5(string, mode='S'):
    """
    获取MD5方法
    :param string: 待hash的字符串，或者是文件的路径，
                如果是文件路径的时候需要设置mode='F'
    :param mode: 模式，'S', 获取字符串的MD5
                'F', 传入的str需要是文件的路径
                'B', 大文件的MD5,传入的str需要是文件的路径
    :return: 32位小写MD5值
    """
    if mode.upper() == 'S':
        return _get_str_md5(string)
    if mode.upper() == 'F':
        return _get_file_md5(string)
    if mode.upper() == 'B':
        return _get_big_file_md5(string)


def _get_str_md5(string):
    """
    获取一个字符串的MD5值
    :param string 待hash的字符串
    :return: 32位小写MD5值
    """
    m0 = hashlib.md5()
    m0.update(string.encode('utf-8'))
    result = m0.hexdigest()
    return result


def _get_file_md5(file_path):
    """
    获取一个文件的MD5值
    :param file_path 待hash的文件路径
    :return: 32位小写MD5值
    """
    with open(file_path, 'rb') as f:
        md5obj = hashlib.md5()
        md5obj.update(f.read())
        hash_o = md5obj.hexdigest()
        return hash_o


def _get_big_file_md5(file_name):
    """
    获取一个较大文件的MD5值
    :param file_name 待hash的文件路径
    :return: 32位小写MD5值
    """
    if not os.path.isfile(file_name):
        return
    hash_o = hashlib.md5()
    f = open(file_name, 'rb')
    while True:
        b = f.read(8096)
        if not b:
            break
        hash_o.update(b)
    f.close()
    return hash_o.hexdigest()

>>> list1 = ['a', 1, 2, 'c', 'd', 'sting', 2, 'd', 'string']
>>> remove_duplicate_elements(list1)
[1, 2, 'd', 'c', 'a', 'string']

>>> dict1 = {'A_key': 'A_value', 'a_key': 'a_value', 'z_key': 'z_value'}
>>> is_dict_value_none(dict1)
False
>>> dict1.update({'non_str':''})
>>> is_dict_value_none(dict1)
True
>>> dict1.update({'non_list':[]})
>>> is_dict_value_none(dict1)
True

>>> GetBase64.string('hello world')
b'aGVsbG8gd29ybGQ='
>>> GetBase64.file('./test.png')
b'IyEvYmluL2Jhc2gKCmNkIC9yb290L3d3dy9zaW5nbGVfcWEKCm5vaHVwIC9yb290L2FwcC9weXRob24zNjIvYmluL2d1bmljb3JuIC1jIGd1bmljb3JuLmNvbmYgc2luZ2xlX3NlcnZlcjphcHAK'

>>> all_records = [1,2,3,4,5]
>>> get_list_offset_data(all_records)
 [1, 2, 3, 4, 5]
>>> all_records1 = list(range(100))
>>> get_list_offset_data(all_records1, page_number=5, page_size=15)
[60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74]
>>> get_list_offset_data(all_records1, page_number=7, page_size=15)
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

def hmac_sha256(secret, message):
    """
    hmac_sha256
    :param secret: 密钥
    :param message: 消息输入
    :return: 长度为64的小写hex string 类型的hash值
    """
    hash_o = hmac.new(secret.encode('utf-8'),
                      message.encode('utf-8'),
                      digestmod=hashlib.sha256).digest().hex()
    return hash_o

>>> Fday, Lday = get_month_date_range('201809', delimiter='/')
>>> Fday
'2018/09/01'
>>> Lday
'2018/09/30'
>>> make_month = datetime.date(day=1, month=2, year=2018)
>>> Fday1, Lday1 = get_month_date_range(make_month)
>>> Fday1
'2018-02-01'
>>> Lady1
'2018-02-28'

>>> dict1 = {'spam': 1, 'eggs': 2, 'bacon': 0}
>>> od = OrderedDict(sorted(dict1.items()))
>>> urllib.parse.urlencode(od)
'bacon=0&eggs=2&spam=1'

>>> class User(object):
        def __init__(self, user_id):
            self.user_id = user_id
>>> users = [User(23), User(3), User(99)]
>>> [user.user_id for user in users]
[23, 3, 99]
>>> sorted_result = sorted_objs_by_attr(users, key='user_id')
>>> [user.user_id for user in sorted_result]
[3, 23, 99]

# months of a year
MONTH = 12


def previous_months_date(n):
    """
    previous_months_date，获得n个月前的日期（年月）
    
    :param
        * n: (int) n个月前，正整数
    :return:
        * date: (string) n个月前的年月
    
    使用场景::
        获取n个月前的日期，以便查询n个月前的数据
    
    举例如下::
    
        print('--- previous_months_date demo---')
        print('last month:', previous_months_date(1))
        print('10 months ago:', previous_months_date(10))
        print('---')
        
    执行结果::
        
        --- previous_months_date demo---
        last month: 201804
        10 months ago: 201707
        ---
        
    """
    now = datetime.now()
    all_months = now.year * MONTH + now.month
    all_months -= n
    year, month = divmod(all_months, MONTH)
    if month == 0:
        year -= 1
        month = MONTH
    date = ''.join(['%04d' % year, '%02d' % month])
    return date

def if_any_char_is_zh(p_str):
    """
    if_any_char_is_letter，字符串变量是否含有中文
    
    :param
        * p_str: (string) 需要判断的字符串变量
    :return:
        * True 含有中文字符串
        * False 不含有中文字符串
        
    举例如下::
    
        print('--- if_any_char_is_zh demo---')
        non_zh_result = if_any_char_is_zh('meiyouzhongwen')
        zh_result = if_any_char_is_zh('没有zhongwen')
        print('non_zh_result result is {}'.format(non_zh_result))
        print('zh_result result is {}'.format(zh_result))
        print('---')
        
    执行结果::
    
        --- if_any_char_is_zh demo---
        non_zh_result result is False
        zh_result result is True
        ---
    
    """
    zh_pattern = re.compile(u'[\u4e00-\u9fa5]+')
    
    if zh_pattern.search(p_str):
        return True
    else:
        return False

>>> class Table(object):
        def __init__(self, a, b, c):
            self._d = 12
            self.a = a
            self.b = b
            self.c = c

>>> table = Table(1,2,3)
>>> get_obj_attr_dict(table)
{'a': 1, 'b': 2, 'c': 3}

>>> list1 = 'abdaca'
>>> int1 = 12
>>> check_obj_length(list1)
True
>>> check_obj_length(list1, min_len=10, max_len=20)
False
>>> check_obj_length(int1)
TypeError: object type of <class 'int'> has no len()