封装
引子
从封装的本身意思去理解，封装就是用一个袋子，把买的水果、书、水杯一起装进袋子里，然后再把袋子的口给封上，照这样的理解来说，封装=隐藏，但是，这种理解是片面的
## 如何封装
在python中用双下划线开头的方式代表把属性隐藏起来（设置为私有的）
class a:
__x = 1 # __代表属性隐藏
def __init__(self,name):
self.__name = name
def __foo(self):
print('run __foo')
def bar(self):
self.__foo()
print('from bar')
慢慢来看
# 打印类的属性
print(a.__x)
attributeerror: type object 'a' has no attribute '__x' # 告诉我们没有这个属性
# 打印类的方法
print(a.__foo)
attributeerror: type object 'a' has no attribute '__foo' # 没有这个方法
# 实例化对象，然后访问对象的方法
a = a('xiao')
a.bar()
运行结果为：
run __foo
from bar
为什么直接访问__x属性和__foo方法不行呢？但是实例化对象后就可以访问呢？我们先开看下名称空间
a = a('xiao')
print(a.__dict__)
print(a.__dict__)
运行结果为：
{'__module__': '__main__', '_a__x': 1, '__init__':
{'_a__name': 'xiao
# 原来这些在类定义的时候发生了变形，把__x变成了_a__x，所以调用方式应该是：
print(a._a__x) # ---->1
这种方法是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义的变形
这种自动变形的特点
在类的外部无法直接访问到 obj.__attrname在类的内部是可以直接使用的，obj.__attrname，在定义阶段已经改成了正确的调用方式了
? def bar(self):
? self.__foo() print('from bar')
子类无法覆盖__开头的属性
这种变形需要注意的是
这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字变形的过程中只是在类的定义时发生一次，在定义后的赋值操作，不会变形
class a:
__x = 1 # __代表属性隐藏
def __init__(self,name):
self.__name = name
def __foo(self):
print('run __foo')
def bar(self):
self.__foo()
print('from bar')
a = a('xiao')
print(a.__dict__)
a.__y = 10 # 在定义后的赋值操作不会变形
print(a.__dict__)
# 打印结果为
{'_a__name': 'xiao'}
{'_a__name': 'xiao', '__y': 10}
在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
# 正常情况
class foo:
def func1(self):
print('from foo')
class bar(foo):
def func1(self):
print('from bar')
b = bar()
b.func1() # 子类重写父类方法
# 运行结果为
from bar
# 如果父类不想让子类覆盖自己的方法，那么就可以将方法定义为私有的
class foo:
def __test(self):
print('from foo')
def test(self):
self.__test()
class bar(foo):
def __test(self):
print('from bar')
print(foo.__dict__)
b = bar()
b.test()
# 那么这个打印结果就是
from foo
封装的意义
封装是把属性和方法进行封装，而不是单纯意义上的隐藏。
封装数据属性将数据隐藏起来不是目的，隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口上附加对该数据操作的现实，以此完成对数据属性操作的严格控制
# 封装数据属性：明确的区分内外，控制外部对隐藏属性的操作行为
class people:
def __init__(self,name,age):
self.__name = name
self.__age = age
def tell_info(self): # 可以自定义格式，可以控制用户的使用行为
print('name:<%s>-age:<%s>'%(self.__name,self.__age))
def set_info(self,name,age):
if not isinstance(name,str):
print('名字必须是字符串类型')
return
if not isinstance(age,int):
print('年龄必须是数字类型')
return
self.__name = name
self.__age = age
p = people('xiao',22)
p.set_info('xiao',22)
p.tell_info()
此时对属性的修改是间接的修改，在接口上附加操作逻辑，来控制对属性的操作，这就是封装数据属性的意义
封装方法属性目的是隔离复杂度
# 在日常生活中，取款是一个功能，而这个功能有很多功能组成：插卡、密码验证、输入金额、打印账单、取款，但是对于使用者来说，只需要知道取款这个功能就可以了，其余的功能我们都隐藏起来，很明显这样做就隔离了复杂度，同时也提升了安全性
class atm:
def __card(self):
print('插卡')
def __auth(self):
print('用户认证')
def __input(self):
print('输入取款金额')
def __print_bill(self):
print('打印账单')
def __take_money(self):
print('取款')
def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()
a=atm()
a.withdraw()
# 运行结果为
插卡
用户认证
输入取款金额
打印账单
取款
封装方法的其他举例：
1.你的身体中没有一处不体现出封装的概念：你的身体把膀胱尿道等等这些尿的功能都隐藏了，然后为你提供了一个尿的接口2.电视机本身就是一个盒子，隐藏了所有细节，但是一定会对外提供一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义上的隐藏3.快门就是傻瓜相机为相机们提供的方法，该方法将内部复杂的照相功能都隐藏起来了
提示：在编程语言中，对外提供的接口（接口可以理解成一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体
封装与可扩展性
# 得到房间的面积
class room: # 定义一个房间类
def __init__(self,name,owner,weight,height): # 房间的名字、所属者、宽度、高度
self.name = name
self.owner = owner
# 对于使用者来说，我只想知道房间的面积，所以在内部需要隐藏起来
self.__weight = weight
self.__height = height
# 因为我们需要得到房间的面积，所以需要给使用者提供一个接口
def tell_info(self):
return self.__weight * self.__height
r = room('赌场','xiao',10,10)
print(r.tell_info()) # 100
# 但是突然有一天，使用者告诉我想知道房间的体积，那么我们应该还要把length传进去
class room: # 定义一个房间类
def __init__(self,name,owner,weight,height,length): # 房间的名字、所属者、宽度、高度
self.name = name
self.owner = owner
# 对于使用者来说，我只想知道房间的面积，所以在内部需要隐藏起来
self.__weight = weight
self.__height = height
self.__length = length
# 因为我们需要得到房间的面积，所以需要给使用者提供一个接口
def tell_info(self):
return self.__weight * self.__height * self.__length
r = room('赌场','xiao',10,10,10)
print(r.tell_info()) # 1000，
1.对于使用者来说，我只需要知道房间的面积、体积是多少，我不需要考虑你们是如何计算的，就像atm一样，我只需要调用withdraw功能取款就可以了，具体的验证我不用关心
2.使用者根本就不需要改变自己的使用方式，直接就用上了新功能，这就是封装可扩展性
property装饰器
刚刚我们已经讲过了，房间的面积\体积是通过计算出来的，也就是我们提供了一个接口，但在使用者看来，这就是一个方法而并非是属性，什么意思呢？我们打一个比喻
class peopon:
def __init__(self,name,age):
self.name = name
self.age = age
def run(self):
print('%s is run'%self.name)
def eat(self):
print('%s is eat'%self.name)
p = peopon('xiaoyafei',22)
print(p.name)
print(p.age)
p.run()
p.eat()
# 运行结果为：
xiaoyafei
22
xiaoyafei is run
xiaoyafei is eat
在上面的代码中，我们可以很明显的知道了，name和age是名词，是对象的属性，而run和eat属于动词，是方法
但是在这个房间中，房间的面积/体积就是一个名字，就应该成为一个属性，就像我们调用p.name/p.age这样可以便捷的访问到属性，所以在提供面积的接口这里应该加上：
class room: # 定义一个房间类
def __init__(self,name,owner,weight,height,length): # 房间的名字、所属者、宽度、高度
self.name = name
self.owner = owner
# 对于使用者来说，我只想知道房间的面积，所以在内部需要隐藏起来
self.__weight = weight
self.__height = height
self.__length = length
# 因为我们需要得到房间的面积，所以需要给使用者提供一个接口
@property
def tell_info(self):
return self.__weight * self.__height * self.__length
r = room('赌场','xiao',10,10,10)
print('房间的面积是：',r.tell_info)
# 运行结果为
房间的面积是： 1000
让我们举一个例子，bmi指数
成人的bmi数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
体质指数（bmi）=体重（kg）÷身高^2（m）
ex：70kg÷（1.75×1.75）=22.86
bmi的指数和人有关，所以需要出创建一个人的类
class people:
def __init__(self,name,weight,height):
self.name = name
self.weight = weight
self.height = height
p = people('xiaoyafei',75,1.81)
p.bmi = p.weight / (p.height ** 2)
print(p.bmi) # 22.89307408198773
我们如果是计算一个人的bmi指数，那么这个代码就够了，如果要计算很多人的话：
p = people('xiaoyafei',75,1.81)
p1 = people('xiaoyafei',76,1.87)
p2 = people('xiaoyafei',77,1.86)
p3 = people('xiaoyafei',78,1.84)
p4 = people('xiaoyafei',79,1.83)
p5 = people('xiaoyafei',75,1.81)
p.bmi = p.weight / (p.height ** 2)
p1.bmi = p.weight / (p.height ** 2)
...
print(p.bmi)
print(p1.bmi)
...
如果每次都要写一次这样的话，就会非常麻烦，所以我们就要在类里给用户提供一个接口：
class people:
def __init__(self,name,weight,height):
self.name = name
self.weight = weight
self.height = height
def bmi(self):
return p.weight / (p.height ** 2)
p = people('xiaoyafei',75,1.81)
print(p.bmi()) # 22.89307408198773
这样的话，已经实现了需求，但是现在就需要加上()，bmi是属于身体的一个名词，如：身高、体重等，是人的一个属性，但是呢？想得到bmi指数，就需要去调用bmi函数，那么我们就想要查询属性这样简单的查询bmi
class people:
def __init__(self,name,weight,height):
self.name = name
self.weight = weight
self.height = height
@property
def bmi(self):
print('------->')
return p.weight / (p.height ** 2)
p = people('xiaoyafei',75,1.81)
print(p.bmi)
# 运行结果为
------->
22.89307408198773
只需要使用p.bmi，就触发了这个方法的执行，对于使用者来说，使用者是可以像访问数据属性一样访问函数属性，本质上是触发了bmi方法的执行，把返回值拿了回来，实现了统一访问的原则，看起来是一个名词的东西，就不要去调用方法，给使用者造成了误解，让使用者能够感觉到就像是在访问函数属性一样
注意：
property方法必须要有返回值
property补充
那么我们刚刚说了就像访问属性一样去触发方法的执行，那么我们能不能对bmi赋值
p.bmi = 111
attributeerror: can't set attribute
答案是不能的，因为bmi方法实际上是一个方法，我们只是通过某种手段让他变的像一个属性，它真正还是方法
为什么要用property
将一个类的函数定义成特性后，对象再去调用的时候obj.name，根本无法察觉到自己的name是执行了一个函数然后计算出来的，这种特性的使用方法遵循了统一的访问原则
除此之外，看下
ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制上，在c 里一般会将所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
class people:
def __init__(self,name):
self.__name = name
@property # 添加一个装饰器
def name(self):
print('getter 方法')
return self.__name
@name.setter # setter方法
def name(self,val):
print('name.setter方法')
if not isinstance(val,str):
print('名字必须是字符串类型')
return
self.__name = val
@name.deleter # delter方法
def name(self):
print('name.delter方法')
print('不允许删除')
p = people('xiao')
那么我们现在如果想获取name属性的值，就需要
print(p.name)
# 运行结果
getter 方法
xiao
如果想要修改name的值，就需要
p.name = 'xiaoyafei'
print(p.name)
# 运行结果
name.setter方法 # 先修改了name属性
getter 方法 # 然后获取name属性
xiaoyafei
如果想删除name属性的话
del p.name # del代表删除
# 运行结果
name.delter方法
不允许删除
property可以把计算才能得到的属性封装成一个让用户访问就像访问数据属性一样的，比如访问name，不添加装饰器是p.name()，调用的是一个方法，而添加了装饰器，就是p.name
绑定方法和非绑定方法
在类内部的定义就是变量和函数的定义，在类内部定义的函数分为两大类：绑定方法与非绑定方法
绑定到对象的方法，在类内部定义的函数不经过任何的装饰，那么这个函数就是绑定给对象使用的，它是类的函数属性，但不是给类用的，如果类一定要用，就没有自动传值的说法了。给对象用的话就是把对象作为第一个参数传递进去
绑定方法又分为两种：绑定到对象的方法和绑定到类的方法
绑定方法
绑定到对象的方法：在类里定义的没有被任何装饰器装饰过的
class foo:
def __init__(self,name,age):
self.name = name
self.age = age
def tell_info(self): # 没有被任何装饰器装饰过的方法是绑定到对象的方法，谁来调用就把谁当做第一个参数传递进去
print('name:<%s> age:<%s>'%(self.name,self.age))
f = foo('肖亚飞',22)
f.tell_info()
print(foo.tell_info)
print(f.tell_info)
# 此时的运行结果是：
name:<肖亚飞> age:<22>
如果代表一个函数听不懂，看下面的代码
def func1():
print('aaaaaaaaa')
print(func1)
结果为:
绑定到类的方法：在类内部定义的被classmethod修饰的方法
class people:
def __init__(self,name):
self.name = name
def tell_info(self):
print('名字是%s' % (self.name))
@classmethod
def func(cls):
print(cls)
print(people.func)
people.func()
# 运行结果如下
非绑定方法
非绑定方法就没有自动传值这么一说了，就是在类中定义的一个普通工具，对象和类都可以使用
class people:
def __init__(self,name):
self.name = name
def tell_info(self):
print('名字是%s' % (self.name))
@classmethod
def func(cls):
print(cls)
@staticmethod # 在类里面写函数，没有自动绑定
def func1(x,y):
print(x y)
p = people('肖亚飞')
print(p.func1)
print(people.func1)
p.func1(1,2)
people.func1(1,2)
# 运行结果是：
3
3
那么，讲完了绑定方法非绑定方法的概念，现在来讲讲什么情况应该使用什么方法吧！
class people:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
# 我们现在想查看这个人的信息，根据函数体的逻辑来看看传递什么进去
def tell_info():
print('name:%s age:%s sex:%s' )
在这段代码中，我还没有写完，我现在有一个需求，我要查看这个人的信息，那么应该要把什么传递进去？如果绑定到对象的方法，那么就应该由对象来调用，自动会将本身当做第一个参数传递进去，而绑定到类的方法，需要手动传值。
看一下我们的重点，我们想要的到的是这个人的信息，那么这个人在哪里？当然是实例化后生成的对象，所以应该使用绑定给对象的方法
class people:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
# 我们现在想查看这个人的信息，根据函数体的逻辑来看看传递什么进去
def tell_info(self):
print('name:%s age:%s sex:%s' % (self.name, self.age, self.sex))
p = people('肖亚飞',22,'male')
p.tell_info()
# 运行结果为：
name:肖亚飞 age:22 sex:male
我们首先在settings.py文件配置用户信息
name = '肖亚飞'
age = 18
sex = 'male'
# 代码开始
import settings
class people:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def tell_info(self):
print('name:%s age:%s sex:%s' % (self.name, self.age, self.sex))
#现在我们想从配置文件里读取配置进行实例化，应该怎么做呢
def from_conf():
obj = people(
settings.name,
settings.age,
settings.sex
)
那么我们想一下，我们之前实例化是什么样的？p = people('aaa',18,'male')，但是现在需要去配置文件里面去找，所以，我们就需要这个类去找，因为我们现在已经不是手动传值了
import settings
class people:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def tell_info(self):
print('name:%s age:%s sex:%s' % (self.name, self.age, self.sex))
#现在我们想从配置文件里读取配置进行实例化，应该怎么做呢
@classmethod # 表示会把类作为第一个参数传递进去
def from_conf(cls):
obj = cls( # 因为类名可能会改，所以就需要一个参数，外部能把这个类传进来
settings.name,
settings.age,
settings.sex
)
return obj
# 绑定给类，就应该由类来调用，会把类作为第一个参数传递进去
p = people.from_conf()
p.tell_info()
# 运行结果为
name:肖亚飞 age:18 sex:male
绑定到类，实例化的时候读取配置进行实例化，那么这就是一个功能，就可以写在类里面
import settings
import time
import hashlib
class people:
def __init__(self,name,age,sex):
self.id = self.create_id()
self.name = name
self.age = age
self.sex = sex
def tell_info(self):
print('name:%s age:%s sex:%s' % (self.name, self.age, self.sex))
#现在我们想从配置文件里读取配置进行实例化，应该怎么做呢
@classmethod
def from_conf(cls):
obj = cls( # 因为类名可能会改，所以就需要一个参数，外部能把这个类传进来
settings.name,
settings.age,
settings.sex
)
return obj
def create_id():
m = hashlib.md5(str(time.time()).encode('utf-8'))
p = people.from_conf()
p.tell_info()
我们在类中创建了一个函数create_id，然后在初始化时调用了这个函数，现在问题来了，我需要指定是绑定到类的方法还是绑定到对象的方法吗？当然不是，因为这就是一个时间戳然后转化成md5码，谁与谁调用没有关系
import settings
import time
import hashlib
class people:
def __init__(self,name,age,sex):
self.id = self.create_id()
self.name = name
self.age = age
self.sex = sex
def tell_info(self):
print('name:%s age:%s sex:%s' % (self.name, self.age, self.sex))
#现在我们想从配置文件里读取配置进行实例化，应该怎么做呢
@classmethod
def from_conf(cls):
obj = cls( # 因为类名可能会改，所以就需要一个参数，外部能把这个类传进来
settings.name,
settings.age,
settings.sex
)
return obj
@staticmethod
def create_id():
m = hashlib.md5(str(time.time()).encode('utf-8'))
return m.hexdigest() # 返回值在实例化对象的初始化方法时已经存在了这个对象的名称空间里了
p = people.from_conf()
p.tell_info()
p1 = people('egon',18,'male')
print(p1.id,time.time())
# time.sleep(2)
p2 = people('egon1',98,'male')
print(p2.id,time.time())
此时不管是类还是对象，获取的都是时间戳的md5，所以这就是非绑定方法的作用， 类和对象都可以调用，没有自动传值的说法
# 运行结果为：
name:肖亚飞 age:18 sex:male
a7666f1d3ab41cdf1d91369bec0fabe0 1527674079.019101
16d9ab79bb41990df733c0db5053a1cd 1527674079.019101
转载于:https://www.cnblogs.com/xiaoyafei/p/9112417.html
?我们都知道bag是“袋子、包包”，
但老外说“it isn't really my bag”，
竟然和“包包”一点关系都没有？
那是什么意思
一、bag不一定是“包包”
bag通常用来表示“包包”，
不过它还可以表示：爱好、特长。
常用表达是：(not) sb's bag ，
(not) sth that you are interested in or good at
你感兴趣或擅长的事物
所以，老外说“it isn't really my bag”，
字面意思是：这不是我的包包，
实际可以表示：这不是我擅长的。
比如，当你邀请别人一起去游泳时
对方说“sorry, it isn't really my bag.”
这种情况，bag就不能理解为包包。
【例句】
dancing is really my bag.
跳舞是我的特长。
二、doggy bag
doggy bag不是狗袋，
而是指：打包剩菜的打包袋。
这个表达最早是老外想打包剩菜，
但又碍于面子，就借口打包回家给狗吃。
久而久之，大家都心照不宣，
于是doggy bag也就成了“打包袋” 。
【例句】
could i get a doggy bag, please?
可以麻烦帮我打包吗？
“打包”也可以这样说：
1、 i want to pack the food.
我想要把食物打包。
2、 i want to wrap the food up.
我想打包食物。
3、may i have a box, p
可以给我个盒子打包吗？
三、in the bag
in the bag字面是“在袋子里”，
如：the wallet is in the bag.
钱包在袋里。
此外，in the bag还可以表示：
(一般指比赛、竞选等)
【例句】
you've been learning so hard these days that the final exam must be in the bag for you.
这几天来你一直那么用功，
期末考试对你来说一定十拿九稳。
四、let the cat out of the bag
字面意思是：让猫到袋子外面来，
实际表示：泄露秘密、说漏嘴。
【例句】
i wanted it to be a surprise,but my sister let the cat out of the bag.
我想给大家来个惊奇，可我妹妹却先说漏了嘴。
作者：有只小猪飞走啦 博客地址：
文章目录
前言一，题目二，解析三，代码
前言
本博客是小博主在做java算法题的过程中一些觉得可以分享的题目，希望对你们有帮助，如果哪里写错了或者有更好的解法，都可以私聊我哈！我和你一起探讨！
一，题目
描述 一个袋子里面有n个球，每个球上面都有一个号码(拥有相同号码的球是无区别的)。如果一个袋子是幸运的当且仅当所有球的号码的和大于所有球的号码的积。 例如：如果袋子里面的球的号码是{1, 1, 2, 3}，这个袋子就是幸运的，因为1 1 2 3 > 1 * 1 * 2 * 3 你可以适当从袋子里移除一些球(可以移除0个,但是别移除完)，要使移除后的袋子是幸运的。现在让你编程计算一下你可以获得的多少种不同的幸运的袋子。 输入描述： 第一行输入一个正整数n(n ≤ 1000) 第二行为n个数正整数xi(xi ≤ 1000) 输出描述： 输出可以产生的幸运的袋子数
二，解析
每次从全集中选择若干元素（小球）组成子集（袋子）。对于任意两个正整数a,b如果满足 a b>ab，则必有一个数为1.可用数论证明：设a=1 x,b=1 y，则1 x 1 y>(1 x)(1 y)，—> 1>xy，则x，y必有一个为0，即a,b有一个为1.推广到任意k个正整数，假设a1,a2,…ak，如果不满足给定条件，即和sum小于等于积pi。如果此时再选择一个数b,能使其满足sum b > pib，则，b必然为1，且为必要非充分条件。反之，如果选择的b>1，则sum b <= pib，即a1,a2,…,ak,b不满足给定条件。因此，将球按标号升序排序。每次从小到大选择，当选择到a1,a2,…,ak-1时满足给定条件，而再增加选择ak时不满足条件（ak必然大于等于max(a1,a2,…,ak-1)），继续向后选择更大的数，必然无法满足！此时不必再 继续向后搜索。如果有多个1，即当k=1时，sum(1)>pi(1)不满足，但下一个元素仍为1，则可以满足1 1>11， 所以要判断当前ak是否等于1，如果等于1，虽然不能满足，组合的个数不能增加，但是继续向后搜索，仍然有满足条件的可能.对于重复数字，组合只能算一个，要去重。
三，代码
import java.util.*;
public class main {
public static void main(string[] args){
scanner sc = new scanner(system.in);
int n = sc.nextint();
int[] arr = new int[n];
for(int i = 0 ; i< n ; i ){
arr[i] = sc.nextint();
}
arrays.sort(arr);
system.out.println(count(arr,n,0,0,1));
}
public static int count(int[] arr,int n ,int pos , int sum , int multi){
int count=0;
for(int i = pos ; i
sum = arr[i];
multi *= arr[i];
if(sum>multi){
count = count 1 count(arr , n , i 1 , sum , multi);
}else if(arr[i] == 1){
count = count count(arr, n ,i 1 ,sum , multi);
}else{
break;
}
sum -= arr[i];
multi /=arr[i];
while(i 1
i ;
}
}
return count;
}
}
牛客网运行结果： 这期博客就到此结束了，希望对你有帮助！ 关注小猪，小猪带你一起学习！
还没有评论，来说两句吧...