seven day--面向对象及模块

 1 # 面向对象
 2 # 类 实例化 对象/实例
 3 # 什么是类？ 拥有相同属性和方法的一类事物
 4 # 什么是对象？ 类的一个实际表现，给类中的属性填上具体的值，能够使用类中的方法
 5 # 实例化的过程中做了那些事儿？
 6     # 对象 = 类名()
 7     # 首先要创造一个对象
 8     # 被创造出来的这个对象会作为参数传递给__init__方法中的第一个参数
 9     # 调用__init__方法，传递一些初始化参数 —— 初始化方法
10     # 将初始化之后的对象返回给调用者
11 # 查看属性和调用方法
12     # 类名 ： 静态属性、类属性
13     # 对象 ： 调用方法（动态属性）、查看对象的属性
14 # 组合 : 两类事物之间的所有关系，什么有什么的关系
15 # 继承 ：两个类之间的包含关系，什么是什么的关系
16     # 钻石继承问题
17         # 经典类 ： 在一个子类中寻找方法的时候，从子类到父类先找到的名字会被执行。
18                     # 深度优先就是在经典类中找类的顺序的一种算法
19         # 新式类 ： 广度优先
20         # py2中，主动继承object类的都是新式类，它的子类也是新式类
21         # py3中，所有的类都是新式类，都继承object
22     # super ：
23         # 自己有父类也有的时候，在单继承中super就可以用父类的
24         # 在多继承中 super遵循mro广度优先顺序
25     # 派生 ：
26         # 属性
27         # 方法
28 # 多态
29         # python中不需要程序员自己实现多态
30         # 在其他强数据类型语言的面向对象中，我要传递一个参数必须指定这个参数的数据类型
31         # 但是，往往在这个地方需要传递的不止一种类型
32         # 建立一个父类，让所有要传递的数据类型都继承这个父类，在参数指定数据类型的时候
33         # 指定父类名就可以了
34 
35 # def eat(Animal alex):pass
36 
37 
38 # 画知识的思维导图：思维导图一定要画！
39     # python ：基础数据类型 文件处理 函数 模块 面向对象
40     # 函数
41         # 函数的定义 ：参数和返回值
42         # 生成器函数
43         # 递归函数
44         # 内置函数
45         # 匿名函数
46     # 面向对象
47         # 基础概念
48         # 定义
49         # 三大特性 ： 封装
50                     # 多态
51                     # 继承
52 
53 # 北大研究生 ：
54     # 整理
55     # 时间分片

 1 #例子一
 2 # class Person:
 3 #     __country=‘中国‘ #私有的静态属性
 4 #     print(__country)   #类里的代码，从定义开始就执行，会输出 中国
 5 #
 6 # #print(Person.__country)   #AttributeError: type object ‘Person‘ has no attribute ‘__country‘
 7 # #私有的名字 ，只能在类的内部使用，不能在类的外部使用
 8 #
 9 # print(Person._Person__country)#可以调用，但不能使用该方式。
10 # print(Person.__name)   #在类的外部不能定义一个私有变量

 1 class Person:
 2     __country = ‘中国‘
 3     def __init__(self,name,pwd):
 4         self.name = name
 5         self.__pwd = pwd      # 私有的对象属性
 6     def login(self):
 7         print(self.__dict__)
 8         if self.name == ‘alex‘ and self.__pwd == ‘alex3714‘:
 9             print(‘登录成功‘)
10 
11 alex = Person(‘alex‘,‘alex3714‘)
12 alex.login()
13 print(alex.__dict__)   #{‘name‘: ‘alex‘, ‘_Person__pwd‘: ‘alex3714‘}
14 print(alex.__pwd)

# class Person:
#     def __init__(self):pass
#     def __制造密码转换(self,inp):
#         print(‘eating‘)
#     def 注册(self):
#         inp = input(‘pwd>>>‘)
#         加密之后的密码 = self.__制造密码转换(inp)

 1 # class Foo:
 2 #     def __init__(self):
 3 #         self.__func()    # self._Foo__func
 4 #     def __func(self):
 5 #         print(‘in Foo‘)
 6 #
 7 # class Son(Foo):
 8 #     def __func(self):    # _Son__func
 9 #         print(‘in son‘)
10 #
11 # s = Son()

 1 # class Foo:
 2 #     def __init__(self):
 3 #         self.func()
 4 #     def func(self):
 5 #         print(‘in Foo‘)
 6 
 7 # class Son(Foo):
 8 #     def func(self):
 9 #         print(‘in son‘)
10 #
11 # s = Son()

 1 from math import pi
 2 class Circle:
 3     def __init__(self,r):
 4         self.r=r
 5     @property
 6     def area(self):
 7         print(‘area被执行了...‘)
 8         return self.r**2*pi
 9     @property
10     def perimeter(self):
11         return self.r*2*pi
12 # # 方法 动词 —— 动作或者技能
13 # # 名词 圆的面积 圆的周长 圆的班级
14 #将一个函数伪装成属性 @property
15 
16 c=Circle(3)
17 print(c.area)
18 print(c.perimeter)

 1 # #练习计算面积--zijixiede
 2 # class mj:
 3 #     def __init__(self,l,h):
 4 #         self.l=l
 5 #         self.h=h
 6 #     @property
 7 #     def area(self):
 8 #         return self.h *self.l
 9 # ss=mj(2,3)
10 # print(ss.area)

 1 #property   和 __私有的名字一起使用----------打折例子
 2 
 3 class Goods:
 4     def __init__(self,price,discount):
 5         self.__price=price
 6         self.discount=discount
 7     @property
 8     def price(self):
 9         return self.__price * self.discount
