day9_面向对象编程

python面向对象编程
类
面向对象的开发语言
一切皆对象
面向过程
面向对象
面向对象它是包含面向过程的

类是一类东西，一个模型；实例是通过这个模型造出来的东西，类和对象的关系就是抽象和具体的关系
对象即实例，实例化就是造实例的过程

面向的对象的三个特性
封装：就是把零散代码封装成一个函数，或者封装成一个类
继承：就是父类有的东西，你也有
多态：一种方法多种实现

print('hello'.count('e'))
print([1, 1, 2, 3].count(1))
print((1, 1, 2, 3).count(3))

命名规范
StrToDict，如果有多个单词的话，每个单词首字母都大写，如果是类名的话，首字母要大写，str_to_dict多个单词用下划线连起来也行
class Student:  # 经典类
          pass
class Student2():  # 新式类，都用这种形式
          pass

class BuyCar(object):  # 新式类
    def fourS(self):
        print('这里是4S店，要买车')
    def dsj(self):
        print('这里来交购置税')
    def sgj(self):
        print('车管所')
    def jgj(self):
        print('交管局')
jxmc = BuyCar()  # 实例化，类名加括号就是对这个类进行实例化，jxmc就是一个实例、对象
jxmc.fourS()  # 通过对象来调用
jxmc.dsj()
jxmc.sgj()
jxmc.jgj()

属性就是类里面的变量，方法就是类里面的函数
构造函数：初始化这个对象，它会在类实例化的时候自动执行
def __init__(self):  # 构造函数

class My:
    def __init__(self):
        return 'hello'

__init__(self)构造函数实例化的时候，如m = My()，会报错，因为__init__特殊方法不应当返回除了None以外的任意对象，具体报错是TypeError: __init__() should return None, not 'str'

析构函数：它是这个实例被销毁的时候自动执行的
def __del__(self):  # 析构函数

在python的类中self代表实例本身(就是实例化之后的这个对象)，其实就是实例对象的唯一标志，具体来说，是该实例的内存地址，在调用实例的方法时，Python解释器会自己把实例传给类的函数中的self，通过self可以随便调用这个类下面的函数、变量，self只能在类里面使用
一个类里面只能有一个构造函数和一个析构函数，函数名不能重复，构造函数和析构函数在类里面不是必须写的
类里面的函数如果有多次调用，而且还要获取到它的返回值，那就用return，如果这个变量就用了一次，那么就用self
类里面定义的函数顺序无关，不是类跟顺序有关系
类变量，存在类里面的，一般一些公共的东西，不会变的
实例变量，实例化的时候才创建的变量，self的都是实例变量

 

私有
私有属性、变量/私有方法、函数
方法或者变量，在前面加上__，(两个下划线)，它就是一个私有方法/私有变量，私有方法或者变量在类里面随便用，出了类就不好使

 

实例方法
必须实例化之后才可以调用的方法，类里面的函数，如果第一个参数是self，那么就是一个实例方法，如def get_salt(self):

属性方法
把一个方法变成一个变量

@property
def add(self):
         return 18
属性方法也是一个实例方法，需要实例化才能使用，属性方法同样可以通过实例方法实现，如果你使用属性方法的话，那么必须得有返回值，而且不能有入参

 

类方法，通过类名可以直接调用，用实例也可以调用，用的比较少
@classmethod
def fuc(cls):
        pass

静态方法，就是写在类里面的一个普通函数而已，通过类名可以直接调用，用实例也可以调用，用的比较少
@staticmethod
def myFunc():
        pass

 

继承，把一些公共的方法、属性抽出来写到一个函数里，私有变量、私有方法不会被继承

组合，就是把类的对象(乌龟类和鱼类)放在另一个类(水池类)里面，现要求定义一个类，叫水池，水池里要有乌龟和鱼

class Turtle:  # 乌龟类
    def __init__(self, x):
        self.num = x


class Fish:  # 鱼类
    def __init__(self, x):
        self.num = x


class Pool:  # 水池类
    def __init__(self, x, y):
        self.turtle = Turtle(x)  # 组合乌龟类进来
        self.fish = Fish(y)  # 组合鱼类进来

    def print_num(self):  # self.turtle和self.fish是对象
        print('水池里有%d只乌龟，小鱼有%d条' % (self.turtle.num, self.fish.num))


pool = Pool(1, 10)
pool.print_num()

属性和方法名字相同(方法和属性名称都是x)，属性会把方法覆盖掉，定义属性用名词，定义方法用动词

class C:
    def x(self):
        print('x-man')


c = C()
c.x()
c.x = 1  # 定义属性为1
print(c.x)  
print(c.x())  # 打印方法会报错，因为方法已经被属性覆盖，TypeError: 'int' object is not callable

==========================================

class BB:
    def printBB(self):
        print('哈哈哈')
        
        
bb = BB()
bb.printBB()
BB.printBB(bb)  # 类名直接调用方法，方法里有个self，必须传一个对象，要不然报错

==========================================

class CC:
    def set(self, x, y):
        self.x = x
        self.y = y

    def print_element(self):
        print(self.x, self.y)


dd = CC()
print(dd.__dict__)  # 打印空的字典
print(CC.__dict__)  
dd.set(4, 5)
print(dd.__dict__)  # 打印{'x': 4, 'y': 5}
del CC
dd.print_element()  # 把类删了，对象还在，方法是静态方法，只有程序运行完了，dd对象才会被回收掉
ee = CC()  # 因为类已经被删除了，报NameError: name 'CC' is not defined