Python面向对象

老树盘根_

已于 2023-08-07 16:51:07 修改

阅读量664

点赞数 1

文章标签：笔记 python

于 2023-04-26 20:40:41 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_59759238/article/details/130394209

版权

01-练习题

抽奖小游戏：某公司周年庆，举办大型抽奖活动，现有一等奖苹果电脑1部，二等奖手机1部，三等奖山地自行车一辆，
现在在座的各位都是抽奖的观众，随机抽取6名观众，随机的抽取奖品，其中一等奖一名，二等奖两名，三等奖三名。

from random import choices,choice
# 自己写的
list = [i for i in range(1, 50)]
list_third = choices(list, k=3)
# print(list_third)
for i in list_third:
    list.remove(i)
list_second = choices(list, k=2)
for i in list_second:
    list.remove(i)
list_first = choice(list)
print(f'获得一等奖的观众是{list_first}，获得二等奖的观众是{list_second}，获得三等奖的观众是{list_third}。')
# 老师写的
import random
prizes = ['苹果电脑', '手机', '手机', '山地自行车', '山地自行车', '山地自行车']
people = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

a = input('是否开始抽奖？Yes or No，请输入：')
if a.lower() == 'yes':
    # 打乱顺序，将抽奖箱摇匀
    random.shuffle(prizes)
    # 打乱顺序，将员工抽奖顺序摇匀
    random.shuffle(people)
    # 先抽取幸运员工
    winners = random.sample(people, k=6)
    print(f'幸运员工{winners}')
    for i in range(6):
        print(f'员工：{winners[i]}抽中了{prizes[i]}')

02-面向对象编程思想

面向对象是一种编程思想，用这种思想指导设计的程序能够把数据和对数据的操作封装在一起组成类，通过类来创建对象，通过对象之间的交互来实现程序的功能。

一、为什么培养面向对象的编程思想？

1.面向过程编程：一遇到问题马上向通过写代码解决问题的逻辑。

2.面向对象编程：遇到问题马上想有没有一个已经存在的对象拥有解决这个问题的能力，如果有，马上拿过来用，反之再自己创造。

二、实际生活中的应用

问题：有脏衣服，我应该怎么洗？

1.面向过程：
a.找容器装脏衣服

b.加洗衣粉、洗衣液等

c.加水、手洗、晾晒

d.下一次有脏衣服重复上面的过程

2.函数

a.造洗衣机

b.放脏衣服

c.加洗衣粉、洗衣液等

d.加水、清洗、甩干、晾晒

e.下一次有脏衣服从第二部开始

3.面向对象

a.先造一个能够洗衣服的洗衣机和能执行命令的佣人

b.每次有脏衣服叫佣人

03-认识类和对象

一、什么是类、什么是对象？

1.类

a.人以类聚、物以群分（近朱者赤、近墨者黑）

b.具有相似内部状态和运动规律的实体的集合（统称为类）

c.具有相同的属性和行为的事务的统称

d.类是抽象的，在使用的时候通常使用的是这个类的一个实体

e.一个类可以有多个对象（实体）

2.对象

a.对象是看得见摸得着的实体，是真实存在的

b.对象是可以直接使用的

二、如何创建类、对象

# 1.定义类（大范围）：使用class关键字定义类
# 语法：class 类名
class Student:

    # 类实例化出的具体的实体，还应该有自己的属性
    # __init__这个样子的叫做魔法方法
    def __init__(self, stu_name: str, stu_age: int):
        """初始化方法（专门在类中初始化的）"""
        self.name = stu_name
        self.age = stu_age
    # 2.在类中去写对象的属性和功能，对象是通过类创建的
    # 类中写函数，这个函数叫做方法
    def play(self):
        print(f'{self.name}在玩游戏。')

    def study(self, course_name):
        print(f'{self.name}正在学习{course_name}')

    # def __str__(self):
    #     return f'{self.name}{self.age}'

3.实例化对象（创建对象）

# 实例化对象时就是在初始化
s1 = Student('张三', 18)
print(s1, Student)
# 调用这个对象拥有的功能
s1.play()   # 学生在玩游戏。
s1.study('python基础')    # 学生正在学习python基础

s2 = Student('李四', 20)
s2.play()

4.从开始学python就已经在接触类和对象

print(list, str, int, float)
# 返回：<class 'list'> <class 'str'> <class 'int'> <class 'float'>

list1 = [1, 2, 3, 4]
list2 = list('1234')
print(list1, list2)
# 返回：[1, 2, 3, 4] ['1', '2', '3', '4']

day27

01-回顾

# 定义学生类
class Student:
    def __init__(self, stu_name, stu_age):
        """这个魔法方法初始化对象属性"""
        self.name = stu_name
        self.age = stu_age

    def play(self):
        """学生具有玩的功能"""
        print(f'{self.name}正在玩游戏')

    def study(self, cou_name):
        """学生具有学习的功能"""
        print(f'{self.name}正在学习{cou_name}')

# 实例化学生对象
s1 = Student('张三', 18)

