python+AI第七课

类和对象

user1 = 'zhangsan'
print(type(user1))
user2 = 'lisi'
print(type(user2))
#<class 'str'>

<class 'str'>里str是类，user1和user2是对象
user1和user2具有各种特征，这里的特征就是对象的属性

类的定义

定义一个只包含方法的

class 类名:

    def 方法1(self, 参数列表):
        pass

    def 方法2(self, 参数列表):
        pass

这里方法的第一个函数为self（约定俗成）

创建对象
当我们当一个类定义完成之后，要使用这个类来创建对象

对象变量 = 类名()

下面来做个练习
需求：
小猫 爱 吃 鱼，小猫 要 喝 水。

分析

• 定义一个猫类 Cat。
• 定义两个方法 eat 和 drink

class cat:
    def eat(self):
        print('小猫爱吃鱼')
    def drink(self):
        print('小猫爱喝水')
cat1 = cat()
cat1.eat()
cat1.drink()

这时会返回

小猫爱吃鱼
小猫爱喝水

self参数

从刚才的例子我们可以看出，在调用对象的方法cat1.eat()和cat1.drink()时是不需要传递self参数，这个self参数是系统自动传递到方法里的。
那self到底是什么？

class cat:
    def eat(self):
        print(f"小猫爱吃鱼,我是{self.name},self的地址是{id(self)}")

    def drink(self):
        print("小猫在喝水")

cat1 = cat()
print(f'tom对象的id是{id(cat1)}')
cat1.name = "Tom"
cat1.eat()
print('-'*60)
cat2 = cat()
print(f'lazy_cat对象的id是{id(cat2)}')
cat2.name = "大懒猫"
cat2.eat()

返回值为

tom对象的id是4340997328
小猫爱吃鱼,我是Tom,self的地址是4340997328
------------------------------------------------------------
lazy_cat对象的id是4341023696
小猫爱吃鱼,我是大懒猫,self的地址是4341023696

可以看出系统自动将cat1作为实参传给eat的self参数

初始化方法init()

当使用类名创建对象时，会自动执行以下操作：

• 为对象在内存中分配空间 —— 创建对象（调用new）
• 为对象的属性 设置初始值 —— 初始化方法(调用init并且将第一步创建的对象，通过self参数传给init)
  这个初始化方法就是init 方法，init 是对象的内置方法（有的书也叫魔法方法，特殊方法）
  init 方法是专门用来定义一个类具有哪些性并且给出这些属性的初始值的方法
  在cat中增加 init 方法，验证该方法在创建对象时会被自动调用

class cat:

    def __init__(self):

        print("这是一个初始化方法")

        # 方法内部使用 self.属性名 = 属性的初始值 就可以 定义属性
        # 定义用 cat 类创建的猫对象都有一个 name 的属性
        self.name = "Tom"

    def eat(self):
        print(f"爱吃鱼{self.name" })

# 使用类名()创建对象的时候，会自动调用初始化方法 __init__
tom = cat()
tom.eat()

改造初始化方法
如果希望在创建对象的同时，就设置对象的属性，可以对 init 方法进行改造
1.把希望设置的属性值，定义成 init 方法的参数
2.在方法内部使用 self.属性 = 形参 接收外部传递的参数
3.在创建对象时，使用 类名(属性1, 属性2...) 调用

class Cat:
    # 将属性值，定义成 __init__ 方法的参数 name
    def __init__(self, name):
       # self.属性 = 形参
        self.name = name
        print(f" 来了{self.name}" )
tom = Cat("Tom")
print(tom)

str 方法

如果用前面的例子print("Tom")会返回<main.Cat object at 0x0000000002852278>内存地址，如果使用str 方法print("Tom")就会返回Tom

class Cat:
    def __init__(self, new_name):
        self.name = new_name
        print("%s 来了" % self.name)
    def __str__(self):
        return self.name
tom = Cat("Tom")
print(tom)

面向对象vs面向过程
理解练习：
面向对象

首先
属性初始化必须有 __init__
class Car:
    def __init__(self, brand, price):
