Python类

最新推荐文章于 2023-04-14 22:35:24 发布

xingyan98

最新推荐文章于 2023-04-14 22:35:24 发布

阅读量179

点赞数

本文链接：https://blog.csdn.net/xingyan98/article/details/97670920

版权

面向过程
函数式编程
面向对象

面向过程

所谓过程就是我们解决问题的步骤，一步步的按照流程去走，有先后之分。

它呢，整个设计就好比流水线，思维上比较机械化。

优缺点：

优点
- 复杂的问题流程化，将问题分解简化。
缺点
- 拓展性不足

面向对象

核心是对象。

正式的来说

对象是一个数据以及相关行为的集合
面向对象是功能上指向建模对象

通过数据和行为方式来描述交互对象的集合。

在Python中，一切皆为对象。

面向对象的优缺点

优点
- 解决程序的拓展性
缺点
- 复杂度远高于面向过程
- 交互性解决问题，无法准确预测结果

object1:
    
Tom
	
    特征：
    school = zucc
    name = Tom
    age = 20
    sex = male
    
    技能:
    eat
    study
    sleepTom
object2:
    
Jack	
    特征：
    school = zucc
    name = Jack
    age = 21
    sex = male
    
    技能:
    eat
    study
    sleep
    sing

类就是类别、种类

对象是特征和技能的统一体。

类则是这一些列对象的特征和技能的结合。

对于现实世界，先有个体（及对象），才有类别；当对于程序，必须先有类，然后才有对象的。

面向对象编程

OOP（object oritented programming）

其实一种程序设计思想。OOP把对象作为程序的一个基本单元。一个对象就包含了数据以及操作的函数。

在Python中，所有数据类型都可以视为对象，同时我们也可以自定义对象。

自定义的对象的数据类型就是面向对象中类（class）的概念

Demo:

加入要处理我们的成绩。为了表示学生的成绩：

面向过程的方式

stu1 = {'name':'Tom','score':99}
stu2 = {'name':'Jack','score':82}

利用函数来实现

def find_score(stu):
    print(stu['name'],':',stu['score'])

如果是面向的对象

class Student:
    def __init__(self,school,name,age,sex):
        self.school = school
        self.name = name
        self.age = age
        self.sex = sex
    def eat(self):
        print(self.name,'is eating.')
    def study(self):
        print(self.name,'is studying.')
    def sleep(self):
        print(self.name,'is eating.')
    def find_inf(self):
        print(self.name,':',self.school,',',self.age,',',self.sex)
stu1 = Student('Tom',99,20,'male')
stu1.find_inf()
stu1.eat()

类的定义和使用

面向对象设计的思想，先抽象出类，再根据类创建实例。

类的定义

class ClassName(object):
    class_statement

类的命名，大驼峰式

所谓大驼峰式变量名称的单词的首字母大写

创建一个类

class MyFirstClass:
    pass

类的作用是一个模板。我们可以在创建实例的时候，把一些我们必选绑定的属性填写进去。这时就通过特殊的__init__方法。在创建实例的时候，绑定相关的属性。比如前面的name,score。

class Student:
    school = 'ZUCC'
    def __init__(self,name,score):
        self.name = name
        self.score = score
stu1 = Student('Tom',99)
print((stu1.name,stu1.score,Student.school))

和普通函数相比，在类中定义方法时，第一个参数必须是self。除第一个参数外，其他的和普通函数没有什么区别。

self 代表的是实例，而非类。

__init__方法

1.为对象初始化自己独有的特征
2.该方法中可以有任意的代码，但是一定不可以有返回值。

数据封装

class Student:
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def find_score(self):
    print(self.name,':',self.score)

syu1 = Student('Tom',99)
stu1.find_score()

我们通过__init__()让stu1实例本身就拥有了相关数据，如果要访问这些数据，我们可以直接在student类的内部定义相关的函数来访问数据，以此‘封装’数据。

这些封装数据的函数和Student类本身就是相关联起来的，他们称之为方法。

类的两个作用：

属性引用
- 类名.属性
实例化
- 类名加上一个括号就是实例化，它能够自动触发__init__函数的运行，进而为每个实例定制自己的特征。

类属性的补充

类属性的查看

1.dir(类名)
- 返回一个列表
2.类名.__dict__
- 返回一个字典，key为属性名，value是属性值。

特殊的类属性

类名.__name__  #返回类的名字
类名.__doc__   #返回说明文档字符串
类名.__base__  #返回类的第一个父类
类名.__bases__ #返回类的所有父类构成的元组
类名.__module__#返回类定义所在的模块
类名.__class__ #实例所对应的类
类名.__dict__  #类的字典属性

总结：

class ClassName:
    def __init__(self,para1,para2,...):
        self.对象属性1 = para1
        self.对象属性2 = para2
        
    def 方法名1(self):
        pass
    def 方法名2(self):
        pass
obj = ClassName(para1,para2)

#对象的实例化，代表具体的东西
#ClassName()：调用__init__
#括号内传参，无需传入self，参数一一对应
#结果是返回对象obj

obj.对象属性1 #查看对象属性
obj.方法名1 #调用类的方法

对象之间的交互

假如说现在定义两个类，Person, Dog

class Person:
    def __init__(self,name,aggr,life_value):
        self.name = name
        self.aggr = aggr
        self.life_value = life_value

    def attack(self,dog):
        dog.life_value -= self.aggr
class Dog:
    def __init__(self,name,bread,aggr,life_value):
        self.name = name
        self.breed = bread
        self.aggr = aggr
        self.life_value = life_value
    def bite(self,people):
        people.life_value -= self.aggr

