#!/usr/bin/env python3
#-*- coding: utf-8 -*-

# 像下面这样定义的不是元组而是一个整数
t = (1)
# 所以tuple中只有一个元素时，必须加上一个逗号， 用来消除歧义

>>> s = set([1, 2, 3, 4, 5])
>>> s
{1, 2, 3, 4, 5}

from collection.abc import Iterable 
isinstance("123", Iterable)

for i, value in enumerate(["A", 'B','C' ]):
print(i, value)

# generator生成的另一种方法
def fib1(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n += 1

    return "done"

# Exercise 写出一个关于杨辉三角形的generator
def yH(max):
    list9 = []
    list8 = []
    index = 1
    while index < max:
        if index == 1:
            list8 = [1]
            yield list8
            index = index + 1
        elif index == 2:
            list8 = [1, 1]
            yield list8
            index = index + 1
        else:
            list9 = [None] * index
            for I in range(1, index - 1):
                list9[I] = list8[I - 1] + list8[I]
            list9[0] = 1
            list9[index - 1] = 1
            yield list9
            index += 1
            list8 = list9


g1 = yH(11)
for n in g1:
    print(n)

f = abs
print(f(-10))

"""
输出：
10
"""

def add(x, y, f):
	return f(x) + f(y)

list(map(str, [1, 2, 3, 4, 5, 6, 7, 9]))

# 关于reduce的用法
# 实现累加
def add(x, y):
    return x + y

redce_detail = reduce(add, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(redce_detail)

# 实现将一个序列中的所有数字变成一个整数
def changeToInteger(x, y):
    return x * 10 + y
list_for_str = [1, 2, 3, 4, 5, 6, 7]
integer = reduce(changeToInteger, list_for_str)
print(integer)

# 使用reduce和map()函数，写出将str转换为int的函数：
def fn(x, y):
    return x * 10 + y

def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
# 上一行末尾的[s]是什么意思？(大概意思我是了解了)
str2int = reduce(fn, map(char2num, "13579"))
print(str2int)

# 用filter求素数 -- 没有怎么看懂
# 首先定义一个从3开始的奇数序列：
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

# 然后定义一个筛选函数
def _not_divisible(n):
    return lambda x: x % n > 0
# 定义一个生成器，不断返回下一个素数
def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it)
        yield n
        it = filter(_not_divisible(n),it) # 构造新序列

# 输出结果：
print("1000以内的所有素数： ")
for n in primes():
    if n< 1000:
        print(n)
    else:
        break

lambda x : x * x
# 上述匿名函数中，第一个x表示函数参数

# 请用sorted()对上述列表分别按名字排序
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

def by_name(t):

    return t[0]

L2 = sorted(L, key=by_name)
print(L2)
# 请用sorted()对上述列表分别按成绩高低排序
def by_score(t):
    return t[1]

L3 = sorted(L, key=by_score)
print(L3)

'''
对于一个求和函数，如果不需要立刻求和，而是在后面的代码中，根据需要再计算。这时就可以不返回求和的结果，而是返回求和的函数
'''
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

# 我们调用lazy_sum()时，返回的并不是求和结果而是求和函数
f = lazy_sum(1, 3, 5, 7, 9)
print(type(f))
print(f())

f1 = lazy_sum(1, 3, 5, 7, 9)
f2 = lazy_sum(1, 3, 5, 7, 9)
print(f1 == f2)
'''输出结果
False
'''

# 在闭包中使用循环变量
def count():
    def f(j):
        def g():
            return j * j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs


f1, f2, f3 = count()
print(f1(), '', f2(), '',  f3()

def int2(x, base=2):
  return int(x, base)

import functools
int2 = functools.partial(int, base=2)
int2('1000000')

__author__ = "YourName"

# 给实例bart绑定一个name属性：
bart.name = 'Bart Simpson'
print(bart.name)

# 可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的init方法，可以在创建实例的时候，
# 就把name，score等属性绑上去
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score


class Student1(object):
    def __init__(self):
        self.name = 'bowenkei'
        self.score = 100

no1 = Student("chenqiaochu", 100)
no2 = Student1()
print("--------------------------")
print(str(no1.score) + " " + no1.name )
print(str(no2.score) + " " + no2.name )
# 注意到init方法的第一个参数永远是self，表示创建的实例本身，因此，在init方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身

# __name变量变成了_Student__name

# 使用isinstance()判断一个变量是否是某些类型中的一个
# 判断某个变量是否是list或者tuple:
print(isinstance([1, 2, 3, 4, 5, 6], (list, tuple)))
print(isinstance((1, 2, 3, 4, 5, 6), (list, tuple)))
print(isinstance('hello', (list, tuple)))

# 获得一个str对象的所有属性和方法
print(dir('str'))

# __len__和len()是等价的，使用后者，它会自动去调用该对象的__len__()
print(len('abc'))
print('abc'.__len__())

# 使用getattr(),setattr(),hasattr()，我们可以直接操作一个对象的状态
class MyObject(object):
    def __init__(self):
        self.x = 9
    def power(self):
        return self.x * self.x


obj = MyObject()
# 测试上面新创建的对象的属性
print(hasattr(obj, 'x'))
print(obj.x)
print(hasattr(obj, 'y'))
setattr(obj, 'y', 19)
print(hasattr(obj, 'y'))
print(getattr(obj, 'y'))
print(obj.y)

# 使用getattr()时，可以传入一个default参数，如果属性不存在，就返回默认值
print(getattr(obj, 'z', '404: No such a attribute'))

# 实例属性和类属性
# 给实例绑定属性
class Student(object):
    def __init__(self, name):
        self.name = name

s = Student('Bob')
s.score = 19
# 给类添加类属性
class Student1(object):
    name = 'Student'
# 上面的name就是类属性。类属性虽然归类所有，但是该类的所有实例都可以访问到
s = Student1()
print(s.name)
print(Student1.name)
s.name = "Michael"
# 因为实例属性的优先级比类属性高，所以他会屏蔽掉类的name属性
print(s.name)
# s有了实例属性之后，Student的name类属性还在且不会消失
# 在删除掉s的实例属性之后，name类属性就会显示出来
del s.name
print(s.name)

# 定义一个函数作为实例方法
def set_age(self, age):
    self.age = age
# 给实例绑定一个方法
s.set_age = types.MethodType(set_age, s)
s.set_age(20)
print(s.age)

def set_score(self, score):
    self.score = score


Student1.set_score = types.MethodType(set_score, Student1)
s.set_score(100)
print(s.score)
s2 = Student1()
s2.set_score(10000)
print(s2.score)

class Bat(Mammal, Flyable):
  pass
# Bat类继承了Mammal和Flyable类

# __str__()和__repr__()用于返回有关类和实例的字符串，其中前者返回用户看到的字符串，后者返回程序开发者看到的字符串，后者是为调试服务的
# 使用下面的方法可以让str()和repr()统一
__str__() = __repr__()
# 直接使用变量时调用的是__repr__()，使用print调用的是__str__
# 如何才能调用__str__方法？使用:
print(Class("Attribute"))

# iter
class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a， b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 推出循环
            raise StopIteration()
        return self.a

# Test
for n in Fib():
    print(n)

# getitem
def __getitem__(self, n):
    a, b = 1, 1
    for x in range(n):
        a, b = b, a + b
    return a
Fib.__getitem__ = types.MethodType(__getitem__, Fib)
# 现在可以按下标访问数列的任意一项了
f = Fib()
print(f[0])

# 让Fib实现切片
# 删除原来的__getitem__方法
del Fib.__getitem__
def __getitem__(self, n):
    if isinstance(n, int):
        a,  b = 1, 1
        for x in n:
            a, b = b, a + b
        return a
    if isinstance(n, slice):
        start = n.start
        stop = n.stop
        if start is None:
            start = 0
        a, b  = 1, 1
        L = []
        for x in range(stop):
            if x >= start:
                L.append(a)
            a, b = b, a + b
        return L
# 把新的__getitem__添加到Fib class中去
Fib.__getitem__ = types.MethodType(__getitem__, Fib)
# 现在可以尝试Fib的切片了
f = Fib()
print(f[0:5])

# __getattr__()
class my_getattr(object):
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        if item == 'score':
            return 99

one_getattr = my_getattr('Bowenkei')
print(one_getattr.name)
print(one_getattr.score)
# 使用__getattr__()返回函数也是可以的
del my_getattr.__getattr__
def __getattr__(self, attr):
    if attr == 'money':
        return lambda: '这是我的存款：∞'
my_getattr.__getattr__ = types.MethodType(__getattr__, my_getattr)

two_getattr = my_getattr("bowenkei")
print(two_getattr.money)
print(two_getattr.money())
# 注意，只有在没有找到属性的情况下，才调用__getattr__(),对于已经存在的属性，不会在__getattr__中查找
print(two_getattr.today) # None
# 如上述任意调用都会返回None，因为__getattr__()的默认返回值就是None,但是如果类中没有__getattr__()
# 方法的时候，调用class中没有的熟悉则都会抛出AttributeError。要让class只响应特定的几个属性，我们就要按照约定，
# 抛出AttributeError的错误
del my_getattr.__getattr__
def __getattr__(self, attr):
    if attr == 'age':
        return lambda :20
    raise AttributeError("\'my_getattr\'object has no attribute \'%s\'" % attr)

my_getattr.__getattr__ = types.MethodType(__getattr__, my_getattr)
three_my_getattr = my_getattr("bowenkei")
print(three_my_getattr.age())
# 由此可以把一个类的所有属性和方法调用全部动态化处理了，不需要任何特殊手段。
# 这种完全动态调用的特性有什么实际作用呢？作用就是，可以针对完全动态的情况做调用
# 如果要写SDK，给每个URL对应的API都写一个方法，那太麻烦，而且API一旦改动，SDK也要改
# 利用完全动态的__getattr__(),可以写出一个链式调用
class Chain(object):
    def __init__(self, path=''):
        self._path = path
    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))
    def __str__(self):
        return self._path

    __repr__ =  __str__

