一.函数式编程和面向对象编程区别
- 函数: 是将某些功能代码封装到函数中,不用重复编写,直接调用函数即可
- 面向对象: 是对函数分类和封装
def email(em,text): """ 发送邮件 :param em: :param text: :return: """ print(em,text) def msg(tel,text): """ 发送短信 :param tel: :param text: :return: """ print(tel,text) def wechat(num,text): """ 发送微信 :param num: :param text: :return: """ print(num,text) # 编写功能:用户购买商品,然后给商家发送提醒 if 1 ==1: msg('13522289159','xxx购买了某个商品') email('592888935@qq.com','xxx购买了某个商品') wechat('xxxxxxx','xxx购买了某个商品')
class Message: def email(self,em,text): """ 发送邮件 :param em: :param text: :return: """ print(em, text) def msg(self,tel, text): """ 发送短信 :param tel: :param text: :return: """ print(tel, text) def wechat(self,num, text): """ 发送微信 :param num: :param text: :return: """ print(num, text) # 编写功能:用户购买商品,然后给商家发送提醒 obj= Message() obj.msg('13522289159', 'xxx购买了某个商品') obj.email('592888935@qq.com', 'xxx购买了某个商品') obj.wechat('xxxxxxx', 'xxx购买了某个商品')
对比:
函数: 定义简单/调用简单
面向对象: 定义复杂/调用复杂 好处:归类/将某些类似的方法(函数)写在一起
总结:
函数式编程可以会比面向对象编程好
python支持两种编程方式
二.类与对象
面向对象编程核心二字即:'对象'
可以把类看做是一个包,包里可以包含多个函数,每个函数实现一个功能
对象则是根据包创建的一个实例,通过实例可以调用包里的函数
定义: class Foo: # 定义了一个类,Foo为类名 def func(): # 在类中编写了一个方法(单独称为函数,放到类中一般都被称为方法) pass 调用: obj = Foo() # 创建了一个对象/实例化一个对象 obj.func() # 通过对象调用类中的方法
class 是关键字,表示你将要创建一个类
创建对象即类名称加括号
提示: 类名定义的时候第一个字母大写,或每个单词的首字母大写(潜规则,可以看出你是不是个老司机)
练习题:
class Account: def login(self): user = input('请输入用户名:') pwd = input('请输入密码:') if user == 'alex' and pwd == 'SB': # SB即:烧饼 print('登录成功') else: print('登录失败') obj = Account() obj.login()
三.三大特性
三大特性:封装/继承/多态
- 封装(顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容)
将相关功能封装到一个类中
class Message: def email(self):pass def msg(self):pass def wechat(self):pass
将数据封装到一个对象中
class Person: def __init__(self,name,age,gender): self.name = name self.age = age self.gender = gender obj1 = Person('侯明巍',18,'男')
obj2 = Person('房文磊',16,'女')
self 是一个形式参数，当执行 obj1 = Person('侯明巍',18,'男' ) 时，self 等于 obj1
当执行 obj2 = Person('房文磊',16,'女' ) 时，self 等于 obj2
所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 及 gender 属性，在内存分别开辟两个空间来保存。
""" 完成以下功能: 老狗/20岁/男/上山去砍柴 老狗/20岁/男/开车去东北 老狗/20岁/男/喜欢大宝剑 """ class LaoLi: def __init__(self,name,age,gender): # 特殊的方法,如果 类名(),则该方法会被自动执行 (构造方法) self.name = name self.age = age self.gender = gender def kc(self): data = "%s,%s,今年%s,喜欢上山去砍材" % (self.name, self.gender, self.age) print(data) def db(self): data = "%s,%s,今年%s,喜欢开车去东北" % (self.name, self.gender, self.age) print(data) def bj(self): data = "%s,%s,今年%s,喜欢去做大保健" % (self.name, self.gender, self.age) print(data) obj = LaoLi('老狗',20,'男') obj.kc() obj.db() obj.bj()
- 继承(面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容)
- 单继承
class SuperBase: # 父类,基类 def f3(self): print('f3') class Base(SuperBase): # 父类,基类 def f2(self): print('f2') class Foo(Base): # 子类,派生类 def f1(self): print('f1') obj = Foo() obj.f1() obj.f2() obj.f3()
原则: 先在自己的类中找,找不到去父类找
站的角度不同,对待父类和子类的定义也不同,子类也有可能是别的类的父类
- 多继承
class Base1: def show(self): print('Base1.show') class Base2: def show(self): print('Base2.show') class Foo(Base1,Base2): pass obj = Foo() obj.show() # 左边比右边更亲
总结:
1. 继承编写
2. python支持多继承
3.为什么要有继承: 提高代码的重用性
- 多态(多种形态和多种状态)
python原生支持多态,所有没有特殊性
其Python崇尚“鸭子类型”
class F1: pass class S1(F1): def show(self): print 'S1.show' class S2(F1): def show(self): print 'S2.show' def Func(args): print args.show() s1_obj = S1() Func(s1_obj) s2_obj = S2() Func(s2_obj)
由于python函数在传参时没无需指定类型,args可以是多种类型,只要其中有seed方法即可
总结:
以上对面向对象知识总结
- 面相对象是一种编程方式,此编程方式的实现是基于对'类'和'对象'的使用
- 类是一个包,包中包装了多个'函数'供使用
- 对象,根据类创建的实例(即:对象),实例用于调用被包装的类中的函数
- 面向对象的三大特性: 封装/继承/多态
- 封装
归类,将函数放置到一个类中
打包,将数据打包放到一个对象中
- 继承
提高代码的重用性
四.类的成员
成员共分为三类:
1.变量
2.方法
3.属性
1.变量
实例变量(字段)
- 公有实例变量(公有字段)
- 私有实例变量(私有字段)
类变量(静态字段)
- 公有类变量(公有静态字段)
- 私有类变量(私有静态字段)
class Foo: # 类变量(静态字段) country = '中国'
# 私有类变量
__secret = '贪污受贿'
def __init__(self,name,age): # 实例变量(字段) self.name = name
# 私有实例变量 __self.age = age def func(self): pass
什么时候用类变量?
当所有对象中有共同的字段时且要改都改要删都删的时候,可以将实例变量(字段)提取到类变量(静态字段)
私有变量在函数外部是无法访问的
class Foo: def __init__(self,name): # 私有实例变量(私有字段) self.__name = name # 在变量前边加 '__' self.age = 26 def func(self): print(self.__name) obj = Foo('侯明巍') # print(obj.__name) # 无法访问 print(obj.age) obj.func() # 可以让内部的func函数帮助执行内部私有的__name
class Foo: __country = '中国' def __init__(self): pass def func(self): # 内部调用 print(self.__country) print(Foo.__country) # 推荐使用类调用 obj = Foo() obj.func() # 外部无法调用内部私有类变量 # print(Foo.__country) # 外部无法调用
############ 无法访问 class Baer(object): __secret = '贪污受贿' class Foo(Baer): def func(self): print(self.__secret) print(Foo.__secret) obj = Foo() obj.func() ############ 可以访问 class Baer(object): __secret = '贪污受贿' def func1(self): print(Baer.__secret) class Foo(Baer): def func2(self): print(self.__secret) print(Foo.__secret) obj = Foo() obj.func1()
2.方法
1.实例方法
公有实例方法
私有实例方法
2.静态方法
公有静态方法
私有静态方法
3.类方法
公有类方法
私有类方法
class Foo(object): def __init__(self,name): self.name = name # 实例方法 def func1(self): print('实例方法') # 私有实例方法 def __display1(self) print('私有方法') # 静态方法 @staticmethod def func2(): print('静态方法') # 私有静态方法 def __display2(): print('私有静态方法') # 类的方法. cls是类 @classmethod def func3(cls): print(类方法) # 私有类方法 @ classmethod def __display(cls) print('私有类方法')
静态方法总结:
1.编写时:
- 方法上方写 @staticmethod
- 方法参数(self)可有可无
2.调用时:
- 类.方法名() # 推荐
- 对象.方法名()
3.什么时候写静态方法
- 无需使用对象中封装的值的时候
类方法总结:
1.定义时:
- 方法上方写 @classmethod
- 方法的参数:至少有一个cls的参数
2.执行时:
- 类名.方法名() # 默认会把当前类传到参数中
3.什么时候用类方法
- 如果在方法中会使用到当前类,那么久可以使用类方
静态方法/类方法和实例方法的区别?
1.定义:
1.实例方法上方什么也不加
2.静态方法上方加 @staticmethod
3.类方法上方加 @classmethod
2.执行:
1.实例方法是先实例化,再通过对象.方法名
2.静态方法是通过类.方法名
3.类方法是通过类.方法名
3.属性(通过方法改造出来的)
公有属性
私有属性
class Foo(object): def __init__(self): pass # 属性 @property def start(self): return "hell word,I's'赛利亚" # 私有属性 @property def __end(self): return '你好啊,我是赛利亚'
属性总结:
1.编写时
- 方法上方写 @property
- 方法参数: 只有一个self
2.调用时: 无需加括号,直接 对象.方法
3.应用场景: 对于简单的方法,当无需传参且有返回值时,可以使用 @property