您将如何确定Python类的每个属性和方法的定义位置？（python确定数据类型）

25-02-16 17

想了解您将如何确定Python类的每个属性和方法的定义位置？的新动态吗？本文将为您提供详细的信息，我们还将为您解答关于python确定数据类型的相关问题，此外，我们还将为您介绍关于13_Python类

想了解您将如何确定Python类的每个属性和方法的定义位置？的新动态吗？本文将为您提供详细的信息，我们还将为您解答关于python确定数据类型的相关问题，此外，我们还将为您介绍关于13_Python 类的属性和方法、Python 复数属性和方法操作实例、Python 多线程常用属性和方法、python3面向对象（3）私有属性和方法以及访问私有属性和方法的方式的新知识。

本文目录一览：

您将如何确定Python类的每个属性和方法的定义位置？（python确定数据类型）
13_Python 类的属性和方法
Python 复数属性和方法操作实例
Python 多线程常用属性和方法
python3面向对象（3）私有属性和方法以及访问私有属性和方法的方式

您将如何确定Python类的每个属性和方法的定义位置？（python确定数据类型）

给定Python中某个类的实例，能够确定源代码的哪一行 _定义了_每个方法和属性将很有用。例如，给定一个模块ab.py

class A(object):
    z = 1
    q = 2
    def y(self): pass
    def x(self): pass

class B(A):
    q = 4
    def x(self): pass
    def w(self): pass

定义一个函数whither（class_，attribute），该函数返回一个元组，该元组包含源代码中定义或子类化的文件名，类和行attribute。这意味着在班级主体中进行定义，而不是由于过度的动态性而导致的最新任务。如果它为某些属性返回“未知”，那就很好。

>>> a = A()
>>> b = B()
>>> b.spigot = 'brass'
>>> whither(a,'z')
("ab.py",<class 'a.A'>,[line] 2)
>>> whither(b,'q')
("ab.py",<class 'a.B'>,8)
>>> whither(b,'x')
("ab.py",9)
>>> whither(b,'spigot')
("Attribute 'spigot' is a data attribute")

我想在对Plone进行内省时使用它，其中每个对象都有数百种方法，对按类而不是按字母顺序组织的方法进行排序将非常有用。

当然，在Python中您可能永远无法合理地知道，但是在大多数为静态代码的常见情况下，获得良好答案将是很好的。

13_Python 类的属性和方法

Python 类

类的定义
- 类的方法至少有一个参数self

class MyClass(object):
    def fun(self):
	    print ''类的方法''

类的实例化 --> 创建对象

obj = MyClass

类的属性
- 公有属性：类内外都能调用的属性
- 私有属性：不能在类外以及被类以外的函数调用，私有属性定义方法：以双下划线开始的成员变量就是私有属性
- 内置属性：系统在定义类的时候默认添加的，由前后双下划线构成，
  - dict:类的属性（包含一个字典，由类的数据属性组成）
  - doc:类的文档字符串
  - name:类名
  - module:类定义所在的模块
类的方法：类的方法定义跟函数的定义一样，但是需要self作为第一个参数
- 公有方法：在类中类外都能调用的方法
- 私有方法：不能被类的外部调用，私有方法定义：方法前面加上双下划线，

类方法：被classmethod()函数处理过，才能被类所调用

	In [8]: class Testing(object):
	...:     def test(self):
	...:         print(''hello test'')
	...:     def test2(self):
	...:         print(''hello test2'')
	...:     pt = classmethod(test)
	...:     

	In [9]: Testing.pt()
	hello test

	In [10]: Testing.test()         ##是不能直接通过类调用类方法的，
	-------------------------------------------------------------------
	TypeError                         Traceback (most recent call last)
	<ipython-input-10-372b771144d0> in <module>()
	----> 1 Testing.test()

	TypeError: unbound method test() must be called with Testing 
	instance as first argument (got nothing instead)

	In [11]: Testing.test2()
	-------------------------------------------------------------------
	TypeError                        Traceback (most recent call last)
	<ipython-input-11-f17045d44574> in <module>()
	----> 1 Testing.test2()

	TypeError: unbound method test2() must be called with Testing 
	instance as first argument (got nothing instead)

静态方法：相当于“全局函数”，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义，静态方法没有“self”参数。

Python 复数属性和方法操作实例

复数是由一个实数和一个虚数组合构成，表示为：x+yj

一个复数时一对有序浮点数 (x,y)，其中 x 是实数部分，y 是虚数部分。

Python 语言中有关复数的概念：

1、虚数不能单独存在，它们总是和一个值为 0.0 的实数部分一起构成一个复数

2、复数由实数部分和虚数部分构成

3、表示虚数的语法：real+imagej

4、实数部分和虚数部分都是浮点数

5、虚数部分必须有后缀j或J

示例代码：

#coding=utf8

aa=123-12j
print aa.real  # output 实数部分 123.0  
print aa.imag  # output虚数部分 -12.0

复数的内建属性：

复数对象拥有数据属性，分别为该复数的实部和虚部。
复数还拥有 conjugate 方法，调用它可以返回该复数的共轭复数对象。
复数属性：real(复数的实部)、imag(复数的虚部)、conjugate()（返回复数的共轭复数）

示例代码：

#coding=utf8

