待整理

import random

def random_line(cols):
    alphabet_list = [chr(i) for i in range(65, 91, 1)] + [chr(i) for i in range(97, 123, 1)]
    # for i in range(cols):
    #     yield random.choice(alphabet_list)
    return (random.choice(alphabet_list) for i in range(cols))

def randome_generate_file(file_path='./sample.csv',lines=10000,cols=1000):
    with open(file_path,'w') as fw:
        for i in range(lines):
            fw.write(','.join(random_line(cols)))
            fw.write('\n')
        fw.flush()


def load_list_data(file_path='./sample.csv',total_num=10000,target_num=1000):
    all_data = []
    target_data = []
    with open(file_path,'r') as fr:
        for count, line in enumerate(fr):
            if count > total_num:
                break
            else:
                all_data.append(line)

    while len(target_data)<=target_num:
        index = random.randint(0,total_num)
        if all_data[index] not in target_data:
            target_data.append(all_data[index])
    return all_data, target_data

def load_dict_data(file_path='./sample.csv',total_num=10000,target_num=1000):
    all_data = {}
    target_data = []
    with open(file_path,encoding='utf8',mode='r') as fr:
        for idx, line in enumerate(fr):
            if idx>total_num:
                break
            all_data[line]=0
    all_data_list = list(all_data)
    while len(target_data)<=target_num:
        random_index = random.randint(0,total_num)
        if all_data_list[random_index] not in target_data:
            target_data.append(all_data_list[random_index])

    return all_data, target_data

def find_test(all_data,target_data):
    test_times = 100
    total_times_cnt = 0

    import time
    for t in range(test_times):
        start = time.time()
        for item in target_data:
            if item in all_data:
                pass
        cost_once = time.time() - start
        total_times_cnt+= cost_once
    return total_times_cnt / test_times

if __name__ == '__main__':
    # randome_generate_file()
    # all_data, target_data = load_list_data()
    all_data, target_data = load_dict_data()
    last_time = find_test(all_data,target_data)
    print(last_time)

# 第一章 一切皆对象
from functools import wraps
import time
def time_decor(func):
    @wraps(func)
    def wrapper_func(*args,**kw):
        start = time.time()
        result = func(*args,**kw)
        end = time.time()
        print('{} cost {:.2f} s '.format(func.__name__,end-start))
        return result
    return wrapper_func

@time_decor
def ask(name):
    print(name)

class Person:
    def __init__(self,name):
        print('hi, '+name)

my_ask = ask
my_ask('frank')
print(type(my_ask))
person = Person('frank')
print(person)
print('*'*100)

class_list = []
class_list.append(my_ask)
class_list.append(Person)
for item in class_list:
    item('tom')

>>> type(type)
<class 'type'>
>>> object.__bases__
()
>>> type.__bases__
(<class 'object'>,)
>>> type(object)
<class 'type'>

type 产生 type 类本身的 实例 产生 object 类, dict 等内建类， class 为万物之始,包括 type(object)， class 生 object 只道法自然 str <-- 'abc'
object 是所有对象的 基类包括 type.__bases__, object.__bases__ 之上再无父类


python 是基于协议的编程语言，因其动态语言的特性，也使得python开发效率极高，但同时也会容易产生很多问题，因为一切皆对象包括类本身，很多问题只有在运行时才能检测出来，
而像JAVA 这种静态语言，在编译时候就能够检测出问题，如：类型检测等


第三章 魔法函数

def my_hex(num):
alpha_list = ['A', 'B', 'C', 'D', 'E', 'F']
hex_list = []
while True:
mod_, num = num%16, num//16
hex_list.append(alpha_list[mod_-10] if mod_>9 else mod_)
if num==0:
break
hex_list.append('0x')
hex_list.reverse()
return ''.join(map(lambda x:str(x) if not isinstance(x,str) else x,hex_list))

def my_octonary(num):
octonary_list = []
while True:
mod_, num = num%8, num//8
octonary_list.append(str(mod_))
if num==0:
break
octonary_list.append('0o')
octonary_list.reverse()
return ''.join(octonary_list)
print(hex(60))
print(my_hex(60))
print(oct(9))
print(my_octonary(9))

def fac(n,res):
if n==1:
return res
else:
return fac(n-1,n*res)
print(fac(6,1))

d = {'a': 1, 'b': {'c': 2}, 'd': ["hi", {'foo': "bar"}]}

def my_dict2obj(args):
class obj(object):
def init(self,d):
for key,value in d.items():
if not isinstance(value,(list,tuple)):
setattr(self,key,obj(value) if isinstance(value,dict) else value)
else:
setattr(self,key,[obj(i) if isinstance(i,dict) else i for i in value])
return obj(args)

x = my_dict2obj(d)

print(x.__dict__)

words = ['apple','bat','bar','atom','book']
alpha_dict = {}

for word in words:
word_list = []
if word[0] not in alpha_dict:
word_list.append(word)
alpha_dict[word[0]] = word_list
else:
alpha_dict[word[0]].append(word)
print(alpha_dict)

from collections import namedtuple
stock_list = [['AAPL','10.30','11.90'],['YAHO','9.23','8.19'],['SINA','22.80','25.80']]
stock_info = namedtuple('stock_info',['name','start','end'])
stock_list_2 = [stock_info(name,start,end) for name,start,end in stock_list ]
print(stock_list_2)

from collections import namedtuple

Card = namedtuple('Card',['suit','rank'])

class French_Deck():
rank = [i for i in range(2,11,1)]+['J','Q','K','A']
suit = 'Spade,Club,Heart,Diamond'.split(r',')
def init(self):
self._card = [Card(s,r) for r in French_Deck.rank for s in French_Deck.suit]

def __getitem__(self, item):
    if isinstance(item,int):
        return self._card[item]
    elif isinstance(item,slice):
        return self._card[item]

def __len__(self):
    return len(self._card)

frenck_deck = French_Deck()
print(frenck_deck[1:3])