Python基础学习（三）_吃饭睡觉打豆豆python

目录

面向对象编程

面向对象和面向过程区别

类的定义

要点：

构造函数——init——()

实例属性和实例方法

类对象

类属性和类方法

——del——方法（析构函数）和垃圾回收机制

——call——方法和可调用对象

方法没有重载

方法的动态性

私有属性和私有方法

@property装饰器

面向对象三大特征

封装（隐藏）

继承

类成员的继承与重写

object根类

多重继承

super（）获得父类定义

多态

特殊方法和运算符的重载

特殊方法

对象的浅拷贝和深拷贝

组合

设计模式

---

面向对象编程

将数据和操作相关的方法封装到对象中

Python中一切皆对象

面向对象和面向过程区别

面向过程思维

面向过程编程更加关注的是“程序的逻辑流程”，是一种“执行者”思维，适合编写小规模的程序

面对对象思维

更关注“软件中对象之间的关系”，是一种“设计者”思维，适合编写大规模程序

总结

都是解决解决问题的思维方式，都是代码组织的方式

解决简单问题可以使用面向过程

解决复杂问题，宏观上使用面向对象把握，微观处理上依然是面向过程

类的定义

将对象比作一个饼干，类就是制造这个饼干的模具

类将行为和状态打包在一起

对象是类的具体实例，一般称为“类的实例”。从一个类创建对象时，每个对象会共享这个类的行为（类中定义的方法）。但会有自己的属性值（不共享状态），更具体一点，方法代码是共享的，属性数据不共享

Python中，一切皆对象。类也称为“类对象”。类的实例也称为“实例对象”

定义类的语法格式如下：

class 类名：

类体

要点：

1.类名必须符合“标识符”的规则，一般规定：首字母大写，多个单词采用“驼峰原则”

2.类体中可以定义属性和方法

3.属性用来描述数据，方法（函数）用来描述该数据相关的操作

class Student:
	def __init__(self,name,score):	#构造函数第一个参数必须为self
		self.name=name
		self.score=score
	def say_score(self):
		print(self.name,"的分数是：",self.score)
s=Student("小明",77)
s.say_score()	#输出：小明 的分数是： 77

构造函数——init——()

一个Python对象包括：

