LearnPython_week4

# -*- coding:utf-8 -*-
# Author:Wong Du

### 原代码
def home():
    print("Welcome to home...")
def shoe():
    print("Welcome to shoe...")
def clothes():
    print("Welcome to clothes...")
def gift():
    print("Welcome to gift...")
home()
shoe()
clothes()
gift()

#################需求：为程序的购物专区增加认证功能#################
### Part1:添加认证函数login()，加入到需要认证模块的函数当中
user = ‘Wong‘
passwd = ‘Wong123‘
def login():
    count = 0
    while count < 3:
        username = input(‘User login: ‘)
        password = input(‘Password: ‘)
        if username == user and password == passwd:
            print("Login successful...")
            break
        else:
            print("Invalid username or password...")
        count += 1

def home():
    print("Welcome to home...")
def shoe():
    login()
    print("Welcome to shoe...")
def clothes():
    login()
    print("Welcome to clothes...")
def gift():
    login()
    print("Welcome to gift...")
home()
shoe()
clothes()
gift()

#################需求：为程序的购物专区增加认证功能#################
### Part2:添加认证函数login(func)，在login()中调用需要添加认证功能的函数
user = ‘Wong‘
passwd = ‘Wong123‘
def login(func):
    count = 0
    while count < 3:
        username = input(‘User login: ‘)
        password = input(‘Password: ‘)
        if username == user and password == passwd:
            print("Login successful...")
            func()
            break
        else:
            print("Invalid username or password...")
        count += 1

def home():
    print("Welcome to home...")
def shoe():
    print("Welcome to shoe...")
def clothes():
    print("Welcome to clothes...")
def gift():
    print("Welcome to gift...")
home()
# shoe()
# clothes()
# gift()
login(shoe)
login(clothes)
login(gift)

#################需求：为程序的购物专区增加认证功能#################
### Part3:添加认证函数login(func)，函数赋值，再调用
user = ‘Wong‘
passwd = ‘Wong123‘
def login(func):
    count = 0
    while count < 3:
        username = input(‘User login: ‘)
        password = input(‘Password: ‘)
        if username == user and password == passwd:
            print("Login successful...")
            func()
            break
        else:
            print("Invalid username or password...")
        count += 1
    return login    #高阶函数，返回login的内存地址

def home():
    print("Welcome to home...")
def shoe():
    print("Welcome to shoe...")
def clothes():
    print("Welcome to clothes...")
def gift():
    print("Welcome to gift...")
home()
# shoe()
# clothes()
# gift()
# shoe = login(shoe)
# clothes = login(clothes)
# gift = login(gift)
# shoe()
# clothes()
# gift()

#################需求：为程序的购物专区增加认证功能#################
### Part4:添加认证函数login(func)，嵌套函数+高阶函数，函数赋值，再调用
user = ‘Wong‘
passwd = ‘Wong123‘
def login(func):
    def auth():
        count = 0
        while count < 3:
            username = input(‘User login: ‘)
            password = input(‘Password: ‘)
            if username == user and password == passwd:
                print("Login successful...")
                func()
                break
            else:
                print("Invalid username or password...")
            count += 1
    return auth    #高阶函数，返回login的内存地址

def home():
    print("Welcome to home...")
def shoe():
    print("Welcome to shoe...")
def clothes(name):
    print("%s,Welcome to clothes..." %name)
def gift():
    print("Welcome to gift...")
home()
shoe = login(shoe)
clothes = login(clothes)
gift = login(gift)
shoe()
clothes()
gift()

### Part5:添加不固定参数，增加装饰器的可扩展性
user = ‘Wong‘
passwd = ‘Wong123‘
def login(func,*args,**kwargs):
    def auth(*args,**kwargs):
        count = 0
        while count < 3:
            username = input(‘User login: ‘)
            password = input(‘Password: ‘)
            if username == user and password == passwd:
                print("Login successful...")
                func(*args,**kwargs)
                break
            else:
                print("Invalid username or password...")
            count += 1
    return auth    #高阶函数，返回login的内存地址

