1.类与对象
1.1对象 = 属性 + 方法
对象是类的实例。换句话说,类主要定义对象的结构,然后我们以类为模板创建对象。类不但包含方法定义,而且还包含所有实例共享的数据。
封装:信息隐蔽技术
我们可以使用关键字 class 定义 Python 类,关键字后面紧跟类的名称、分号和类的实现。
class Turtle:
'''
关于类的一个简单的例子
'''
#属性
color = 'green'
weight = 10
legs = 4
shell = True
mouth = '大嘴'
#方法
def climb(self):
print('我正在很努力的向前爬...')
def run(self):
print('我正在飞快的向前跑')
def eat(self):
print('有的吃,真满足。。。')
def sleep(self):
print('困了,睡了,晚安,zzz')
a = Turtle()
print(a)
#<__main__.Turtle object at 0x0000021CA4759EE0>
print(type(a))
#<class '__main__.Turtle'>
print(a.__class__)
#<class '__main__.Turtle'>
print(a.__class__.__name__)
#Turtle
a.climb()
#我正在很努力的向前爬...
a.run()
#我正在飞快的向前跑
类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称(对应于该实例,即该对象本身),按照惯例它的名称是 self。在调用方法时,我们无需明确提供与参数 self 相对应的参数。
class Ball:
def setName(self,name,age):
self.name = name
self.age = age
def kick(self):
print("我叫{0},今年{1}".format("alise",10))
a = Ball()
a.kick()
我叫alise,今年10
1.2 Python 的魔法方法
类有一个名为__init__(self[, param1, param2…])的魔法方法,该方法在类实例化时会自动调用。
类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称(对应于该实例,即该对象本身),按照惯例它的名称是 self。在调用方法时,我们无需明确提供与参数 self 相对应的参数。
class Ball:
def __init__(self,name,age):
self.name = name
self.age = age
def kick(self):
print("我叫%s,今年%d岁"%(self.name,self.age))
a = Ball("Alise",10)
a.kick()
我叫Alise,今年10岁
class JustCounter:
__secretCount = 0
publicCount = 0
def count(self):
self.__secretCount +=1
self.publicCount += 1
print(self.__secretCount)
counter = JustCounter()
counter.count() #1
counter.count() #2
print(counter.publicCount) #2
print(counter._JustCounter__secretCount) #2 Python的私有为伪私有
print(counter.__secretCount)
#AttributeError: 'JustCounter' object has no attribute '__secretCount'
1
2
2
2
1.3 公有和私有
class Site:
def __init__(self,name,url):
self.name = name
self.__url = url
def who(self):
print(self.name)
print(self.__url)
def __foo(self):
print("这是私有方法")
def foo(self):
print('这是公共方法')
self.__foo()
x = Site('alise','123456')
x.who()
# alise
# 123456
x.foo()
# 这是公共方法
# 这是私有方法
x.__foo
#AttributeError: 'Site' object has no attribute '__foo'
1.4 继承
class DerivedClassName(BaseClassName):
<statement-1>
.
.
.
<statement-N>
需要注意圆括号中父类的顺序,若是父类中有相同的方法名,而在子类使用时未指定,Python 从左至右搜索,即方法在子类中未找到时,从左到右查找父类中是否包含方法。
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("我叫%s :我%d岁"%(self.name,self.age))
#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构造
people.__init__(self,n,a,w)
self.grade = g
def speak(self):
print("我叫%s,今年%d岁了,我在读%d年级"%(self.name,self.age,self.grade))
s = student('alise',18,6,3)
s.speak()
#我叫alise,今年18岁了,我在读3年级
我叫alise,今年18岁了,我在读3年级
1.5 类、类对象和实例对象(概念)
对象:创建一个类,其实也是一个对象也在内存开辟了一块空间,称为类对象,类对象只有一个。
#类对象
class A(object):
pass
类对象:就是通过实例化类创建的对象,称为实例对象,实例对象可以有多个。
#实例化对象a,b,c都属于实例对象。
a = A()
b = A()
c = A()
类属性:类里面方法外面定义的变量称为类属性。类属性所属于类对象并且多个实例对象之间共享同一个类属性,说白了就是类属性所有的通过该类实例化的对象都能共享。
class A():
a = xx #类属性
def __init__(self):
A.a = xx #使用类属性可以通过(类名,类属性)调用
实例属性:实例属性和具体的某个实例对象有关系,并且一个实例对象和另外一个实例对象是不共享属性的,说白了实例属性只能在自己的对象里面使用,其他的对象不能直接使用,因为self是谁调用,它的值就属于该对象。
class 类名():
__init__(self):
self.name = xx #实例属性
类属性和实例属性区别
类属性:类外面,可以通过实例对象.类属性和类名.类属性进行调用。类里面,通过self.类属性和类名.类属性进行调用。
实例属性 :类外面,可以通过实例对象.实例属性调用。类里面,通过self.实例属性调用。
实例属性就相当于局部变量。出了这个类或者这个类的实例对象,就没有作用了。
类属性就相当于类里面的全局变量,可以和这个类的所有实例对象共享。
#创建类对象
class Test(object):
class_attr = 100 #类属性
def __init__(self):
self.sl_attr = 100 #实例属性
def func(self):
print('类对象.属性值:',Test.class_attr) #调用类属性
print('self.类属性的值',self.class_attr) #相当于把类属性变成实例属性
print('self.实例属性的值',self.sl_attr) #调用实例属性
a = Test()
a.func()
# 类对象.属性值: 100
# self.类属性的值 100
# self.实例属性的值 100
b = Test()
b.func()
# 类对象.属性值: 100
# self.类属性的值 100
# self.实例属性的值 100
a.class_attr = 200
a.sl_attr = 200
a.func()
# 类对象.属性值: 100
# self.类属性的值 200
# self.实例属性的值 200
b.func()
# 类对象.属性值: 100
# self.类属性的值 100
# self.实例属性的值 100
Test.class_attr = 300
a.func()
# 类对象.属性值: 300
# self.类属性的值 200
# self.实例属性的值 200
b.func()
# 类对象.属性值: 300
# self.类属性的值 300
# self.实例属性的值 100
注意:属性与方法名相同,属性会覆盖方法。
转载于:https://lsgogroup.blog.csdn.net/article/details/102292580