1.id(identity识别码）

2.type（对象类型）

3.value（对象的值）

（1）属性（attribute）

（2）方法（method）

创建对象，需定义构造函数——init——（）方法，构造方法用于执行“实例对象的初始化工作”即对象创建后，初始化当前对象的相关属性，无返回值。

——init——（）要点：

1.名称固定，必须为——init——（）

2.第一个参数固定，必须为self。self指的就是刚刚创建好的实例对象

3.构造函数通常用来初始化实例对象属性

4.通过“类名”（参数列表）来调用构造函数，调用后，将创建好的对象返回给相应的变量

5.——init——（）方法：初始化创建好的对象。初始化指的是：“给实例属性赋值”

6.——new——（）方法：用于创建对象，但一般无需重写定义该方法

Python中的self，相当于c++的self指针，java和c#中的this关键字。Python中，self必须为构造函数的第一个参数，名字可任意改写，但一般遵守惯例，都叫做self

实例属性和实例方法

实例属性

从属于实例对象的属性，也称为“实例变量”

1.实例属性一般在——init——（）方法中，通过如下方法定义：

self.实例属性名=初始值

2.在本类的其他实例方法中也通过self进行访问

self.实例属性名

3.创建实例对象后，通过实例对象访问

obj = 类名（） #创建对象，调用——init——（）初始化属性

obj.实例属性名 = 值 #可以给已有属性赋值，也可以新增属性

实例方法

从属于实例对象

定义格式： def 方法名（self[，形参列表]）

函数体

方法调用格式如下：

对象.方法名（[实参列表]）

要点：

1.定义实例方法时，第一个参数必须为self，与前面一般，self指的是实例对象

2.调用实例方法时，不需要也不能给self传参，self由解释器自动传参

函数与方法的区别

1.都是用来完成一个功能的语句块，本质一样

2.方法调用时，通过对象来调用，方法从属于特定的实例对象，普通函数没有这个特点

3.直观上看，方法定义时需要传递self，函数不需要

实例对象的方法调用本质

a=Student()

————解释器翻译————> Student.say_score(a)

a.say_score()

其他操作

1.dir（obj）可以获得对象的所有属性、方法

2.obj.——dict——对象的属性字典

3.pass语句 空语句

4.isinstance（对象、类型） 判断“对象”是不是”指定类型“

类对象

“class 类名：”实际上，当解释器执行class语句时，就会创建一个类对象

class Student:
	pass
print(type(Student))
print(id(Student))
stu=Student
s1=stu()
print(s1)
'''
输出：
<class 'type'>
2709603698720
<__main__.Student object at 0x00000276E0E0B250>
'''

实际上生成一个变量名，也就是类名“Student”的对象，通过赋值给新的变量stu，也能实现相关的调用。说明，确实创建了“类对象”。

pass为空语句，就是表达什么都不做。只是作为一个占位符存在，当你写代码时，遇到暂时不知道往方法或类中加入什么时，可以先用pass占位，后期在不上

类属性和类方法

类属性

从属于“类对象”，也称为“类变量”，可以被所有实例对象共享。定义方式：

class 类名：

类变量名=初始值

在类中或类的外面，可通过：“类名.类变量名”来读写

类方法

从属于“类对象”的方法，通过装饰器@classmethod来定义，格式：

@classmethod

def 类方法名（cls [，形参列表]）

函数体

要点：

1.@classmethod必须位于方法上行

2.第一个cls必须有。cls指的是“类对象”本身

3.调用类方法格式：“类名.类方法名（参数列表）”参数列表中，不需要也不能给cls传值

4.类方法中访问实例属性和实例对象会导致访问错误

5.子类继承父类方法时，传入的是子类对象，二非父类对象

静态方法

Python中允许定义与“类对象”无关的方法，成为静态方法

“静态方法”和在模块中定义的普通函数没有区别，只不过“静态方法”放到了“类的名字空间”里，需要类去调用。

静态方法通过装饰器@staticmethod来定义

格式： @staticmethod

def 静态方法名（[形参列表]）

要点： 1.@staticmethod必须位于方法上面一行

2.调用静态方法格式：“类名.静态方法名（参数列表）”

3.静态方法中访问实例属性和实例对象会导致错误

class Student :      #类名一般首字母要大写，多字母采用驼峰机制
 
    competer = "SXT"        #类属性
 
    @classmethod        #类方法
    def printcompeter(cls):
        print(cls.competer)
 
    @staticmethod       #静态方法
    def add(a,b):
        return a+b
 
    def __init__(self, name,score):
        self.name=name
        self.score=score
 
    def print_score(self):      #self必须是第一个参数
        print("{0}的分数是：{1},他的公司是{2}".format(self.name, self.score, Student.competer))
Student.printcompeter()
 
s2=Student.add(3,9)
print(s2)
s1=Student("小琪", 88)
s1.print_score()
'''
输出：
SXT
12
小琪的分数是：88,他的公司是SXT
'''

——del——方法（析构函数）和垃圾回收机制

——del——方法称为“析构方法”用于实现对象被销毁时所需的操作

Python实现自动的垃圾回收，当对象没有被引用时（引用次数为0时）由垃圾回收器调用——del——方法

我们也可以通过del语句删除对象，从而保证调用——del——方法

系统会自动提供——del——方法，一般不需要析构方法

# #测试__del__方法销毁
 
class Person():
    def __del__(self):      #一般情况下不需要自己定义，程序结束后会自动启动该回收机制
        print("销毁程序：{0}".format(self))
 
s1=Person()
s2=Person()
del(s1)
print("程序结束")
'''
输出：
销毁程序：<__main__.Person object at 0x0000022909A1B250>
程序结束
销毁程序：<__main__.Person object at 0x0000022909A1A650>
'''

——call——方法和可调用对象

定义了——call——方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用

#测试__call__方法基本用法
 
class MonthSalary():
    def __call__(self, monthsalary):
        print("算工资了***********************************")
        yearsalary = monthsalary*12
        daysalary = monthsalary//22.5
        hoursalary=daysalary//8
        return dict(yearsalary=yearsalary, monthsalary=monthsalary, daysalary=daysalary,hoursalary=hoursalary)
 
s1=MonthSalary()
print(s1(30000))
'''
输出：
算工资了***********************************
{'yearsalary': 360000, 'monthsalary': 30000, 'daysalary': 1333.0, 'hoursalary': 166.0}
'''

方法没有重载

Python中，方法的参数没有生命类型（调用确定参数的类型），参数的数量也可由可变参数控制。因此，Python是没有方法的重载的，定义一个方法即可有多种调用方式。相当于实现了其他语言的方法的重载

若在类体中定义了多个重名的方法，只有最后一个方法有效

不要使用重名的方法！Python中没有重载

方法的动态性

Python是动态语言，可以动态的为类添加新方法，或者动态的修改自己类已有的方法

#测试方法的动态性
 
class Person():
    def work(self):
        print("好好学习，天天向上")      #Python中：方法是对象，函数是对象，一切都是对象
 
 
def play_game(name):
    print("{0}游戏中".format(name))
 
def work1(a):
    print("吃饭，睡觉，打豆豆")
 
 
s1=Person()
s1.work()
 
s2=Person()
Person.work=work1
Person.play=play_game
s2.work()
s2.play()
'''
输出：
好好学习，天天向上
吃饭，睡觉，打豆豆
<__main__.Person object at 0x00000188631CA0B0>游戏中
'''

私有属性和私有方法

Python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别

要点：

1.通常约定两个下划线开头的属性是私有的（private）。其他为公共的（public）

2.类内部可以访问私有属性（方法）

3.类外部不呢直接访问私有属性（方法）

4.类外部可以通过“—类名——私有属性（方法）名”访问私有属性

方法本质上也是属性，只不过是可以通过（）执行而已，所以，此处讲的私有属性和公有属性，也同时讲解了私有方法和公有方法的用法

#测试私有属性基本用法
 
class Person():
 
    __competer = "sxt"      #私有类属性
 
    def __init__(self, name,age):
        self.name=name
        self.__age=age  #私有属性
 
    def __work(self):   #私有方法
        print("好好学习，天天向上")
        print("年龄是{0}".format(self.__age))
        print(Person.__competer)
 
s1=Person("小高" ,18)
print(s1.name)
print(s1._Person__age)
print(s1._Person__work())
 
print(Person._Person__competer)
print(dir(s1))
'''
输出
小高
18
好好学习，天天向上
年龄是18
sxt
None
sxt
['_Person__age', '_Person__competer', '_Person__work', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
'''

@property装饰器

可以将一个方法的调用方式编程“属性调用”

#测试@property装饰器的用法
 
class Person():
 
    def __init__(self, name, salary):
        self.__name=name
        self.__salary=salary
 
    @property
    def salary(self):
        return self.__salary
    @salary.setter
    def salary(self,salary):
        if 1000 < salary < 50000:
            self.__salary = salary
        else:
            print("录入错误，薪资应在1000-50000这个范围")
s1=Person("小高",10000)
print(s1.salary)
s1.salary=9999
print(s1.salary)
'''
输出：
10000
9999
'''

面向对象三大特征

封装（隐藏）

隐藏对象的属性和实现细节，只对外提出必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”

python追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员的自觉实现

继承

继承可以让子类具有父类的特性，提高了代码的重用性

从设计上是一种增量的进化，原有父类设计不变的情况下，可增加新的功能，或者改进已有的算法

面向对象程序设计的重要特征，实现代码复用的重要手段。被继承的那一类被称为父类或基类，继承的那一类被称为子类或派生类

语法格式：Python支持多重继承，一个子类可以继承多个父类

class 子类类名（父类1[，父类2……]）：

类体

若类中未定义指定父类，则默认父类是object类，也就是说object是所有类的父类。里面定义了一些所有共有的默认实现：——new——（）

定义子类时，必须在其构造函数中调用父类的构造函数

父类名.——init——（self，参数列表）

#测试继承的基本用法
 
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
 
 
s1=Student("小明",19,100)
s1.say_age()
print(s1.name)
print(dir(s1))
print(s1._Person__age)          #父类的私有属性，只能这么调用
 
#Student->Person->object
print(Student.mro())        #打印类自身以及其所含的父类
'''
输出：
年龄，这是个私有问题
小明
['_Person__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'say_age', 'score']
19
[<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
'''

类成员的继承与重写

1.成员继承：子类继承了父类除构造函数之外的所有成员

2.方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

#测试方法的重写
 
class Person:
 
    def __init__(self, name, age):
        self.name=name
        self.age=age
 
    def say_age(self):
        print("我的年龄是:{0}".format(self.age))
 
    def say_introduce(self):
        print("我的名字是：",self.name)
 
class Student(Person):
    def __init__(self,name,age,score):
       Person.__init__(self,name,age)   #必须显式调用父类初始化方法，不然解释器不会去调用
       self.score=score
 
    def say_introduce(self):
        print("报告老师，我的名字是：",self.name)
 
s1=Student("小明",18,100)
s1.say_age()
s1.say_introduce()
'''
输出：
我的年龄是:18
报告老师，我的名字是： 小明
'''

查看类的继承层次结构

通过方法mro（）或者类的属性——mro——可以输出这个类的继承层次结构

object根类

object是所有类的父类

dir（）查看对象属性

要点： 1.person对象增加了几个属性

2.object的所有属性，person类作为object类的子类，显然包含了所有属性

3.打印age.name,say_age，发现say_age虽是方法，实际上也是属性，只不过这个属性的类型是“method”

重写——str——（）方法

用于返回一个对“对象的描述”，对应于内置函数str（）。经常用时print（）方法。帮助查看对象信息。 ——str——（）可以重写

#测试重写object的__str__()
 
class Person():
    def __init__(self,name):
        self.name=name
 
    def __str__(self):
        return "我的名字是{0}".format(self.name)
s=Person("小明")
print(s)
'''
输出：
我的名字是小明
'''

多重继承

Python支持多重继承，一个子类可以有多个直接父类，这样就具备了多个父类的特点。但由于这样会被“类的整体层次”搞得异常复杂，尽量避免使用

mro（）

Python支持多重继承（若父类中有相同名字的方法，在子类没有指定父类名时，解释器将以“从左到右”按顺序搜索

MRO（Mehtod Resdution Order)：方法解析顺序。可通过mro（）方法获得“类的层次结构”方法解析顺序也是按照这个“类的层次结构”寻找的

