python

三大编程范式

　　1.面向过程
　　2.函数式
　　3.面向对象
　　注意 编程范式没有高低之分,只有适用不适用.

面向对象编程:

　　编程是程序源用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合 ，正所谓条条大道通罗马，实现一个任务的方式很多种不同的方式，对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然有些语言可以同时支持多种编程范式，两种最重要的编程范式分别是面向对象和面向对象过程。
oop编程是利用“类”和“对象”老创建各种模型来实现对真是世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率，另外，基于面向对象的程序可以使它人更容易理解你的代码逻辑，从而使团队开发变得更加从而。

面向对象的几个核心特性如下：

object对象

　　一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同。

encapsulation封装(类)

　　在类中对数据的复制、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含看类的数据和方法。

inheritance继承：

　　一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。

类的特殊方法以及定义:

#类的特殊方法以及定义:

#类声明:驼峰命名
# class Class_Name(object):
#     '''__doc__ 的特殊属性.文档属性'''
#
#     #类的初始化方法:(这个方法没有返回值,返回为None)
#     def __init__(self,name):
#         self.name = name

#实例化的初始化字典:
# print(abc.__dict__)

#属性字典(类特殊属性*****)
# print(Class_Name.__dict__)

#文档属性(类特殊属性*****)
# print(Class_Name.__doc__)

#类的名字(类特殊属性)
# print(Class_Name.__name__)

#类的起始继承(类特殊属性)
# print(Class_Name.__bases__)

#类的模块(类特殊属性)
# print(Class_Name.__module__)

实例化相关:

# 实例化章节

# question-1:
# 有人说,类有数据属性和函数属性,实例对象是由类产生的,所以实例也有数据属性和函数属性?
#错误!
# question-2:
# 实例由类产生的,所以实例肯定能访问类属性?
#错误!

#实例化的对象本身没有函数方法,其函数方法是只是引用类的函数方法.
#实例化对象的作用域属性为class类中init的属性,当访问的属性没有时,它会向class类的作用域中找访问的属性(类的作用域).

#实例化:
# class Class_Name(object):
#     def __init__(self,name):
#         self.name = name
#     def A(self):
#         return "AAA"
#
# abc = Class_Name('XA')
# print(Class_Name.__dict__)
# print(abc.__dict__)

#question-3
#在类的属性定义中,加self 或 不加 self 的区别是什么?
# self ,界定了类的类属性和实例化属性.
#不加self,表示是类的一个属性（可以通过“类名.变量名”的方式引用）
#加self,表示是类的实例的一个属性（可以通过“实例名.变量名”的方式引用）
#
# class Class_Name(object):
#     def __init__(self,name):
#         self.name = name
#     def A(self):
#         return "AAA"
#     def B():
#         return "BBB"
# #实例化
# abc2 = Class_Name('X2')
# #实例化调用实例化属性:(正常输出)
# print(abc2.A())
# #实例化调用类的属性(报错)
# print(abc2.B())
# #类调用类属性:(正常输出)
# print(Class_Name.B())

类属性操作:

# 类属性操作:
# class A(object):
#     a = 123

# #查看类的属性:
# print(A.a)
#
# #修改类的属性:
# A.a = 321
# print(A.a)
# print(A.__dict__)
#
# #增加类的属性:
# A.b = 111111
# print(A.b)
# print(A.__dict__)
#
# #删除
# del A.b
# print(A.__dict__)

#**********************************
# 类函数属性操作:(定义类函数方法时不要加self,加self就是实例化属性了)
# class A(object):
#     def AA():
#         print("aa")

#查看类的函数属性:(输出:aa)
# A.AA()

#修改类的函数属性:(输出:BB)
# def BB():
#     print('BB')
#
# A.AA = BB
# A.AA()

#删除类的函数属性:
# print(A.__dict__)
# del A.AA
# print(A.__dict__)

#增加类的函数属性
# def CC():
#     print('CC')
# print(A.__dict__)
# A.CC = CC
# print(A.__dict__)

实例属性操作:

#实例属性操作:
class A(object):
    a = 123
    def __init__(self,name):
        self.name = name
    def B(self):
        print("BB")

#实例化:
AA = A('anec')

#查看实例字典
print(AA.__dict__)
#查看实例属性:
print(AA.name)
#查看实例函数属性:
print(AA.B)
AA.B()

# #增加一个实例属性
AA.C = 123
print(AA.__dict__)
print(AA.C)

#增加一个实例函数属性:(可以做到,但不建议这种操作)
# def D():
#     print("DD")
# AA.D = D
# print(AA.__dict__)
# print(AA.D)
# AA.D()

#不要修改底层的属性字典(可以做到,但不建议这种操作)
# AA.__dict__['E'] = "EE"
# print(AA.__dict__)
# print(AA.E)

#修改实例属性
AA.name = "xiaohong"
print(AA.__dict__)
print(AA.name)

#删除实例属性
del AA.name
print(AA.__dict__)

对象、实例、全局变量 关系:

例一:

# 例一:
class Chinese:
    country = "china"
    def __init__(self,name):
        self.name = name

p1 = Chinese('anec')
print(p1.country)
p1.country = "美国"
print(Chinese.country)
print(p1.country)
#上面输出结果是???
# 结果为:
# china
# china
# 美国
#p1自身没有函数属性,所以第一个p1是类的country : china
#类访问自身的属性country :china
#p1定义了一个新的country属性,p1访问country属性时,发现自身有这个属性所以:美国

例二:

#例二:
country = "中国"
class Chinese:
    country = "湖南"
    def __init__(self,name):
        self.name = name
        print(country)
p1 = Chinese('anec')

print(p1.country)
print(Chinese.country)
#输出结果为?????
# 中国
# 湖南
# 湖南
#1.这里要注意类和实例访问属性都是通过 类名/实例名.属性/函数属性 的形式访问的,
#2.这里print(country)没有以上的方法调用,所以访问的是全局的变量值
#3.init在实例化之前执行,所以输出了中国,而后两个打印都是访问的类的属性.

例三:

# 例三:
class Chinese:
    xx = ['a','b']
    def __init__(self,name):
        self.name = name

p1 = Chinese('anec')
p2 = Chinese('anec2')

p1.xx = [1,2,3]
print(Chinese.xx)
print(p1.xx)
print(p1.__dict__)

print("*"*20)

p2.xx.append("C")
print(Chinese.xx)
print(p2.xx)
print(p2.__dict__)

# 结果:
# ****************
# ['a', 'b']
# [1, 2, 3]
# {'name': 'anec', 'xx': [1, 2, 3]}
# ********************
# ['a', 'b', 'C']
# ['a', 'b', 'C']
# {'name': 'anec2'}
# ****************
#注:
# p1是新增了一个xx属性,所以在p1.__dict__中新增了一个属性xx
# p2 并没有新增属性,而是在类的属性上新增一个元素,所以类属性增加了元素,p2__dict__中没有新增属性