Python日记Day_8 类

最新推荐文章于 2024-08-10 10:46:00 发布

三木今天学习了嘛

最新推荐文章于 2024-08-10 10:46:00 发布

阅读量245

点赞数

分类专栏： Python基础语法文章标签： python

本文链接：https://blog.csdn.net/weixin_45751396/article/details/106664653

版权

Python基础语法专栏收录该内容

22 篇文章 0 订阅

订阅专栏

《Python编程从入门到实践》日记Day_8

第八章类

类相当于把函数给封装起来，是一组函数。

1.类的好处主要有
方便复用（如果你用函数写，就要复制整块代码，增加了代码量，增加了出错率）
方便扩展（函数写段代码，若要升级、扩展，都十分复杂，容易出错，用类来扩展，则方便清晰）
方便维护（因为类是把抽象的东西映射成我们常见的，摸得到的东西，容易理解，维护也方便）

①创建和使用类

创建

class Dog():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print(f"My dog's name is {name}, he is {age} years old.", )
    def sit(self):
        print(self.name.title() + " is now sitting.")
    def roll_over(self):
        print(self.name.title() + " rolled over.")
my_dog = Dog("duoduo", 3)
####
Process finished with exit code 0

Python中规定首字母大写的名称指的是类。
方法__init__，Python调用Dog类的时候呢，会自动的引入实参self。每个与类相关联的方法调用时对会传递实参self，他是一个指向实例本身的引用，让实参能够访问类中的属性和方法。

访问、使用

class Dog(): 
	--snip--
my_dog = Dog("duoduo", 3)
a = my_dog.name
print(a)
my_dog.sit()
my_dog.roll_over()
###
My dog's name is duoduo, he is 3 years old.
duoduo
Duoduo is now sitting.
Duoduo rolled over.

可以看到 __init__中的形参self 实际上是帮助了类里面的函数来调用传递过来的实参。这一点和函数一模一样。

class Dog():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def sit(self):
        print(self.name.title() + " is now sitting.")
    def roll_over(self):
        print(self.name.title() + " rolled over.")

my_dog = Dog("duoduo", 3)
your_dog = Dog("niuniu",2)
print("My dog's name is" + my_dog.name + ", he is "+ str(my_dog.age) +" years old.",)
print("Your dog's name is" + your_dog.name + ", he is "+ str(your_dog.age) +" years old." )
#####
My dog's name isduoduo, he is 3 years old.
Your dog's name isniuniu, he is 2 years old.

②.使用类和实例

给属性指定默认值。在 __init__中完成

class Car():
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def describe(self):
        L_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return L_name
    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")
my_new_car = Car("Audi", "A4", "2019")
print(my_new_car.describe())
my_new_car.read_odometer()
####
2019 Audi A4
This car has 0 miles  on it.

修改属性的值
1.直接修改
顾名思义，修改参数值

class Car():
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def describe(self):
        L_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return L_name
    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")
        
my_new_car = Car("Audi", "A4", "2019")
print(my_new_car.describe())
my_new_car.odometer_reading = 10000
my_new_car.read_odometer()
####
2019 Audi A4
This car has 10000 on it.

2.通过方法修改属性值

在类中定义函数来修改值。

class Car():
    --snip--
    update_odometer(self, mile):
        if mile >= 0:
            self.odometer_reading = mile
        else:
            print("ERROR!")


my_new_car = Car("Audi", "A4", "2019")
print(my_new_car.describe())
my_new_car.update_odometer(151613)
my_new_car.update_odometer(-4151)
my_new_car.read_odometer()
####
2019 Audi A4
ERROR!
This car has 151613 miles on it.

3.通过方法对属性的值进行递增

在类中定义函数来修改值。

class Car():
	--snip--
	def increment_odometer(self, mile):
       		self.odometer_reading += mile

my_new_car = Car("Audi", "A4", "2019")
print(my_new_car.describe())
my_new_car.update_odometer(0)
my_new_car.read_odometer()
my_new_car.increment_odometer(12101)
my_new_car.read_odometer()
####
2019 Audi A4
This car has 0 miles on it.
This car has 12101 miles on it.

③继承