def home():
    print("Welcome to home...")
def shoe():
    print("Welcome to shoe...")
def clothes(name,*args,**kwargs):
    print("%s,Welcome to clothes..." %name)
def gift():
    print("Welcome to gift...")
home()
# shoe = login(shoe)
clothes = login(clothes)
# gift = login(gift)
# shoe()
clothes(‘Wong‘)
# gift()

### Part6:函数赋值的方式看起来太low了，用装饰器专用调用方法
user = ‘Wong‘
passwd = ‘Wong123‘
def login(func,*args,**kwargs):
    def auth(*args,**kwargs):
        count = 0
        while count < 3:
            username = input(‘User login: ‘)
            password = input(‘Password: ‘)
            if username == user and password == passwd:
                print("Login successful...")
                func(*args,**kwargs)
                break
            else:
                print("Invalid username or password...")
            count += 1
    return auth    #高阶函数，返回login的内存地址

def home():
    print("Welcome to home...")
@login      #相当于shoe = login(shoe)
def shoe():
    print("Welcome to shoe...")
@login      #相当于shoe = login(clothes)
def clothes(name,*args,**kwargs):
    print("%s,Welcome to clothes..." %name)
@login      #相当于shoe = login(gift)
def gift():
    print("Welcome to gift...")
home()
# shoe()
clothes(‘Wong‘)
# gift()

### Part7:为函数添加不同平台qq/wechat/weibo等认证功能
user = ‘Wong‘
passwd = ‘Wong123‘
def login(auth_type,*args,**kwargs):
    def auth(func,*args,**kwargs):
        def inner(*args,**kwargs):
            if auth_type == ‘qq‘:
                count = 0
                while count < 3:
                    username = input(‘User login: ‘)
                    password = input(‘Password: ‘)
                    if username == user and password == passwd:
                        print("Login successful...")
                        func(*args,**kwargs)
                        break
                    else:
                        print("Invalid username or password...")
                    count += 1
            else:
                print("Sorry,Only support qq login...")
        return inner    #高阶函数，返回login的内存地址
    return auth

def home():
    print("Welcome to home...")
@login(‘qq‘)      #相当于shoe = login(shoe)
def shoe():
    print("Welcome to shoe...")
@login(‘weibo‘)      #相当于shoe = login(clothes)
def clothes(name,*args,**kwargs):
    print("%s,Welcome to clothes..." %name)
@login(‘wechat‘)      #相当于shoe = login(gift)
def gift():
    print("Welcome to gift...")
home()
shoe()
clothes(‘Wong‘)
gift()

# -*- coding:utf-8 -*-
# Author:Wong Du


‘‘‘
生成器 generator
生成器最直观的效果就是节省内存
    1.传统的列表等集合体是把所有元素存在内存里，当我们需要某个元素时，再从集合体里调用，此方式耗费内存，效率低下
    2.生成器可以理解为是把一套计算方法和一个内存地址绑定在一起，这个内存地址里面没有生成元素，当我们需要某个元素时，再通过内存地址里面的算法一个一个生成元素
制造生成器：
    1.g = (x*2 for x in range(10))
    2.用yield在函数中定义，把整个函数制造成一个生成器
特性：
    生成器只能向后生成元素
    生成器有两种调用方式
        1. __next__方法
            g.__next__()
        2. for循环调用
            for i in g:
                print(i)
‘‘‘

### 制造生成器和类型说明
g = (x*2 for x in range(10))
print(type(g))
print(g)
‘‘‘
输出：
<class ‘generator‘>
<generator object <genexpr> at 0x0000000000A2A938>
‘‘‘

### 生成器的调用特点
print(g.__next__())
print(next(g))
print("走走神。。。")
print(next(g))
print(g.__next__())
print("发发呆。。。")
for i in g:
    print(i)

