三大特性以及归一化设计

最新推荐文章于 2023-02-10 21:02:37 发布

dihong7215

最新推荐文章于 2023-02-10 21:02:37 发布

阅读量199

点赞数

文章标签： python java c#

原文链接：http://www.cnblogs.com/ALADL/p/9255562.html

版权

谈论新内容之前我们还是应该了解一下它之前的内容

　　继承：

　　　　新式类：继承object类的类就是新式类。(python3x中都是新式类)

　　　　经典类：不继承object类就是经典类。

　　　　python2x：默认所有类都不继承object，所以默认所以类都是经典类。

　　单继承，多继承。

　　单继承：

　　1.查询顺序

　　　　class A:

　　　　　　name = 'alex'

　　　　　　def func(self):

　　　　　　　　print(666)

　　　　calss B:

　　　　　　age = 12

　　　　b1 = B()

　　　　b1.age

　　　　b1.name

View Code

　　2.只执行子类的方法

　　　　class A:

　　　　　　name = 'alex'

　　　　　　def func(self):

　　　　　　　　print('IN  A')

　　　　class B:

　　　　　　age = 12

　　　　　　def func(self):

　　　　　　　　print('IN   B')

　　　　b1 = B()

　　　　b1.func()

View Code

　　3.既要执行父类又要执行子类的方法

　　　　class A:
　　　　　　name = 'alex'
　　　　　　def func(self):
　　　　　　　　print('IN A')

　　　　class B(A):
　　　　　　age = 12
　　　　　　def func(self):
　　　　　　　　#super().func() # 第一种 super(B,self).func()
　　　　　　　　A.func(self) # 第二种
　　　　　　　　print('IN B')
　　　　b1 = B()
　　　　b1.func()

View Code

　　4.多继承：

　　　　新式类：广度优先。python3x：类名。mor()

　　　　经典类：一直找，找到底

好的，接下来我们就来看看接口类个抽象类：

　　接口类和抽象类在工作中，更多的是代表一种书写规范

　　python的三大特性：

　　　　python多态（鸭子类型）

　　　　　　python不同于java，python中没有多态这一说法，更多的是被叫做鸭子类型，

　　　　python封装。

# 第一版,不好,没有统一化设计,第二版解决.
# class QQ:
# 　　def pay(self,money):
#　　　　   print('您用qq支付了%s元' % money)
#
# class Ali:
# 　　 def pay(self,money):
# 　　　　 print('您用支付宝支付了%s元' % money)
#
# q1 = QQ()
# q1.pay(100)
# a1 = Ali()
# a1.pay(200)

View Code

# 第二版 ,相安无事,此时来了一个野生程序员.完成了一个微信功能
class QQ:
　　def pay(self,money):
　　　　print('您用qq支付了%s元' % money)

class Ali:
　　def pay(self,money):
　　　　print('您用支付宝支付了%s元' % money)


class Wechat:
　　def wechatpay(self,money):
　　　　print('您用微信支付了%s元' % money)

def pay(obj,money):
　　obj.pay(money) # q1.pay(100)

# q1 = QQ()
# a1 = Ali()
# pay(q1,100) # 统一化设计
# pay(a1,200)
# w1 = Wechat()
# w1.wechatpay(500)

View Code

# 第三版,重新改版微信支付功能
# class QQ:
# 　　 def pay(self,money):
# 　　　　 print('您用qq支付了%s元' % money)
#
# class Ali:
# 　　 def pay(self,money):
# 　　　　 print('您用支付宝支付了%s元' % money)
#
# class Wechat:
#　　 def pay(self,money):
# 　　　　 print('您用微信支付了%s元' % money)
#
# def pay(obj,money):
# obj.pay(money) # q1.pay(100)
#
# q1 = QQ()
# a1 = Ali()
# pay(q1,100) # 统一化设计
# pay(a1,200)
# w1 = Wechat()
# pay(w1,500)

View Code

# 第四版,为了避免上述野生程序员可能发生的问题,我要制定一个规范.

class Payment: # 抽象类,或者接口类:制定一个规范.
def pay(self):pass


class QQ(Payment):
　　def pay(self,money):
　　　　print('您用qq支付了%s元' % money)


class Ali(Payment):
　　def pay(self,money):
　　　　print('您用支付宝支付了%s元' % money)

class Wechat(Payment):
　　def pay(self,money):
　　　　print('您用微信支付了%s元' % money)

def pay(obj,money):
obj.pay(money) # a1.pay(200)

# q1 = QQ()
# a1 = Ali()
# pay(q1,100) # 统一化设计
# pay(a1,200)
# w1 = Wechat()
# pay(w1,500)

View Code

# 第五版 强制制定规范,如果未按照规范执行,就会报错.
from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta): # 抽象类 接口类 规范和约束 metaclass指定的是一个元类
　　@abstractmethod
def pay(self):pass # 抽象方法

class QQ(Payment):
　　def pay(self,money):
　　　　print('您用qq支付了%s元' % money)
def ret(self):
print('支付失败....')

class Ali(Payment):
　　def pay(self,money):
　　　　print('您用支付宝支付了%s元' % money)

class Wechat(Payment):
　　def pay(self,money):
　　　　print('您用微信支付了%s元' % money)

def pay(obj,money):
obj.pay(money) # a1.pay(200)

q1 = QQ()
a1 = Ali()
w1 = Wechat()
# q1 = QQ()
# a1 = Ali()
# pay(q1,100) # 统一化设计
# pay(a1,200)
# w1 = Wechat()
# pay(w1,500)

View Code