# 上述代码想象成借助python已经定义好的字符串、列表等数据类型的类
# 来初始化一个字符串、列表对象
string = str()
string1 = '123456789'
print(string, type(string))

# s1这个对象已经有了自己的属性和方法（功能）
# 对象调用自己的属性和方法
print(s1.name, s1.age)
s1.play()
s1.study('python基础')

s2 = Student('李四', 20)

02-面向对象中self的作用

# 定义学生类
class Student:
    def __init__(self, stu_name, stu_age):
        """这个魔法方法初始化对象属性"""
        self.name = stu_name
        self.age = stu_age
        print('初始化：', self, id(self))

    def play(self):
        """学生具有玩的功能"""
        print(f'{self.name}正在玩游戏')
        print('play：', self, id(self))


    def study(self, cou_name):
        """学生具有学习的功能"""
        print(f'{self.name}正在学习{cou_name}')
        print('study：', self, id(self))

# 实例化对象
s1 = Student('张三', 18)
# id()：能够查看python中数据的内存地址
# print(s1, id(s1))
print('s1对象：', s1, id(s1))
s1.play()
s1.study('python基础')

# self关键字指向实例化出来的对象

03-认识类和对象

# 定义学生类
class Student:
    # 定义类属性：通过这个类实例化的对象共同拥有的属性
    school = '清华大学'

    def __init__(self, stu_name, stu_age):
        """这个魔法方法初始化对象属性"""
        """对象属性"""
        self.name = stu_name
        self.age = stu_age
        # print('初始化：', self, id(self))

    def play(self):
        """学生具有玩的功能"""
        print(f'{self.name}正在玩游戏')
        # print('play：', self, id(self))


    def study(self, cou_name):
        """学生具有学习的功能"""
        print(f'{self.name}正在{self.school}学习{cou_name}')
        print(f'{self.name}正在{Student.school}学习{cou_name}')
        # print('study：', self, id(self))

s1 = Student('张三', 18)
# 调用类属性
# 方式一：对象.类属性
print(s1.school)    # 返回：清华大学
# 方式二：类.类属性
print(Student.school)   # 返回：清华大学
# 可以给类属性改值，也可以给对象属性改值
s1.school = '北京大学'
print(s1.school)    # 返回：北京大学
s1.name = '法外狂徒'    # 返回：法外狂徒
print(s1.name)
s1.study('python基础')

04-对象

1.定义一个圆类，实现实例化不同的圆，能够计算出这个圆的周长和面积。

# 自己写的
class circle:
    pi = 3.14
    def __init__(self, radius):
        self.radius = radius
    def perimeter(self):
        perimeter = 2 * self.radius * circle.pi
        return f'圆的周长是{perimeter}'
    def area(self):
        area = self.radius ** 2 * self.pi
        return f'圆的面积是{area}'

s1 = circle(3)
print(s1.perimeter())
print(s1.area())
# 老师写的
import math

class Circle:
    Pi = math.pi

    def __init__(self, r):
        self.r = r

    def area(self):
        return round(Circle.Pi * self.r ** 2, 2)

    def primeter(self):
        return round(2 * Circle.Pi * self.r, 2)

c1 = Circle(3)
print(f'半径为{c1.r}的圆的面积为{c1.area()}')
print(f'半径为{c1.r}的元的周长为{c1.primeter()}')

2.定义一个类，描述平面（二维坐标系）上的点，要求提供一个方法能实现计算到另一个点的距离，另一个点默认是原点。

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance(self, other):
        return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5

p1 = Point(3, 4)
p2 = Point()
print(p1.distance(p2))
p3 = Point(100, 100)
print(p1.distance(p3))

3.定义一个时钟类描述数字时钟

class Click:
    def __init__(self, hour=0, minute=0, second=0):
        self.h = hour
        self.m = minute
        self.s = second

    def show(self):
        """用来显示时间：24小时制"""
        return f'{self.h:0>2}:{self.m:0>2}:{self.s:0>2}'

    def run(self):
        self.s += 1
        if self.s == 60:
            self.m += 1
            self.s = 0
            if self.m == 60:
                self.h += 1
                self.m = 0
                if self.h == 24:
                    self.h = 0
import time
import os
# 获取本地时间：localtime()
time.localtime()
t = time.localtime()
c1 = Click(t.tm_hour, t.tm_min, t.tm_sec)
while True:
    print(c1.show())
    time.sleep(1)
    # windows使用cls命令清屏
    os.system('cls')
    c1.run()

使用终端terminal执行python代码命令：python 需要运行的文件（注意路径）

停掉终端中的程序：ctrl + z或者ctrl + c

05-魔法方法

一、什么是魔法方法（魔术方法）？

魔术方法是被双下划线__（dunder）包围的特殊方法，例如__init__

魔术方法是python内置的方法，不需要主动调用，他们会在适当的时候自动执行。

二、基本的魔术方法

__add__定义了加法行为

__sub__减法

__mul__乘法