### 函数生成器,
## 生成器的send方法可以给yield赋值
print(‘华丽分割线‘.center(40,‘*‘))
# def fib(max):       #普通函数
#     n,a,b = 0,0,1
#     while max > n:
#         print(b)
#         a,b = b,a+b
#         n += 1
#     return ‘done‘
# print(type(fib))
def fib(max):       #函数生成器
    n,a,b = 0,0,1
    while max > n:
        # print(b)
        yield b
        a,b = b,a+b
        n += 1
    return ‘done‘
print(type(fib(5)))
for i in fib(5):
    print(i)

### 单线程并行效果
import time
def foo(name):
    print("%s 要开始吃包子了" %name)
    while True:
        baozi = yield
        print("包子 %s 被 %s 吃了" %(baozi,name))

def war():
    a1 = foo(‘A‘)
    a2 = foo(‘B‘)
    a1.__next__()
    a2.__next__()
    print("我要准备做包子啦...")
    for i in range(5):
        time.sleep(1)
        print("做了2个包子...")
        a1.send(i)
        a2.send(i)


war()

# -*- coding:utf-8 -*-
# Author:Wong Du

‘‘‘
迭代器
定义：迭代器与生成器类似，属数据流对象
    可以直接作用于for循环的对象统称为可迭代对象：Iterable，如list、dict、set、tuple、str等
    可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator，生成器是迭代器
判断方法：
    from collections import Iterator    #导入Iterator模块
    from collections import Iterable    #导入Iterable模块
    print(isinstance(g,Iterable))    #判断g是否是一个可迭代对象
    print(isinstance(g,Iterator))    #判断g是否是一个迭代器
生成迭代器：
    iter()方法可以把可迭代对象编程一个迭代器
    如：
        list = (1,2,3,4)
        list = iter(list)
‘‘‘

### 判断是否为迭代器或可迭代对象的方法
from collections import Iterator
from collections import Iterable
str = ‘111‘
print(isinstance(str,Iterable))    #True
print(isinstance(str,Iterator))    #False
list = [1,2,3]
print(isinstance(list,Iterable))    #True
print(isinstance(list,Iterator))    #False
g = (i*2 for i in range(5))
print(isinstance(g,Iterable))    #True
print(isinstance(g,Iterator))    #True


### 可迭代对象可通过iter()方法变成一个迭代器
tup = (1,2,3,4,5,4)
print(type(tup))        #tuple
tup = iter(tup)
print(type(tup))        #tuple_iterator

# -*- coding:utf-8 -*-
# Author:Wong Du

def dir_object():
    ## 删除对象的属性方法
    ## delattr(object, name: str)
    delattr(‘Wong‘, ‘count‘)

    ## 判断对象是否有这个属性方法
    ## hasattr(object, name: str)
    print(hasattr(‘Wong‘, ‘count1‘))

    ## 获取对象的属性方法，如存在可直接调用执行，如不存在则可配置default返回相关信息
    ## getattr(object, name: str, default)
    print(getattr(‘Wong,ggg‘, ‘count‘, ‘不存在‘))

    ## 为对象添加属性方法
    ## setattr(object, name: str, value)
    def Wong(name):  # 定义函数对象
        print("Welcome to", name)
        print("I am 23 years old")
        return ‘done‘
    setattr(Wong, ‘author‘, ‘Wongdu‘)  # 增加‘author‘属性
    print(hasattr(Wong, ‘author‘))  # 验证

# 绝对值，
# abs(n)，Return the absolute value of the argument.
print( abs(-22) )

# 判断可迭代对象内元素是否全为真
# all(Iterable)
‘‘‘Return True if bool(x) is True for all values x in the iterable.
If the iterable is empty, return True.‘‘‘
print( all([1,2,3,0]) )

# 判断可迭代对象内元素是否有真
# any(Iterable)
‘‘‘Return True if bool(x) is True for any x in the iterable.
If the iterable is empty, return False.‘‘‘
print( any([1,‘0‘,‘‘]) )