10     @price.setter     #修改价格
11     def price(self,newprice):
12         self.__price=newprice
13     @price.deleter  #删除
14     def price(self):
15         del self.__price
16 
17 apple=Goods(8,0.7)
18 print(apple.price)
19 apple.price=10
20 print(apple.price)
21 print(apple.__dict__)
22 del apple.price
23 print(apple.__dict__)
24 # print(apple.price)
25 
26 结果：
27 5.6
28 7.0
29 {‘_Goods__price‘: 10, ‘discount‘: 0.7}
30 {‘discount‘: 0.7}

 1 # class Person:
 2 #     Country = ‘中国人‘
 3 #     @classmethod       #把func变成了一个类方法
 4 #     def func(cls):     # cls是指向类的内存空间
 5 #         print(‘当前的角色的国籍是%s‘%cls.Country)
 6 
 7 # alex = Person()
 8 # alex.func()
 9 # Person.func()
10 # 如果某一个类中的方法 并没有用到这个类的实例中的具体属性
11 # 只是用到了类中的静态变量 就使用类方法

1 class Student:
2     @staticmethod
3     def login():
4         name = input(‘name : ‘)
5         pwd = input(‘pwd : ‘)
6         if name ==‘‘ and pwd ==‘‘:
7             print(‘实例化‘)
8 
9 Student.login()

 1 # 什么叫序列化呢？
 2     # { ‘10100011‘:{‘name‘:,age: ,class:},}
 3     # 数据类型 —— 字符串的过程
 4 # 什么时候要用序列化呢？
 5     # 数据从内存到文件
 6     # 数据在网络上传输  字节 - 字符串 - 字典
 7 # python中的序列化模块都有哪些？
 8     # json   通用的 支持的数据类型 list tuple dict
 9     # pickle python中通用的 支持几乎所有python中的数据类型
10     # shelve python中使用的便捷的序列化工具
11 
12 # dumps loads
13 # dump load
14 
15 import json
16 dic = {"k":‘v‘}
17 # print(type(dic))
18 # json_dic = json.dumps(dic) #{"k": "v"}  # 字典转字符串的过程 ——序列化
19 # print(json_dic)
20 # print(dic)    #{‘k‘: ‘v‘}
21 # print(type(json_dic))
22 # print(json.loads(json_dic)) # 字符串 转回其他数据类型 —— 反序列化
23 
24 # with open(‘d‘,‘w‘) as f:
25 #     json.dump(dic,f)       # dump是和文件交互的
26 #     json.dump(dic,f)       # dump是和文件交互的
27 
28 # with open(‘d‘) as f:
29 #     print(json.load(f))      # 从文件中反序列化
30 
31 # 如果要dump多条数据
32 # 每一条数据先dumps一下 编程字符串 然后打开文件 write写进文件里 \n
33 # 读取的时候按照标志读取或者按行读
34 # 读出来之后 再使用loads

# with open(‘aaa‘,‘w‘) as f:
#     str_dic = json.dumps(dic)
#     f.write(str_dic+‘\n‘)
#     f.write(str_dic+‘\n‘)
#     f.write(str_dic+‘\n‘)
#     f.write(str_dic+‘\n‘)

# with open(‘aaa‘) as f:
#     for line in f:
#         print(json.loads(line.strip()))

 1 # import pickle
 2 # class A:
 3 #     def __init__(self,name):
 4 #         self.name = name
 5 #
 6 # alex = A(‘alex‘)
 7 # print(pickle.dumps(alex))
 8 # with open(‘bbb‘,‘wb‘) as f:
 9 #     pickle.dump(alex,f)
10 #     pickle.dump(alex,f)
11 #     pickle.dump(alex,f)
12 #
13 # with open(‘bbb‘,‘rb‘) as f:
14 #     while True:
15 #         try:
16 #             obj = pickle.load(f)
17 #             print(obj.name)
18 #         except EOFError:
19 #             break

1 # import hashlib
2 # #hashlib.md5()#<md5 HASH object @ 0x000000000218C8A0>一种算法
3 # md5obj=hashlib.md5() #实例化一个md5摘要算法的对象
4 # # 能够让一个字符串 唯一的 对应一个固定的值
5 # md5obj.update(‘lijie123‘..) #使用md5算法的对象来操作字符串
6 # #获取算法的结果
7 # ret=md5obj.hexdigest()
8 # print(ret,type(ret),len(ret))

 1 ‘aaa‘.startswith(‘a‘)
 2 ret=getattr(‘aaa‘,‘startswith‘)  #一个对象
 3 print(ret(‘a‘))  #True
 4 
 5 class Person:
 6     def __init__(self,name):
 7         self.name=name
 8     def eat(self):print(‘eating‘)
 9     def drink(self):print(‘drinking‘)
10     def play(self): print(‘playing‘)
11     def sleep(self): print(‘sleeping‘)
12 
13 # alex=Person(‘alex‘)
14 # print(getattr(alex,‘name‘))
15 # while True:
16 #     inp = input(‘>>>‘)
17 #     if hasattr(alex,inp):
18 #         getattr(alex,inp)()
19 #小结：
20 # 首先 使用getattr取获取一个名字，如果在这个对象的命名空间中没有这个名字 会报错
21 # getattr的反射好伴侣 hasattr
22 # 如果使用getattr取获取一个方法，那么只能拿到这个方法的内存地址 加上括号就是执行，当然，括号里的参数可以照传不误
23 # 如果getattr获取一个属性，那么直接使用反射就可以获取到值