什么时候使用继承：假如我需要定义几个类，而类与类之间有一些公共的属性和方法，这时我就可以把相同的属性和方法作为基类的成员，而特殊的方法及属性则在本类中定义。这样子类只需要继承基类（父类），子类就可以访问到基类（父类）的属性和方法了，它提高了代码的可扩展性和重用行。如：猫，狗都属于动物，它们行为相似性高，都会叫，会吃，会喝，会拉，会撒娇。

子类继承了其弗雷所有的属性和方法，同时还可以定义自己的属性和方法。

class Car():	
	--snip--
	
class ELectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)

my_tesla = ELectricCar('tesla', 'model s', 2020)
print(my_tesla.describe())
#####
2020 tesla model s

并且我们可以给子类添加特有的属性和方法

class Car():
	--sinp--

class ELectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        self.battery = 70
    def describe_battery(self):
        print(f"This car has a {self.battery} -KWH battary.")

my_tesla = ELectricCar('tesla', 'model s', 2020)
print(my_tesla.describe())
my_tesla.describe_battery()
####
2020 tesla model s
This car has a 70 -KWH battary.

也可以重写父类的方法。

可在子类中定义这样一个方法，即它与要重写的父类方法同名，这样Python将不会考虑这个父类方法，而只关注你在子类中定义的相应的方法
对于父类的方法，只要它不符合子类模拟的事物的行为，都可进行重写。

def fill_gas_tank(self):
    print(f"There is no gas tank in tesla.")

将实例用作属性

class Car():
	--snip--

class Battery():
    def __init__(self,battery_size = 70):
        self.battery_size = battery_size
    def descirbe_battary(self):
        print(f"This car has a {self.battery_size} -KWH battary.")

class ELectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        self.battery = Battery()

my_tesla = ELectricCar('tesla', 'model s', 2020)
print(my_tesla.describe())
my_tesla.battery.descirbe_battary()
#####
2020 tesla model s
This car has a 70 -KWH battary.

添加新的属性

class Car():
   --snip--

class Battery():
    def __init__(self,battery_size = 70):
        self.battery_size = battery_size
    def descirbe_battary(self):
        print(f"This car has a {self.battery_size} -KWH battary.")
    def get_range(self):
        if self.battery_size == 70:
            print(f"This car can run almost 270KM.")
        elif self.battery_size == 85:
            print(f"This car can run almost 330KM.")

class ELectricCar(Car):
    --snip

my_tesla = ELectricCar('tesla', 'model s', 2020)
print(my_tesla.describe())
my_tesla.battery.descirbe_battary()
my_tesla.battery.get_range()
#####
2020 tesla model s
This car has a 70 -KWH battary.
This car can run almost 270KM.

④导入类
import sys
sys.path.append(“E:\A-桌面-Flies\Pycharm”)
from car_electriccar import Car, Battery, ELectricCar
从文件名导入类

可以根据类所在文件名的不同定义不同的路径，都可以的。
后续的Python标准库，则引入了Python编好的类，以及类的编码风格，在书上看看就行了。我就不打字啦。(●ˇ∀ˇ●)

下面是我的运行实例。导入类不成功的话，可以看一下下哈哈O(∩_∩)O
在这里插入图片描述

2021-09-17

参加华为官方手册：让Python给你一个对象实验指导手册

1. 类的创建与使用

1.1 类的定义

创建 Employee类，根据 Employee类创建的每个实例都将存储名字和薪水。：

class Employee(object):
    "所有员工的基类"
    emCount = 0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.emCount += 1

    def dispalyEmployee(self):
        print(f'Name:{self.name}, Salary:{self.salary}')

    def lingqu(self):
        print(f'{self.name}领取了本月的工资{self.salary}')


emp1 = Employee("sanmu", 30000)
emp2 = Employee("su", 34000)
emp1.dispalyEmployee()
print(f'Total Employee {Employee.emCount}')
emp1.salary = 31000
emp1.lingqu()

Name:sanmu, Salary:30000
Total Employee 2
sanmu领取了本月的工资31000

1.2 继承

class Parent(object):
    parentAttr = 100
    def __init__(self):
        print("调用父类构造函数")
    def parentMethod(self):
        print("调用父类方法")
    def setAttr(self, attr):
        Parent.parentAttr = attr
    def getAttr(self):
        print("父类属性：", Parent.parentAttr)

