Python_基础_(面向对象)

## 三大编程范式

1：面向过程编程

2：函数式编程

3：面向对象编程

## 类与对象的相关知识

 类：将一类事物的相同特征或动作整合到一起就是类，类就是一个抽象的概念

对象：就是基于类而创建的一个具体的事物

类和对象的关系：对象是由类来产生的，上帝造人，上帝首先有一个造人的模板，这个模板既是人的类，然后上帝根据类的定义来产生一个个的人

 实例化：什么叫实例化，由类生产对象的过程叫实例化，实例化的结果就是一个对象，或者叫一个实例

## 声明一个函数基本结构

def functionName(args):
    "函数声明文档字符串"
    函数体

## 声明一个类基本结构

ckass 类名:
    "类声明文档字符串"
    类体

## 创建一个类

class Data:     # 规范，类名的首字母大写
    pass

d1 = Data()
# 用类Data实例化出一个对象d1
# 实例化Data(),产生一个返回的结果

## 类的类型划分

## 经典类
class 类名:
    pass

# 新式类
class 类名(父类):
    pass

# 注：只有在python2中采区分新式类和经典类
# Python3中的都为新式类

## 属性

用来描述一类事物，类的对象就是一个具体的事物，是事物就具有属性

1：数据属性：就是指变量

2：函数属性：指的是函数，在面向对象中通常称为方法

# 注：类和对象均通过"."来访问自己的属性

## 类中的内置函数

class Java:
    "注释文档:该类实现的功能为"
    ide = "MyEclipse"   # 数据属性
    def Bug(self):      # 函数属性
        print("你的程序出现了Bug")

print(Java.ide)     # 输出为 MyEclipse
j = Java.Bug
print(j)            # 得到函数Bug的内存地址  <function Java.Bug at 0x000001773135BC80>
j(j)                # 相当于执行函数Bug得到  你的程序出现了Bug

print(Java.__dict__)    # 查看属性字典，存放类的数据属性，类的函数属性
# {'__module__': '__main__', 'ide': 'MyEclipse', 'Bug': <function Java.Bug at 0x000002BD3B5ABC80>, '__dict__': <attribute '__dict__' of 'Java' objects>, '__weakref__': <attribute '__weakref__' of 'Java' objects>, '__doc__': None}

print(Java.__dict__["ide"])    # 输出为MyEclipse,上方的Java.ide实质上是到属性字典中查找

Java.__dict__["Bug"]("Bug")    # 输出 你的程序出现了Bu

Java.__name__    # 显示类名
Java.__doc__    # 注释文档
Java.__base__    # 显示Object，所有的类都有一个共同的祖先Object <class 'object'>
Java.__bases__    # 将object以元组的形式显示出来，(<class 'object'>,)
Java.__dict__    # 属性字典
Java.__module__    # 显示该类所在的模块，类在本文件中，执行本文件，指输出__main__，类在其它文件中，显示文件的路径
Java.__class__    # <class 'type'>

## 对象相关知识

class Program:
    ide = "MyEclipse"
    def __init__(self,author,development_time,size):
        self.author = author
        self.development_time = development_time
        self.size = size
        print("程序的作者是:%s，程序的创作时间为:%s，程序的大小为%s" %(self.author,self.development_time,self.size))

    def Bug(self):
        print("你的程序没有Bug哈哈哈")

P = Program("Henry","2018.1.1",1024)
# 实例化出一个对象
# 输出   程序的作者是:Henry，程序的创作时间为:2018.1.1，程序的大小为1024

## __init__

class Program:
    ide = "MyEclipse"
    def __init__(self,author,development_time,size):
        # 内置的初始化函数，当实例化时就自动调用
        # 不用像函数中的那样return init(author,development_time,size)，自动返回
        # self代表的是自己本身,将所有东西都封装到self中，自动返回，返回的是self

        self.author = author
        self.development_time = development_time
        self.size = size
        print("程序的作者是:%s，程序的创作时间为:%s，程序的大小为%s" %(self.author,self.development_time,self.size))

    def Bug(self):
        print("你的程序没有Bug哈哈哈")

P = Program("Henry","2018.1.1",1024)
# 函数的实例化过程，调用初始化函数__init__,得到的是一个对象形式
# 实际上将实例化得到的对象 j 传递给self

# 输出   程序的作者是:Henry，程序的创作时间为:2018.1.1，程序的大小为1024

print(P.ide)
# 调用数据属性（init中找不到则到外层找该属性，找到类这层没有，则会报错，而函数可以到全局变量中查找）

Program.Bug(P)  # 类Bug中有self时，就传入一个实例化出的对象（后面还会解决）
P.Bug()

# self：代表的是创建类的实例化本身，谁来实例化就代表谁，在__init__内部可以将各种属性绑定到self，因为self就指向了创建实例本身；当有了__init__方法，在创建实例时就不能传入空参数，必须传入与__init__中匹配的参数，但self不需要传入,Python解释器会自己将实例变量传入

# 实例只有数据属性，实例的函数属性是在类中找的

# 两字典：初始化字典，类字典；当初始化字典中找不到属性则到类字典中找

## 初始化字典和类字典的区别