__mod__余数（求模）

__floordiv__整除

__truediv__真除法（普通除法）

x = 1
y = 2
print(x.__add__(y))  # 3
print(x.__sub__(y))  # -1
# __init__:当一个对象被初始化时绑定对象属性用的
# __del__:一个对象将要被系统回收时调用的（垃圾回收机制）
# __str__:当你调用str()时触发__str__；当你使用%s时触发__str__；当你打印一个对象时触发__str__

list1 = list('12345')
print(list1)

class A:
    def __str__(self):
        return '这是对象A'

print(A())  # 返回：这是对象A

06-了解对象方法、类方法、静态方法

python中这三个概念有点混乱，会玩对象方法就行

class Rectangle:
    # 边的数量
    sides = 4
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @classmethod
    def get_sides(cls):
        """
        类方法，一个类中专门用来访问类属性的方法，使用@classmethod修饰，方法中的参数不是self，而是cls，cls指向这个类
        """
        return cls.sides

    @staticmethod
    def perimeter(width, height):
        """
        静态方法，使用@staticmethod修饰，默认没有任何形参
        可以被任何地方调用，求任何矩形的周长
        """
        return (width + height) * 2

    def get_perimeter(self):
        """这个对象方法只能被当前对象调用，计算当前对象的周长"""
        return self.perimeter(self.width, self.height)


    def area(self):
        """对象方法"""
        return self.width * self.height
print(Rectangle.perimeter(10, 20))  # 60
r1 = Rectangle(10, 20)
print(r1.get_perimeter())   # 60
print(r1.area())    # 200

1.类属性，既可以被类调用，又能被对象调用，但是一般访问类属性都是使用类方法来访问，通过类方法传递给其他的方法。

2.静态方法虽然被定义到类中，但是这个静态方法其实是独立于类的，因为这是个矩形类，它肯定有计算周长的方法。平时不用类，也会涉及到一些计算矩形周长的问题，在这个矩形类中写这个静态方法，仅仅是完善这个类并且方便其他人直接调用这个方法。静态方法既不能访问类属性，也不能访问对象属性。

3.静态方法既能被类调用，又能被对象调用。

4.对象方法get_perimeter作用：此时矩形类中已经存在了一个计算周长的方法，所以不需要再写一遍计算过程，但是静态方法既不能访问类属性，又不能访问对象属性，所以只能使用对象调用静态方法，通过传值的方法写入到对象方法中间接调用

07-扑克牌游戏

一副扑克牌只有52张牌（不要大小王），游戏需要将52张牌随机的发到4个玩家手中，每个玩家手中分13张牌，按照黑桃♠、红桃♥、梅花♣、方片♦的顺序和点数从小到大排序列，暂时不实现其他功能。

创建的类：

1.扑克牌类

class Poker:
    """所有扑克牌都有这样的属性"""
    color = ['黑桃', '红桃', '梅花', '方片']
    king = ['大王', '小王']
    num = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']

    def __init__(self, color, num, king=[]):
        """本次不需要大小王"""
        self.puke = [i + j for i in color for j in num] + king



# 扑克类测试
if __name__ == '__main__':
    P1 = Poker(Poker.color, Poker.num)
    print(P1.puke)

2.发牌的荷官

from random import shuffle
from poker import Poker
class heguan:
    def __init__(self, name='王二麻子'):
        self.name = name
        # 计数，数发了多少牌
        self.num = 0

    def shuffle_cards(self, puke):
        shuffle(puke)
        return puke

    def deal(self, puke):
        card = puke[self.num]
        self.num += 1
        return card



# 测试荷官类
if __name__ == '__main__':
    # 实例化扑克牌对象
    P1 = Poker(Poker.color, Poker.num)
    # 实例化荷官对象
    H1 = heguan()
    # 打印扑克牌
    print(P1.puke)
    # 洗牌
    H1.shuffle_cards(P1.puke)
    print(P1.puke)
    # 发牌
    print(H1.deal(P1.puke))
    print(H1.deal(P1.puke))

3.玩家类

from poker import Poker
from heguan import heguan
class Player:
    def __init__(self, name):
        self.name = name
        # 玩家拿着自己的牌
        self.card = []

    def get_card(self, card):
        self.card.append(card)



# 实例化扑克牌
P1 = Poker(Poker.color, Poker.num)
print(P1.puke)
# 实例化荷官
H1 = heguan()
# 荷官洗牌
H1.shuffle_cards(P1.puke)
# 洗牌之后的牌
print(P1.puke)
# 实例化4个玩家
play_name = ['李狗蛋', '王二狗', '渣渣辉', '古惑仔']
p1, p2, p3, p4 = [Player(i) for i in play_name]
# 给4个玩家发牌
players = [p1, p2, p3, p4]
for _ in range(13):
    for play in players:
        play.get_card(H1.deal(P1.puke))
print('****发牌完成****')
print(p1.name, p1.card)
print(p2.name, p2.card)
print(p3.name, p3.card)
print(p4.name, p4.card)