# Demo
print(Chain('bowenkei').status.user.timeline.list)
print(Chain('bowenkei').status)
print(Chain('bowenkei').status.user)
print(Chain('bowenkei').status.user.timeline)
print(Chain('bowenkei').status.user.timeline.list)
"""output:
bowenkei/status/user/timeline/list
bowenkei/status
bowenkei/status/user
bowenkei/status/user/timeline
bowenkei/status/user/timeline/list
"""

# call
# 在Python中可以直接在实例本身上调用实例方法
# 任何类，只要实现一个call()方法就可以直接对实例进行调用
class Call_student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)

call_s = Call_student('bowenkei')
call_s()
"""
call()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。

如果你把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的，这么一来，我们就模糊了对象和函数的界限。
"""
# 如何判断一个变量是对象还是函数？
# 能被调用的对象就是一个Callable对象
# 函数和带有call()的类实例都是Callable对象
# 使用callable()
print(callable(Call_student))

# 使用枚举类
from enum import Enum, unique
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

# 输出枚举成员
print(Month.Jan.value)
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)
# value属性是自动赋给成员的int常量，默认从1开始计数
# 从Enum中派生出自定义类
@unique
class Weekday(Enum):
    Sun = 0 #Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

# @unique是一个装饰器，可以帮助我们检查有没有重复值
# 访问枚举类型可以有若干种方法
print(Weekday.Mon)
print(Weekday['Sat'])
print(Weekday(1))
# 即既可以用成员名称引用枚举常量，又可以直接根据value的值获得枚举常量

