Python--oop面向对象的学习1

类和对象的成员分析

·类和对象都可以存储成员，成员可以归类为所有,也可以归对象所有

·类存储成员时使用的是与类关联的一个对象

·独享存储成员时存储在当前对象中

·对象访问一个成员，如果对象中没有该成员，尝试访问类中的同名成员

　　　如果对象中有此成员，一定使用该对象中的成员

·创建对象的时候，类中的成员不会自动放到对象当中，而是得到一个空的对象，没有成员

·通过对象对类中成员重新赋值或者通过对象添加成员，对应成员会被保存在对象中，而不会修改类成员 

class student():
    name = "claire"
    age = 18
    def say(self):
        self.name = "lala"
        self.age = 25
print(student.name)
print(student.age)
print(id(student.name))
print(id(student.age))
print("*"*20)
A = student()
print(student.__dict__)
print(A.__dict__)
A.name = "tony"
A.age = 20
print(A.name)
print(A.age)
print("*"*20)
print(id(A.name))
print(id(A.age))

claire
18
2633264420040
140709556217008
********************
{'__module__': '__main__', 'name': 'claire', 'age': 18, 'say': <function student.say at 0x000002651AF2BC80>, '__dict__': <attribute '__dict__' of 'student' objects>, '__weakref__': <attribute '__weakref__' of 'student' objects>, '__doc__': None}
{}
tony
20
********************
2633267041312
140709556217072

关于self

·self在对象的方法中表示当前对象本身，但是如果通过对象调用一个方法，那么该对象会自动传入到当前的第一个参数当中

·self并不是一个关键字，只是一个接受对象的普通参数，理论上用任何一个普通变量代替

·方法中有self形参的方法非绑定的方法，可以通过对象访问，没有self的是绑定类的方法，只能通过类访问

`使用类访问绑定类的方法时，如果类方法中需要当前类的成员，可以通过__class__来实现。--如下面的第三个脚本

 

class student():
    name = "claire"  
    age = 18
    def say(self):    
        self.name = "lala"  #对象的name
        self.age = 25    #对象的name
        print("my name is {0}".format(self.name))
        print("my age is {0}".format(self.age))
dandan = student()
dandan.say()

?

1 2	my name is lala my age is 25

class student():
    name = "claire"
    age = 18
    def say(self):
        self.name = "lala"
        self.age = 25
        print("my name is {0}".format(self.name))
        print("my age is {0}".format(self.age))
    def sayagain():
        print("hello,nice to see you again")
dandan=student()
dandan.say()
#dandan.sayagain()  会报TypeError: sayagain() takes 0 positional arguments but 1 was given
student.sayagain() #调用绑定类函数使用类名

my name is lala
my age is 25
hello,nice to see you again

class student():
    name = "claire"
    age = 18
    def say(self):
        self.name = "lala"
        self.age = 25
        print("my name is {0}".format(self.name))
        print("my age is {0}".format(self.age))
        print("lei's age is {0}.".format(__class__.age))
    def sayagain():
        print(__class__.name)
        print(__class__.age)
        print("hello,nice to see you again")
dandan=student()
dandan.say()
student.sayagain()

my name is lala
my age is 25
lei's age is 18.
claire
18
hello,nice to see you again

class A():
    name="haha"
    age=18
    def __init__(self):
        self.name ="dandan"
        self.age = 20
    def say(self):
        print(self.name)
        print(self.age)
class B():
    name = "bbb"
    age = 90
a = A()    #此时，系统会默认把a作为第一个参数传入函数
a.say()
A.say(a)    #此时self被a代替
A.say(A)    #此时可以把A作为参数，直接调用了类
17 A.say(B)　　#此时传入的是类实例B,因为B具有name 和age属性，所以不会报错

dandan
20
dandan
20
haha
18
bbb
90