# 把对象变成可打印的字符串形式，如存在中文字符，则用二进制表示；repr则所见即所得
# ascii(object)；repr(object)
print(ascii({‘name‘:‘wong‘,‘age‘:23,‘您好‘:‘‘}))
print([repr([1,2,3,‘22‘,‘您好‘])])

# 把int对象转换成二进制
# bin(number:int)
‘‘‘Return the binary representation of an integer.‘‘‘
print( bin(256) )

# 判断对象是否可调用，如函数是可调用的
# callable(object)
def calla():print("It is callable...")
print( callable(calla) )

# 使用序号i返回一个字符的Unicode字符串
# chr(i)
print(chr(1111))

# 打印给定对象的所有方法
# dir(object)
print( dir([1,2,3]) )

# 返回一个元组，关系：((x-x%y)/y, x%y)
# divmod(number,numbre)
print( divmod(22.22,23) )

#退出程序
import time
time.sleep(1)
exit("退出程序")

# 为集合体元素进行编号一一对应
dict = {‘name‘:‘Wong‘,‘age‘:23,‘sox‘:‘man‘}
print(dict)
for k,v in enumerate(dict):
    print(k,v,dict[v])

# 在全局和本地语境中评估给定的源。
#eval()

# 在全局和本地语境中执行给定的源。
#exec()

# 格式化输出
print("My name is {_name}".format(_name="Wong"))

# 过滤可迭代对象中的元素生成一个迭代器
s = filter(lambda x:x==1,range(10))  #
print(s)
for s1 in s:
    print(s1)

# 对可迭代对象中的元素进行计算生成一个迭代器
g = map(lambda x:x*5,range(10))
print(g)
for g1 in g:
    print(g1)


# 返回包含当前作用域全局变量的字典
print(globals())
# 返回包含当前作用域局部变量的字典
print(locals())
# 没有参数时，返回当前作用域局部变量的字典，相当于locals()
print(vars())

# 返回一个对象的哈希值
# hash(object)
list = []
for i in [‘1‘,‘666‘,‘2‘,‘3‘,‘45‘,33]:
    print(hash(i))
    list.append(hash(i))
list.sort()
print(list)

# 查看帮助
# help(object)
help(dict)

# 返回int对象的16进制
# hex(int)
print(hex(111))

# 判断对象是否属于哪个类型
# isinstance(object,union)
print(isinstance(‘11‘,int))
from collections import Iterator,Iterable
print(isinstance(‘asdfg‘,Iterable))
print(isinstance(‘asdfg‘,Iterator))

# 用户输入
# input()
name = input("您的名字是：")
print(name)

# 返回对象的内存地址
# id(object)
print(id(‘name‘))

# 把可迭代对象变成迭代器
# iter(iterable)
list = [1,2,34,5]
list = iter(list)
print(list)

# 计算集合体的长度
# len(list)等，可迭代对象？
print(len({‘name‘:"wong",‘age‘:23}))

# 版本作者等信息
copyright()
credits()
license()

# 取可迭代对象中的最大值
# max(Iterable)
print(max({‘name‘:‘wong‘,‘age‘:23}))

# 取可迭代对象中的最小值
# min(Iterable)
print(min({‘name‘:‘wong‘,‘age‘:23}))

# 打开文件
# open(file,mode,encoding)
f = open(‘test‘,‘r‘)
f.close()

# 返回int对象的八进制表示
# oct(int)
print(oct(64))

