私有权限
类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问；
类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问；
私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。
私有属性和私有方法 类部调用私有属性和私有方法
class Preson(object):
#初始化方法
def __init__(self,name,age):
#实例属性
self.name = name
#私有属性
self. __age = age
#私有方法
def __primethod(self):
print("我是私有方法")
#在本类里面去调用私有方法
def method(self):
return self.__primethod()
print("我是私有方法")
# 在本类里面去调用私有属性
def sx(self):
return self.__age
p = Preson("jack",25)
print(p.name)
私有属性和私有方法
1). 私有属性，可以在类内部通过self调用，但不能通过对象访问
2). 私有方法，可以在类内部通过self调用，但不能通过对象访问
3). 对象不能访问私有权限的属性和方法
4). 子类不能继承父类私有权限的属性和方法
5). Python中没有像C++中 public 和 private, protected 这些关键字来区别公有属性和私有属性。
6). Python是以属性命名方式来区分，如果在属性和方法名前面加了2个下划线'__'，则表明该属性和方法是私有权限，否则为公有权限。
修改私有属性的值
对象名.属性名 = 数据 ----> 直接修改
对象名.方法名() ----> 间接修改
class Preson(object):
#初始化方法
def __init__(self,name,age):
#实例属性
self.name = name
#私有属性
self. __age = age
#私有方法
# def __primethod(self):
# print("我是私有方法")
# #在本类里面去调用私有方法
# def method(self):
# return self.__primethod()
# print("我是私有方法")
# # 在本类里面去调用私有属性
# def sx(self):
# return self.__age
#修改私有属性的值
def set_age(self,age):
self.__age = age
#获取私有属性的值
def get_age(self):
return self.__age
p = Preson("jack",25)
print(p.name)
#调用私有属性的值，修改
p.set_age(15)
#打印
print(p.get_age())
实例属性(对象属性)
可以通过实例化对象调用，类不能调用
#实例化对象调用，类不能调用
class People(object):
address = '山东' # 类属性
def __init__(self):
self.name = 'xiaowang' # 实例属性
self.age = 20 # 实例属性
p = People()
p.age = 12 # 实例属性
print(p.address) # 正确
print(p.name) # 正确
print(p.age) # 正确
print(People.address) # 正确
print(People.name) # 错误
print(People.age) # 错误
通过实例(对象)去修改类属性
#通过实例(对象)去修改类属性
class People(object):
country = 'china' #类属性
print(People.country)
p = People()
print(p.country)
p.country = 'japan'
print(p.country) # 实例属性会屏蔽掉同名的类属性
print(People.country)
del p.country # 删除实例属性
print(p.country)
静态方法和类方法和实例方法
初始化方法只能用实例化对象去调用类方法和静态方法能用实例化对象去调用也能使用类名调用类方法使用@classmethod装饰，第一个参数为类（cls），调用时可以通过类的实例或者类本身来调用。
实例方法定义时第一个参数为类的一个实例（self），调用时必须通过实例调用。
静态方法使用@staticmethod装饰，调用时可以使用类的实例或者类本身来调用。
class Pople(object):
def __init__(self):
print("我是实例方法")
@classmethod
def ge_country(cls):
print("我是类方法")
@staticmethod
def ge_country1():
print("我是静态方法")
#创建实例化对象
p = Pople()
#初始化方法只能用实例化对象去调用
p.__init__()
#类方法和静态方法能用实例化对象去调用也能使用类名调用
p.ge_country()
Pople.ge_country()
p.ge_country1()
Pople.ge_country1()
__new__方法
class A(object):
def __init__(self):
print("*" *10)
print(self)
print(" __init__方法")
def __new__(cls, *args, **kwargs):
print(id(cls))
print("__new__方法")
ret = object.__new__(cls)
return ret
a = A ()
单例模式
class Foo(object):
instance = None
def __init__(self):
self.name = 'alex'
def __new__(cls):
#进行判断如果为真的话就返回这个类
if Foo.instance:
return Foo.instance
#否则的话就new
else:
Foo.instance = object.__new__(cls)
return Foo.instance
obj1 = Foo()#获取的new 方法的返回的值
obj2 = Foo()
print(obj1,obj2)
#定义一个教师类Teacher父类
class Teacher(object):
def __init__(self,money,age):
self.__money = money
self.age = age
def __money(self):
print("私有挣钱的方法")
def student(self):
print("好好学习，天天向上")
# 调用老师类中的私有方法
def _money1(self):
return self._money()
print("私有挣钱的方法")
# 调用老师类中的私有属性
def _sx(self):
return self.__money
print("私有属性")
#定义一个学生类student子类 子类继承父类
class Student(Teacher):
pass
#重写父类student方法
def student(self):
print("好好学习，天天向上")
stu = Student(10000,45)
print(stu.age)
stu.student()
stu._sx()
class Teacher (object):
def __init__(self,money,age):
self.__money = money
self.age = age
#修改私有属性
def set_money(self,money):
self.__money = money
def ge_money(self):
return self.__money
class Student (Teacher):
pass
b = Student(100000,45)
#实例化对象调用set修改方法修改
b.set_money(200000)
#进行输出
print(b.ge_money())
私有属性和私有方法 类部调用私有属性和私有方法
class Teacher (object):
def __init__(self,name,age):
self.name = name #实例属性
self.__age = age #私有属性
def __money(self): #私有方法
print("我是私有方法")
def dymoney(self): # 调用私有方法
return self.__money()
def dyage(self): #调用私有属性
return self.__age
def set_age(self,age): #修改私有属性的值
self.__age = age
def get_age(self): #获取私有属性的值
return self.__age
class Student(Teacher):
pass
stu = Student("jack",20)
print(stu.name)
#调用私有方法
stu.dymoney()
#调用私有属性
print(stu.dyage())
#调用私有属性
stu.set_age(222222)
print(stu.get_age())
