Python基础知识第八天

最新推荐文章于 2024-09-14 19:55:48 发布
最新推荐文章于 2024-09-14 19:55:48 发布
阅读量406 收藏
点赞数
分类专栏： Python基础知识 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/elly_yang/article/details/127553381
版权

方法的重载：
Python中没有方法的重载你，因为Python的参数没有类型(调用时确定参数的类型)，丁依依的方法即可有多种调用方式，相当于实现其他语言中方法的重载
如果定义了多个重命名参数，只有最后一个生效

方法的动态性：
Python是动态的语言，我们可以动态的为类添加新方法，或动态的修改类已有的方法

私有属性和私有方法(实现封装)：
注：方法本质上也是属性
Python对于类的成员没有严格的访问控制限制
通常，两个下划线开头的属性是私有的，其他为共有
类内部可以访问私有属性(方法)
类外部不能直接访问私有属性(方法)
类外部可以通过“_类名__私有属性(方法)名”访问私有属性

# 测试私有属性
class Employee:
    def __init__(self, name, age):
        self.name = name
        self.__age = age # 变为私有属性

e = Employee('Y', 27)
print(e.name)
print(e._Employee__age) # 访问私有属性

Y
27

# 测试私有方法
class Employee:
    def __init__(self, name, age):
        self.name = name
        self.__age = age # 变为私有属性

    def __work(self): # 私有方法
        print('努力找工作')
        print('{0} is {1} years old'.format(self.name, self.__age))

e = Employee('Y', 27)
e._Employee__work()

努力找工作
Y is 27 years old

@property装饰器：
可以将方法的调用变成属性的调用
一帮用于给属性增加get和set的方法

# @property测试
class Employee:
    @property
    def salary(self):
        print('salary')
        return 100000

e = Employee()
print(e.salary)

@property的用法：

# 常规
class Employee:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if 0 < age < 150:
            self.__age = age
        else:
            print('Wrong!')

e = Employee('Y', 27)
print(e.get_age())
e.set_age(18)
print(e.get_age())

# @property方法
class Employee:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, age):
        if 0 < age < 150:
            self.__age = age
        else:
            print('Wrong!')

e = Employee('Y', 27)
print(e.age)
e.age = 160
print(e.age)
e.age = 18
print(e.age)

面向对象三大特征：
封装(隐藏)，继承和多态
封装：隐藏对象的属性和实现细节，指对外提供必要的方法，相当于“细节封装起来”，只对外暴露“相关的调节方法”
继承：继承可以让子类(派生类)具有父类(基类)的特性，提高了代码的重要性，Python支持多重继承
多态：多态指同一个方法调用由于对象不同会产生不同的行为，例如每个人放松的方法不同

# 继承
class 子类名([父类1],[父类2],...):
	类体

如果定义没有指定父类，默认父类为object类
定义子类时，子类函数必须调用父类函数

class Person:

    def __init__(self, name, age):
        self.name = name
        self.__age = age # 私有子类不能用

    def say_age(self):
        print('年龄')

class Student(Person):
    def __init__(self, name, age, score):
        Person.__init__(self, name, age) # 必须显式的调用父类，不然不会调用
        self.score = score

s = Student('Y', 27, 100)
s.say_age()
print(s._Person__age) # 调用父类私有

类成员的继承和重写：
成员继承：子类继承了父类的构造方法之外的所有成员
方法重写：子类可以重新定义父类中的方法，这样会覆盖父类的方法，称为“重写”

# 测试方法重写
class Person:

    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def say_age(self):
        print('年龄', self.__age)

    def introduce(self):
        print('名字是{0}'.format(self.name))

class Student(Person):
    def __init__(self, name, age, score):
        Person.__init__(self, name, age) # 必须显式的调用父类，不然不会调用
        self.score = score

    def introduce(self):
        '''
        重写父类方法
        '''
        print('我的名字是{0}'.format(self.name))

s = Student('Y', 27, 100)
s.say_age()
s.introduce()

