python面对对象小汇总

类的起名规则

# 所有的类名要求首字母大写,多个单词使用驼峰式命名法 如 ValueError

# 类中方法: 普通方法 类方法 静态方法 魔术方法

class Phone:

# 类属性

brand = "vivo"

price = 2999

type = "Z5 pro"

# 魔术方法 系统默认执行

def __init__(self, owner="徐坤坤"): # init 初始化 ,owner可以外界传参

print("--------init")

self.owner = owner

# 类里面的方法

def call(self):

print("self.......", self)

print(self.note) # 不能保证每个self都有note

print(f"{self.owner} 拿着 {self.brand} 手机 ,跑步,价值 {self.price}")

print("正在法典化")

zzk = Phone("立农")

print(zzk.brand)

print(zzk)

zzk.note = "我是zk的通讯录"

zzk.call()

class Cat:

type = "猫"

def __init__(self, nickname, age, color):

self.nickname = nickname

self.age = age

self.color = color

def eat(self, food):

print(f"{self.nickname} like {food}")

def catch_mouse(self, color, weight):

print(f"{self.nickname} 抓了 {color}色 重{weight}kg 的 杰瑞")

def sleep(self, hour):

if hour < 5:

print("sleep! baby")

else:

print('get up!baby,let"s catch mice')

def show(self):

print("my baby detailed information---->")

print(self.color, self.nickname, self.age)

# 类方法

class Dog:

# 类属性

aa = "阿发"

__age = 18 # 私有化,外界不能直接访问

def __init__(self, name="欢欢"):

self.name = name

def run(self):

print(f"{self.name} run to me")

def eat(self):

print("eat bone")

self.run() # 类中方法的调用,需要通过self

# 以下是类方法 不需要依赖对象

@classmethod

def test(cls):

print(cls) # 指的是 的类

# print(cls.name) 不能用

cls.__age = 20 # 修改类属性

print(f"我是{cls.aa} {cls.__age}") # 类方法不能使用

# 静态方法

@staticmethod # 不能使用self.方法

def test1():

print("-------->静态方法")

print(Dog.__age) # 不能使用类中对象属性

# 静态方法:很类似类方法

# 1.需要加@staticmethod

# 2.无需传递参数

# 3.也只能访问类属性和方法,对象的不行

# 4.加载时机同类方法

类方法 静态方法

不同:

1.装饰器不同

2.类方法是有参数的,静态方法没有参数

相同:

1.只访问类的属性和方法,对象是无法访问的

2.都可以通过类名调用访问

3.都可以在创建对象之前使用,因为是不依赖于对象

class Person:

def __init__(self, name):

print("------->init", self)

self.name = name

def __str__(self):

return "姓名是"

def __new__(cls, *args, **kwargs):

print("------->new")

postion = object.__new__(cls) #

print(postion)

return postion # 地址返给对象self

def __call__(self, name):

print("---------->call")

print("我执行的对象参数是:", name)

def __del__(self): # 程序结束前的最后一步会执行这个

print("结束啦")

# del p # NameError: name 'p' is not defined 删除了,再引用就会报错

p = Person("jack")

print("sdfg", p)

# 查看引用的次数

import sys

t = sys.getrefcount(p) # 自身引用也算一次

print(t)

# 私有化 __属性"

# """

# 好处:

# 1.隐藏属性,不被外界修改

# 2.修改同过函数修改 set属性名,并添加限制条件

# """

# 封装: 1.私有化属性 2.定义公有set和get方法

# 开发中私有化

import random

class Student:

def __init__(self, name, age):

self.name = name

self.__age = age

self.__score = 95

# 老版本

# 定义公有set和get

# set 为了赋值

def setAge(self, age):

if age > 0 and age <= 100:

self.__age = age

else:

print("年龄不在范围内")

# get 用于取值

def getAge(self):

return self.__age

# 新版本

@property

def score(self):

return self.__score

@score.setter

def score(self, score):

if score > 100:

print("wrong")

else:

self.__score = score

def __str__(self):

return f"姓名:{self.name},age:{self.__age},score:{self.__score}"

zzk = Student("zzk", 16)

zzk.setAge(18)

print(zzk.getAge())

print(zzk)

zzk.score = 99 # 设置了条件

print(zzk.score) # 新版本中,私有化变量可以直接访问

print(zzk.__dir__())

print(zzk._Student__score) # 这种访问方法不推荐

print("---------------------------------------------------")

# 公路 和 车

class Road:

def __init__(self, name, length):

self.name = name

self.length = length

class Car:

def __init__(self, name, speed):

self.name = name

self.speed = speed

def get_time(self, road):

ran_time = random.randint(1, 10)

msg = f"{self.name} 的车 速度:{self.speed} run:{ran_time} on {road}"

print(msg)

def __str__(self):

return self.name+str(self.speed)

# 创建实例对象

r = Road("小路", 12000)

benchi = Car("奇瑞", 120)

benchi.get_time(r.name)

print(benchi)

继承

# 知识点:

# 1.has a 一个类中使用了另外一种自定义的类型

# 2.类型:系统 int float

# 自定义 自定义类 student

#

# 3.is a

# 继承,减少代码冗余

# 父类提供的方法不能满足子类的需求,就需要在子类中定义一个同名的方法,这种行为:重写

# <>

class Person:

def __init__(self, name, love):

self.name = name

self.love = love

def run(self):

print("i can run")

class Student(Person):

def __init__(self, name, love, teacher):

self.teacher = teacher

print("i am student init", self.teacher)

# 如何调用父类的__init__

super(Student, self).__init__(name, love) # super 相当于父类的对象

# 这边相当于一个判断

def run(self):

print("我跑啦,哈哈哈")

zzk = Student("zzk", "烤鸭", "hld")

zzk.run()

print(zzk.love)

class Person:

def __init__(self, no, name, salary):

self.no = no

self.name = name

self.salary = salary

def __str__(self):

msg = f"工号:{self.no} \n 姓名: {self.name} \n 工资:{self.salary}"

return msg

def getSalary(self):

return self.salary

class Worker(Person):

def __init__(self, no, name, salary, hours, per_hour):

super().__init__(no, name, salary)

self.hours = hours

self.per_hour = per_hour

def getSalary(self):

money = self.hours * self.per_hour

self.salary += money

return self.salary

class Saleman(Person):

def __init__(self, no, name, salary, salemoney, percent):

super().__init__(no, name, salary)

self.salemoney = salemoney

self.percent = percent

def getSalary(self):

money = self.salemoney * self.percent

self.salary += money

return self.salary

# 创建对象

w = Worker("001", "康", 2000, 150, 60)

x = w.getSalary()

print("月薪:", x)

print("-----------------------------")

saler = Saleman("002", "lucy", 5000, 5000000, 0.003)

s = saler.getSalary()

print("月薪:", s)

print(s)

# 多继承

class A:

def test(self):

print("-----------AAAAAA")

class B:

def test1(self):

print("----------BBBBB")

class C(A, B):

def test2(self):

print("-----CCCC")

c = C()

c.test()

c.test1()

c.test2()

"""

python 允许多继承

def 子类(父类1,父类2)

多继承搜索顺序

广度优先

python2 是 从左到右,深度优先

"""

print(C.__mro__) # 显示搜索顺序

# isinstance(obj,类) 判断obj 是不是类的对象或者判断obj是不是该子类的对象