Python 入门 之 类成员

Stella981
• 阅读 631

Python 入门 之 类成员

1、类的私有成员:

私有: 只能自己拥有

以 __ 开头就是私有内容

对于每一个类的成员而言都有两种形式:

- 公有成员,在任何地方都能访问
- 私有成员,只有在类的内部才能使用

私有成员和公有成员的访问限制不同:
    静态字段(静态属性)
        - 公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
        - 私有静态字段:仅类内部可以访问;


class Human:

    live = "有思想"        # 类公有的属性
    __desires = "有欲望"   # (程序级别)类私有的属性
    _desires = "有欲望"    # (程序员之间约定俗成)类私有的属性

    def __init__(self,name,age,sex,hobby):
        self.name = name
        self.age = age
        self.sex = sex        # 对象的公有属性
        self.__hobby = hobby  # 对象的私有属性

    def func(self):
        # 类内部可以查看对象的私有属性
        print(self.__hobby)

    def foo(self):            # 公有方法
        # 类内部可以查看类的私有属性
        print(self.__desires)

    def __abc(self):          # 私有方法
        print("is abc")

class B(Human):
    pass
    
    def run(self):
        print(self.__desires)
        self._Human__abc()    # 强制继承(非常不推荐使用)

b = B("天魔",28,"男","女孩子")
print(b.__desires)
b.run()
b._Human__abc()         # _类名私有的属性和方法
                        # 子类不能继承父类中私有的方法和属性

# 类的外部查看
print(Human.live)
print(Human._desires)

 # 保证数据的安全性
Human.live = "无脑"
print(Human.live)

​ 为什么可以通过.类__私有成员名访问呢?因为类在创建时,如果遇到了私有成员(包括私有静态字段,私有普通字段,私有方法)它会将其保存在内存时自动在前面加上类名.

2、类的其他成员

(1)类方法:

class A:

    def func(self):         #实例方法
        print("is A func")

a = A()  # 实例化 一个对象(实例)
A.func()  # 添加参数
a.func()


class A:

    def func(self):             #实例方法
        print("is A func")

import time
class Times:

    t = time.time()   # 类属性

    @classmethod    
    def func(cls):
        print(cls)   # 类的地址
        print("is A func")
        object = cls()    # 使用类方法可以获取到类地址进行实例化
        cls.t = 1010101

a = A()
a.func()

Times.func()
print(Times.t)


class Human:
    count = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def add_count(cls):
        cls.count += 1       # 可以通过类名修改类属性

    @classmethod
    def get(cls):
        return cls.count

Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
print(Human.get())     # 输出实例化的次数

<1> 类方法的作用:

类方法可以自动变换类名(最大的作用)
1> 使用类方法可以获取到类地址进行实例化
2> 可以通过类名修改类属性

类方法偶然会使用,使用最多的还是实例化方法

(2)静态方法(使用更少)

class A:

    def func(self):        # 实例方法
        print("is A func")

    @classmethod
    def cls_func(cls):     # 类方法
        print("is A cls_func")

    @staticmethod
    def static_func():      # 静态方法
        print("他就是普通的函数了")
        
def static_func():
    print("他就是普通的函数了")

A.static_func()
a = A()
a.static_func()

<1> 静态方法不依赖于对象和类(静态方法就是一个普通的函数)

2、属性 :组合(伪装)

class A:

    live = "有思想"

    def func(self):
        print("is A func")

A.live
A.func()


class A:

    @property 
    def func(self):
        print("is A func")

a = A()
a.func


class Bmi:

    live = "有思想"

    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

    @property
    def bmi(self):
        return self.weight / self.height ** 2

    @bmi.setter            # 设置属性时执行
    def bmi(self,value):
        print(value)
        print("设置属性时执行我")

    @bmi.getter            # 查看属性时执行
    def bmi(self):
        print("查看属性时执行我")

    @bmi.deleter           # 删除属性时执行
    def bmi(self):
        print("删除属性时执行我")

rimo = Bmi(1.8,100)
print(rimo.live) # 真属性

rimo.live = "无脑"
del Bmi.live
print(rimo.live)
print(rimo.bmi)
print(Bmi.__dict__)

rimo.bmi = 20    # 伪装成属性进行设置
print(rimo.bmi)  # 伪装成属性
del rimo.bmi



class Foo:

    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')

    AAA = property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA = 'aaa'
del f1.AAA

3、元类

(1)type 查看数据类型(能够查看出当前内容从属于那个类)

print(type("alex"))
print(type([1,2,3,4]))
print(type((1,2,3,40)))



