<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>
class Foo(object):
    def __init__(self,name):
        self.name=name

obj=Foo('luwei')
v1=getattr(obj,'name')#==obj.name
print(v1)
print(obj.name)
setattr(obj,'name','llll')
if hasattr(obj,'name'):
    print('123')
print(getattr(obj,'name'))
# delattr(obj,'name')
# print(getattr(obj,'name'))<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>

class Foo:
    def show(self):
        print(123)
        pass

Foo.show('a')
<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>

#1.请使用面向对象实现栈（后进先出）
'''
class  Foo:
    def __init__(self):
        self.list=[]
    def pop(self):
        a=self.list.pop()
        return a
    def push(self,name):
        self.list.append(name)
        return self.list
obj=Foo()
obj.push('luwei1')
obj.push('luwei2')
obj.push('luwei3')
obj.push('luwei4')
v=obj.push('luwei5')
print(v)
print(obj.pop())
print(obj.pop())
print(obj.pop())


#2.请是用面向对象实现队列（先进先出）
class  Foo:
    def __init__(self):
        self.list=[]
    def pop(self):
        a=self.list.pop(0)
        return a
    def push(self,name):
        self.list.append(name)
        return self.list
obj=Foo()
obj.push('luwei1')
obj.push('luwei2')
obj.push('luwei3')
obj.push('luwei4')
v=obj.push('luwei5')
print(v)
print(obj.pop())
print(obj.pop())
print(obj.pop())

#3如何实现一个可迭代对象？
# class Foo:
#     def func(self):
#         yield 1
#         yield 2
#         yield 3
# obj=Foo()
# for  i in obj.func():
#     print(i)
# class Foo:
#     def __iter__(self):
#         return iter([1,2,3,4])
# obj=Foo()
# for  i in obj:
#     print(i)

#4.看代码写结果
class Foo(object):

    def __init__(self):
        self.name = '武沛齐'
        self.age = 100


obj = Foo()
setattr(Foo, 'email', '<EMAIL>')

v1 = getattr(obj, 'email')
v2 = getattr(Foo, 'email')

print(v1, v2)#<EMAIL> <EMAIL>


#5请补充代码（提：循环的列表过程中如果删除列表元素，会影响后续的循环，推荐：可以尝试从后向前找）


li = ['李杰', '女神', '金鑫', '武沛齐','女神1','女神11','女神111']
name = input('请输入要删除的姓氏：') # 如输入“李”，则删除所有姓李的人。
# 请补充代码
class Foo:

    def pop(self,name):
        l=[]
        self.name=name
        for i in li:
            if i.startswith(self.name):
                l.append(i)
        return set(li).difference(set(l))

        #return li

obj=Foo()
v=obj.pop(name)
print(list(v))


#6.有如下字典，请删除指定数据。
class User(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


info = [User('武沛齐', 19), User('李杰', 73), User('景女神', 16)]

name = input('请输入要删除的用户姓名：')
# 请补充代码将指定用户对象再info列表中删除。

for i in range(len(info),0,-1):#3,2,1
    if info[i-1].name==name:
        info.remove(info[i-1])
    print(info[i-1].name)
print(info)
'''


#7.补充代码实现：校园管理系统。

class User(object):
    def __init__(self, name, email, age):
        self.name = name
        self.email = email
        self.age = age

    def __str__(self):
        return self.name


class School(object):
    """学校"""

    def __init__(self):
        # 员工字典，格式为：{"销售部": [用户对象,用户对象,] }
        self.user_dict = {}



    def invite(self, department, user_object):
        """
        招聘，到用户信息之后，将用户按照指定结构添加到 user_dict结构中。
        :param department: 部门名称，字符串类型。
        :param user_object: 用户对象，包含用户信息。
        :return:
        """
        if department not in self.user_dict:
            self.user_dict[department]=[user_object]
            return
        self.user_dict[department].append(user_object)
        return

    def dimission(self, username, department=None):
        """
        离职，讲用户在员工字典中移除。
        :param username: 员工姓名
        :param department: 部门名称，如果未指定部门名称，则遍历找到所有员工信息，并将在员工字典中移除。
        :return:
        """
        self.username=username
        if department:
            user_msg=self.user_dict.get(department)
           # print(type(user_msg))
            for i in user_msg:
                i.name==self.username
                user_msg.remove(i)
        else:
            for a,b in self.user_dict.items():
                for i in b[::-1]:
                    if i.name ==self.username:
                        b.remove(i)

    def run(self):
        """
        主程序
        :return:
        """

        while True:
            user_choice=input('请选择：1.invite,2.dimission:')
            if user_choice=='1':
                user_depart = input('department:')
                user_name=input('usernmae:')
                user_email=input('email:')
                user_age=input('age:')
                self.invite(user_depart,User(user_name,user_email,user_age))
                #obj=User(None,None,None)
                #setattr(obj,'name',user_name)
            else:
                user_depart = input('department:(N)')
                user_name = input('usernmae:')
                if user_depart.upper()=='N':
                    self.dimission(user_name)
                else:
                    self.dimission(user_name,user_depart)
            print(self.user_dict)



if __name__ == '__main__':
    obj = School()
    obj.run()

<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>
class Foo(object):
	def __iter__(self):
		yield 1 	#返回生成器
		yield 2
		yield 3
