python — 成员

成员

类成员:

• 类变量
• 绑定方法
• 静态方法
• 类方法
• 属性

实例（对象）成员： 实例变量

1 实例变量

实例变量（又叫做：字段/属性）

2 类变量

类变量（又叫做：静态字段/属性）

定义：写在类的下一级和方法同一级。

访问：

• 1. 类.类变量名称
  2. 对象.类变量名称

练习题：

class Base:
    x = 1
    
obj = Base()

print(obj.x) # 先去对象中找，没有再去类中找。
obj.y = 123  # 在对象中添加了一个y=123的变量。
print(obj.y)
obj.x = 123  # 在对象中添加了一个x=123的变量。（不可以修改类中的变量）
print(obj.x)
print(Base.x)
Base.x = 666 # 类可以修改类中的变量 x = 666

class Parent:
    x = 1
    
class Child1(Parent):
    pass

class Child2(Parent):
    pass

print(Parent.x,Child1.x,Child2.x) # 1 1 1
Child1.x = 2
print(Parent.x,Child1.x,Child2.x) # 1 2 1
Child2.x = 3
print(Parent.x,Child1.x,Child2.x) # 1 2 3

总结：

找变量优先找自己，自己没有找类或基类；修改或赋值只能在自己的内部设置。

3 方法（绑定方法/普通方法)

定义：至少有一个self参数

执行：先创建对象，由对象.方法()

class Foo:
    def func(self,a,b):
        print(a,b)
        
obj = Foo()
obj.func(1,2)
# ###########################
class Foo:
    def __init__(self):
        self.name = 123

    def func(self, a, b):
        print(self.name, a, b)

obj = Foo()
obj.func(1, 2)

用到对象中封装值时，一般使用绑定方法。

4 静态方法

定义：

• @staticmethod装饰器
• 参数无限制

执行：

• 类.静态方法名 ()
• 对象.静态方法名 ()（不推荐使用：因为没有意义）

class Foo:
    def __init__(self):
        self.name = 123

    def func(self, a, b):
        print(self.name, a, b)

    @staticmethod   # python中内置的，只需调用就可以用
    def f1():
        print(123)

obj = Foo()
obj.func(1, 2)

Foo.f1() # 可以不用传参数，只需调用
obj.f1() # 不推荐

5 类方法

定义：

• @classmethod装饰器
• 至少有cls参数，当前类。

执行：

• 类.类方法()
• 对象.类方法() （不推荐）

class Foo:
    def __init__(self):
        self.name = 123

    def func(self, a, b):
        print(self.name, a, b)

    @staticmethod
    def f1():
        print(123)

    @classmethod
    def f2(cls,a,b):
        print('cls是当前类',cls)
        print(a,b)
obj = Foo()
obj.func(1, 2)

Foo.f1()
Foo.f2(1,2)

@classmethod和@staticmethod的区别？

• 一个是类方法一个静态方法。
• 定义：
  类方法：用@classmethod做装饰器且至少有一个cls参数。
  静态方法：用staticmethod做装饰器且参数无限制。
• 调用：
  类.方法直接调用。
  对象.方法也可以调用。

6 属性

在一个方法上加@property，方法就变成了属性，调用时不用加()。

定义：

• @property装饰器
• 只有一个self参数

执行：对象.方法 不用加括号。

class Foo:

    @property
    def func(self):
        print(123)
        return 666

obj = Foo()
result = obj.func
print(result)

# 属性的应用

class Page:
    def __init__(self, total_count, current_page, per_page_count=10):
        self.total_count = total_count
        self.per_page_count = per_page_count
        self.current_page = current_page
    @property
    def start_index(self):
        return (self.current_page - 1) * self.per_page_count
    @property
    def end_index(self):
        return self.current_page * self.per_page_count


USER_LIST = []
for i in range(321):
    USER_LIST.append('alex-%s' % (i,))

# 请实现分页展示：
current_page = int(input('请输入要查看的页码：'))
p = Page(321, current_page)
data_list = USER_LIST[p.start_index:p.end_index]
for item in data_list:
    print(item)

7 特殊成员

7.1 __init__

初始化方法，用于给对象中赋值。

class Foo:
    """
    类是干啥的。。。。    # 注释类
    """
    def __init__(self,a1):
        """
        初始化方法
        :param a1: 
        """
        self.a1 = a1
        
obj = Foo('alex')

7.2 __new__

用于创建空对象，又叫构造方法

