一、类
方法：
1、普通方法:
定义格式:
def 方法名(self,参数1，参数2):
pass
调用：
都要依赖对象调用方法
对象名.方法名(参数)
注意： 在调用过程中会默认传递self对象，self表示的是对象本身
方法中访问对象属性：
self.属性名
self.属性名= 值 ----》 改变对象属性的值
方法中访问普通方法：
self.方法名(参数)
class Bank_money: def __init__(self, card): self.card = card self.money = 0 def cun_kuan(self, money): self.money += money print('{}存款成功，余额为：{}'.format(self.card, self.money)) self.show() def qu_kuan(self, money): if money<self.money: self.money -= money print('{}取款成功，余额为：{}'.format(self.card, self.money)) self.show() else: print('余额不足！！！') def show(self): print('卡号：{} 余额：{}'.format(self.card,self.money)) a = Bank_money('001') a.cun_kuan(20000) card2 = Bank_money('002') card2.cun_kuan(20000) card2.qu_kuan(10000)
2、类方法
类方法：
定义格式：
@classmethod
def 类方法名(cls,参数):
pass
静态方法
定义格式：
@staticmethod
def 方法名(self):
pass
使用：
类名.方法名（）
class Utils: # 类属性 version = '1.0' # 对象属性 def __init__(self): self.id = '001' # 类方法 @classmethod def conn_db(cls): # cls就是类对象本身 print('加载数据库的驱动程序，当前版本号是',cls.version) print('数据库建立连接成功！！') # cls.select_add() @staticmethod def select_add(): # 参数：不依赖对象self，也不依赖类cls print('查询数据库的数据，当前版本号为:',Utils.version) Utils.conn_db() def add(self): print('添加成功！！！') # Utils.conn_db() # 类方法能否被对象调用？ 能访问 # u = Utils() # u.conn_db() # 对象调用conn_db(cls) ----cls 任然是类对象本身 # 类方法中能否访问对象属性？ # 不能 # 静态方法的调用： Utils.select_add() # 静态方法能否被对象方法？ 能访问 # u = Utils() # u.select_add() # 类方法能否调用静态方法？ 静态方法能否调用类方法？ print('-------------------------') Utils.conn_db() # 类方法，静态方法中能调用普通方法？ 不能
3、魔术方法
魔术方法就是一种类的特殊方法，普通方法需要调用，魔术方法由系统自己调用。
class Person(object): def __init__(self): print('------->init') def __new__(cls, *args, **kwargs): print('------->new') return object.__new__(cls)
def __del__(self):
print('------del')
p = Person() print(p)
__str__ 魔术方法
__repr__
作用：都是讲对象转成字符串的表示形式
repr(obj):----- __repr__
class Person(object): def __init__(self,name,age): self.name = name self.age = age def __str__(self): return self.name+'\t'+str(self.age) def __repr__(self): return 'helloworld' def __call__(self, *args, **kwargs): print('我被调用') def __len__(self): return 6 p = Person('gang',20) print(p) p() p1 = Person('lisi',60) print(p1) r = repr(p1) # 调用的时候自动触发 print(r) print(len(p1)) list1 = [1,4,5,6,7,7,9] print(len(list1))
运算相关的魔术方法：
__gt__ >
__lt__ <
__eq__ ==
__le__ <=
__ge__ >=
class Cat: def __init__(self, nickname, age): self.nickname = nickname self.age = age # def __gt__(self, other): # return self.age>other.age # def __lt__(self, other): # return self.age<other.age def __eq__(self, other): return self.age == other.age def __add__(self, other): return self.age+other.age def __int__(self): return self.age c1 = Cat('小虎', 2) c2 = Cat('犊子', 3) c3 = Cat('犊子2', 3) # print(c1 > c2) # print(c1 < c2) print(c1 == c2) result = c1 +c2 +int(c3) print(result)
跟属性相关的魔术方法：
__getattr__
__setattr__
class Person: def __init__(self,name): self.name = name def __getattr__(self, item): if item =='age': return 20 elif item =='gender': return 'men' else: return '不存在此属性{}'.format(item) # def __setattr__(self, key, value): # print(key,value) # 不能进行赋值的操作，会出现递归的错误 p = Person('gang') print(p.name) print(p.age) print(p.gender) p.name = '飞蛾扑火' print(p.name)
4、私有化:只能类自身中进行调用，对象外部无法访问
实现属性或者私有化要通过：__属性名()__,__方法名__()
python中的私有化，底层对私有属性进行了改名操作：_类名__属性名
class Person: def __init__(self,name): self.name = name self.__age = 20 def show_age(self): print('年龄：',self.__age) def __test(self): print('测试私有的test方法') p = Person('jack') print(p.name) # print(p.__age) p.show_age() p._Person__test()
5、封装
扫描二维码关注公众号，回复：
6965739 查看本文章
1、属性和方法----封装到类中
2、属性封装：将属性私有化，并定义共有的set和get方法
私有化作用：
1、隐藏属性，只能在类中使用
2、对私有属性的取值和赋值起到一定的限制作用
3、通过set方法限制赋值，通过get限制取值
class Person: # 限制作用 __slots__ = ['__name', '__age', '__flag'] def __init__(self, name, age): self.__name = name self.__age = age self.__flag = True def get_name(self): if self.__flag: return self.__name else: return '没有权限查看用户名' def get_age(self): return self.__age def set_name(self, name): if len(name) >= 6: self.__name = name else: print('名字必须要大于等于6位') def set_age(self, age): if 125 > age > 0: self.__age = age else: print('没有这种人存在') p = Person('lucy', 20) print(p.get_name()) p.set_name('steven') print(p.get_name()) p.set_name('tom') print(p.get_name()) p.set_age(120) print(p.get_age())
6、@property 装饰器是用来装饰类中方法的
步骤：
1、在get方法上面添加@property装饰器，函数名字最好更加简要，让使用者或访问的时候更加好用
2、装饰set方法：
@属性名.setter
def 属性名(self,参数)：
pass
3、使用
对象 = 类名（参数）
print(对象.属性名) -----get方法
对象.属性名 = 值 ------set方法
class Person: __slots__ = ['__name', '__age', '__flag', '__password'] def __init__(self, name, age): self.__name = name self.__password = '123' self.__age = age self.__flag = False @property def name(self): if self.__flag: return self.__name else: return '没有权限查看用户名' @name.setter def name(self, name): if len(name) >= 6: self.__name = name else: print('名字必须要大于等于6位') def get_age(self): return self.__age def set_age(self, age): if 125 > age > 0: self.__age = age else: print('没有这种人存在') def login(self, name, password): if self.__name == name and self.__password == password: print('登录成功') self.__flag = True else: print('登陆失败') p = Person('jack', 20) p.login('jack','123') print(p.name) p.name = 'jerryganng' print(p.name)
二、继承：
为什么要用继承：使代码更加简练，提高代码的可读性
实现继承：
class 子类名(父类)
pass
子类继承了父类的非私有的属性和方法
公有的属性和方法是可以直接在子类中访问的，但是私有的是无法访问的
# 父类 基类 超类 class Person: def __init__(self, name, age): self.name = name self.age = age self.__money = 10000 def eat(self): print('去食堂吃饭！！') def sleep(self): print('想睡觉了！！') # 子类 class Student(Person): def __init__(self): print('-------student init') class Teacher(Person): def show(self): print(self.name) print(self.__money) # self._Person__money class Admin(Person): pass s = Student() print(s) t = Teacher('zhangsan',45) print(t) t.eat() t.sleep() print(t.name) print(t.age) # print(t._Person__money) t.show()