print(Program.__dict__)
# {'__module__': '__main__', 
# 'ide': 'MyEclipse', 
# '__init__': <function Program.__init__ at 0x00000246A85DBD08>, 
# 'Bug': <function Program.Bug at 0x00000246A85DBD90>, 
# '__dict__': <attribute '__dict__' of 'Program' objects>, 
# '__weakref__': <attribute '__weakref__' of 'Program' objects>, 
# '__doc__': None}

print(P.__dict__)
#{'author': 'Henry', 
# 'development_time': '2018.1.1',
# 'size': 1024}

## 类属性的增删改查

class Program:
    ide = "MyEclipse"
    def __init__(self,author,development_time,size):
        self.author = author
        self.development_time = development_time
        self.size = size
        print("程序的作者是:%s，程序的创作时间为:%s，程序的大小为%s" %(self.author,self.development_time,self.size))

    def Bug(self):
        print("你的程序没有Bug哈哈哈")

# 查
print(Program.ide)  # MyEclipse

# 改
Program.ide = "Eclipse"
print(Program.ide)  # Eclipse

# 删
del Program.ide
print(Program.__dict__)     # 打印出的中无ide

# 增
Program.ide2 = "PyCharm"
print(Program.__dict__)     # 打印中多了ide2字典

# 增加函数属性
def equipment(self,mouse):
    print("鼠标为:%s" %mouse)

Program.Equ = equipment
print(Program.__dict__)     # 打印中加入方法 Equ
P = Program("Henry","2018.1.1",1024)
P.Equ("联想")

## 实例属性的增删改查

class Program:
    ide = "MyEclipse"
    def __init__(self,author,development_time,size):
        self.author = author
        self.development_time = development_time
        self.size = size
        print("程序的作者是:%s，程序的创作时间为:%s，程序的大小为%s" %(self.author,self.development_time,self.size))

    def Bug(self):
        print("你的程序没有Bug哈哈哈")


P = Program("Henry","2018.1.1",1024)
print(P.__dict__)       # {'author': 'Henry', 'development_time': '2018.1.1', 'size': 1024}

# 查
print(P.author)             # Henry
print(P.development_time)   # 2018.1.1
print(P.size)               # 1024

# 增
P.author_age = 18
print(P.__dict__)           # {'author': 'Henry', 'development_time': '2018.1.1', 'size': 1024, 'author_age': 18}
print(P.author_age)         # 18

def test(self):
    print("这是新增函数")

P.test = test
print(P.__dict__)           # {'author': 'Henry', 'development_time': '2018.1.1', 'size': 1024, 'author_age': 18, 'test': <function test at 0x00000157C604BC80>}
print(Program.__dict__)     # 没有上方新增的方法

# 改
P.author_age = 19
print(P.author_age)         # 19

# 删
del P.author_age
print(P.__dict__)           # {'author': 'Henry', 'development_time': '2018.1.1', 'size': 1024, 'test': <function test at 0x000001BE7FF9B7B8>}

# 注：不要修改底层的字典属性
P.__dict__["author"] = "YuHong"
print(P.author)             # YuHong
print(P.__dict__)           # {'author': 'YuHong', 'development_time': '2018.1.1', 'size': 1024, 'test': <function test at 0x00000174DF4DB7B8>}

## 将一个类当成一个作用域

class MyClass:
    pass

x = 1
y = 2

MyClass.x = 3
MyClass.y = 4

print(x,y)                  # 1  2
print(MyClass.x,MyClass.y)  # 3  4

## 其它注意点

ide = "MyEclipse"
class Program:

    def __init__(self,author,development_time,size):
        self.author = author
        self.development_time = development_time
        self.size = size
        print(ide)      # 调用全局变量中的coountry

    def Bug(self):
        print("你的程序没有Bug哈哈哈")
        
P = Program("Henry","2018.1.1",1024)    # MyEclipse

---

ide = "MyEclipse"
class Program:
    ide = "Eclipse"     # 当有一个局部变量时
    def __init__(self,author,development_time,size):
        self.author = author
        self.development_time = development_time
        self.size = size
        print(ide)      # 调用全局变量中的coountry

    def Bug(self):
        print("你的程序没有Bug哈哈哈")

P = Program("Henry","2018.1.1",1024)    # MyEclipse

---

class Program:
    ide = "Eclipse"
    list_num = ["a","b"]
    def __init__(self,author,development_time,size):
        self.author = author
        self.development_time = development_time
        self.size = size

    def Bug(self):
        print("你的程序没有Bug哈哈哈")

P = Program("Henry","2018.1.1",1024)
print(P.list_num)           # ['a', 'b']
P.list_num = [1,2,3,4,5]    # 相当于新建一个list_num列表
print(Program.list_num)     # ['a', 'b']
print(P.__dict__)           # {'author': 'Henry', 'development_time': '2018.1.1', 'size': 1024, 'list_num': [1, 2, 3, 4, 5]}
print(Program.__dict__)     # 中没有  'list_num': [1, 2, 3, 4, 5]

P.list_num.append("c")      # 该添加是在初始化函数 __init__中添加的
print(P.list_num)           # [1, 2, 3, 4, 5, 'c']
print(Program.list_num)     # ['a', 'b']