Some Toy

记录一些感觉不错或者是惊艳的Python代码

Count duplicates elements from file

# -*- coding:utf-8 -*-

f = open('test.txt')
content = []

[content.append(x) for line in f.readlines() for x in line.split()]
# 外层循环读取行，内层循行对行进行切割，然后append进content列表

# 从content列表中取出每个元素，然后进行排序，列表中的元素为Key，统计出来的重复次数为Value，最后输出打印
print({i: content.count(i) for i in content})

# 来自StackOverFlow里的两位大神~

Count Prime

def prime(n):
    for i in range(2, n):
        if n % i == 0:  # 如果余数为0表示能被整除，则不是素数
            return False
    else:   # n为2，range失败自动归为素数，或者遍历(2,n)完成后仍没有被整除则表示是素数
        #print(n, 'is Prime Number.')
        return True  

def sum_prime(n):
    sum = 0     # 存放素数总和
    for i in range(2, n + 1): 
        if prime(i): sum += 1  # 如果Prime返回True，则Sum+1
    return sum  # 输出素数总和

print(sum_prime(100))

Merge list and keep order

和并两个有序列表，并且保持合并后的列表有序

l1 = [2, 4, 6, 8, 9, 10]
l2 = [0, 1, 2, 6, 7, 9, 100, 134]

'''
思路
1. 因为是两个list都是有序列表，所以对比两个列表末尾的元素取出最大值
2. 根据最大值创建一个最大值+1的dict叫做bucket(桶)
3. 合并两个list然后进行循环，根据列表中的元素找到bucket中的key，然后对value+1
4. 最后遍历bucket，取出value不等于0的，然后根据key对应的value循环输出key
'''
def merge(list1, list2):
    max_num = [list1[-1] if list1[-1] > list2[-1] else list2[-1]][0]
    bucket = {x: 0 for x in range(max_num + 1)}
    for k in list1 + list2: bucket[k] += 1
    return [k for k in bucket for v in range(bucket[k]) if bucket[k] != 0]

print(merge(l1, l2))

take out uniq value from list

找出一个列表中，只出现了一次的数字， 并且保持原来的次序。例如 [1, 2, 1, 3, 2, 5] 结果为 [3, 5]

lst = [1, 2, 1, 3, 2, 5]

'''
思路
1. 取出最大数字
2. 按照最大数创建字典
3. 循环list，元素出现一次则+1，依次类推
4. 循环dict，取出只出现value为1的key
'''

def max(lst):
    num = 0
    for i in lst:
        if i > num:
            num = i
    return num

def uniq(lst):
    max_num = max(lst)
    bucket = {x:0 for x in range(max_num + 1)}
    for k in lst: bucket[k] += 1
    return [k for k in bucket if bucket[k] == 1]

print(uniq(lst))

Convert str to int

把字符串转化为数字， 例如 '123' 转化为 123 '0.254' 转化为 0.254，不允许使用int函数 float函数 eval函数，不允许导入任何模块

def do(in_str):
    out_num = 0
    multiplier = 1
    for x in range(0, len(in_str)):
        out_num = out_num * 10 + ord(in_str[x]) - ord('0')
    return out_num * multiplier

def str_to_int(in_str):
    if '.' in in_str:
        big_num, small_num = in_str.split('.')
        cifang = len(small_num)
        return do(big_num) + do(small_num) / 10 ** cifang
    else:
        return do(in_str)

print(str_to_int('23'), type(str_to_int('23')))
print(str_to_int('23.3'), type(str_to_int('23.3')))
print(str_to_int('23.33'), type(str_to_int('23.33')))
print(str_to_int('23.333'), type(str_to_int('23.333')))
print(str_to_int('6666666'), type(str_to_int('6666666')))

Match words

import re
collection = [ 'django_migrations.py',
               'django_admin_log.py',
               'main_generator.py',
               'migrations.py',
               'api_user.doc',
               'accounts.txt'
]

def LotusFinder(user_input, collection):
    suggection = []
    pattern = '.*?'.join(user_input)
    regex = re.compile(pattern)
    for item in collection:
        match = regex.search(item)
        if match:
            suggection.append((len(match.group()), match.start(), item))
    return [x for _, _, x in sorted(suggection)]
print(LotusFinder('mig', collection))
'''
导入re模块
定义suggestion列表
切割字符串,例如abc -> .*a.*b.*.c.*
编译正则以加快速度
循环集合列表
开始匹配
若匹配成功则添加至suggestion列表
循环结束后退出函数return suggestion列表
'''