1、编程的方式
2、面向对象的基本概念
3、类的基本概念
4、类的定义与调用——简单代码举例
注：建议类名的开头字母用大写，在Python中，类内的函数称作方法，类外的函数还是称作函数。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
#类
classPerson:
i =10#属性（变量）
defeat(self):#方法（函数）
print("eating...")
pass
#类的调用
a = Person()
a.eat()
#运行结果：
eating...
classPerson():
#对象属性 构造方法 在实例化对象时会自动调用
# 实例化的对象就具有name和age两个属性
#self是指当前的对象 self不是关键字可以被代替，但是习惯使用self指代当前对象
def__init__(self,name,age):
# 通过构造方法声明了两个对象属性
#对象.name属性 = name参数
self.name = name
self.age = age
#声明一个类方法
defspeak(self):
print("Hello,my name is %s,and I'm %d years old"%(self.name,self.age))
#创建实例对象 会触发构造方法
people01 = Person("Jack",18)#通过Person类实例化出一个people对象
print(people01)#打印Person对象在内存中的地址
print(people01.name,people01.age)#打印对象的属性
#给对象添加属性
people01.sex ="F"
print(people01.sex)
#类方法的调用
people01.speak()
#运行结果：
<__main__.Person object at0x0059C5B0>
Jack18
F
Hello,my nameisJack,andI'm 18 years old
5、类的方法
示例代码：
#方法——静态方法
classS():
#实例（对象）属性
def__init__(self,name,age):#self一般指实例对象
self.name = name
self.age = age
@staticmethod #用staticmethod装饰器修饰 表示test2为静态方法
deftest2():#不能传入self 对象的引用
print("test2...")
s1 = S("Joe",18)
s1.test2()#通过实例调用静态方法
S.test2()#通过类名调用静态方法
#方法——类方法
classC():
#类属性
country ="China"
#实例（对象）属性
def__init__(self,name,age):
self.name = name
self.age = age
@classmethod #用classmethod装饰器修饰 表示test3为类方法
deftest3(cls):#cls指的是类
print("test3...",cls.country)#类方法调用类属性
c1 = C("Jack",18)
c1.test3()#通过实例调用类方法
C.test3()#通过类名调用类方法
#运行结果：
test1...
test2...
test2...
test3... China
test3... China
（1）构造方法：构造方法不能重载（被覆盖）
在Python中内置，每一个类都有一个默认的不带参数的构造方法，不需要人为的单独调用，在调用类的同时就运行了构造方法。
构造方法的作用：初始化数据、创建对象（构造方法的调用）
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
classPerson:
def__init__(self):
print("构造方法")
pass
Person()#类的调用--创建对象
#运行结果
构造方法
带参数的构造方法：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
classPerson:
# def __init__(self):
# print("构造方法")
def__init__(self,x):
print("带参数的构造方法:",x)
defadd(self,x,y):
print(x+y)
pass
zs = Person("hello")#类的调用--创建对象
zs.add(1,2)
#运行结果：
带参数的构造方法: hello
3
（2）面向对象的思路
（3）类方法
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
#类方法
classPerson:
defeat(self):#类方法
print("eating...")
pass
a = Person()#类方法调用
a.eat()
#运行结果：
eating...
（4）私有方法
只允许在类的内部使用，专门为类服务的。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
classPerson:
defeat(self):# 类方法
print("eating...")
self.__sleep()# 调用私有方法
def__sleep(self):#私有方法--类的外部不能使用
print("sleeping...")
pass
b = Person()
b.eat()
#运行结果：
eating...
sleeping...
6、属性
示例属性、类属性代码：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
#属性
classa():
def__init__(self,name,age):
self.name = name#实例属性
self.age = age
#类内部使用实例属性 self.实例属性名
defget(self):
print(self.name)
a1 = a("Jack",18)
#类内部使用实例属性 self.实例属性名
a1.get()
#类外部使用实例属性 对象名.实例属性名
print(a1.name)
#类属性 在__init__()方法外声明
#类内部使用 类名.属性名 调用
#类外部使用通过 类名.属性名 或者 对象名.属性名 方式调用
classb():
name ="Janne"#类属性
#类内部使用类属性——类名.属性名
defget(self):
print(b.name)
#类外部使用类属性 通过 类名.属性名
print(b.name)
#类外部使用类属性 通过 对象名.属性名
b1 = b()
print(b1.name)
#类内部使用类属性——类名.属性名
b1.get()
#运行结果：
Jack
Jack
Janne
Janne
Janne
（1）类属性/类变量：在类的外部可以调用
（2）私有变量/私有属性：只能在类的内部，通过self使用
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
#属性/变量
classPerson:
i =10#类属性/类变量
__j =20#私有属性/私有变量
defeat(self):# 类方法
print("eating...")
print(self.__j)# 调用私有变量
pass
b = Person()
print(b.i)#通过引用调用（建议）
print(Person.i)#可通过类名调用
b.eat()
#运行结果：
10
10
eating...
20
classGirlFriend():
#声明对象属性 通过构造方法
def__init__(self,name,age,phone,pwd):
#给对象的属性（变量名）前面加上 __ 成为了私有的属性
self.__name = name
self.__age = age
self.__phone = phone
self.__pwd = pwd
#通过预留的接口 对私有属性名进行访问或修改
defgetInfo(self,pwd):
ifpwd =="1234":
print("My girlfriend is %s,and she's %d years old,Her telephone number is %d"%(self.__name,self.__age,self.__phone))
else:
print("you failed...")
defsetName(self,name):
self.__name = name#类内修改私有属性
gf = GirlFriend("Janne",18,13511112222,"1234")
gf.setName("Malianna")
gf.getInfo("1234")
#运行结果：
My girlfriendisMalianna,andshe's 18 years old,Her telephone number is 13511112222
（3）特殊的类属性
7、继承
Python中支持多继承，作用：复用，不建议使用多继承（类对象爆炸）、
继承示例代码：
#继承
#父类
classAnimal():
def__init__(self,name,food,drinks):
self.name = name
self.food = food
self.drinks = drinks
defeat(self):
print("%s 爱吃 %s"%(self.name,self.food))
defdrink(self):
print("%s 爱喝 %s"%(self.name,self.drinks))
#子类
classDog(Animal):
defsound(self):
print("wonf wonf...")
classCat(Animal):
defsound(self):
print("miao miao...")
dogs = Dog("哮天犬","骨头","雪碧")
dogs.eat()
dogs.drink()
dogs.sound()
print("========================")
cats = Cat("波斯猫","鱼","可乐")
cats.eat()
cats.drink()
cats.sound()
#运行结果：
哮天犬 爱吃 骨头
哮天犬 爱喝 雪碧
wonf wonf...
========================
波斯猫 爱吃 鱼
波斯猫 爱喝 可乐
miao miao...
示例一：
多继承
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
#多继承
classRun3000:
defrun(self):
print("run 3000")
classJump3:
defjump(self):
print("jump 3")
classSport(Run3000,Jump3):#继承
pass
sport = Sport()
sport.run()
sport.jump()
#运行结果：
run3000
jump3
示例二：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
classFather:
def__init__(self):
print("father 构造")
defteach(self):
print("father teaching")
classChild(Father):
pass
zs = Child()#子类继承与父类，创建子类前先创建父类
zs.teach()
#运行结果：
father 构造
father teaching
子类中重写父类的方法：重写体现多态
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
classFather:
def__init__(self):
print("father 构造")
defteach(self):
print("father teaching")
classChild(Father):
defteach(self):#方法重写
print("child teaching")
zs = Child()#子类继承与父类，创建子类前先创建父类
zs.teach()
#运行结果：
father 构造
child teaching
新式类：
如果父类的构造方法带参数，则需要子类通过super操作去完成调用。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
#新式类
classFather(object):
def__init__(self,i):
print("father 构造"+ i)
defteach(self):
print("father teaching")
classChild(Father):
def__init__(self):
super(Child,self).__init__("hello")
defteach(self):#方法重写
print("child teaching")
zs = Child()#子类继承与父类，创建子类前先创建父类
zs.teach()
#运行结果：
father 构造hello
child teaching
多继承又不完全，父类都有构造方法时，当子类多继承时，只有一个父类的构造方法被调用。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu
classRun3000:
def__init__(self):
print("run 3000 构造方法")
defrun(self):
print("run 3000")
classJump3:
def__init__(self):
print("jump 3 构造方法")
defjump(self):
print("jump 3")
classSport(Run3000,Jump3):#继承
pass
sport = Sport()
sport.run()
sport.jump()
#运行结果：
run3000构造方法
run3000
jump3
8、面向对象编程
（1）定义
（2）示例代码——人开车