# 用处: 在工作中,如果你要是规定几个类必须有一样的方法,
# 你要抽象类,制定一个规范,强制其有此方法.
# python没有多态的概念,但是python崇尚鸭子类型.
# 定义变量的方法:
#1,java c# 需要定义类型. int i= 3
#2,java c# 没有多继承的概念.
# i = 1
# i = 'alex'
# 鸭子类型: 它看着像鸭子,那么他就是鸭子.

# str list tuple
str.index()
s1 = 'alex'
class Str:
　　def index(self):
　　　　pass

class List:
　　def index(self):
　　　　pass

class tuple:
　　def index(self):
　　　　pass

View Code

#python中好多不同类但同名的方法不是强制规定,而是约定俗成,像上面这三种类,都同样据有index方法,而且功能相似,
# 则他们三个互称为鸭子.

#封装就是将一些属性或者方法(有用的信息)放置在一个空间中.
1,封装对象的封装.

class Person:
　　def __init__(self,name,age):
　　　　self.name = name
　　　　self.age = age
p1 = Person('oldboy',1000)
p2 = Person('alex',10000)
print(p1.name)
print(p2.name)

View Code

封装

(私有成员.)
类的结构分析:

class Person:
　　mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段
　　__level = '高等动物' # 第一部分:私有静态变量,私有静态字段
　　def __init__(self,name,age,sex): # 构造方法 # 第二部分 动态方法,方法(函数)
　　　　self.name = name # 公有对象属性
　　　　self.age = age
　　　　self.__sex = sex # 私有对象属性
　　def func(self): # 第二部分:普通方法
　　　　print(666)
　　def __func1(self): # 第二部分:私有方法
　　　　print(777)

　　@staticmethod # 静态方法
　　def f2():pass

　　@classmethod # 类方法
　　def f2(self): pass

　　@property # 属性
　　def hex(self):pass

# 类整体分类:

#　　第一部分: 公有静态字段 mind = '有思想...' ,私有静态字段. __level = '高等动物'
#　　第二部分: 特殊方法(__init__(公有属性,私有属性),__str__...)
# 　　　　普通方法 def func(self)
# 　　　　私有方法 def __func1(self):
#　　　　类方法:
# 　　　　　　@classmethod
#　　　　　　 def f2(self): pass
#　　　　 静态方法:
# 　　　　　　@staticmethod # 静态方法
# 　　　　　　　　 def f2():pass
#　　　　属性:
# 　　　　　　@property # 属性
# 　　　　　　def hex(self): pass

# 私有成员: 私有静态字段,私有属性,私有方法   在变量前+ __双下划线.

# 私有静态字段

# class Animal:
# 　　 __cloth = '皮毛' # _Animal__cloth

# class Person(Animal):
# 　　 mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段
#　　  __level = '高等动物' # 第一部分:私有静态变量,私有静态字段 # _Person__level
#
# 　　 def __init__(self,name,age): # 构造方法 # 第二部分 动态方法,方法(函数)
# 　　　　 self.name = name # 公有对象属性
# 　　　　 self.age = age
# 　　 def func(self):
#　　　　 print(self.__level)
# 　　　　 print(self._Animal__cloth)
# 　　　　print(self.__cloth)

# 在类的外面访问: 私有静态字段是访问不到的.

# p1 = Person('alex',1000)
# print(p1.mind)
# print(p1.__level)
# print(Person.__level)
# print(Person.__dict__)
# print(Person._Person__level)
# 可以通过对象._类名__变量名 类名._类名__变量名 可以访问到,但是绝对不要这么访问.

# 在类的内部: 私有静态字段是可以访问

# p1 = Person('alex',1000)
# p1.func()

# 父类的私有静态字段,派生类可否访问? 不可访问.

# p1 = Person('alex',10)
# print(p1.__cloth)
# p1.func()

私有方法

# class Animal:
# 　　 def __f1(self):print(1111) # _Animal__f1
#
# class Person(Animal):
# 　　 mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段
# 　　 def __init__(self,name,age): # 构造方法 # 第二部分 动态方法,方法(函数)
# 　　　　 self.name = name # 公有对象属性
# 　　　　 self.age = age
# 　　　　 self.__sex = sex
# 　　 def __func(self): # _Person__func()
# 　　　　 print(666)
# 　　 def func1(self):
# 　　　　 self.__func() # self._Person__func()
# 　　 def func2(self):
# 　　　　 self.__f1() # self._Person__f1()

# 类外面访问不到.

# p1 = Person('OLDBOY',1000)
# p1.__func()

# 类内部可以方法.

# p1 = Person('OLDBOY',1000)
# p1.func1()

# 派生类中也是不能访问的.

# p1.func2()

# 私有属性也是类外部不能访问,派生类不能访问,只能在类内部访问.

class Animal:
def __f1(self):print(1111) # _Animal__f1

class Person(Animal):
　　mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段
　　def __init__(self,name,age,sex): # 构造方法 # 第二部分 动态方法,方法(函数)
　　　　self.name = name # 公有对象属性
　　　　self.age = age
　　　　self.__sex = sex
　　def __func(self): # _Person__func()
　　　　print(666)

class A:
　　def __init__(self):
　　　　self.func()
　　def func(self):
　　　　print('IN A')
class B(A):
　　def func(self):
　　　　print('IN B')
b1 = B()
# print(b1.name)
# print(b1.func)
print(b1.func)
print(b1.func())

View Code

转载于:https://www.cnblogs.com/ALADL/p/9255562.html

dihong7215

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
三大特性以及归一化设计

谈论新内容之前我们还是应该了解一下它之前的内容　　继承：　　　　新式类：继承object类的类就是新式类。(python3x中都是新式类)　　　　经典类：不继承object类就是经典类。　　　　python2x：默认所有类都不继承object，所以默认所以类都是经典类。　　单继承，多继承。　　单继承：　　1.查询顺序　　　　class A:...
复制链接

扫一扫