per = Person('T',10,1000)
dog = Dog('J','Husky',5,500)

print(dog.life_value)
per.attack(dog)
print(dog.life_value)

类命名空间与对象、实例的空间

创建一个类就会创建一个类的名称空间，用来存储我们定义的所有的变量名。这些名字就是属性。

类的属性有两种：

静态属性
- 直接在类中定义的变量
动态属性
- 在类中定义的方法

静态属性是共享给所有对象的

动态属性是绑定到所有的对象

类的三大特性

继承
多态
封装

在面向对象编程中，当我们定义一个新类的时候，可以从某个现有的类继承，新的类就被称为子类（Sub Class），而被继承的类则被称为基类，父类，超类（Base Class , Father Class , Super Class）

比如，我们定义一个动物类（Animal）,其中有一个run()函数。

class Animal(object): #定义父类
    def run(self):
        print('Animal is running')
class Animal2():
    pass
class Dog(Animal): #单继承
    pass
class Cat(Animal): #单继承
    pass
class Husky(Animal,Animal2): #多继承，用逗号隔开
    pass

dog = Dog()
cat = Cat()

print(dog.run())
print(cat.run())
#如果不指定基类，Python类会默认继承object类，
#object是所有Python类的基类，提供一些常见方法的实现。

继承查看：ClassName.__bases__

多态

当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，再运行代码时，总会调用子类的方法。这样，就是继承的另外一个好处，多态。

class Animal(object): #定义父类
    def run(self):
        print('Animal is running')
class Animal2():
    pass
class Dog(Animal): #单继承
    def run(self):
        print('Dog is running')
    pass
class Cat(Animal): #单继承
    def run(self):
        print('Cat is running')
    pass
class Husky(Animal,Animal2): #多继承，用逗号隔开
    pass

dog = Dog()
cat = Cat()
dog.run()
cat.run()

理解多态，首先要对数据类型再进行说明。定义一个类的时候，实际上就是定义了一种数据类型。我们自定义的数据类型和Python自带的数据类型，比如string，list，dict，没什么区别。

用isinstance()来判断某个变量是否是某个类型

对于一个变量，我们只要知道它的父类型，无需确切知道子类型，就可以放心调用相关的方法。运行时具体的方法时作用在子类型上海市父类型上，由我们运行的对象决定。

也就是说，调用时只管调用，不管细节。

当我们新增一个子类时，我们只要保证相关的方法编写正确，就不用管原来的代码如何调用的。

---->‘开闭原则’

对拓展开放：允许新增子类
对修改封闭：不需要修改依赖父类类型的函数。

总结：

继承可以一级一级的继承下来，类比人类，就好比爷爷奶奶到父母到子女。

任何类都可以追溯到根类object。

私有属性

在类的内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作。这样，隐藏内部的复杂逻辑。

比如Student类:

class Student:
    school = 'ZUCC'
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def find_score(self):
        print(self.name,':',self.score)
stu1 = Student('Tom',99)
stu2 = Student('Jack',89)
print(stu1.score)
stu1.score = 97
print(stu1.score)

从这可以看出外部代码可以自由修改一个实例的属性（name, score）

如果要让内部属性不被外部访问，我们可以在属性名称前加两个下划线。

在Python中，实例的变量名如果以双下划线开头，就变成了一个私有变量。

封装

隐藏对象的属性和实现细节，仅对外提供公共访问的方式。

这样做的优点在于：

1.可以将变化隔离；
2.便于使用；
3.方便了提供整个数据的安全性；
4.提高复用性。

原则：

将不需要对外提供的内容隐藏起来；
隐藏属性，提供公共方法对其进行访问

----> 私有方法，私有变量 ----> 私有属性

用双下划线开头的方式将属性隐藏起来，设置为私有的。

class Student:
    school = 'ZUCC'
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def get_name(self):
        return self.__name
    def get_score(self):
        return  self.__score

    def set_score(self,score):
        if 0<=score<=100:
            self.__score = score
        else:
            raise ValueError('Bad score')
    def find_score(self):
        print(self.__name,':',self.__score)
stu1 = Student('Tom',99)
stu2 = Student('Jack',89)

# print(stu1.find_score())
# stu1.score = 97
# print(stu1.find_score())
# print(stu1.set_score(97))
# print(stu1.find_score())
print(stu1._Student__score)

鸭子类型

class Animal(object): #定义父类
    def run(self):
        print('Animal is running')
class Animal2():
    pass
class Dog(Animal): #单继承
    def run(self):
        print('Dog is running')
    pass
class Cat(Animal): #单继承
    def run(self):
        print('Cat is running')
    pass
class Husky(Animal,Animal2): #多继承，用逗号隔开
    pass
class Test:
    def run(self):
        print('多态测试')

dog = Dog()
cat = Cat()
test = Test()
dog.run()
cat.run()
test.run()

def run_twice(animal):
    animal.run()
    animal.run()


run_twice(test)

鸭子类型不要求有严格的继承关系，一个对象，只要“看起来像鸭子，走起路来还是像鸭子”
也就是说，如果编写现有对象的自定义版本，可以继承该对象，也可以创建一个外观和行为像的对象，但与其无任何关系的全新对象。

比方说，利用标准库中定义的各种“与文件类似”的对象，尽管这些对象的工作方式像文件，但他们并没有继承内置文件对象的方法。

class TestFile:
    def read(self):
        pass
    def write(self):
        pass
class OperFile:
    def read(self):
        pass
    def write(self)
    	pass