super（）获得父类定义

在子类中，若想要获得父类的方法时，可通过super（）来做。super（）代表父类的定义，不是父类对象

#测试super（），代表父类的定义，而不是父类的对象
class A:
    def say(self):
        print("A:{0}".format(self))
 
class B(A):
    def say(self):
        super().say()                       #等价于A.say(self)
        print("B:{0}".format(self))
 
s=B()
s.say()
'''
输出：
A:<__main__.B object at 0x000001D19FB6A0B0>
B:<__main__.B object at 0x000001D19FB6A0B0>
'''

多态

指同一个方法调用，由于对象不同可能会产生不同的行为

关于多态注意：

1.多态是方法的多态，属性没有多态

2.多态的存在有2个必要条件：继承、方法重写

#测试多态的基本用法
 
class Man:
    def eat(self):
        print("该开饭了！！！")
class Chinese(Man):
    def eat(self):
        print("中国人用筷子吃饭")
class England(Man):
    def eat(self):
        print("英国人用刀叉吃饭")
class Indian(Man):
    def eat(self):
        print("印度人用右手吃饭")
 
def eatMan(m):
    if isinstance(m,Man):
        m.eat()
    else:
        print("未到时间，不能吃饭")
 
eatMan(Chinese())
eatMan(England())
'''
输出：
中国人用筷子吃饭
英国人用刀叉吃饭
'''

