python 类与对象

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