# 通过单个字符，返回ascii表的对应编号
# ord(str)
print(ord(‘@‘)

# 打印内容
# print("你想表达的内容")
print("打印")

# 按如下公式计算
# Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
# pow(int, int, *int)
print(pow(2,8,127))

# 退出程序，指定退出程序code
# quit(code)
count = 0
while True:
    print("你是风儿我是沙，缠缠绵绵走天涯...")
    if count >1000:
        quit(4)
    count += 1

# 反转集合体内元素并生成一个迭代器
# reversed(sequence)
rev_iter = reversed([1,2,33,4])
print(rev_iter)
for _i in rev_iter:
    print(_i)

# 设置数字的精确位，会四舍五入算法
# round(number, ndigits=None)
print(round(23.266655555,5))

# 排序可迭代对象内的元素
# sorted(Iterable)
print(sorted([1,2,44,5,66,7]))

# 求和
# sum(int)
print(sum([1,2,3,44,5]))

# 将多个可迭代对象的元素一一对应形成一个元组，生成一个迭代器，长度以最小元素的可迭代对象为准
# zip(Iterable1,Iterable2,Iterable3...)
print(zip([1,2,3,55,6]))
for iz in zip([1,2,3,55,6],{‘name‘:‘wong‘,‘age‘:23}):
    print(iz)

# -*- coding:utf-8 -*-
# Author:Wong Du

‘‘‘
序列化
序列化可将非字符串的数据类型的数据进行存档，如字典、列表甚至是函数等等
反序列化，将通过序列化保存的文件反序列化即可得到数据原本的样子，可直接使用
python中序列化的方式：
    json：只可序列化简单的数据类型，如字典、列表等，其他语言也有json，即json可跨语言进行序列和反序列化
    pickle：python独有的序列化，可序列化一切数据，以二进制的形式保存
    python中json和pickle的用法基本上是一模一样的
‘‘‘

dict = {‘name‘:‘wong‘,‘age‘:‘23‘}

# with open(‘test‘,‘w‘) as f:
#     f.write(dict)
### 报错：TypeError: write() argument must be str, not dict


‘‘‘
### 把字典用json序列化后写入文件
### json.dumps(obj); json.dump(obj, fp)
### f.write(json.dumps(dict)) == json.dump(dict,f)
‘‘‘
import json
with open(‘test‘,‘w‘) as f:
    # f.write(json.dumps(dict))
    json.dump(dict,f)
### 成功写入

‘‘‘pickle序列化‘‘‘
import pickle
def foo():
    print("In the foo...")
foo()
with open(‘test2‘,‘wb‘) as f:       #以二进制字节类型写入到文件当中，所以mode = ‘wb‘
    # f.write(pickle.dumps(foo))
    pickle.dump(foo,f)
### 写入成功！注意，这里的写入是把foo函数对象写入到文件当中，反序列化后，当代码里没有foo函数对象，则会报错


list = [1,2,3,4,‘name‘]
with open(‘test3‘,‘wb‘) as f:
    # f.write(pickle.dumps(list))
    pickle.dump(list,f)

# -*- coding:utf-8 -*-
# Author:Wong Du

‘‘‘
序列化
序列化可将非字符串的数据类型的数据进行存档，如字典、列表甚至是函数等等
反序列化，将通过序列化保存的文件反序列化即可得到数据原本的样子，可直接使用
python中序列化的方式：
    json：只可序列化简单的数据类型，如字典、列表等，其他语言也有json，即json可跨语言进行序列和反序列化
    pickle：python独有的序列化，可序列化一切数据，以二进制的形式保存
‘‘‘

# with open(‘test‘,‘r‘) as f:
#     print(f.read())
#     f.read()[‘name‘]
### 报错：TypeError: string indices must be integers

‘‘‘
### json反序列化读取文件内容，可直接获取到字典，进行元素调用
### json.loads(str); line = json.load(fp)
### line = json.loads(f.read()) == line = json.load(f)
‘‘‘
import json
with open(‘test‘,‘r‘) as f:
    # line = json.loads(f.read())
    line = json.load(f)
    print(type(line))
    print(line[‘age‘])
### 成功调用
‘‘‘
输出：
<class ‘dict‘>
23
‘‘‘


import pickle
def foo():
    print("In the foo2...")
with open(‘test2‘,‘rb‘) as f:       #以二进制字节类型读取文件内容，所以mode = ‘rb‘
    # line = pickle.loads(f.read())
    line = pickle.load(f)
    line()


with open(‘test3‘,‘rb‘) as f:
    # line = pickle.loads(f.read())
    line = pickle.load(f)
    print(type(line))
    print(line[4])