class Complex(object):
    '''创建一个静态属性用来记录类版本号'''
    version=1.0
    '''创建个复数类，用于操作和初始化复数'''
    def __init__(self,rel=15,img=15j):
        self.realPart=rel
        self.imagPart=img
       
    #创建复数
    def creatComplex(self):
        return self.realPart+self.imagPart
    #获取输入数字部分的虚部
    def getImg(self):
        #把虚部转换成字符串
        img=str(self.imagPart)
        #对字符串进行切片操作获取数字部分
        img=img[:-1] 
        return float(img)  
                       
def test():
    print "run test..........."
    com=Complex()
    Cplex= com.creatComplex()
    if Cplex.imag==com.getImg():
        print com.getImg()
    else:
        pass
    if Cplex.real==com.realPart:
        print com.realPart
    else:
        pass
    #原复数
    print "the religion complex is :",Cplex
    #求取共轭复数
    print "the conjugate complex is :",Cplex.conjugate()
    
if __name__=="__main__":
    test()

参考：https://www.runoob.com/w3cnote/python-complex-intro.html

Python 多线程常用属性和方法

多线程导入模块：

from threading import Thread 或 import threading
注意：一般使用高级线程模块，threading 而不用 Thread 模块，threading 模块中包含 Thread 类

Thread模块：低级模块，不推荐使用，不支持守护线程（daemon）概念

threading模块：高级模块，推荐使用，已对 Thread类进行封装，支持daemon

Threading 模块属性和方法：

from threading import Thread                #导入Threading 高级模块中的 Thread 类
def foo(arg,v):                             #定义1个执行函数
    print(arg,v)                         
t1=Thread(target=foo,args=(''ddd'',1,))       #创建1个 Thread 线程实例
t1.start()                                  #执行这个线程

基本属性：

start() 线程准备就绪，等待CPU调度,准备开始执行
getName()：获取线程名称
setName(''name'') : 为线程设置名称
daemon：守护线程（可理解为新建的子线程为后台线程）

如果你设置一个线程为守护线程（当设置t1.setDaemon(True)时），就表示你在说这个线程是不重要的，在进程退出的时候，不用等待这个线程执行玩完后才退出，即前台进程结束后，后台进程也跟着结束了

isDaemon()
setDaemon()
是否为守护线程 True( 是守护线程，不重要 ) False （不是守护线程）
用法：t1.setDaemon( True 或False )
默认为False ，等前台（主）线程执行完后才执行，且放在 t1.start() 前面才有效

守护线程例子：

from threading import Thread                  #导入Threading 高级模块中的 Thread 类
import time

def foo(arg,v):                              #定义1个执行函数,需要执行10秒
    for i in range(10):
        print(''守护线程开始执行''+str(i)+''秒'')
        time.sleep(1)
print(''主线程（前台线程）开始'')                   #主线程（前台线程）执行1个动作，打印
t1=Thread(target=foo,args=(''ddd'',1,))        #实例化1个子线程
t1.setDaemon(True)                           #设置这个子线程为守护线程（后台线程）
t1.start()                                   #子线程开始工作，执行1个10秒的函数
#print(t1.getName())
print(''主线程执行中'')                           #主线程（前台线程）执行1个动作，打印
print(''线程结束'')                              #主线程（前台线程）执行1个动作，打印
time.sleep(5)                                #主线程一共执行了5秒

输出结果：

主线程（前台线程）开始
守护线程开始执行0秒
主线程执行中
线程结束
守护线程开始执行1秒
守护线程开始执行2秒
守护线程开始执行3秒
守护线程开始执行4秒
守护线程开始执行5秒

如上图所示，前台进程执行5秒后，就退出了，虽然守护线程（后台线程）需要执行10秒，但5秒后，也跟着主线程一起退出了。

python3面向对象（3）私有属性和方法以及访问私有属性和方法的方式

python3中的私有属性和方法是以__两个下划线开头的：

class Woman(object):        #定义一个woman类      
    def __init__(self,name):
        self.name = name    #公有属性
        self.__age = 22　　　#私有属性

    def __money(self):      #私有方法
        print("哈哈哈，我有很多存款")

obj1 = Woman("红红")
obj1.name          #可以直接访问
print(obj1.__age)  #不可以直接访问
obj1.__money　　　　#不可以直接访问

第一种访问：访问私有属性和方法的方式（在类内，普通方法可以访问私有属性和方法，然后再调用普通方法来访问私有的）：

class Woman(object):
    def __init__(self,name):
        self.name = name
        self.__age = 22

    def __money(self):
        print("哈哈哈，我有很多存款")

    def func_age(self):    #定义一个普通方法来访问 私有属性
        print("访问到了你的年龄：%s" % self.__age)

    def func_money(self):   #定义一个普通方法来访问 私有方法
        self.__money()

obj1 = Woman("红红")

obj1.func_age()
obj1.func_money()

第二种访问：访问私有属性和方法的方式（通过_类名__私有（属性或方法））

class Woman(object):
    def __init__(self,name):
        self.name = name
        self.__age = 22

    def __money(self):
        print("哈哈哈，我有很多存款")



obj1 = Woman("红红")
print(obj1._Woman__age)   #通过_Woman__age
obj1._Woman__money()　　　#通过_Woman__money()

关于您将如何确定Python类的每个属性和方法的定义位置？和python确定数据类型的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于13_Python 类的属性和方法、Python 复数属性和方法操作实例、Python 多线程常用属性和方法、python3面向对象（3）私有属性和方法以及访问私有属性和方法的方式等相关知识的信息别忘了在本站进行查找喔。

本文标签：