#类里面定义的属性，所有方法都是共享的
        self.brand = brand
        self.price = price
    def printCarInfo(self):
        print(f"the car's Info in class:brand{self.brand},price:{self.price}")

    def CarInfo(type, price):
        print("the car's type %s,price:%d" % (type, price))
carOne = Car('passat', 250000)
carTwo = Car('ford', 280000)
carOne.printCarInfo()
carTwo.printCarInfo()

面向过程

def CarInfo(type,price):
    print ("the car's type %s,price:%d"%(type,price))

print('函数方式（面向过程）')
CarInfo('passat',250000)
CarInfo('ford',280000)

从上面的例子来看面向过程要比面向对象的代码要简单的多，那面向对象的好处是什么呢？
当我们对上面的例子添加需求时：
添加行驶里程的功能
面向对象

class Car:
    def __init__(self, brand, price):
        self.brand = brand
        self.price = price
        self.distance = 0 #新车

    def printCarInfo(self):
        print ("the car's Info in class:type %s,price:%d" % (self.brand, self.price))

    def driveDistance(self,distance):
        self.distance += distance

print(f'面向对象')
carOne = Car('passat',250000)
carOne.printCarInfo()
carOne.driveDistance(100)
carOne.driveDistance(200)
print(f'passat已经行驶了{carOne.distance}公里')
print(f'passat的价格是{carOne.price}')

面向过程

def CarInfo(type,price):
    print ("the car's type %s,price:%d"%(type,price))

def driveDistance(oldDistance,distance):
        newDistance = oldDistance + distance
        return newDistance

print('函数方式（面向过程）')
CarInfo('passat',250000)
distance = 0
distance = driveDistance(distance,100)
distance = driveDistance(distance,200)
print(f'passat已经行驶了{distance}公里')

对于面向过程来说 ‘’客户代码‘’需要录入的信息太多，对于面向对象来说 ‘’客户代码‘’无需录入大量信息。

再加一个需求： 车每行驶1公里，车的价值贬值10元 面向对象的实现方式

class Car:
    def __init__(self,type,price):
        self.type = type
        self.price = price
        self.distance = 0 #新车

    def printCarInfo(self):
        print ("the car's Info in class:type %s,price:%d"%(self.type,self.price))

    def driveDistance(self,distance):
        self.distance += distance
        self.price -= distance*10

print(f'面向对象')
carOne = Car('passat',250000)
carOne.printCarInfo()
carOne.driveDistance(100)
carOne.driveDistance(200)
print(f'passat已经行驶了{carOne.distance}公里')
print(f'passat的价格是{carOne.price}')

作业：
使用类改编奖学金问题

# -*- coding:utf-8 _*-
# @Time    : 公元 2019/11/14 21:25
# @Author  : WenTing Men
# @Email   : wentingmen@163.com
# @File    : class.py
# @Software: PyCharm
class Student:
    def __init__(self, name, score, c_score, leader, west, paper):
        self.name = name
        self.score = score
        self.c_score = c_score
        self.leader = leader
        self.west = west
        self.paper = paper
        self.reward = 0
        #print(f'{self.name}信息已接收')
    def get_reward(self):
        if int(self.score) > 80 and int(self.paper) > 0:
            self.reward += 8000
        if int(self.score) > 85 and int(self.c_score) > 80:
            self.reward += 4000
        if int(self.score) > 90:
            self.reward += 2000
        if int(self.score) > 85 and self.west == 'Y':
            self.reward += 1000
        if int(self.c_score) > 80 and self.leader == 'Y':
            self.reward += 850
        #print(f'学生{self.name}获奖学金{self.reward}元')


N = int(input('输入一个整数N：'))
n = 1
sum_dict = {}
while n <= N:
    line = input(f'请输入第{n}名学生信息')
    stu_lst = line.split(' ')
    d = Student(stu_lst[0],stu_lst[1],stu_lst[2],stu_lst[3],stu_lst[4],stu_lst[5])
    d.get_reward()
    sum_dict[d.name] = d.reward
    n += 1
sum = 0
max = 0
max_stu = ''
for name, reward in sum_dict.items():
    if max < reward:
        max = reward
        max_stu = name
    sum += reward

print(max_stu)
print(max)
print(sum)