day7 面向对象进阶

面向对象高级语法部分

通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法。

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0
    def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @staticmethod
    def talk():
        print("I like to study python")

class Teacher(SchoolMember):
    def __init__(self,name,age,sex,course,salary):
        super(Teacher,self).__init__(name,age,sex)
        self.course = course
        self.salary = salary

    def Teaching(self):
        print("Teacher %s is teaching %s." %(self.name,self.course))

s1 = Teacher("alex",22,"Femal","python",10000)

print("before:",s1.member_nums)
SchoolMember.member_nums = 12
print("before:",s1.member_nums)

s1.member_nums = 666     #是在类中重新生成一个变量

print("after:",s1.member_nums)
SchoolMember.member_nums = 12
print("after:",s1.member_nums)

在上面代码中，member_nums是类变量，如果直接调用s1.member_nums的话，调用的是类里面的值；如果s1.member_nums = 666，等于在实例里面增加了一个新的变量，这个时候，修改类的值的时候，是不会影响实例里面变量的值的。上面代码的输出结果如下：

before: 0
　　before: 12
　　after: 666
　　after: 666

类的静态方法@staticmethon:

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0
    def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %SchoolMember.member_nums)

    @staticmethod
    def walk(self):
        print("%s is walking......" %self.name)

#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.walk()运行结果如下：Traceback (most recent call last):  File "/home/zhuzhu/day7/staticmethon方法.py", line 22, in <module>    s1.walk()TypeError: walk() missing 1 required positional argument: ‘self‘

上面代码中，如果没有@staticmethon的话，代码执行肯定没有问题，但是当有了@staticmethod的时候，系统提示少了一个参数。如果我们把一个方法变成了一个静态方法，那么这个方法与实例就没有太大的关系了。

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0
    def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %SchoolMember.member_nums)

    @staticmethod        #让方法在类中剥离，与类没有关系，调用要传递参数
    def walk(self):
        print("%s is walking......" %self)

#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.walk("alex")

@staticmethod静态方法是让类中的方法与类没有关联，调用的时候要传递参数才能调用。

    类方法

类方法通过@classmethod装饰器实现，类方法和普通方法的区别是， 类方法只能访问类变量，不能访问实例变量

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0
    def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    #@classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %self.name)

SchoolMember.member_nums
#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.talk()

上面代码中，（1）类是不能直接访问实例里面的属性的；（2）@classmethod的作用是让程序只能访问类中的变量，比如上面代码中的SchoolMember.member_nums，这个是类的方法，我们可以在talk中进行访问，但是不能访问self.name，因为@classmethod只能访问类属性。

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0
    def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %self.name)

SchoolMember.member_nums
#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.talk()

运行结果如下：
Traceback (most recent call last):
  File "/home/zhuzhu/day7/staticmethon方法.py", line 18, in <module>
    s1.talk()
  File "/home/zhuzhu/day7/staticmethon方法.py", line 13, in talk
    print("%s like to study python"  %self.name)
AttributeError: type object ‘SchoolMember‘ has no attribute ‘name‘

从上面可以看出，上面的代码@classmethon禁止了类中的实例变量，只能使用类变量。即不能使用self.name、self.age和self.sex，只能使用self.nember_nums和SchoolMember.member_nums类的变量。如下：

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0
    def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %SchoolMember.member_nums)

SchoolMember.member_nums
#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.talk()

运行结果如下：
0 like to study python

    属性方法

属性方法的作用就是通过@property把一个方法变成一个静态属性

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0
    def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %SchoolMember.member_nums)

    @property     #把类的方法变成一个属性，调用要使用s1.walk不加括号直接调用，称为一个属性
    def walk(self):
        print("%s is walking......" %self.name)

#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.walk()运行结果如下：Traceback (most recent call last):  File "/home/zhuzhu/day7/staticmethon方法.py", line 22, in <module>    s1.walk()TypeError: ‘NoneType‘ object is not callable

如果不添加@property的话，程序是能够正常运行的，但是添加了@property之后，程序运行出现错误，是什么原因呢？因为@property是将类的方法变成了类的属性，调用的时候我们只需执行s1.walk()无需添加括号即可执行，如下：

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0
    def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %SchoolMember.member_nums)

    @property     #把类的方法变成一个属性，调用要使用s1.walk不加括号直接调用，称为一个属性
    def walk(self):
        print("%s is walking......" %self.name)

#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.walk运行结果如下：Alex is walking......

