python day11 函数（第三篇）

成员

类成员:

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

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

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('二狗','[email protected]'),User('二蛋','[email protected]'),User('狗蛋','[email protected]')]

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,'[email protected]')

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方法。

总结：

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