面向对象初级

    面向对象初级：
    1.面向对象三大特征：封装  继承   多态    self含义：  指向实例对象本身，让实例能够访问类中的属性和方法
    2.类和对象的创建：    
类和对象的创建（登录注册功能）

1. class User:
2.     def __init__(self,name,pwd):
3.         self.name = name
4.         self.pwd = pwd
6. class User_Mannager():
7.     def __init__(self):
8.         self.user_list = []#存放User类对象
9.     def regist(self):
10.         """
11.         用户注册
12.         """
13.         while True:
14.             name = input('输入用户名N(退出）：')
15.             if name.upper() == 'N':
16.                 break
17.             for item in self.user_list:
18.                 if item.name == name:
19.                     print('用户名已存在,重新输入')
20.                     flag = True
21.                     break
22.             else:
23.                 pwd = input('输入密码：')
24.                 self.user_list.append(User(name,pwd))
25.                 print('注册成功')
26.                 return
27.             continue
28.     def Login(self):
29.         """
30.         用户登录
31.         """
32.         while True:
33.             name = input('输入用户名：')
34.             pwd = input('输入密码：')
35.             for i in self.user_list:
36.                 if i.name == name and i.pwd == pwd:
37.                     print('登录成功')
38.                     return
39.             else:
40.                 print('用户名密码错误')
41.                 continue
43.     def run(self):
44.         """
45.         程序入口
46.         """
47.         while True:
48.             func_dict = {'1':self.Login,'2':self.regist}
49.             print('界面(N退出):1【登录】2.【注册】')
50.             num = input('输入：')
51.             if num.upper() == 'N':
52.                 return
53.             func = func_dict.get(num)
54.             if func:
55.                 func()
56.             else:
57.                 print('输入错误')
59. if __name__ == "__main__":
60.     obj = User_Mannager()
61.     obj.run()

复制代码

属性：对象具有的特征叫属性
    设置和获取对象具有的属性：
      1，静态  类中：  对象.属性=值    
             外部：  设置：obj = Foo(属性的值）
                  获取：对象.属性  
      2，动态(反射）：以字符串的形式去设置获取对象属性  类中：对象.属性=值或者pass  
                                外部：setattr：新增此对象的属性及值或者修改此对象已经具有的属性的值    
                                   格式：setattr（对象   ，属性   （字符串形式），值   （任意类型））
                                   getattr：获取对象已经具有的属性的值                
                                   格式：getattr（对象，属性  （字符串形式），默认值（属性不存在时返回，任意类型）
属性的设置和获取（静态和动态）

1. #设置和获取对象的值方法一（静态）：
2. class Foo:
3.     def __init__(self,n,p):     #给这个类所创建的对象中公有的属性进行值的初始化
4.         self.name = n
5.         self.pwd = p
6. obj = Foo('guohan',123)     #设置对象属性的值（对象属性的值封装到对象中）
7. print(obj.name)     #获取对象的值
8. #>>>guohan
11. #设置和获取对象的值方法二(动态：内置函数）：     setattr getattr
12. class Foo:
13.     def __init__(self,n,p):     #给这个类所创建的对象中公有的属性进行值的初始化
14.         self.name = n
15.         self.pwd = p
16. obj = Foo(1,1)
17. n = input('输入用户名：')
18. p = input('输入密码：')
19. setattr(obj,'name',n)    #通过内置函数setattr去设置\修改对象的属性
20. setattr(obj,'pwd',p)
21. data1 = getattr(obj,'name',0)   #通过内置函数getattr去获取对象中封装的属性的值
22. data2 = getattr(obj,'pwd',0)
23. data3 = getattr(obj,'email',0)
24. print(data1)
25. print(data2)
26. print(data3)
27. #>>>guoahn
28. #>>>111
29. #>>>0

复制代码

    3.封装：    同一类的方法封装到同一类中    值封装到对象中
            类中的属性和方法：公有（一般都是）  私有（以_开头）：类实例化的对象无法直接访问私有成员（属性和方法）
            获取对象中封装的所有值
对象.__dict__以字典形式获取对象的属性和值

1. #获取对象中封装的所有的属性ji
2. class Foo:
3.     def __init__(self,name,pwd,eamil):
4.         self.name = name
5.         self.pwd =  pwd
6.         self.eamil = eamil
7. obj = Foo('guohan','123','888')
8. print(obj.__dict__)
9. #>>>{'name': 'guohan', 'pwd': '123', 'eamil': '888'}
10. setattr(obj,'name','gh')
11. print(obj.__dict__)
12. #>>>{'name': 'gh', 'pwd': '123', 'eamil': '888'}

复制代码

    4.继承：    搞清楚self是谁由谁创建 调用方法时去self自己的类中去找  
            查找方法顺序：先再自己类中找再去基类找（多个基类则由左至右）  时刻注意self是谁
    5.多态：    对于一个函数而言，Python对于参数的类型不会限制，那么传入参数时就可以是各种类型，在函数中如果有例如：arg.方法，那么就是对于传入类型的一个限制（类型必须有该方法）。
              这就是鸭子模型只要有该方法，就是我们要想的类型
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！