年龄 27
我的名字是Y

类的层次结构：
通过类的方法.mro()或者类的属性__mro__可以输出这个类的层次结构

object根类：
object是所有类的父类
dir()可以查看类的所有属性

重写__str__()方法：
用于返回一个对于“对象的描述”，对应于内置函数str()，经常用于print()方法，帮助我们查看对象的信息，str()可以重写

class Person:

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

p = Person('Y')
print(p)

<__main__.Person object at 0x0000019DDC737D00>

# 重写__str__()
class Person:

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

    def __str__(self):
        return '名字是{0}'.format(self.name)
    
p = Person('Y')
print(p)

名字是Y

Python支持多重继承，一个子类可以有多个父类，好处是类更灵活，坏处是破坏了“类的结构”，尽量避免使用

mro()函数：
如果多个父类有相同名字的方法，在子类没有指定父类时，解释器将从左到右按顺序搜索
mro：方法解析顺序，可以通过mro()方法获得类的层次结构，方法解析顺序也是按照这个层级结构寻找到
super()获取父类的定义：
是定义不是对象！

# 测试super()
class A:
    def say(self):
        print('A', self)

class B(A):
    def say(self):
        super().say() # 和A.say(self)一样
        print('B', self)

B().say()

A <__main__.B object at 0x0000023DF0136DD0>
B <__main__.B object at 0x0000023DF0136DD0>

多态：
指同一个方法调用由于对象不同会产生不同的行为
多态是方法的多态，属性没有多态
多态的存在有两个必要条件，继承和方法重写

组合：

# 测试组和
# 继承的方法
class A1:
    def say_A1(self):
        print('A1, A1, A1')

class B1(A1):
    pass

b1 = B1()
b1.say_A1()

A1, A1, A1

# 组合的方法
class A2:
    def say_A2(self):
        print('A2, A2, A2')

class B2:
    def __init__(self, A):
        self.A = A

b2 = B2(A2())
b2.A.say_A2()

A2, A2, A2

练习：

# 测试has—a关系，使用组合
class MobilePhone:
    def __init__(self, cpu, screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print('计算')
        print('cpu对象:', self)

class Screen:
    def show(self):
        print('显示')
        print('screen对象:', self)

m = MobilePhone(CPU(), Screen())
m.cpu.calculate()
m.screen.show()

计算
cpu对象: <__main__.CPU object at 0x00000223E4317D00>
显示
screen对象: <__main__.Screen object at 0x00000223E4316B90>

设计模式，工厂模式实现：
工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择现实类、创建对象进行统一的管理和控制

# 测试工厂模式
class CarFactory:
    def creat_car(self, brand):
        if brand == '奔驰':
            return Benz()
        elif brand == '宝马':
            return BMW()
        elif brand == '比亚迪':
            return BYD()
        else:
            return '未知品牌'

class Benz:
    pass

class BMW:
    pass

class BYD:
    pass

factory = CarFactory()
c1 = factory.creat_car('奔驰')
c2 = factory.creat_car('比亚迪')
print(c1)
print(c2)

<__main__.Benz object at 0x000001EE789C7CD0>
<__main__.BYD object at 0x000001EE789C6B90>

设计模式，单例模式实现：
核心作用是确保一个类只有一个实例对象，并提供一个访问该实例的全局访问点
单例模式只生成一个实例对象，减少系统开销，提高性能

# 测试单例模式
class MySingle:
    __obj = None        #类属性
    __init_Flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self, name):
        if MySingle.__init_Flag == True:
            print('初始化')
            self.name = name
            MySingle.__init_Flag = False

a = MySingle('aa')
b = MySingle('bb')
c = MySingle('cc')
print(a)
print(b)
print(c)

初始化
<__main__.MySingle object at 0x0000027FD6607D00>
<__main__.MySingle object at 0x0000027FD6607D00>
<__main__.MySingle object at 0x0000027FD6607D00>

# 没有控制初始化
class MySingle:
    __obj = None        #类属性

    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self, name):
            print('初始化')
            self.name = name


