#类
class 类名:
def func(self):
print('类中的实例方法')
实例=类名()
实例.func()
#封装.
# #把几个属性封装到对象中
class ren:
def __init__(self,name,age,gender,hobby):
self.name=name
self.age=age
self.gender=gender
self.hobby=hobby
ren1=ren('小明',18,'男','玩耍')
print(ren1.name)
#继承
#派生类继承基类的属性和动作
class animal:
huxi=True
def chi(self):
print('吃')
def shui(self):
print('睡')
def he(self):
print('喝水')
class cat(animal):
def zhualaoshu(self):
print('抓老鼠')
class dog(animal):
def chaijia(self):
print('拆家')
cat1=cat()
cat1.chi()
cat1.shui()
cat1.he()
cat1.zhualaoshu()
print(cat1.huxi)
#多态
#类中的实例方法a可以是任何类型的数据,
# 可以是官方给定的数据类型.可以是自己定义的类.
class foo:
def func1(self,a):
print(type(a))
return type(a)
shili=foo()
shili.func1(True)
shili.func1(1)
shili.func1(1.2)
shili.func1("hahah")
shili.func1({12,123})
shili.func1([1,1,23,34])
shili.func1((1,2,3,4))
shili.func1({'k1':12,'k2':15})
shili.func1(cat1)
shili.func1(ren1)
#类方法
class Foo1:
@classmethod
def func(cls,a1):
print(a1)
shili1=Foo1()
shili1.func('你好1')
Foo1.func('你好2')
#实例方法
class Foo2:
def func(self,a1):
print(a1)
shili2=Foo2()
shili2.func('你好3')
Foo2.func(shili2,'你好4')#用类强行执行实例方法,
#类和函数的区别:
#在面向对象编程中方法是类里面编写的函数
#1 定义时,实例方法至少需要一个self形参
#2 调用时,实例方法需要通过实例对象来调用
#在面向过程编程中,函数就是对某些动作和功能的封装
#1 定义时,可以不传参数
#2 调用时,只需要函数名()就可以
#__new__与__init__
#构造方法是__new__,会为对象创建一个内存空间,并把这个内存空间的地址返回给
#初始化方法__init__.
1. 面向对象帮你解决什么问题? 封装: 归类,将函数放置到一个类中. 打包,将数据打包放到一个对象.
2. 三大特性 封装 继承 多态,Python原生支持多态,崇尚鸭子模型.由于Python函数传参时,无序指定类型: def func(arg): # arg可以是多种类型,只要其中有send方法即可.
arg.send()
3. 编写面向对象程序
归类+提取公共值
4. self到底是谁?
self参数是Python帮助我们自动传递.
如果执行面向对象中的方法时,前面必须有一个对象: xxx.func()
class Foo:
def f1(self):
pass
def f2(self):
self.f1()
obj = Foo()
obj.f2()
5. Python支持多继承
6. 类的成员
class Foo:
# 方法
def __init__(self,name):
# 实例变量/字段
self.name = name
# 方法
def func(self):
pass
# obj,Foo类的对象
# obj,Foo类的实例
obj = Foo('朱奎峰')
成员共分为三类:
变量:
- 实例变量(字段)
- 公有实例变量(字段)
- 私有实例变量(字段)
- 类变量(静态字段)
- 公有类变量(静态字段)
- 私有类变量(静态字段)
实例一:
class Foo:
# 类变量(静态字段)
country = "中国"
def __init__(self,name):
# 实例变量(字段)
self.name = name
def func(self):
pass
obj1 = Foo('季红')
obj2 = Foo('王晓东')
Foo.country
思考题: 如何验证儿子都不知道私有字段的存在.
无法访问:
class Base(object):
__secret = "受贿"
class Foo(Base):
def func(self):
print(self.__secret)
print(Foo.__secret)
obj = Foo()
obj.func()
可以访问:
class Base(object):
__secret = "受贿"
def zt(self):
print(Base.__secret)
class Foo(Base):
def func(self):
print(self.__secret)
print(Foo.__secret)
obj = Foo()
obj.zt()
方法:
- 实例方法
class Foo(object):
def __init__(self, name):
self.name = name
# 实例方法
def func(self):
print(self.name)
obj = Foo('..')
obj.func()
- 静态方法
class Foo(object):
def __init__(self, name):
self.name = name
# 静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法
@staticmethod
def display(a1,a2):
return a1 + a2
Foo.display(1,3)
- 类方法
class Foo(object):
# 类方法,cls是类
@classmethod
def show(cls,x1,x2):
print(cls,x1,x2)
# 执行类方法
Foo.show(1,8)
面试题: 静态方法/类方法和实例方法的区别?
属性(通过方法改造出来):
示例:
class Foo(object):
def __init__(self):
pass
@property
def start(self):
return 1
@property
def end(self):
return 10
obj = Foo()
print(obj.start)
print(obj.end)
"""
# 总结:
# 1. 编写时
# - 方法上方写 @property
# - 方法参数:只有一个self
# 2. 调用时:无需加括号 对象.方法
# 3. 应用场景: 对于简单的方法,当无需传参且有返回值时,可以使用 @property
"""7. 嵌套
面向对象:
"""
创建三个学校且三个学校的设施内容等都是一致.
"""
class School(object):
def __init__(self, name, address):
self.name = name
self.address = address
def speech(self):
print('讲课')
obj1 = School('北京校区', '昌平')
obj2 = School('上海校区', '浦东')
obj3 = School('深圳校区', '南山')
class Teacher(object):
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.__salary = salary
self.school = None
t1 = Teacher('李', 19, 188888)
t2 = Teacher('赵', 18, 60)
t3 = Teacher('张',16, 900000)
# ############## 老师分配校区
t1.school = obj1
t2.school = obj1
t3.school = obj2
# ####################################
# 查看t1老师,所在的校区名称/地址
print(t1.school.name)
print(t1.school.address)
print(t1.name)
print(t1.age)
t1.school.speech()
准则: 字段和方法的归类.
以前:
[
{"name":'alex1','age':18,xxx:999},
{"name":'alex2',age':18},
]