python初级笔记5 面向对象

最新推荐文章于 2024-10-14 17:16:49 发布

...:...:...

最新推荐文章于 2024-10-14 17:16:49 发布

阅读量703

点赞数 25

文章标签：笔记

本文链接：https://blog.csdn.net/cycyzh/article/details/137736050

版权

创造类的方式

class 类名（object）：

属性

方法

类名用大驼峰命名法

函数在类中叫做方法

类名后面的括号用来继承

class Student(object):
    name = None
    age = None
    id = None
  
print(Student)

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\1.py
<class '__main__.Student'>

实例化对象

对象名=类名（）

class Student(object):
    name = None
    age = None
    id = None

if __name__ == '__main__':
    stu1=Student()
    print(stu1)

默认打印的是内存地址

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\1.py
<__main__.Student object at 0x0000019F6C192060>

访问实例化对象方法与属性

对象名.方法

对象名.属性

class Student(object):
    name = None
    age = None
    Zhuanye = None
    id = None
 
if __name__ == '__main__':
    stu1 = Student()
    stu1.id = 2001
    stu1.name = "vn"
    print(stu1.name)
    print(stu1.id)

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\1.py
vn
2001

self

self会默认指向调用这个方法的的对象本身，可以修改名称，单值一定，且不参与传参
打印self指向一块内存地址，是stu1的内存地址

class Student(object):
    name = None
    age = None
    Zhuanye = None
    id = None
    def hobby(self):
        print(self)
if __name__ == '__main__':
    stu1 = Student()
    stu1.hobby()

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\1.py
<__main__.Student object at 0x0000019F15D72180>

class Student(object):
    name = None
    age = None
    Zhuanye = None
    id = None
    def hobby(self):
        print(self.name)

if __name__ == '__main__':
    stu1 = Student()
    stu1.name = "vn"
    stu1.hobby()

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\1.py
vn

初始化对象

定义类经常会用到__init__函数（方法），首先需要理解的是，两个下划线开头的函数是声明该属性为私有，不能在类的外部被使用或访问。而__init__函数（方法）支持带参数类的初始化，也可为声明该类的属性（类中的变量）。__init__函数（方法）的第一个参数必须为self，后续参数为自己定义。

def __init__(self,参数):

参数赋值

当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

__str__方法需要返回一个字符串，当做这个对象的描写

class Person(object):
    def __init__(self,name,age,zhuanye,id):
        self.name=name
        self.age=age
        self.id=id
        self.zhuanye=zhuanye
    def eat(self):
        print("吃饭了")
    def __str__(self):
        return f"人的名字是{self.name}"

obj1 = Person("zhangsan",55,"liuliu",45678)
print(obj1.name)

在pycharm中对象初始化会自动出现提示标语；

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\2.py
zhangsan

练习

class HouseItem(object):
    def __init__(self,itemname,area):
        self.name=itemname
        self.area=area
    def __str__(self):
        return f"{self.name}的占地面积是{self.area}"
if __name__== '__main__':
    bed=HouseItem("席梦思",4)
    chest = HouseItem("衣柜",2.5)
    table = HouseItem("餐桌", 2)
print(bed)
print(chest)
print(table)

打印对象默认返回内存地址，但是因为用来魔术方法：def __str__(self):，所以可以返回想要的

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\房子.py
席梦思的占地面积是4
衣柜的占地面积是2.5
餐桌的占地面积是2

class HouseItem(object):
    def __init__(self,itemname,area):
        self.name=itemname
        self.area=area
    def __str__(self):
        return f"{self.name}的占地面积是{self.area}"

class House(object):
    def __init__(self, House_type,area):
        self.type = House_type
        self.area = area
        self.free_area = area
        self.item_list = []
    def add_item(self,item):
        # print(f"添加的家具是={item}")
        if self.area < item.area:
            print("剩余空间不够，放不下")
        else:
            self.item_list.append(item.name)
            self.free_area-=item.area
    def __str__(self):
        return f"房子的户型是{self.type}，赋值的总面积是{self.area},房子剩余面积为{self.free_area},占地面积是{self.area-self.free_area},家具列有{self.item_list}"

if __name__== '__main__':
    house=House("三室一厅",21)
    bed = HouseItem("席梦思", 4)
    chest = HouseItem("衣柜", 2.5)
    table = HouseItem("餐桌", 2)
    house.add_item(bed)
    print(house)

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\房子.py
房子的户型是三室一厅，赋值的总面积是21,房子剩余面积为17,占地面积是4,家具列有['席梦思']

面对对象的特征：封装、继承、多态

封装：

a、把类的成员全部封装在类中
b、不希望被随意访问，因此在大多数情况下，往往要对对象的属性私有化，提供公开的方法进行访问

私有的成员在类内部才能用方法访问到
私有方法就在类内部调用