class Child(Parent):
    def __init__(self):
        print("调用子类构造函数")
    def childMethod(self):
        print("调用子类方法")

c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值

多继承：

创建父类 Dog，具备属性年龄和姓名；会吃饭和叫。
创建父类 Wolf，具备属性姓名、颜色；会捕猎。

多继承实现新的类 Husky：

class Dog(object):
    def __init__(self, age, name):  # dog_class 中的属性
        self.age = age
        self.name = name
    def bark(self):
        print(f'{self.name} is barking.')
    def eat(self, food):
        print(f'{self.name} is eating {food}')   # food 是特定功能eat中的属性
class Wolf(object):
    def __init__(self, name, color):
        self.name = name
        self.color = color
    def hunt(self, prey):
        print(f'{self.name} is hunting for {prey}')
class Husky(Dog, Wolf):
    def daze(self):
        print(f'{self.name} is in a daze.')

Husky1 = Husky(name="二哈", age= 1)
Husky1.eat("狗粮")
Husky1.hunt("小鸡仔")
Husky1.bark()
Husky1.daze()

私有化的属性

在私有属性前面

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__friend = ["李四", "王五"]
    def __play(self):
        print("打篮球")

class child(Person):
    pass

c = child("张三", 18)
print(c.friend)
c.__play

在这里插入图片描述

反射

通过字符串的形式来判断当前对象是否存在该属性或者方法。
hasattr(obj,name_str): 判断 object 是否有 name_str 这个方法或者属性。
getattr(obj,name_str): 获取 object 对象中与 name_str 同名的方法或者函数。
setattr(obj,name_str,value): 为 object 对象设置一个以 name_str 为名的 value 方法或者属性。
delattr(obj,name_str): 删除 object 对象中的 name_str 方法或者属性。

class Dog(object):
    def __init__(self, age, name):
        self.age = age
        self.name = name
    def eat(self, food):
        print("%s 吃 %s" % (self.name, food))
    def bark(self):
        print("呜..汪...汪汪..")

dog = Dog(3, "大黄")
dog.eat("qiaokeli")

if hasattr(dog, "eat"):
    eat = getattr(dog, "eat")
    food = input("你要喂它吃什么：")
    eat(food)
    setattr(dog, "temp", "饱")
    print("大黄吃%s 了" % dog.temp)

2. 类的属性(Attr)的操作

getattribute，设置属性被访问时的操作

class people(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __getattribute__(self, item):
#  重写__getattribute__方法，形参 obj 是访问的属性，是一个属性名字字符串
        if item =="age":
            print("问别人的年龄是不礼貌的")
        else: #else 此处为其他属性访问过程，如果不写，那 age 和 show 方法就访问不到了
            temp = object.__getattribute__(self, item)
            return temp
    def show(self):
        print("---")

s = people("python",30)
print(s.age)
print(s.name)
s.show()

获取私有属性并赋值：

property 让方法向属性一样调用。

class Dog(object):
    def __init__(self, age, name):
        self.__age = age
        self.name = name
    @property  # 让方法向属性一样调用：
    def age(self):
        return self.__age
    @age.setter # 设置属性赋值要求
    def age(self, Age):
        if 0 < Age < 100:
            self.__age = Age
            return self.__age
        else:
            self.__age = 18
            return self.__age

dog = Dog(142451, 'BayMAX')
dog.age = 10
print(dog.age)

在类中设置只读属性：

class Dog(object):
    def __init__(self, age, name):
        self.__age = age
        self.name = name
    @property  # 让方法向属性一样调用：
    def age(self):
        return self.__age
    @age.getter
    def age(self):
        return self.__age

dog = Dog(142451, 'BayMAX')

print(dog.age)
dog.age = 10

在这里插入图片描述

3. 设计模式基础

class phone(object):
    def __init__(self, color, price):
        self.color = color
        self.price = price
    def get_price(self):
        return self.price

class DaMi(phone):
    def __init__(self, name):
        print(f'这是一台{name}')

class Li(phone):
    def __init__(self, name):
        print(f'这是一台{name}')

class Factory(object):
    def getphone(self, name, brand):
        if brand == 'DaMi':
            return DaMi(name)
        if brand == 'Li':
            return Li(name)

factory = Factory()
phone = factory.getphone("大米 11","DaMi")