---

---

Python3中类的高级语法及实战

Python3(基础|高级)语法实战(|多线程|多进程|线程池|进程池技术)|多线程安全问题解决方案

---

---

一:  类定义语法 

通过下面的实例,你将会了解到如下的内容体系：

(1)类静态属性

(2)类动态属性

(3)类初始化过程: __init__(self)被执行，相当于java中的构造函数

(4)类变量与实例变量

(5)怎样限制某个类无限添加动态属性

# -*- coding:utf8 -*-
class ClassCreate:
    """A simple example class"""
    # 类的静态属性i
    i = 1234

    @staticmethod
    def functionMethod(self):
        return "I Love You !"


print(
    """
    【面向对象OOP编程是一种编程思想：
    Python中使用关键字class来创建一个类,class之后紧根类名,并与冒号结尾】
    """)

print("调用类的静态方法：", "使用类名.静态方法(类的实例化对象)")

myClass = ClassCreate()
print(ClassCreate.functionMethod(myClass))
print()
print("类的成员变量为所有对象实例共享:[静态属性] ", myClass.i)

print(
    """
    调用类的内置属性: __name__,__doc__,__module__,__base__,__dict__
    """
)
print("打印类的内置属性: ")
print(ClassCreate.__class__)
print(ClassCreate.__name__)
print(ClassCreate.__doc__)
print(ClassCreate.__base__)
print(ClassCreate.__bases__)
dictData = ClassCreate.__dict__
print(dictData)
print()
print(dictData['functionMethod'])

print("""
     类的属性分: 
        (1)定义类时定义的属性叫静态属性
        (2)动态属性是通过：类对象.属性名=属性值的方式动态添加的属性成为动态属性
""")


class Person:
    pass


person = Person()
person.name = "张三"
person.age = 30
print('''
    使用一个空类,处理动态添加属性的问题,在实际引用中,所有的类都具有这种动态添加的属性的特性
''')
print("访问类的动态属性: 用户的名称%s" % person.name, "用户的年龄: %d" % person.age)

print("删除类的动态属性: name: 使用: ", "del person.name")
del person.name

try:
    print("访问类的动态属性: 用户的名称%s" % person.name, "用户的年龄: %d" % person.age)
except AttributeError as err:
    print("访问删除的动态属性name,异常: ", err.__traceback__)

print("""
   为了无上限的给类动态添加属性: 可以使用__slots__属性给类可以动态添加属性的限制,__slots__元组可以限制类中添加的属性:例如定义类的时候
   限制类只能添加动态属性: __slots__ = ('name','age','address')这些属性,如添加这些以外的属性,将会报错
""")

print('例如: 我们定义Record类')


# 定义一个空类,设置合法的属性为
class Record:
    """使用内置属性__slots__声明类的合法动态属性"""
    __slots__ = ('name', 'age')
    address = ''  # 该类包括一个类属性: address


Anna = Record()
Anna.name = '张三'
# 修改类变量address,只能使用：类名.属性名 = 属性值;而不能使用：对象.属性名=属性值的方式
Record.address = '北京市'
Anna.age = 20

print("Anna : ", Record.__dict__)
# 访问类变量确可以使用：对象名.属性名
print("长期居住地址: ", Record.address)

print('''
   当我们动态前景: college属性时,看看发生声明效果
''')
try:
    Anna.college = '清华大学'
    print(Anna.college)
except AttributeError as err:
    print("添加非法的动态属性(college),异常信息: %s......." % err)

print()
print('-------------------------------------------------------------------------------------------------')

print("""
    实例化对象： 通常我们要使用类中的成员及方法完成相应的业务逻辑,需要实例化该类: python中,实例化对象有两种方式:
    (1)类名+括号:  类名()
         当我们没有在类中声明__init__()方法或者时声明了__init(self)__时,实例化类就只需： 类名() 即可
    (2)类名+括号(参数列表)
         当我们声明了__init__(self,other parameters) ,方式除了有self参数外,还有我们拓展的对象成员变量时,需要使用这种方式创建类实例对象
""")


