python学习 day22 (3月29日)----(生成器推导式）

新手上路请多担待

1

2

封装

3

私有化封装

#__author : 'liuyang' 
#date : 2019/3/29 0029 上午 9:35
# 不想让别人看 修改 我的属性
# 源码来说
    # 用户名 和 密码
# 狭义上的封装  ：  私有化的方法 和属性
# 广义上的封装  ：  把方法和属性根据类别装到类中

#方法静态变量实例变量（对象属性）都可以私有化
#所谓的私有化：
#就是只能在类的内部课件，
#类的外部是不能访问或者查看
class Goods:
    def __init__(self,name,proce):
        self.name = name
        self.__price = proce#私有属性
    def get_price(self):
        print(self.__price)
apple = Goods('苹果',2)
# print(apple.get_price().__price)
apple.get_price()
import hashlib
# class Auto:
#     def __init__(self,name,pwd):
#         self.name = name
#         self.pwd = name
#     def md5(self):
#         md5 =
#         md5.update()

class Goods:
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    def get_price(self):   #内部 self._类名__属性
        print(self.__price)
    def set_num(self):
        self.__num = 20
apple = Goods('苹果',5)
# print(apple.__price)    #AttributeError: 'Goods' object has no attribute '__price'
print(apple.__dict__)   #{'name': '苹果', '_Goods__price': 5}
print(apple._Goods__price)  #5  #私有的形成
# 定义了私有的只不过 是改了一个名 并不是真正的隐藏了  隐姓埋名
# 所有的私有的变化都是 在类的[内部]定义完成的
apple.__num = 10
print(apple.__dict__)
# print(self._apple__selfnum)
class Foo:
    def __init__(self):
        self.__func()
    def __func(self): #私有化 _Foo__func()
        print('foo')
class Son(Foo):             #_Son__func() 指针去找init init 找_Foo__func()
    def __func(self):
        print('son')
Son()       #改名了

class User:
    def __wahaha(self):
        print('1')      ##self._User__wahaha()
class V(User):      #AttributeError: 'V' object has no attribute '_V__wahaha'
    def func(self):     #self._V__wahaha()
        self.__wahaha()
# V().func()
#私有的这个概念： 单反不在一个类里就报错
#私有的所有内容： 实例变量（对象属性）
                #静态变量（类变量），方法都不能被子类继承

class User:
    def wahaha(self):
        print('1')      ##self._User__wahaha()
class V(User):      #AttributeError: 'V' object has no attribute '_V__wahaha'
    def func(self):     #self._V__wahaha()
        self.wahaha()
V().func()      #1  func()执行了 类（）.方法（）
                # 不是 __init__ 的 V()

# 公有的 再累的内部随便用public
# 其它语言里 外部不能用 可以继承的 保护的
#私有的 private 只能在类的内部使用 既不能被继承 也不能再累的外部使用

4

property

# 私有 property 是一对好搭档
# 圆形类
# 计算面积 计算周长
# 半径 面积 周长  --->属性

class Circle:
    def __init__(self,r):
        self.r = r
    @property       #把装饰的一个方法伪装成一个属性
    def area(self):
        return 3.14*self.r**2
c1 = Circle(5)
print(c1.r)
c1.r = 10
print(c1.area)      #更符合属性
import time
class Person:
    def __init__(self,name,birth):
        self.name = name
        self.birth = birth
    @property
    def age(self):
        struct = time.localtime()
        age = struct.tm_year - int(self.birth.split('-')[0])
        return age

liuda = Person('liuda','1999-8-19')

print(liuda.age)

私有概念+property 不能改 

#__author : 'liuyang' 
#date : 2019/3/29 0029 上午 11:08
#一个属性 只让看不让改
class Goods:
    dicount = 0.8   # 全场折扣
    print(dicount)  #这里可以
    def __init__(self,name,price):
        self.name= name
        self.__price = price
    @property  #只支持 obj.price 的方式查看这个结果
    def price(self):    #这个编程了self.price
      # 在里面用得用self.dicount
        return self.__price  * self.dicount   #下一个是静态变量
              #self.dicount 和 Goods.dicount 的区别是 类名改了就得又改     #原价格

    @price.setter # 1,前者伪装过 2.后两个和前面的同名
    def price(self,value):
        if type(value) is int or type(value) is float:
            self.__price = value
        # print('--->',value)

apple = Goods('shu',5)
apple2 = Goods('shus',2)
print(apple.price)

# apple.price = 10    # 只能看不能改
apple.__price = 1000    # 不能改 这里 随便改
print(apple.__price)  #10
print(apple.price)    #5

Goods.dicount =1
print(apple.price)
print(apple2.price)
# apple.__price = 2
apple.price = 8     #对应的调用的是被setter装饰的price方法
print(apple.price)  #对应调用的是被property装饰的price

# 后面很多条件
# 如果我们定义的是普通的变量或者属性
    #那么这个属性可以从外部直接访问
    #可以任意的修改 obj.attr = 123
    #甚至可以删除 del obj.attr
#私有化
    #把一个属性加上双下划线__属性名
    #这个属性就连在外面看都看不见
    #我们实际上有些场景允许别人看，不许改
        #__属性
        #@property 装饰的属性名
        #def 属性名（）：
    #我们允许别人看，也允许别人改，但是不能瞎改，有一些要求
        # __属性
        # @property 装饰的属性名
        # def 属性（）：return__属性

        # @属性.setter
        # def 属性（self ,value）：
        #加点条件
        #

#__author : 'liuyang' 
#date : 2019/3/29 0029 上午 11:08
#一个属性 只让看不让改
class Goods:
    dicount = 0.8   # 全场折扣
    print(dicount)  #这里可以
    def __init__(self,name,price):
        self.name= name
        self.__price = price
    @property  #只支持 obj.price 的方式查看这个结果
    def price(self):    #这个编程了self.price
      # 在里面用得用self.dicount
        return self.__price  * self.dicount   #下一个是静态变量
              #self.dicount 和 Goods.dicount 的区别是 类名改了就得又改     #原价格

    @price.setter # 1,前者伪装过 2.后两个和前面的同名
    def price(self,value):
        if type(value) is int or type(value) is float:
            self.__price = value
        # print('--->',value)

    @price.deleter
    def price(self):
        del self.__price        # 有这个才删除
        print('执行我了')

apple = Goods('shu',5)
apple2 = Goods('shus',2)
print(apple.price)

# apple.price = 10    # 只能看不能改
apple.__price = 1000    # 不能改 这里 随便改
print(apple.__price)  #10
print(apple.price)    #5

Goods.dicount =1
print(apple.price)
print(apple2.price)
# apple.__price = 2
apple.price = 8     #对应的调用的是被setter装饰的price方法
print(apple.price)  #对应调用的是被property装饰的price

## apple.__price = 2  不能 所以 #@price.setter
# del apple.__price   不能外部删除 所以#@price.deleter

apple.price         #@property
apple.price = 9     #@price.setter  #函数里得有修改
del apple.price     #@price.deleter #函数里得有删除
print(apple.__dict__)
#apple.__price = 1000    # 不能改 这里 随便改
#{'name': 'shu', '__price': 1000}


# 后面很多条件
# 如果我们定义的是普通的变量或者属性
    #那么这个属性可以从外部直接访问
    #可以任意的修改 obj.attr = 123
    #甚至可以删除 del obj.attr
#私有化
    #把一个属性加上双下划线__属性名
    #这个属性就连在外面看都看不见
    #我们实际上有些场景允许别人看，不许改
        #__属性
        #@property 装饰的属性名
        #def 属性名（）：
    #我们允许别人看，也允许别人改，但是不能瞎改，有一些要求
        # __属性
        # @property 装饰的属性名
        # def 属性（）：return__属性

        # @属性.setter
        # def 属性（self ,value）：
        #加点条件
        #修改__属性


#私有的：通过给__名字这样的属性 或者方法加上当前所在类的前缀，把属性隐藏其阿里
        #只能在本类的内部使用，不能再类的外部使用，不能被继承

#property 把一个方法 伪装成属性

#property 和私有的两个概念一起用
    #定义一个私有的
    #在定义一个同名共有的方法，  @property装饰

    #在定义一个同名共有的方法，@方法名.setter
    #在定义一个同名共有的方法，@方法名.deleter

6  类和self   classmethod

#__author : 'liuyang' 
#date : 2019/3/29 0029 下午 12:22
class Goods:
    dicount = 0.8   # 全场折扣
    print(dicount)  #这里可以
    def __init__(self,name,price):
        print(self,'121')
        self.name= name
        self.__price = price
    @property  #只支持 obj.price 的方式查看这个结果
    def price(self):    #这个编程了self.price
      # 在里面用得用self.dicount
        return self.__price  * self.dicount   #下一个是静态变量
              #self.dicount 和 Goods.dicount 的区别是 类名改了就得又改
                # self.dicount 不好使 ，goods.dicount keyi
    # def chang_disount(self,value):        #self没有用
    #     Goods.__discount = value                                    # 用类
    @classmethod  #把一个对象方法改成了类方法      #把self改成了类
    def chang_disount(cls,value):        #self没有用
        print(cls,'1',Goods)   #<class '__main__.Goods'> 1 <class '__main__.Goods'>
        cls.__discount = value                                    # 用类

    @classmethod
    def get_discount(cls):
        return cls.__discount
# Goods.chang_disount()                                                #
A = Goods('apple',2)

Goods.chang_disount(12)
A.chang_disount(12)
print(A.get_discount())

# 类方法
    #1.有些时候我们要修改的是类中的静态变量/类变量
    # 此时根本不会和self有任何的操作关联
    #这时传一个 self参数对我们完全没有用
    #我们希望接受的是当前我们所在的类
appp = Goods('apple',2)
appp.chang_disount(1)
print(Goods.get_discount())

#  类方法 推荐使用类名调用而不是使用对象名调用
#  没写死  自动传 类名

7  自己想代码 想python语法的用法  想龟叔的想法 python 设计思想

class A:
    # def func(): #不错
    @staticmethod  #声明一个普通的不会使用类相关的方法
    def func():     #此时func是一个静态方法
        print('既不操作和self相关')
        print('也不操作和类名相关')
A.func()

# login() 登录功能
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age =age
    @staticmethod
    def login(self):pass

#先获取这个学生的用户名和密码
#判断他登录成功之后进行实例化

# a = Student('liuda',2)
Student.login()
stu = Student('liuda')

# 先进行思考  
#方法就在那，
#自己有想法，先学，去想python的用法
# 有一些也可能是老师也没想到的

#  思维导图写

 #凌晨5点备课到 8点上课  讲课到凌晨1点   下课凌晨2点 上海的分培训机构