obj=Foo()
for item in obj:
    print(item)


<file_sep>### day22

-  可迭代对象
- 约束+异常
- 反射

#### 内容详细

##### 1.可迭代对象

表象：可以被for循环对象就可以称为是可迭代对象：'xx'，[1，2，3，4]，{2，3，4}

```
class Foo()：
	pass
obj=Foo()
```

思考：如何让一个对象变成一个可迭代对象？

在类中实现__ iter __方法且返回一个迭代器（生成器）

```
class Foo(object):
	def __iter__(self):
		return iter([1,2,3,4])#返回迭代器
obj=Foo()

class Foo(object):
	def __iter__(self):
		yield 1 	#返回生成器
		yield 2
		yield 3
obj=Foo()
```

记住：只要能被for循环就是执行iter方法

##### 2.约束

```
class Interface(object):
    def send(self):
        raise NotImplementedError()

class Base(Interface):
    def send(self):
        pass


class Foo(Interface):
        pass


obj=Foo()
obj1=Base()
obj.send()
obj1.send()
```

##### 3.反射

根据字符串的形式去某个对象中操作他的成员

- getattr(对象,‘字符串')  根据字符串的形式去某个对象中获取对象的成员
- hasattr(对象,‘字符串') 根据字符串的形式去某个对象中判断是否有该成员对象的成员
- setattr(对象，’变量‘，’值‘)根据字符串的形式去某个对象中设置成员
- delattr（对象,‘字符串')根据字符串的形式去某个对象中删除成员

```
class Foo(object):
    def __init__(self,name):
        self.name=name
	def login(self):
		pass
obj=Foo('luwei')
#获取变量
v1=getattr(obj,'name')#==obj.name
print(v1)
print(obj.name)
setattr(obj,'name','llll')#obj.name='llll'
print(getattr(obj,'name'))
if not hasattr(obj,'login')
	return 'no no no '
#获取方法
method_name=getattr(obj,'login')
method_name()
#删除成员
delattr(obj,'name')
```

python一切皆对象，所以以后想要通过字符串的形式操作其内部成员都可以反射的机制实现。



##### 4.特殊模块：importlib

根据字符串形式去导入一个模块。

```
#用字符串的形式导入模块
import importlib

v=importlib.import_module('x.y')#等于from x import y

#用字符串的形式去对象(模块)找到成员。
getattr(v,'func')
```





 <file_sep>#-*-coding:utf-8-*-
# Author:<NAME>
class Interface(object):
    def send(self):
        raise NotImplementedError()

class Base(Interface):
    def send(self):
        pass


class Foo(Interface):
        pass


obj=Foo()
obj1=Base()
obj.send()
obj1.send()<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>

import os,sys

path=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(path)

class Base(object):
    def process(self):
        raise  NotImplementedError()


class AuthMiddleware(Base):
    def process(self):
        return 'auth'<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>

def func():
    print(123)<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>
'''
请编写网站实现如下功能。
需求：

实现 MIDDLEWARE_CLASSES 中的所有类，并约束每个类中必须有process方法。

用户访问时，使用importlib和反射 让 MIDDLEWARE_CLASSES 中的每个类对 login、logout、index 方法的返回值进行包装，最终让用户看到包装后的结果。
如：

用户访问 : http://127.0.0.1:8000/login/ ，
页面显示： 【csrf】【auth】【session】 登录 【session】 【auth】 【csrf】

用户访问 : http://127.0.0.1:8000/index/ ，
页面显示： 【csrf】【auth】【session】 登录 【session】 【auth】 【csrf】

即：每个类都是对view中返回返回值的内容进行包装。

'''

MIDDLEWARE_CLASSES = [
    'utils.session.SessionMiddleware',
    'utils.auth.AuthMiddleware',
    'utils.csrf.CrsfMiddleware',
]

from wsgiref.simple_server import make_server
import importlib






class View(object):
    def login(self):
        sum=''
        for i in MIDDLEWARE_CLASSES:
            path, cls = i.rsplit('.', maxsplit=1)
            path1=importlib.import_module(path)
            a1=getattr(path1,cls)().process()
            sum=sum+' '+a1
        return sum+'登陆'+sum

    def logout(self):
        return '等处'

    def index(self):
        csrf = importlib.import_module('utils.csrf')
        a = 'CrsfMiddleware'
        a1=getattr(csrf, a)().process()
        return '首页'+a1


def func(environ,start_response):
    start_response("200 OK", [('Content-Type', 'text/plain; charset=utf-8')])
    obj = View()
    method_name = environ.get('PATH_INFO').strip('/')
    if not hasattr(obj,method_name):
        return ["".encode("utf-8"),]
    response = getattr(obj,method_name)()
    return [response.encode("utf-8")  ]


server = make_server('127.0.0.1', 8000, func)
server.serve_forever()<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>


import os,sys

path=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(path)

class Base(object):
    def process(self):
        raise  NotImplementedError()

class SessionMiddleware(Base):
    def process(self):
        return 'session'

<file_sep>#-*-coding:utf-8-*-
# Author:<NAME>

#用字符串的形式导入模块
import importlib

v=importlib.import_module('x.y')#等于from x import y

#用字符串的形式去对象(模块)找到成员。
getattr(v,'func')()