python成员私有声明：__属性/方法

访问私有成员：对象名._类名__成员

class Login(object):
    def __init__(self,u,p):
        self.name=u
        self.__passwd=p
    def get_passwd(self):
        return self.__passwd
    def set_passwd(self,pp):
        self.__passwd=pp
        return f"新的密码更改为{self.__passwd}"

if __name__ == '__main__':
    obj1 = Login("rtyu",56789)
    print(obj1._Login__passwd)
    print(obj1.set_passwd("张三王麻子"))

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\封装2.py

56789
新的密码更改为张三王麻子

_方法名,_变量（不能被其他模块所引用），主要针对from 模块 import *

封装：全局方法：

#通过我们的全局方法
class Login(object):
    def __init__(self,u,p):
        self.name=u
        self.__passwd=p
    def get_passwd(self):
        return self.__passwd
    def set_passwd(self,pp):
        self.__passwd=pp
        return f"新的密码更改为{self.__passwd}"
    pp=property(get_passwd,set_passwd)
 
if __name__ == '__main__':
    obj1 = Login("rtyu",56789)
    print(obj1.pp)#相当于调用了get_passwd
    obj1.pp = "心得"#相当于调用了set_passwd
    print(obj1.pp)

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\封装2.py
56789
心得

第三种封装方法

#通过我们的全局方法
class Login(object):
    def __init__(self,u,p):
        self.name=u
        self.__passwd=p
    def get_passwd(self):
        return self.__passwd
    def set_passwd(self,pp):
        self.__passwd=pp
        return f"新的密码更改为{self.__passwd}"

    @property
    def passwd(self):
        return self.__passwd
    @passwd.setter
    def passwd(self,pp):
        self.__passwd=pp
if __name__ == '__main__':
    obj1 = Login("rtyu",56789)
    print(obj1.passwd)
    obj1.passwd="我是一个新人"
    print(obj1.passwd)

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\封装2.py
56789
我是一个新人

函数覆盖

函数重载：存在多个函数名相同的函数，但是参数个数或者参数类型不同，
会使在调用的时候，自动调用对应的参数

python里面没有函数重载，python是弱数据类型的语言。
python有函数覆盖，相同函数会得到同名的、离调用最近的函数覆盖

继承

继承：
父类：被继承的一方超类基类
子类：继承的那一方

无法继承父亲的私有成员

没有成员的子类

class Dad(object):
    def __init__(self,name,age,money):
        self.name = name
        self.age = age
        self.money = money
    def eat(self):
        print("我是父亲爱吃的")
    def zhuanqian(self):
        print("爸爸的赚钱")


class Son(Dad):
    pass
   

f = Dad("zhangxi",56,"1万")

s = Son("二狗",11,100020)
print(s.age)
s.eat()
print(s.money)
print(s.name)
s.zhuanqian()

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\函数重载.py
11
我是父亲爱吃的
100020
二狗
爸爸的赚钱

有自己成员的子类

super这个方法这个指针指向自己的父类
自己没有的才会去继承父亲的

class Dad(object):
    def __init__(self,name,age,money):
        self.name = name
        self.age = age
        self.money = money
    def eat(self):
        print("我是父亲爱吃的")
    def zhuanqian(self):
        print("爸爸的赚钱")

class Son(Dad):
    def __init__(self,hobby,age,name):
        super().__init__("zhangsan",34,"100000")
        self.age = age
        self.name=name
        self.hobby = hobby
    def zhuanqian(self):
        print("我的赚钱")


f = Dad("zhangxi",56,"1万")

s = Son("sing",11,"里斯")
print(s.age)
print(s.money)
print(s.hobby)
print(s.name)
s.zhuanqian()
s.eat()

结果：

E:\Python\python.exe E:\学习笔记\Python\4.21\函数重载.py
11
100000
sing
里斯
我的赚钱
我是父亲爱吃的

方法重写

要是非要想要调用父亲的方法，可以利用super

比如:

def zhuanqian(self):

super().zhuanqian(）

多继承

支持继承多个类

class Dad(object):
    def __init__(self,name,age,money):
        self.name = name
        self.age = age
        self.money = money
    def eat(self):
        print("我是父亲爱吃的")
    def zhuanqian(self):
        print("爸爸的赚钱")


class Mon(object):
    def mon(self):
        print("mamama")

class Son(Dad,Mon):
    def __init__(self,hobby,age,name):
        super().__init__("zhangsan",34,"100000")
        self.age = age
        self.name=name
        self.hobby = hobby
    def zhuanqian(self):
        print("我的赚钱")


f = Dad("zhangxi",56,"1万")

s = Son("sing",11,"里斯")
print(s.age)
print(s.money)
print(s.name)
s.zhuanqian()
s.eat()
s.mon()