class Foo(object):
    def __init__(self):
        """
        用于给对象中赋值，初始化方法
        """
        self.x = 123
    def __new__(cls, *args, **kwargs):
        """
        用于创建空对象，构造方法
        :param args: 
        :param kwargs: 
        :return: 
        """
        return object.__new__(cls)

obj = Foo()

类实例化一个对象：先执行__new__创建一个空对象，再执行__init__初始化对象

7.3 __call__

对象后面加()，就可以执行python的一个方法：__call__方法

class Foo(object):
    def __call__(self, *args, **kwargs):
        print('执行call方法')

obj = Foo()
obj()          =====>  Foo()()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from wsgiref.simple_server import make_server

def func(environ,start_response):
    start_response("200 OK", [('Content-Type', 'text/plain; charset=utf-8')])
    return ['你好'.encode("utf-8")  ]

class Foo(object):

    def __call__(self, environ,start_response):
        start_response("200 OK", [('Content-Type', 'text/html; charset=utf-8')])
        return ['你<h1 style="color:red;">不好</h1>'.encode("utf-8")]


# 作用：写一个网站，用户只要来方法，就自动找到第三个参数并执行。
server = make_server('127.0.0.1', 8000, Foo())
server.serve_forever()

7.4__getitem__ __setitem__ __delitem__

class Foo(object):

    def __setitem__(self, key, value):
        pass

    def __getitem__(self, item):
        return item + 'uuu'

    def __delitem__(self, key):
        pass


obj1 = Foo()
obj1['k1'] = 123  # 内部会自动调用 __setitem__方法
val = obj1['xxx']  # 内部会自动调用 __getitem__方法
print(val)
del obj1['ttt']  # 内部会自动调用 __delitem__ 方法

7.5 __str__

class Foo(object):
    def __str__(self):
        """
        只有在打印对象时，会自动化调用此方法，并将其返回值在页面显示出来
        :return: 
        """
        return 'asdfasudfasdfsad'

obj = Foo()
print(obj)

class User(object):
    def __init__(self,name,email):
        self.name = name
        self.email = email
    def __str__(self):
        return "%s %s" %(self.name,self.email,)
user_list = [User('二狗','2g@qq.com'),User('二蛋','2d@qq.com'),User('狗蛋','xx@qq.com')]
for item in user_list:
    print(item)

注意：不要相信print打印出来的（显示出来的不一定是字符串，也可能是类实例化的对象）

7.6 __dict__

class Foo(object):
    def __init__(self,name,age,email):
        self.name = name
        self.age = age
        self.email = email

obj = Foo('alex',19,'xxxx@qq.com')
print(obj)
print(obj.name)
print(obj.age)
print(obj.email)
val = obj.__dict__ # 去对象中找到所有变量并将其转换为字典
print(val)

7.7 上下文管理

class Foo(object):
    def __enter__(self):  # 打开文件
        self.x = open('a.txt',mode='a',encoding='utf-8')
        return self.x
    def __exit__(self, exc_type, exc_val, exc_tb): # 关闭文件
        self.x.close()

with Foo() as ff:
    ff.write('alex')
    ff.write('alex')
    ff.write('alex')
    ff.write('alex')

# 练习题
# 方法1
class Context:
    def __enter__(self):
        print('进入')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('推出')

    def do_something(self):
        print('内部执行')

with Context() as ctx:
    print('内部执行')
    ctx.do_something()

# 方法二
class Foo(object):
    def do_something(self):
        print('内部执行')

class Context:
    def __enter__(self):
        print('进入')
        return Foo()

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('推出')

with Context() as ctx:
    print('内部执行')
    ctx.do_something()

注：只要有with就要用到__enter__、__exit__这两个方法

7.8 两个对象相加 __add__

val = 5 + 8
print(val)

val = "alex" + "sb"
print(val)

class Foo(object):
    def __add__(self, other):
        return 123  # __add__是由obj1触发的，self是obj1，other是obj2，返回的值给val.
    
obj1 = Foo()
obj2 = Foo()
val  = obj1 + obj2
print(val)

7.9 可迭代对象 __iter__

表象：可以被for循环的对象就可以称之为是可迭代对象，如：'ax'、[1,2,3]、[]

如何让一个对象变成可迭代对象？

在类中实现__iter__方法且返回一个迭代器（或生成器）。

class Foo:
    def __iter__(self):
        return iter([1,2,3,4])

obj = Foo()


class Foo:
    def __iter__(self):
        yield 1
        yield 2
        yield 3

obj = Foo()

记住：只要能被for循环就是去看它内部的iter方法。

总结：

特殊成员：就是为了能够快速实现执行某些方法而生。

转载于:https://www.cnblogs.com/yangjie0906/p/10771351.html