class PersonInstance:
    """类实例化的方式,重写类的init方法"""

    # 该方法在类实例化时,首先被调用,主要完成一些初始化功能
    def __init__(self, name, age, address):
        self.name = name
        self.address = address
        self.age = age
        print("name|age|address这上属性属于该类实例化后的对象的成员;这些成员变量属于所有实例对象共有")

    def getinfo(self):
        return self.name, str(self.age), self.address


person = PersonInstance("老杨", 20, "北京市海淀区中关村软件创新中心101")
print("调用类的普通方法,看法该方法返回的值 ", person.getinfo())
print("调用类的普通方法,看法该方法返回的值类型: ", type(person.getinfo()))

print()
print("隐藏调用类的初始化方法: ")


class MyChildren:
    """演示隐藏调用类的初始化化法"""

    def __init__(self):
        print("MyChildren类初始化时,init方法会被调用")


# 类初始化对象
myChildren = MyChildren()

二：静态|动态属性演示

D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\oop\ClassGrammarCreate.py 

    【面向对象OOP编程是一种编程思想：
    Python中使用关键字class来创建一个类,class之后紧根类名,并与冒号结尾】
    
调用类的静态方法： 使用类名.静态方法(类的实例化对象)
I Love You !

类的成员变量为所有对象实例共享:[静态属性]  1234

    调用类的内置属性: __name__,__doc__,__module__,__base__,__dict__
    
打印类的内置属性: 
<class 'type'>
ClassCreate
A simple example class
<class 'object'>
(<class 'object'>,)
{'__module__': '__main__', '__doc__': 'A simple example class', 'i': 1234, 'functionMethod': <staticmethod(<function ClassCreate.functionMethod at 0x0000018ACFD44D60>)>, '__dict__': <attribute '__dict__' of 'ClassCreate' objects>, '__weakref__': <attribute '__weakref__' of 'ClassCreate' objects>}

<staticmethod(<function ClassCreate.functionMethod at 0x0000018ACFD44D60>)>

     类的属性分: 
        (1)定义类时定义的属性叫静态属性
        (2)动态属性是通过：类对象.属性名=属性值的方式动态添加的属性成为动态属性

    使用一个空类,处理动态添加属性的问题,在实际引用中,所有的类都具有这种动态添加的属性的特性

访问类的动态属性: 用户的名称张三 用户的年龄: 30
删除类的动态属性: name: 使用:  del person.name
访问删除的动态属性name,异常:  <traceback object at 0x0000018ACFD54840>

   为了无上限的给类动态添加属性: 可以使用__slots__属性给类可以动态添加属性的限制,__slots__元组可以限制类中添加的属性:例如定义类的时候
   限制类只能添加动态属性: __slots__ = ('name','age','address')这些属性,如添加这些以外的属性,将会报错

例如: 我们定义Record类
Anna :  {'__module__': '__main__', '__doc__': '使用内置属性__slots__声明类的合法动态属性', '__slots__': ('name', 'age'), 'address': '北京市', 'age': <member 'age' of 'Record' objects>, 'name': <member 'name' of 'Record' objects>}
长期居住地址:  北京市

   当我们动态前景: college属性时,看看发生声明效果

添加非法的动态属性(college),异常信息: 'Record' object has no attribute 'college'.......

-------------------------------------------------------------------------------------------------

    实例化对象： 通常我们要使用类中的成员及方法完成相应的业务逻辑,需要实例化该类: python中,实例化对象有两种方式:
    (1)类名+括号:  类名()
         当我们没有在类中声明__init__()方法或者时声明了__init(self)__时,实例化类就只需： 类名() 即可
    (2)类名+括号(参数列表)
         当我们声明了__init__(self,other parameters) ,方式除了有self参数外,还有我们拓展的对象成员变量时,需要使用这种方式创建类实例对象

name|age|address这上属性属于该类实例化后的对象的成员;这些成员变量属于所有实例对象共有
调用类的普通方法,看法该方法返回的值  ('老杨', '20', '北京市海淀区中关村软件创新中心101')
调用类的普通方法,看法该方法返回的值类型:  <class 'tuple'>

隐藏调用类的初始化方法: 
MyChildren类初始化时,init方法会被调用

Process finished with exit code 0
 

后续高级用户待完善.........................