import logging
try:
  do something
  except Exception as e:
    logging.exception(e)
    
  do someting

class FootError(ValueError):
  	    pass

def foo(s):
    n = int(s)
    if n == 0:
        raise FootError("invalid value: %s " %s)

    return 10 / n

foo('0')

# 断言(assert)
def foo(s):
    n = int(s)
    assert n != 0, '0 is zero!'
    return 10 / n

def main():
    foo('0')

main()

# assert的意思是，表达式n!=0应该是True，否则，根据程序运行的逻辑，后面的代码肯定会出错。如果断言失败，
# assert语句本身就会抛出AssertionError
# 启动python解释器时可以用 -0 参数(python3 -0 python_file_name)来关闭assert，关闭后，所有的assert语句可以当成pass

# logging
import logging
logging.basicConfig(level=logging.INFO)
s = '0'
n = int(s)
logging.info("n = %d" % n)
print(10 / n)
'''
# info是通告，信息的意思
# logging的好处就是，它允许你使用不同的参数来区分记录信息的级别，可选的参数有debug, info, waring, error。
# 当我们选定其中info的时候哦，logging.debug就不起作用了，这样就可以输出不同级别的信息，也不用删除。
# 使用logging的另外一个好处是，通过简单的配置，一条语句可以同时输出到不同的地方，比如console和文件

import pdb
for i in range(10):
    pdb.set_trace() # 设置断点
    print(i)
    pdb.set_trace() # 设置断点

>>> f = open('/User/Test/test.txt', 'r')

try: 
    file_object = open('/Users/bowenkei/Desktop/Test.txt', 'r')
    print(file_object.read())
    
finally:
    if file_object:
        file_object.close()

with open('/Users/bowenkei/Desktop/Test.txt', 'r') as file_object:
    print(file_object.read())

with open('/Users/bowenkei/Desktop/GBK.txt', encoding='gbk') as file_object:
    print(file_object.read())

with open('/Users/bowenkei/Desktop/GBK.txt', encoding='gbk', errors='ignore') as file_object:
    print(file_object.read())

>>> f = StringIO()
>>> f.write('hello')
5
>>> f.write(' ')
1
>>> f.write('')
0
>>> f.write('world!')
6
>>> print(f.getvalue()) # 用于获得写入后的str
hello world!

>>> from io import BytesIO
>>> f = BytesIO()
>>> f.write('中文'.encode('utf-8'))
6
>>> print(f.getvalue())
b'\xe4\xb8\xad\xe6\x96\x87'

# 导入os模块之后，使用os.name可以获得操作系统类型
# 如果是posix，说明系统是Linux、Unix或Mac OS X，如果是nt，就是Windows系统。
# 要获取详细的系统信息，可以调用uname()函数：
# 注意uname()函数在Windows上不提供，也就是说，os模块的某些函数是跟操作系统相关的。
import os 
print(os.name)
print(os.uname())

# 查看变量
os.environ
# 获取某个环境变量的值
os.emviron.get('key')

import pickle
import json
# 将class对象序列为JSON的{} 和 反序列化class对象
class SuperMan(object):
    def __init__(self, name='bowenkei', age=20, sex='man'):
        self.name = name
        self.age = age
        self.sex = sex

    def get_name(self):
        return self.name


s = SuperMan()


def superman2dict(super):
    return {
        'name': super.name,
        'age': super.age,
        'sex': super.sex
    }


def dict2super(dict):
    return SuperMan(dict['name'], dict['age'], dict['sex'])


print(json.dumps(s, default=superman2dict))
print(json.dumps(s, default=lambda obj: obj.__dict__))

json_str = '{"name": "lei bo wen", "age": 20, "sex": "man"}'
print(json.loads(json_str, object_hook=dict2super))
new_superman = json.loads(json_str, object_hook=dict2super)
print(new_superman.name)

import os
print("Process (%s)  start ... " % os.getpid())
pid = os.fork()
if pid == 0:
        print("I am child process (%s) and my parent is %s." % (os.getpid(), os.getppid()))
else:
        print("I (%s) just created a child process (%s)." % (os.getpid(), pid))


"""
    os.getpid(): 获取当前进程id
    os.getppid()： 获取父进程id
"""

from multiprocessing import Process
import os
def run_proc(name):
    print("Run child process %s (%s) ..." % (name, os.getpid()))

if __name__ == '__main__':
    print("Parent process %s ." % os.getpid())
    p  = Process(target=run_proc, args=('test',))
    print("Child process will start.")
    p.start()
    p.join()
    print("Child process end.")
    
"""
创建子进程时，使用Process传入一个执行函数和函数的参数以创建一个实例。用start()方法启动；join()方法可以等待子进程结束后再继续往下运行。
"""

from multiprocessing import Pool
import os, time, random
def long_time_task(name):
    print("Run task %s (%s)" % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print("Task %s runs %0.2f" % (name, (end - start)))

if __name__ == '__main__':
    print("Parent process %s." % os.getpid())
    p = Pool(4)
    for i in range(5):
        p.apply_async(long_time_task, args=(i,))
    p.close()
    p.join()
    print("All subprocesses done.")

"""
对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。

请注意输出的结果，task 0，1，2，3是立刻执行的，而task 4要等待前面某个task完成后才执行，这是因为Pool的默认大小在我的电脑上是4，
因此，最多同时执行4个进程。这是Pool有意设计的限制，并不是操作系统的限制。如果改成：p = Pool(5)就可以同时跑5个进程。
Pool的默认大小是CPU的核心数。
"""

import subprocess
print('$ nslookup www.python.org')
r = subprocess.call(['nslookup', 'www.python.org'])
print('Exit code:', r)

import subprocess
print('$ nslookup')
p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b'set q=mx\npython.org\nexit\n')
print(output.decode('utf-8'))
print('Exit code:', p.returncode)

import os, time, random
# 以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据
# 写数据进程执行的代码
def write(q):
    print("Process to write: %s" % os.getpid())
    for value in ['A', 'B', 'C']:
        q.put(value)
        time.sleep(random.random())


# 读数据进程执行的代码
def read(q):
    print("Process to read:%s " % os.getpid())
    while True:
         value = q.get(True)
         print("Get %s from queue" % value)


if __name__ == '__main__':
    # 父进程创建Queue，并传给各个子进程
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))

    # 启动子进程pw，写入：
    pw.start()
    # 启动子进程pr，读取：
    pr.start()
    # 等待pw结束
    pw.join()
    # pr进程是死循环，只能强行终止：
    pr.terminate()

# Python中 _thread和threading用于多线程。其中_thread是低级模块，threading是高级模块，它对_thread进行了封装。
# 启动一个线程就是把一个函数传入并创建Thread实例，然后调用start()开始执行
import time, threading

def loop():
    print("thread %s is running ... " % threading.current_thread().name)
    n = 0
    while n < 5:
        n =  n + 1
        print("thread %s >>> %s " % (threading.current_thread().name, n))
        time.sleep(1)
    print("thread %s ended" % threading.current_thread().name)


print('thread %s is running... ' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopThread') # 这里指定了子线程的名字
t.start()
t.join()
print("thread %s ended." % threading.current_thread().name)

# 没有使用Lock之前：
import threading, time
#
balance = 0
def change_it(n):
    #
    global balance
    balance = balance + n
    balance = balance -  n


def run_thread(n):
    for i in range(10000):
        change_it(n)

t1 = threading.Thread(target=run_thread, args=(5, ))
t2 = threading.Thread(target=run_thread, args=(8, ))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

import threading, time
#
balance = 0
lock = threading.Lock()
def change_it(n):
    #
    global balance
    balance = balance + n
    balance = balance -  n


def run_thread(n):
    for i in range(10000):
        # 获取锁
        lock.acquire()
        try:
            change_it(n)
        finally:
            # 释放锁
            lock.release()

t1 = threading.Thread(target=run_thread, args=(5, ))
t2 = threading.Thread(target=run_thread, args=(8, ))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

# 实现
from ReviewPython3 import Student
import threading
global_dict = {}

def std_thread(name):
    std = Student(name)
    # 把std放到全局变量global_dict中：
    global_dict[threading.current_thread()] = std
    do_task1()
    do_task2()

def do_task1():
    # 不传入std，而是根据当前的线程查找
    std = global_dict[threading.current_thread()]
def do_task2():
    std = global_dict[threading.current_thread()]

import threading
local_school = threading.local()

def process_student():
    # 获取当前线程关联的student
    std = local_school.student
    print("Hello, %s (in %s)" % (std, threading.current_thread().name))


def process_thread(name):
    # 绑定ThreadLocal的student：
    local_school.student = name
    process_student()


t1 = threading.Thread(target=process_thread, args=('Alice', ), name='Thread-A')
t2 = threading.Thread(target=process_thread, args=('Bob', ), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

import re
# 使用match方法判断正则表达式是否匹配
is_true = re.match(r'bowen[a-zA-Z]{3}', 'bowenkei')
print(is_true)
# 如果匹配，会返回一个Match对象，否则返回None。

import re
yourname = input("Enter your name: ")

if re.match(r'bowen[a-zA-Z]{3}$', yourname):
    print("Your name is true.")
else:
    print("Sorry, your name is not right.")

# 普通的切分代码：
print('a  b     c'.split(' ')) # ['a', '', 'b', '', '', '', '', 'c']

# 使用正则表达式
print('a  b     c'.split(' '))  # ['a', '', 'b', '', '', '', '', 'c']
print(re.split(r'\s+', 'a  b     c'))  # ['a', 'b', 'c']
print(re.split(r'[\s,]+', 'a,b,c, d'))  # ['a', 'b', 'c', 'd']
print(re.split(r'[\s,;]+', 'a,b;c, d'))  # ['a', 'b', 'c', 'd']

# 分组
m = re.match(r'^([0-9]{3})-(\d{3,8})$', '012-456789')
print(m)
print(m.group(0))
print(m.group(1))
print(m.group(2))
'''
012-456789
012
456789
'''
# 注意到group(0)始终是原始字符串。
# 匹配时间： 19:05:30
time = '19:05:30'

m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', time)

print(m.groups())

re_name = re.compile(r'bowen[a-zA-Z]{3}')

yourname =  'bowenkei'
yourname1 =  'bowenlei'

print(re_name.match(yourname))
print(re_name.match(yourname1))

'''
1.1 请尝试写一个验证Email地址的正则表达式。版本一应该可以验证出类似的Email
1.2 版本二可以提取出带名字的Email地址
'''
import re
# Version 1
# someone@gmail.com
# bill.gates@microsoft.com
email_1 = re.compile(r'^[\w\.]+@[\w]+\.com$')
print(email_1.match('someone@gmail.com'))
print(email_1.match('bill.gates@microsoft.com'))
print(email_1.match('nianchucqc@gmail.com'))

# Version 2
# <Tom Paris> tom@voyager.org

email_2 = re.compile(r'^(<)([\w\.\s]+)(>)(\s[\w\.\s]+@[\w\.\s]+)$')
print(email_2.match('<Tom Paris> tom@voyager.org').group(2))

# 获取当前时间
from datetime import datetime
n = datetime.now()
print(n)

print(type(n)) # 获得datetime类型
# 注意，使用的是datetime包下的datetime类

# 获取指定日期和时间
dt = datetime(2008, 8, 8, 20, 8, 8)
print(dt)

# datetime转换为timestamp
'''
在计算机中，时间实际上使用数字表示的。我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0。
1970年以前的时间timestamp为负数。
当前时间就是相对于epoch time的秒数，称为timestamp
可以认为： 
timestamp = 0 = 1970-1-1 00:00:00 UTC+0:00
对应的北京时间就是： 
timestamp = 0 = 1970-1-1 08:00:00 UTC+8:00