a = MySingle('aa')
b = MySingle('bb')
c = MySingle('cc')
print(a)
print(b)
print(c)

初始化
初始化
初始化
<__main__.MySingle object at 0x00000206B6727CD0>
<__main__.MySingle object at 0x00000206B6727CD0>
<__main__.MySingle object at 0x00000206B6727CD0>

练习工厂模式和单例模式的结合使用：

class CarFactory:
    __obj = None  # 类属性
    __init_Flag = True

    def creat_car(self, brand):
        if brand == '奔驰':
            return Benz()
        elif brand == '宝马':
            return BMW()
        elif brand == '比亚迪':
            return BYD()
        else:
            return '未知品牌'

    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self):
        if CarFactory.__init_Flag == True:
            print('初始化 CarFactory')
            CarFactory.__init_Flag = False

class Benz:
    pass

class BMW:
    pass

class BYD:
    pass

factory = CarFactory()
c1 = factory.creat_car('奔驰')
c2 = factory.creat_car('比亚迪')
print(c1)
print(c2)

factory2 = CarFactory()
print(factory)
print(factory2)

初始化 CarFactory
<__main__.Benz object at 0x0000021B27746DD0>
<__main__.BYD object at 0x0000021B27746E00>
<__main__.CarFactory object at 0x0000021B27746DA0>
<__main__.CarFactory object at 0x0000021B27746DA0>
elly_yang
关注
专栏目录
100天精通Python丨基础知识篇 —— 01、C站最全Python标准库总结
独木不成林，单弦不成音。
06-29 51万+
❤粉丝福利：免费下载海量【PPT模板、简历模板、学习资料】https://app.yinxiang.com/fx/13ce6bbd-f36f-4e92-be53-92dd381ed729
Python初学（二）10月
m0_50903443的博客
10-19 110
父类子类继承的学习 定义属性和强制继承 class employee(object, metaclass=ABCMeta): def __init__(self, name): self._name = name @property#定义属性，可以被读取属性 比如employee.name def name(self): return self._name @abstractmethod#强制继承者一定有的的属性 def get_s
python基础语法
qq_35547417的博客
08-29 368
。
Python Person类 Employee类 Number类 Studet类 Computer类
builie0748594740的博客
11-01 3768
Python Person类 Employee类 Number类 Studet类 Computer类 课堂作业
python创建员工_初识python： 类练习 - 老板&员工
weixin_39775872的博客
12-11 450
#!/user/bin env python#author:Simple-Sir#time:2019/8/30 14:12#类的练习：老板与员工classBoss():‘‘‘老板类money : 老板的金额workload : 工作量emplist ： 员工列表‘‘‘def __init__(self,money,workload):super(Boss,self)self.money=money...
Python基础知识 第八天总结
fjh007的博客
03-25 282
python基础知识笔记
qq_47541315的博客
10-01 3万+
python基础语法知识总结笔记，视频看的是b站的黑马程序员8天学会Python基础。
Python基础知识点梳理
热门推荐
m0_46245938的博客
02-04 4万+
python常见知识点梳理 摘要： 本文主要介绍一些平时经常会用到的python基础知识点，用于加深印象。python的详细语法介绍可以查看官方编程手册，也有一些在线网站对python语法进行了比较全面的介绍，比如菜鸟教程： python3 教程|菜鸟教程 本文主要是介绍基础语法，操作实例在另一篇博客中单独介绍： python语言介绍 python是一门解释型语言，python的设计目标： 一门...
Python入门基础知识总结
不想学习的打工人的博客
11-24 2万+
Python 是一种解释型、面向对象的语言
Python基础知识梳理
心皿月的博客
04-19 1万+
一、Python语言编程特征 二、基本数据类型（5个） 变量： 常量 类型转换问题 三、输入、输出函数 四、运算符 1、算法运算符 2、逻辑运算符 3、成员运算符 五、随机值获取、重命名 1、获取随机值 2、重命名 六、if语句 七、for循环 八、while循环 java→面向对象 ，c →面向过程；而python介于java和c 之间，既面向对象，又面向过程。 一、Python语言编程特征 Python源文件通常用.py作为扩展名 Python.........
超完整Python基础入门知识教程Python从入门到进阶知识大全Python开发基础知识能力
02-21
本教程《超完整Python基础入门知识教程Python从入门到进阶知识大全》包含了1885页的丰富内容，旨在全面教授Python开发的基础知识，帮助初学者快速掌握Python编程，并逐步提升至进阶水平。 一、Python入门基础 1. ...
【python入门必背】python入门基础知识点合集、python基础知识背记手册
10-05
【python入门必背】python入门基础知识点合集、python基础知识背记手册 主要内容概要： 第1章 走进 Python. 第2章 Python语言基础 第3章 运算符与表达式 第4章 流程控制语句 第5章 列表与元组 第6章 字典与集合 第...
基础-python基础知识源码
04-21
本资源包“基础-python基础知识源码”显然旨在帮助初学者深入理解Python的核心概念和实践技能。 Python的基础教学通常涵盖以下几个关键领域： 1. **语法基础**：Python的语法非常直观，例如缩进替代其他语言的花...
python中基础知识和练习
03-02
"python中基础知识和练习"这个主题涵盖了Python编程的入门概念和实践环节，是初学者掌握Python的关键。 1. **变量与数据类型**：Python支持多种数据类型，如整型(int)、浮点型(float)、字符串(str)、布尔型(bool)、...
爆改YOLOv8|使用MobileNetV4替换yolov8的Backbone
weixin_43986124的博客
09-12 922
MobileNetV4，yolov8改进backbone, yolov8改进， 即插即用
Python办公自动化案例（二）：对比两个Excel数据内容并标出不同
衍生星球的博客
09-14 177
在数据处理和分析的日常工作中，我们经常需要比较两个Excel文件的差异。这可能是为了验证数据的一致性、检查数据的准确性，或者在版本控制中追踪更改。手动比较这些文件不仅耗时，而且容易出错。幸运的是，Python的openpyxl库提供了一种自动化这一过程的方法。
蒙特卡罗方法——布丰投针实验近似计算圆周率python代码实现
2301_79376014的博客
09-09 521
蒙特卡罗——布丰实验
Python实现多线程、多进程及协程
qq_42568323的博客
09-09 1110
本文详细介绍了 Python 中多线程、多进程和协程的并发模型及其实现方式，并通过具体场景演示了如何使用面向对象思想实现这些模型。在实际应用中，应根据任务的类型和需求选择合适的并发模型，从而优化程序的性能和资源利用率。本文将详细介绍 Python 中的多线程、多进程和协程的概念及其实现方式，并通过具体场景展示如何在 Python 中使用面向对象的思想实现这些并发模型。接下来，我们通过一个计算密集型任务的示例来演示多进程的实现：计算一系列大数字的阶乘。主程序中创建并启动了多个计算进程，并使用。
Python——俄罗斯方块
最新发布
2302_81225694的博客
09-14 249
这段代码使用了Pygame库来实现游戏的图形界面，通过键盘控制方块的移动和旋转。游戏循环不断更新方块的位置和网格状态，并绘制在屏幕上。在方块达到底部或无法继续移动时，判断是否有满行，并清除满行的方块。游戏会根据方块的状态和移动情况不断更新，直到无法继续下落为止，游戏结束。俄罗斯方块游戏是一款经典的益智游戏，通常使用编程语言Python来实现。请注意，这只是一个简单的示例，可能还有一些功能和优化方面的改进。您可以根据自己的需求进行修改和扩展。
Python基础知识训练与编码解析
"Python基础训练题涉及的内容包括Python脚本执行方式、位与字节的关系、ASCII、Unicode、UTF-8和GBK编码的区别、Python注释、变量声明规则、位运算在变量表示中的应用、布尔值以及字符串操作方法的运用。" 在Python...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值