上面代码中，@property是将类的方法变成了成员的属性，我们可以直接使用s1.walk即可调用。

时间： 2024-10-25 21:52:37

day7 面向对象进阶的相关文章

day7面向对象--进阶

静态方法(@staticmethod)     通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里可以通过self.调用实例变量或类变量,但静态方法是不可以访问实例变量或类变量的,一个不能访问实例变量和类变量的方法,其实相当于跟类本身已经没什么关系了,它与类唯一的关联就是需要通过类名来调用这个方法. class Dog(object): def __init__(self,name): self

Python之路，Day7 - 面向对象编程进阶

本节内容 面向对象高级语法部分 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业开发一个支持多用户在线的FTP程序 面向对象高级语法部分 静态方法 通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法什么是静态方法呢其实不难理解普通的方法可以在实例化后直接调用并且在方法里可以通过self.调用实例变量或类变量但静态方法是不可以访问实例变量或类变量的一个不能访问实例变量和类变量的方法其实相当于跟类本身已经没什么关系了它与类唯一的关联就是需要通过

Python【day7】：Python学习(面向对象进阶、反射、socket介绍）

面向对象进阶 1.类变量和实例变量 # 一.变量 # 变量包括:实例变量和类变量, # 他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同, # 实例变量属于对象 # 类变量属于类 class Province(object): country = "中国" #类变量 def __init__(self, name): self.name = name # 实例变量 # 直接访问实例变量(实例名来调用) obj = Province('河北省') print(obj.na

Python基础-面向对象进阶

面向对象进阶 一 类中的装饰器方法  classmethod staticmethod property 1.1 property 一般情况下,方法都是动词.指某一类事物的动作 在计算圆形的周长和面积的时候,他们应该是圆形的属性,但是这里确是一个方法.这不符合python面向对象(能够完全区分属性和方法)的理念. 所以我们可以用一个装饰器去将一个属性性质的函数,装饰成一个属性.可以以调用属性的方式去调用他. from math import pi class Circle: def __init

Python之路【第八篇】：Python基础（24）——面向对象进阶

参考连接: Python 面向对象(初级篇) http://www.cnblogs.com/wupeiqi/p/4493506.html python 面向对象(进阶篇) http://www.cnblogs.com/wupeiqi/p/4493506.html python 面向对象及相关 http://www.cnblogs.com/wupeiqi/articles/5017742.html 面向对象进阶: 类成员之字段.方法.属性: 类成员修饰符: 类成员之特殊成员 1.类方法 普通的方法

2Python全栈之路系列之面向对象进阶及类成员

Python全栈之路系列之面向对象进阶及类成员 再次了解多继承 先来一段代码 #!/usr/bin/env python # _*_ coding:utf-8 _*_ class A:     def bar(self):         print("BAR")         self.f1()          class B(A):     def f1(self):         print("B")          class C:     def 

Python-Day7 面向对象进阶/异常处理/Socket

一.面向对象高级语法部分 1.静态方法     通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里可以通过self.调用实例变量或类变量,但静态方法是不可以访问实例变量或类变量的,一个不能访问实例变量和类变量的方法,其实相当于跟类本身已经没什么关系了,它与类唯一的关联就是需要通过类名来调用这个方法. class Dog(object): def __init__(self,name): self

Python面向对象进阶和socket网络编程-day08

写在前面 上课第八天,打卡: 为什么坚持?想一想当初: 一.面向对象进阶 - 1.反射补充 - 通过字符串去操作一个对象的属性,称之为反射: - 示例1: class Chinese: def __init__(self,name): self.name=name p = Chinese('standby') # 实例化一个对象 print(p) # 打印这个对象 --- <__main__.Chinese object at 0x0000000000B3A978> - 示例2: >&g

python面向对象进阶版

面向对象基础知识: 1.面向对象是一种编程方式,此编程方式的实现是基于对类和对象的使用: 2.类是一个模板,模板中包装了多个'函数'供使用(可以将多函数中公用的变量封装到对象中): 3.对象,根据模板创建的实例(即:对象),实例用于被包装在类中的函数: 4.面向对象三大特性:封装.继承和多态. 面向对象进阶篇详细介绍python类的成员.成员修饰符和类的特殊成员. 类的成员 类的成员可以分为三大类:字段.方法和属性 注:所有成员中,只有普通字段的内容保存对象中,即:根据此类创建了多少对象,在内存