可见timestamp的值与时区毫无关系，因为timestamp一旦确定，其UTC时间就确定了，转换到任意时区的时间也是完全确定的，
这就是为什么计算机存储的当前时间是以timestamp表示的，因为全球各地的计算机在任意时刻的timestamp都是完全相同的（假定时间已校准）。
'''
tt = dt.timestamp()
print(tt)

# timestamp是一个浮点数，后面的小数表示毫秒
# Java和JavaScript的timestamp使用整数表示毫秒数，只需要将其timestamp除以1000就得到Python的浮点数表示方法

# timestamp转换为datetime
dt_1 = datetime.fromtimestamp(tt)
print(dt_1)

'''
timestamp没有时区，但是datetime有时区。
fromtimestamp默认转换为本地时间，也就是操作系统设置的时间。
要想转换为UTC标准时间可以将其替换为utcformtimestamp
'''
## 获得08年奥运会举办时标准UTC时间
dt_2 = datetime.utcfromtimestamp(tt)
print(dt_2)
# 可见北京时间时间比UTC标准时间多了8个小时
print("-------------------------------")
# str转换为datetime(转换后的时间没有时区信息) —— 使用strptime()
copy = datetime.strptime('200888200808', '%Y%m%d%H%M%S')
print(copy)
"""
注意： 
year: Y
month: m
day: d
hour: H
minute: M
second: S
"""
print("-------------------------------")
# datetime转换为str —— 使用strftime()
print(n.strftime('%A, %B, %d %H:%M:%S'))
print("-------------------------------")
# datetime加减
"""
对时间和日期进行加减实际上就是把datetime往后或者往前计算，得到新的datetime。在导入timedelta这个类之后，加减可以直接使用+,-运算符

"""
from datetime import timedelta
# 获取当前时间
now = datetime.now()
print(now)
# 时间加
print(now + timedelta(hours=8))
# 时期减
print(now - timedelta(days=3))
# 时间加减
print(now + timedelta(days=3, hours=10))

print("-------------------------------")
# 本地时间转换为UTC时间
"""
一个datetime类型有一个时区属性tzinfo，但是默认为None，所以无法区分这个datetime到底是哪个时区，除非强行给datetime设置一个时区
"""
from datetime import timezone
now = datetime.now()
print(now)
# 创建时区UTC+8
timezone_utc_8 = timezone(timedelta(hours=8))

datetime = now.replace(tzinfo=timezone_utc_8)
print(datetime)

print("-------------------------------")
# 时区转换
# 拿到utc时间，并设置时区为utc+0.00
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
print('UTC时间：',utc_dt)

#  astimezone()将时区转换为北京时间
beijing_date = datetime.astimezone(timezone(timedelta(hours=8)))
print('北京时间：',beijing_date)
# astimezone()转换为东京时间
dongjing_date = datetime.astimezone(timezone(timedelta(hours=9)))
print('东京时间：', dongjing_date)

"""
时区转换的关键在于，拿到一个datetime时，要获知其正确的时区，然后强制设置时区，作为基准时间。

利用带时区的datetime，通过astimezone()方法，可以转换到任意时区。

注：不是必须从UTC+0:00时区转换到其他时区，任何带时区的datetime都可以正确转换，例如上述bj_dt到tokyo_dt的转换。
"""

"""
假设你获取了用户输入的日期和时间如2015-1-21 9:01:30，以及一个时区信息如UTC+5:00，均是str，请编写一个函数将其转换为timestamp：
"""
# answer
import re
from datetime import timezone, datetime, timedelta
def to_timestamp(dt_str, tz_str):
    dt_com = re.compile(r'UTC([+|-][\d]{1,2}):00')
    tz = dt_com.match(tz_str).group(1)
    int_tz = int(tz)
    set_timezone = timezone(timedelta(hours=int_tz))
    str2dt = datetime.strptime(dt_str, '%Y-%m-%d %H:%M:%S')
    str2dt_new = str2dt.replace(tzinfo=set_timezone) # 使用replace之后必须复制给另外一个变量，否则tzinfo无法修改

    return str2dt_new.timestamp()




# 测试:
t1 = to_timestamp('2015-6-1 08:10:30', 'UTC+7:00')
assert t1 == 1433121030.0, t1
t2 = to_timestamp('2015-5-31 16:10:30', 'UTC-09:00')
assert t2 == 1433121030.0, t2
print('Pass')

# namedtuple
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)

print(p.x)
print(p.y)

"""
namedtuple是一个函数，用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素
下面验证Point的类型：
"""
print(isinstance(p, Point))
print(isinstance(Point, tuple))
print(isinstance(p, tuple))

# 下面使用namedtuple定义一个圆
Circle = namedtuple('Circle', ['x', 'y', 'radius'])
# 创建一个圆形
circle = Circle(0, 0, 5)
print("The center of the circle is (%d, %d), and its radius is %s " % (circle.x, circle.y, circle.radius))

# namedtuple
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)

print(p.x)
print(p.y)

"""
namedtuple是一个函数，用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素
下面验证Point的类型：
"""
print(isinstance(p, Point))
print(isinstance(Point, tuple))
print(isinstance(p, tuple))

# 下面使用namedtuple定义一个圆
Circle = namedtuple('Circle', ['x', 'y', 'radius'])
# 创建一个圆形
circle = Circle(0, 0, 5)
print("The center of the circle is (%d, %d), and its radius is %s " % (circle.x, circle.y, circle.radius))

# defaultdict
'''
使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict
默认值是调用函数返回的，函数在创建defaultdict对象时传入
除了在Key不存在时返回默认值，defaultdict的其他行为跟dict是完全一样的
'''
from collections import defaultdict

dd = defaultdict(lambda: 'The default value')
dd['key1'] = ' The value of key1'
print(dd['key1'])  # The value of key1
print(dd['key2'])  # The default value

# OrderedDict
'''
dict是无序的，如果要保持Key的顺序，可以使用OrderedDict;
OrderedDict的Key会按照插入的顺序排列，不是Key本身排序；
'''
from collections import OrderedDict
d = dict(a=1, c = 3, b = 2)  # {'a': 1, 'b': 2, 'c': 3} ——--- Python3.6以后dict也是有序的了。
print(d)
# 实现Orderedict
d1 = OrderedDict(d)
print(d1)
# OrderedDict可以实现一个FIFO(先进先出)的dict，当容量超出限制时，先删除最早添加的Key：
# 下面这个实现没有怎么看懂
class LastUpdatedOrderedDict(OrderedDict):
    def __init__(self, capacity):
        super(LastUpdatedOrderedDict, self).__init__()
        self.__capacity = capacity

    def __setitem__(self, key, value):
        containsKey = 1 if key in self else 0
        if len(self) - containsKey >= self.__capacity:
            last = self.popitem(last=False)
            print('remove', last)

        if containsKey:
            del self[key]
            print('set', (key, value))

        else:
            print('add', (key, value))
        OrderedDict.__setitem__(self, key, value)

# Counter： 一个简单的计数器
# 使用Counter统一字符串中字符出现的次数
# Counter就是一个dict
from collections import Counter
c = Counter()
s = 'today is a good day, it\'s a good time to learn something'
for ch in s:
    c[ch] = c[ch] + 1

print(c)

# base64
# 解编码
import base64
# 编码
bs1 = base64.b64encode(b'binary string')
print(bs1)
# 解码
bs2 = base64.b64decode(bs1)
print(bs2)

# 使用url-safe的base64编码
'''
由于标准的Base64编码后可能出现字符+和/，在URL中就不能直接作为参数，所以又有一种"url safe"的base64编码，其实就是把字符+和/分别变成-和_
'''
bs3 = base64.b64encode(b'i\xb7\x1d\xfb\xef\xff')
print(bs3)  # b'abcd++//' ---- 字符+和/没有改变
bs4 = base64.urlsafe_b64encode(b'i\xb7\x1d\xfb\xef\xff')
print(bs4)  # 字符+和/分别变成了-和_

str.capitalize()
# 上述方法并不会改变str中的内容，只是会返回一个首字母大写的副本

# struct
# struct的pack函数把任意数据类型变成bytes
import struct
s = struct.pack('>I', 10240099)
print(s)  # b'\x00\x9c@c'
# 上面>表示： 字节顺序是big-endian，也就是网络序；I表示4字节无符号整数
# 后面的参数个数要和处理指令一致
# unpack把bytes变成相应的数据类型
four_bytes_int, two_bytes_int = struct.unpack('>IH', b'\xf0\xf0\xf0\xf0\x80\x80')
print(four_bytes_int)  # 4042322160
print(two_bytes_int)  # 32896
# H表示2字节无符号整数

import struct
# 请编写一个bmpinfo.py，可以检查任意文件是否是位图文件，如果是，打印出图片大小和颜色数。
s = b'\x42\x4d\x38\x8c\x0a\x00\x00\x00\x00\x00\x36\x00\x00\x00\x28\x00\x00\x00\x80\x02\x00\x00\x68\x01\x00\x00\x01\x00\x18\x00'

def bmpinfo(s):
    if not isinstance(s, bytes):
        s = bytes(s, encoding='utf-8')
    if s[0:2] == (b'BM' or b'BA'):
        result = struct.unpack('<ccIIIIIIHH', s)
        photo_size = result[-4:-2]
        print("此位图的大小是：%d x %d" % (photo_size[0], photo_size[1]))
        print("此位图的颜色数是：%d" % result[len(result) - 1])

    else:
        print("抱歉， 这不是一个位图。")

bmpinfo(s)
s1 = 'fdsfsdfsdfdsf'
bmpinfo(s1)

"""
output:
b'BM'
此位图的大小是：640 x 360
此位图的颜色数是：24
b'fd'
抱歉， 这不是一个位图。
"""

# hashlib
import hashlib
md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?'.encode('utf-8'))
print(md5.hexdigest())
'''
MD5是常见的摘要算法，速度很快，生成结果是固定的128bit字节，通常用一个32位的16进制字符串表示。
'''

"""
另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：
"""
sh1 = hashlib.sha1()
sh1.update('how to use sha1 in '.encode('utf-8'))
sh1.update('python hashlib?'.encode('utf-8'))
print(sh1.hexdigest())
""""
SHA1的结果是160bit字节，通常用一个40位的16进制字符串表示
"""

import hashlib


# 1 - 根据用户输入的口令，计算出存储在数据库中的MD5口令：
def calc_md5(password):
    s = str(password)
    one_md5 = hashlib.md5()
    one_md5.update(s.encode('utf-8'))

    return one_md5.hexdigest()


print(calc_md5("todayisaniceday."))

# 2 - 设计一个验证用户登录的函数，根据用户输入的口令是否正确，返回True或False：
db = {
    'michael': 'e10adc3949ba59abbe56e057f20f883e',
    'bob': '878ef96e86145580c38c87f0410ad153',
    'alice': '99b1c2188db85afee403b1536010c2c9'
}

def login(user, password):
    s = str(password)
    one_md5 = hashlib.md5()
    one_md5.update(s.encode('utf-8'))
    return one_md5.hexdigest() == db[str(user)]


print(login('michael', 123456))
print(login('bob', '888888'))
print(login('alice', password=123456))

def calc_mad(password):
	return get_md5(password + 'the-Salt')

import hashlib

# 根据用户输入的登录名和口令模拟用户注册，计算更安全的MD5：
salt_value = 'the-Salt'
db = {}
def register(username, password):
    db[username] = get_md5(password + username + salt_value)



def get_md5(password):
    s = str(password)
    one_md5 = hashlib.md5()
    one_md5.update(s.encode('utf-8'))
    return one_md5.hexdigest()



# 测试
register('bob', 'hello world')
print(db)  # {'bob': '7fa0c1935fed7e7730be403321f3b04c'}
register('bowenkei', 'today is a good day')
print(db)

# 根据修改后的MD5算法实现用户登录的验证：
def login(user, password):
    return db[str(user)] == get_md5(str(password) + str(user) + salt_value)


# Test
print(login('bob', 'hello world'))
print(login('bowenkei', 'today is a good day'))
print(login('bowenkei', 123456))