特殊方法和运算符的重载

每个运算符实际上都对应了相应的方法

可以重写上面的方法，实现方法的重载

#测试运算符的重载
 
class Person:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):
        if isinstance(other,Person):
            return "{0}-{1}".format(self.name,other.name)
        else:
            return "不是同一类，不能进行相加"
    def __mul__(self,other):
        if isinstance(other,int):
            return self.name*other
 
a=Person("小明")
b=Person("小高")
print(a+b)
print(a*10)
'''
输出：
小明-小高
小明小明小明小明小明小明小明小明小明小明
'''

特殊方法

对象的浅拷贝和深拷贝

变量的赋值操作

只是形成两个变量，实际还是指向同一个对象

浅拷贝

Python拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象

深拷贝

使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同

#测试对象的浅复制，深复制
import copy
class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu=cpu
        self.screen=screen
class Cpu:
    def calculate(self):
        print("计算1234567890")
        print("cpu:",self)
class Screen:
    def show(self):
        print("展示一幅美丽的风景")
        print("screen:{0}".format(self))
 
#测试变量赋值
c1=Cpu()
c2=c1
print(c1)
print(c2)
 
#测试浅复制
s1=Screen()
m1=MobilePhone(c1,s1)
m2=copy.copy(m1)
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)
 
#测试深复制
m3=copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)
'''
输出：
<__main__.Cpu object at 0x000001FD5506BFD0>
<__main__.Cpu object at 0x000001FD5506BFD0>
<__main__.MobilePhone object at 0x000001FD5506BE80> <__main__.Cpu object at 0x000001FD5506BFD0> <__main__.Screen object at 0x000001FD5506BF40>
<__main__.MobilePhone object at 0x000001FD5506BB50> <__main__.Cpu object at 0x000001FD5506BFD0> <__main__.Screen object at 0x000001FD5506BF40>
<__main__.MobilePhone object at 0x000001FD5506BE80> <__main__.Cpu object at 0x000001FD5506BFD0> <__main__.Screen object at 0x000001FD5506BF40>
<__main__.MobilePhone object at 0x000001FD55069F00> <__main__.Cpu object at 0x000001FD55069DE0> <__main__.Screen object at 0x000001FD55069D80>
'''

