python基础day08(面向对象）

guowu666

已于 2023-10-14 19:29:59 修改

阅读量34

点赞数 2

分类专栏： python基础文章标签： python 开发语言青少年编程

于 2023-10-03 19:15:31 首次发布

本文链接：https://blog.csdn.net/weixin_58189050/article/details/133492145

版权

python基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.面向对象

如何用面向对象实现某个功能:

1.定义类，在类中定义方法，在方法中实现具体的功能

2.实例化类的一个对象，通过对象去调用并执行方法。


class Message:

    def send_email(self, email, content):
        data = "给{}发邮件，内容是：{}".format(email,content)
        print(data)


msg_object = Message() # 实例化一个对象 msg_object，创建了一个一块区域。
msg_object.send_email("bei@live.com","注册成功")# 调用了send_email这个方法

注意：1.类名称首字母大写&驼峰式命名；2.py3之后默认类都继承object；3.在类种编写的函数称为方法；4.每个方法的第一个参数是self。

1.1对象和self

在每个类中都可以定义个特殊的：__init__ 初始化方法，在实例化类创建对象时自动执行，即：对象=类()。

class Message:

    def __init__(self, content):
        self.data = content

    def send_email(self, email):
        data = "给{}发邮件，内容是：{}".format(email, self.data)
        print(data)

    def send_wechat(self, vid):
        data = "给{}发微信，内容是：{}".format(vid, self.data)
        print(data)


# 对象 = 类名() # 自动执行类中的 __init__ 方法。

# 1. 根据类型创建一个对象，内存的一块 区域 。
# 2. 执行__init__方法，模块会将创建的那块区域的内存地址当self参数传递进去。    往区域中(data="注册成功")
msg_object = Message("注册成功")

msg_object.send_email("bj@live.com")  # 给bj@live.com发邮件，内容是：注册成功
msg_object.send_wechat("bj")  # 给bj发微信，内容是：注册成功

通过上述的示例，你会发现：

对象，让我们可以在它的内部先封装一部分数据，以后想要使用时，再去里面获取。
self，类中的方法需要由这个类的对象来触发并执行（对象.方法名），且在执行时会自动将对象当做参数传递给self，以供方法中获取对象中已封装的值。

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

self，本质上就是一个参数。这个参数是Python内部会提供，其实本质上就是调用当前方法的那个对象。
对象，基于类实例化出来”一块内存“，默认里面没有数据；经过类的 __init__方法，可以在内存中初始化一些数据。

1.2成员

成员分为变量和方法

变量
- 实例变量
- 类变量
方法
- 绑定方法
- 类方法
- 静态方法

1.2.1变量

实例变量:属于对象，每个对象中各自维护自己的数据。
类变量:属于类，可以被所有对象共享，一般用于给对象提供公共数据（类似于全局变量）。

大原则各自调用自己的变量,对象也可以调用类变量

class Person(object):
    country = "中国"  # 类变量

    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age  ##实例变量

    def show(self):
        # message = "{}-{}-{}".format(Person.country, self.name, self.age)
        message = "{}-{}-{}".format(self.country, self.name, self.age)
        print(message)


print(Person.country)  # 中国

p1 = Person("z", 20)
print(p1.name)
print(p1.age)
print(p1.country)  # 中国

p1.show()  # 中国-z-20

1.2.2易错点

读和写对的区别

读:优先在自己里边读,没有的再去其他里边读
写:只能在自己里边写

class Person(object):
    country = "中国"

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

    def show(self):
        message = "{}-{}-{}".format(self.country, self.name, self.age)
        print(message)

print(Person.country) # 中国

p1 = Person("z",20)
print(p1.name) # z
print(p1.age) # 20
print(p1.country) # 中国
p1.show() # 中国-z-20

p1.name = "root"     # 在对象p1中讲name重置为root
p1.num = 19          # 在对象p1中新增实例变量 num=19
p1.country = "china" # 在对象p1中新增实例变量 country="china"

print(p1.country)   # china
print(Person.country) # 中国

class Base(object):
    country = "中国"


class Person(Base):

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

    def show(self):
        message = "{}-{}-{}".format(Person.country, self.name, self.age)
        # message = "{}-{}-{}".format(self.country, self.name, self.age)
        print(message)


# 读
print(Base.country)  # 中国
print(Person.country)  # 中国

obj = Person("z", 19)
print(obj.country)  # 中国
b=Base()
# 写 
Base.country = "china"  # 将Base的country改成china
Person.country = "泰国"  # 在Person 中添加一个country
obj.country = "日本"  # 在obj对象中添加一个country

1.2.3方法

绑定方法
类方法
静态方法

class Foo(object):

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

    def f1(self):
        print("绑定方法", self.name)

    @classmethod
    def f2(cls):
        print("类方法", cls)

    @staticmethod
    def f3():
        print("静态方法")


# 绑定方法（对象）
obj = Foo("z", 20)
obj.f1()  # Foo.f1(obj)

# 类方法
Foo.f2()  # cls就是当前调用这个方法的类。（类）
obj.f2()  # cls就是当前调用这个方法的对象的类。

# 静态方法
Foo.f3()  # 类执行执行方法（类）
obj.f3()  # 对象执行执行方法

1.2.4属性

属性其实是由绑定方法 + 特殊装饰器组合创造出来的，让我们以后在调用方法时可以不加括号

class Foo(object):

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

    def f1(self):
        return 123

    @property
    def f2(self):
        return 123


obj = Foo("武沛齐")

v1 = obj.f1()
print(v1)

v2 = obj.f2
print(v2)

属性编写的两种方法

1.基于装饰器的

class C(object):

    @property
    def x(self):
       print("x")

    @x.setter
    def x(self, value):
        print(value)

    @x.deleter
    def x(self):
       print("del")


obj = C()

obj.x
obj.x = 123
obj.x= 777
del obj.x
print(obj.x)

# x
# 123
# 777
# del
# x
# None

2.基于变量

class C(object):
    
    def getx(self): 
		pass
    
    def setx(self, value): 
		pass
        
    def delx(self): 
		pass
        
    x = property(getx, setx, delx, "I'm the 'x' property.")
    
obj = C()

obj.x
obj.x = 123
del obj.x

注意：由于属性和实例变量的调用方式相同，所以在编写时需要注意：属性名称不要实例变量重名。

class Foo(object):

    def __init__(self, name, age):
        self.name = name  # 报错，错认为你想要调用 @name.setter 装饰的方法。
        self.age = age

    @property
    def name(self):
        return "{}-{}".format(self.name, self.age)


obj = Foo("zz", 123)

如果真的想要在名称上创建一些关系，可以让实例变量加上一个下划线。

class Foo(object):

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

    @property
    def name(self):
        return "{}-{}".format(self._name, self.age)


obj = Foo("武沛齐", 123)
print(obj._name)
print(obj.name)

1.3成员修改符

公有:可以再任何地方调用这个成员
私有:只能在类中访问成员(私有要在前面加__)

class Foo(object):

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

    def get_data(self):
        return self.__name

    def get_age(self):
        return self.age


obj = Foo("zj", 123)


# 公有成员
print(obj.age)
v1 = obj.get_age()
print(v1)

# 私有成员
# print(obj.__name) # 错误，由于是私有成员，只能在类中进行使用。
v2 = obj.get_data()
print(v2)

特别提醒：父类中的私有成员，子类无法继承。


class Base(object):

    def __data(self):
        print("base.__data")

    def num(self):
        print("base.num")


class Foo(Base):

    def func(self):
        self.num()
        self.__data() # # 不允许执行父类中的私有方法


obj = Foo()
obj.func()

# 保错 'Foo' object has no attribute '_Foo__data'

正确


class Base(object):

    def __data(self):
        print("base.__data")

    def num(self):
        print("base.num")
        self.__data()  #


class Foo(Base):

    def func(self):
        self.num()


obj = Foo()
obj.func()

1.4对象嵌套

将对象作为参数,传递进去

1.5特殊成员

特殊方法以__方法__格式

__init__ 初始化方法

lass Class():
    def __init__(self, name, age):
        self.name = name
        self.age = age


foo = Class("zsj", 18)

__call__ 让对象可以执行

class Class():
   def __call__(self, *args, **kwargs):
       print("""  pppp""")

foo = Class()
foo()

__str__可以让对象返回字符串

class Class():

    def __str__(self):
        return "你们好"


foo = Class()
#data = str(foo)
#print(data)  #

 print(foo)

__dict__将实例变量构造成字典

class Class():

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


foo = Class("zsj", 19)
print(foo.__dict__)##{'name': 'zsj', 'age': 19}

__getitem__、__setitem__、__delitem__不同形式的方法调用不同形式的函数

class Class():

    def __setitem__(self, key, value):
        print("{}-{}".format(key, value))

    def __getitem__(self, item):
        print(item)

    def __delitem__(self, key):
        print(key)


foo = Class()
foo["zsj"] = 16  # 自动调用__setitem__方法
foo["zsj"]  # ...  __getitem__
del foo["k3"]  # ... delitem..

# zsj-16
# zsj
# k3

__enter__.__exit__ with 对象时自动先执行 enter with 里的缩进完成时自动执行exit

class Class():

    def __enter__(self):
        print("进去了")
        return 888  # 返回几f就是几

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("出来了")


foo = Class()
with foo as f:
    print(f)
    print(123)
#进去了
#888
#123
#出来了

__add__可以让两个对象相加时自动执行方法得到一些结果

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

    def __add__(self, other):  # other指想加的第二个对象
        print("{}-{}".format(self.name,other.name))


foo = Class("zsj")
foo2 = Class("牛B")
data = foo + foo2

__iter__

1.迭代器

# 迭代器类型的定义：
1.当类中定义了 __iter__ 和 __next__ 两个方法。
2.__iter__ 方法需要返回对象本身，即：self
3. __next__ 方法，返回下一个数据，如果没有数据了，则需要抛出一个StopIteration的异常。

# 创建 迭代器类型 ：
	class IT(object):
        def __init__(self):
            self.counter = 0

        def __iter__(self):
            return self

        def __next__(self):
            self.counter += 1
            if self.counter == 3:
                raise StopIteration()
            return self.counter

# 根据类实例化创建一个迭代器对象：
obj1 = IT()
# 1.
# v1 = obj1.__next__()
# v2 = obj1.__next__()
# v3 = obj1.__next__() # 抛出异常

#2.
# v1 = next(obj1)  # obj1.__next__()
# print(v1)
#
# v2 = next(obj1)
# print(v2)
#
# v3 = next(obj1)
# print(v3)
#3.
obj2 = IT()
for item in obj2:  # 首先会执行迭代器对象的__iter__方法并获取返回值，一直去反复的执行 next(对象)
    print(item)

# 迭代器对象支持通过next取值，如果取值结束则自动抛出StopIteration。
# for循环内部在循环时，先执行__iter__方法，获取一个迭代器对象，然后不断执行的next取值（有异常StopIteration则终止循环）。

2.生成器

# 创建生成器函数
    def func():
        yield 1
        yield 2
    
# 创建生成器对象（内部是根据生成器类generator创建的对象），生成器类的内部也声明了：__iter__、__next__ 方法。
    obj1 = func()
    
    v1 = next(obj1)
    print(v1)

    v2 = next(obj1)
    print(v2)

    v3 = next(obj1)
    print(v3)


    obj2 = func()
    for item in obj2:
        print(item)

如果按照迭代器的规定来看，其实生成器类也是一种特殊的迭代器类。

3.可迭代对象

# 如果一个类中有__iter__方法且返回一个迭代器对象 ；则我们称以这个类创建的对象为可迭代对象。

class Foo(object):
    
    def __iter__(self):
        return 迭代器对象()# 生成器 即实列化对象的类是生成器或迭代器
    
obj = Foo() # obj是 可迭代对象。

# 可迭代对象是可以使用for来进行循环，在循环的内部其实是先执行 __iter__ 方法，获取其迭代器对象，然后再在内部执行这个迭代器对象的next功能，逐步取值。
for item in obj:
    pass

class IT(object):
    def __init__(self):
        self.counter = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.counter += 1
        if self.counter == 3:
            raise StopIteration()
        return self.counter


class Foo(object):
    def __iter__(self):
        return IT()


obj = Foo() # 可迭代对象


for item in obj: # 循环可迭代对象时，内部先执行obj.__iter__并获取迭代器对象；不断地执行迭代器对象的next方法。
    print(item)

# 基于可迭代对象&迭代器实现：自定义range
class IterRange(object):
    def __init__(self, num):
        self.num = num
        self.counter = -1

    def __iter__(self):
        return self

    def __next__(self):
        self.counter += 1
        if self.counter == self.num:
            raise StopIteration()
        return self.counter


class Xrange(object):
    def __init__(self, max_num):
        self.max_num = max_num

    def __iter__(self):
        return IterRange(self.max_num)


obj = Xrange(100)

for item in obj:
    print(item)

v1 = list([11,22,33,44])

v1是一个可迭代对象，因为在列表中声明了一个 __iter__ 方法并且返回一个迭代器对象。


from collections.abc import Iterator, Iterable

v1 = [11, 22, 33]
print( isinstance(v1, Iterator) )  # false，判断是否是迭代器；判断依据是__iter__ 和 __next__。
v2 = v1.__iter__()
print( isinstance(v2, Iterator) )  # True



v1 = [11, 22, 33]
print( isinstance(v1, Iterable) )  # True，判断依据是是否有 __iter__且返回迭代器对象。

v2 = v1.__iter__()
print( isinstance(v2, Iterable) )  # True，判断依据是是否有 __iter__且返回迭代器对象。

2.三大特性

这种面向对象编程方式有三大特性：封装、继承、多态。

2.1封装

封装主要体现在两个方面：

将同一类方法封装到了一个类中。
将数据封装到了对象中，在实例化一个对象时，可以通过__init__初始化方法在对象中封装一些数据，便于以后使用。

2.2继承

即：子类可以继承父类中的方法和类变量（不是拷贝一份，父类的还是属于父类，子类可以继承而已）。

class Base:

    def func(self):
        print("Base.func")


class Son(Base):

    def show(self):
        print("Son.show")


s1 = Son()
s1.show()
s1.func()  # 优先在自己的类中找，自己没有才去父类。

s2 = Base()
s2.func()
# Son.show
# Base.func
# Base.func

示列：

。。。

2.3多态

指的是一类事物有多种形态，一个抽象类有多个子类（因而多态的概念依赖于继承），不同的子类对象调用相同的方法，产生不同的执行结果，多态可以增加代码的灵活度

。。。。

2.4补充

在Python3中编写类时，默认都会继承object（即使不写也会自动继承）。

class Foo:
    pass

class Foo(object):
    pass

这一点在Python2是不同的：

继承object，新式类
不继承object，经典类

guowu666

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
python基础day08(面向对象）

如何用面向对象实现某个功能:1.定义类，在类中定义方法，在方法中实现具体的功能2.实例化类的一个对象，通过对象去调用并执行方法。注意：1.类名称首字母大写&驼峰式命名；2.py3之后默认类都继承object；3.在类种编写的函数称为方法；4.每个方法的第一个参数是self。
复制链接

扫一扫