class A:
    pass

a = A()

print(type(a))



print(type(A))
print(type(str))
print(type(list))
print(type(tuple))
print(type(object))
python自带的str、list、tuple也是某一个类的对象(python中一切皆对象)

(2)isinstance 判断参数1是不是参数2的对象

print(isinstance([1,2,3],list))
print(isinstance(str,type))
print(isinstance(list,type))
print(isinstance(object,type))

(3)issubclass 判断参数1是不是参数2的子类

class A:
    pass

class B(A):
    pass

print(issubclass(B,A))

4、元类 -- 构建类

(1)object 与 type的关系

<1> object是type的对象
<2> 新式类都默认继承object
print(issubclass(type,object))  # type是object的子类
print(isinstance(object,type))  # object是type的对象
点赞
收藏
评论区
推荐文章
Wesley13 Wesley13
3年前
java中一些常考知识
一、static的作用 static是修饰符,用于修饰成员变量(静态变量/类变量)。static修饰的成员被所有对象共享。static优先于对象存在。static修饰的成员可以用类名.静态成员来访问。注:1.静态方法只能访问静态成员,非静态方法既能访问静态成员又可以访问非静态成员。2.静态方法中不可
Wesley13 Wesley13
3年前
java语言与jvm虚拟机简介
一、java语言  1.1支持面向对象编程oop    强调支持,因为java同样可以面向过程编程,但java是为oop而生的。    oop的三大特性是:封装、继承、多态。    封装主要针对成员变量而言,oop的思想要求成员变量均为私有,不应该对外能够访问,一个符合oop思想的类应该只有公共方
Wesley13 Wesley13
3年前
java第四次上机作业
编写“电费管理类”及其测试类。第一步编写“电费管理”类私有属性:上月电表读数、本月电表读数构造方法:无参、2个参数成员方法:getXXX()方法、setXXX()方法成员方法:显示上月、本月电表读数第二步编写测试类创建对象一:上月电表读数为1000,本月
Wesley13 Wesley13
3年前
java作用域public ,private ,protected 及不写时的区别
在说明这四个关键字之前,我想就class之间的关系做一个简单的定义,对于继承自己的class,baseclass可以认为他们都是自己的子女,而对于和自己一个目录下的classes,认为都是自己的朋友。1、public:public表明该数据成员、成员函数是对所有用户开放的,所有用户都可以直接进行调用2、private:private表示私有,私有的
Stella981 Stella981
3年前
Lua基础(对象)
:和.区别.   stu{id100,name"Tom",age21}成员变量   function stu.toString()成员函数    return stu.id .. stu.name .. stu.age   endprint(stu
Stella981 Stella981
3年前
JavaScript中的私有成员
JavaScript(https://www.oschina.net/action/GoToLink?urlhttp%3A%2F%2Fwww.yaohaixiao.com%2Fcategory%2Ffrontend%2Fjavascript%2F)是世界上最被误解的语言。很多人认为它缺乏信息隐藏的特性所以对象不能有私有实例变量和方法。但这是一个误解。
Wesley13 Wesley13
3年前
C++中类中范围解析运算符::和点运算符(.)
C 类成员函数类的成员函数是指那些把定义和原型写在类定义内部的函数,就像类定义中的其他变量一样。类成员函数是类的一个成员,它可以操作类的任意对象,可以访问对象中的所有成员。让我们看看定义的类Box,现在我们要使用成员函数来访问类的成员,而不是直接访问这些类的成员:classBox{public:double
Stella981 Stella981
3年前
Python的类成员和对象成员
Python中有个类成员的概念,绝对是困扰新手的问题。看看下面的代码就知道两者的区别了。!/usr/bin/pythoncoding:utf8importtimefromdatetimeimportdatetimeclassWorker:
Wesley13 Wesley13
3年前
Java中的权限修饰符
Java中修饰符总结:1.访问控制修饰符 作用:用于控制被修饰变量、方法、类的可见范围. public的访问级别是最高的,其次是protected、默认和private. 成员变量和成员方法可以处于4个访问级别中的一个:公开、受保护、默认或私有. 
小万哥 小万哥
6个月前
C++ 访问说明符详解:封装数据,控制访问,提升安全性
C访问说明符访问说明符是C中控制类成员(属性和方法)可访问性的关键字。它们用于封装类数据并保护其免受意外修改或滥用。三种访问说明符:public:允许从类外部的任何地方访问成员。private:仅允许在类内部访问成员。protected:允许在类内