组合

“is-a”关系。可以使用“继承”，从而实现子类拥有的父类的方法和属性 xx是xx（用继承）

“has-a”关系，可以使用“组合”也能实现一个类拥有另一个类的方法和属性 xx拥有xx（用组合）

#测试组合的基本用法
 
#继承
class A1:
    def say(self):
        print("*"*50)
class B1(A1):
    pass
c1=B1()
c1.say()
 
#组合
class A2:
    def say(self):
        print("#"*50)
class B2:
    def __init__(self,m):
        self.m=m
c2=B2(A2())
c2.m.say()
'''
输出：
**************************************************
##################################################
'''

设计模式

设计模式是面向对象语言特有的内容

工厂模式

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

#测试工厂模式
 
class CarFactory:
    def create_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
c1=CarFactory()
b=c1.create_car("奔驰")
print(b)
b=c1.create_car("上海大众")
print(b)
b=c1.create_car("宝马")
print(b)
'''
输出：
<__main__.Benz object at 0x000002433DCBBEE0>
品牌未知，无法创造！！！
<__main__.BMW object at 0x000002433DCBBEE0>
'''

单例模式

确保一个类只有一个实例，并且提供一个访问该实例的全局访问点

#测试单例模式
class CarFactory:
    __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 CarFactory.__init__flag:
            print("init*********************")
            self.name=name
            CarFactory.__init__flag=False
a=CarFactory("aaa")
b=CarFactory("bbb")
print(a)
print(b)
'''
输出：
init*********************
<__main__.CarFactory object at 0x0000027D1397A5C0>
<__main__.CarFactory object at 0x0000027D1397A5C0>
'''

减少了对系统资源的开销，当一个对象的产生需要比较多的资源，可以产生一个"单例对象"然后永久驻留内存中，从而极大的降低开销