python类

一，类

1，类是摸板，里面有组合数据，实现功能的方法。
2，类里面有可以改变自身的方法__init__函数
3，类和模块类似，运行时创建，创建后修改
4，类成员通常是public，成员函数virtual
5，python提供的内置类型类，可以作为父类来继承

二，类为模板

1，属性引用
Moduel_Name.func_name 对模块中名称的引用称为属性引用。
Moduel_Name 是一个模块对象，fun_name是它的属性。
模块的属性和模块中定义的全局名称之间存在映射关系：它们共享一个命名空间！

2 ，属性
可以只读或者只写，如果可写，模块的属性可以赋值，可以删除
Moduel_Name.var = 10
del Moduel_Name.var 会从Moduel_Name对象中移除var属性

3，类里面定义的变量

• 类里面定义函数

	>>> class MyClass:
	...     def say_hello(): # 标准是带self的参数
	...             print('hello world!')
	...
	>>> MyClass
	<class '__main__.MyClass'>
	>>> MyClass.say_hello() # 属性引用
	hello world!
	>>>

类里面函数可能还有self 的参数
一个类（全局命名空间）里面的作用域是局部作用域
通过创建对象使得类里面的局部作用域生效

• 一个有属性，函数的类demo

class MyClass:
    ''' 这是一个py类的annotation '''
    # 类的属性
    i = 99

	# 类的初始化方法
    def __init__(self):
        self.data = []
    # 类的自定义函数  
    def say_hello(self):
        return 'hello world'

4，类对象

• 访问类里面的元素有两种方法：属性引用和实例化

• 属性引用:

MyClass.var

• 实例化
  类的实例使用函数表示法

x = MyClass()

• 类的构造方法

class Test:
	def __init__(self):
		print('这是py类的构造方法，用来初始化这个类')
	def __init__(self, name):
		print(name)
			
	# 实例化操作创建对象时，类会自动创建带有特定初始状态的自定义实例
	
	''' 当一个类定义了 __init__() 方法时，
	类的实例化操作(t = Test('rye'))自动为新创建的类实例
	发起调用 __init__()。两个init会被调用。
	'''

• init里面的局部名称属于实例对象

class MyClass:
    ''' 这是一个py类 有两个init初始化类的方法，创建类后所有init里面的局部变量就会存在
	      __init__self后面参数没被赋值就是None
    '''
    i = 99
    def __init__(self):
        self.data = []
    def __init__(self, count):
        self.c = count
    def say_hello(self):
        return 'hello world'
	
	# ！上面的类要实例化时，注意传入参数，按照__init__的self后面是否有其它参数。

'''
MyClass.c 这样访问时错误的，c输入实例对象。
'''

5，实例对象 ==> 自定义对象产生的

• 实例对象的操作是属性引用（数据属性和方法）
• 数据属性不需要在类里面声明，像局部变量一样，第一次赋值时产生。
• 数据属性可以根据类对象无中生有
• counter就是实例对象的属性引用

def my_obj():
    me.counter = 0
    while me.counter < 20:
        me.counter += 1
    print(me.counter)

my_obj()
# del me.counter 不删除就会存在

• 实例方法，是类对象调用类的函数

	Me = MyClass(None)
	Me.say_hello() 就是一个方法对象
	而MyClass.say_hello(None) 就是一个函数对象

6， 方法对象

me = MyClass(None)
# 方法对象
def test_func_obj():
    val = me.say_hello() # 用实例对象调用类的函数
    while True:
        print(val) 

test_func_obj()

print("me.say_hello()相当于  MyClass.say_hello(me)")

♥注意

• 方法的特殊之处就在于实例对象会作为函数的第一个参数被传入。 实例对象取代了self。
• 总之，调用一个具有 n 个参数的方法就相当于调用再多一个参数的对应函数， 这个参数值为方法所属实例对象，位置在其他参数之前。

7，类和实例变量

• 类对象的属性，函数属于所有对象 self属于某个对象。

# 类和实例变量
class Dog:
    name = 'kid'

    def __init__(self, color):
        self.color = color

# 实例变量属于对象，类变量被对象共享
d1 = Dog('black') 
d2 = Dog('yellow') 
print(d1.name, d1.color, '\n', d2.name, d2.color)
'''
kid black
 kid yellow
'''

# color是每个对象具有的，name被共享

d1.name = 'jack'
print(d1.name, d1.color, '\n', d2.name, d2.color)
'''
改变类变量后，
jack black 
 kid yellow
'''

• 用__init__来解决类变量共享

# 类变量的错误设计，不该出现数据共享
class Dog:
    tricks = []

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

    def add_trick(self, trick):
        self.tricks.append(trick)

d = Dog('d1')
dd  = Dog('d2')
d.add_trick('jump!')
dd.add_trick('roll!')
print(d.tricks) 
print(dd.tricks) 
''' ['jump!', 'roll!'] 两只狗都会了
    ['jump!', 'roll!']
'''

# 正解
class Dog():
    def __init__(self, name):
        self.name = name
        self.tricks = []

    def add_trick(self, trick):
        self.tricks.append(trick)

d = Dog('d1')
dd  = Dog('d2')
d.add_trick('jump!')
dd.add_trick('roll!')
print(d.tricks)
print(dd.tricks)
'''
['jump!']
['roll!']
'''

有点懵，但还好，会用了。

转载：https://blog.csdn.net/qq_44783283/article/details/105927789