2020-09-27 Python 学习心得（类、对象与魔法方法）

最新推荐文章于 2022-11-25 17:58:43 发布

薛定谔の小花猫

最新推荐文章于 2022-11-25 17:58:43 发布

阅读量376

点赞数

分类专栏：学习笔记文章标签： python

本文链接：https://blog.csdn.net/qq_43478017/article/details/108815844

版权

学习笔记专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1、类与对象

1.1对象 = 属性 + 方法

1.1.1 封装：平常用的sort print append等函数。

class Spider:
# 属性
    color = 'Black'
    weight = 1
    legs = 8
    shell = False
    mouth = '针状口器'
# ⽅法
    def climb(self):
        print('我正在很努⼒力力的向前爬...')
    def run(self):
        print('我正在⻜飞快的向前跑...')
    def bite(self):
        print('咬死你咬死你!!')
    def eat(self):
        print('有得吃，真满⾜足...')
    def sleep(self):
        print('困了了，睡了了，晚安，zzz')
tt = Spider()
print(tt)
print(type(tt))
print(tt.__class__)
print(tt.__class__.__name__)
tt.climb()
tt.run()
tt.bite()
print(type(Spider))

<__main__.Spider object at 0x0000016AB02279D0>
<class '__main__.Spider'>
<class '__main__.Spider'>
Spider
我正在很努⼒力力的向前爬...
我正在⻜飞快的向前跑...
咬死你咬死你!!
<class 'type'>

1.1.2 继承：子类共享父类的数据和方法。

list1 = [2, 1, 7, 3, 5]
list1.sort()
print(list1)
class Mylist(list):
    pass
list2 = Mylist()
list2.append(5)
list2.append(3)
list2.append(6 )
print(list2)
list2.sort()
print(list2)

[1, 2, 3, 5, 7]
[5, 3, 6]
[3, 5, 6]

1.1.3 多态：不同对象对同一方法响应不同的行动。

class A:
    def fun(self):
       # return '我是A'
        print('我是A')
class B:
    def fun(self):
        #return '我是B'
        print('我是B')
class C:
    def fun(self):
        print('我是C')
a = A()
b = B()
print(a.fun())
print(b.fun())

我是A
我是B

#不使用print,使用return时的输出是：
我是A
None
我是B
None

1.2 self

self相当于C++的this指针，比普通函数多self。

class Ball:
    def setName(self, name):
        self.name = name
    def kick(self):
        print('我叫%s, 该死的，谁踢我。。。' % self.name)
a = Ball()
a.setName('球A')
b = Ball()
b.setName('球B')
c = Ball()
c.setName('呀~ 土豆')
print(a.kick())
print(b.kick())
print(c.kick())

我叫球A, 该死的，谁踢我。。。
None
我叫球B, 该死的，谁踢我。。。
None
我叫呀~ 土豆, 该死的，谁踢我。。。
None

1.3 魔法方法

两边都有双下划线

class Ball:
    def __init__(self, name):
        self.name = name
    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)
a = Ball("球A")
b = Ball("球B")
a.kick()
b.kick()

我叫球A,该死的，谁踢我...
我叫球B,该死的，谁踢我...

1.4 共有和私有

#类的私有属性
class JustCounter:
    __secretCount = 0 # 私有变量量
    publicCount = 0 # 公开变量量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)
counter = JustCounter()
counter.count() # 1
counter.count() # 2
print(counter.publicCount) # 2
print(counter._JustCounter__secretCount) # 2 Python的私有为伪私有
print(counter.__secretCount)

1
2
2
2
AttributeError: 'JustCounter' object has no attribute '__secretCount'

1.5 继承

定义类的括号内为父类。·如果子类中定义与父类同名的方法或属性,则会自动覆盖父类对应的方法或属性。多继承容易混乱慎用。

1.6 组合

class Turtle:
    def __init__(self, x):
        self.num = x
class Fish:
    def __init__(self, x):
        self.num = x
class Poll:
    def __init__(self, x, y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)
    def print_num(self):
        print("水池里一共有乌龟%d对，小鱼%d条" % (self.turtle.num
                                     , self.fish.num))
pool  = Poll(1, 10)
print(pool.print_num())

水池里一共有乌龟1对，小鱼10条

1.7 类、类对象、实例对象

类对象:创建一个类,其实也是一个对象也在内存开辟了一块空间,称为类对象,类对象只有一个。

实例对象:就是通过实例化类创建的对象,称为实例对象,实例对象可以有多个。

类属性:类里面方法外面定义的变量称为类属性。类属性所属于类对象并且多个实例对象之间共享同一个类属性,说白了就是类属性所有的通过该类实例化的对象都能共享。

属性与方法名相同，属性会覆盖方法。

class A:
def x(self):
print('x_man')
aa = A()
aa.x() 
aa.x = 1
print(aa.x)
aa.x()

x_man
1
TypeError: 'int' object is not callable

1.8 绑定

方法需要实例才能被调用，这就是绑定。

class CC:
    def setXY(self, x, y):
        self.x = x
        self.y = y
    def printXY(self):
        print(self.x, self.y)
dd = CC()
print(dd.__dict__)
print(vars(dd))
print(CC.__dict__)
dd.setXY(4, 5)
print(dd.__dict__)
print(vars(CC))
print(CC.__dict__)

{}
{}
{'__module__': '__main__', 'setXY': <function CC.setXY at 0x0000025E9C6CB3A0>, 'printXY': <function CC.printXY at 0x0000025E9C6CBA60>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}
{'x': 4, 'y': 5}
{'__module__': '__main__', 'setXY': <function CC.setXY at 0x0000025E9C6CB3A0>, 'printXY': <function CC.printXY at 0x0000025E9C6CBA60>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}
{'__module__': '__main__', 'setXY': <function CC.setXY at 0x0000025E9C6CB3A0>, 'printXY': <function CC.printXY at 0x0000025E9C6CBA60>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

1.9 相关的内置函数

issubclass(object, classinfo) :判断是否为子类。

hasattr(object, name):判断对象是否有什么属性。

getattr(object, name, default):返回一个对象的属性值。

setattr（object， name, value）:设置属性值。

delattr（object， name）：删除属性。

class(fget, fset, fdel, doc)

2、魔法方法

魔法方法的第一个参数应为cls（类方法）或者self（实例方法）

2.1 基本的魔法方法

2.1.1 init(self, )

                               **创建实例的初始化方法**

class Rectangle:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def getPeri(self):
        return (self.x + self.y) * 2
    def getArea(self):
        return self.x * self.y
rect = Rectangle(4, 5)
print(rect.getPeri()) 
print(rect.getArea()) 

18
20

2.1.2 new(cls, )

new 方法主要是当你继承一些不可变的class(比如int, str, tuple) ,提供给你一个自定义这些的实例化过程的途径。

class CapStr(str):#str 不可更改，使用new,定义大写字符串
    def __new__(cls, string):
        string = string.upper()
        return str.__new__(cls, string)
a = CapStr("i love FichC.com")
print(a)

I LOVE FICHC.COM

2.1.3 del(self)

析构器,当一个对象将要被系统回收之时调用的方法。

2.1.4str , repr

str 良好可读性；repr 开发者调试。

import datetime
today = datetime.date.today()
print(str(today))
print(repr(today))
print('%s' %today)
print('%r' %today)

2020-09-27
datetime.date(2020, 9, 27)
2020-09-27
datetime.date(2020, 9, 27)

2.2 算术运算符

加、减、乘、真除、地板除、模、幂、左移、右移、位运算

2.3 反算术运算符

正常前加‘r’，意思就是反过来计算。

class Nint(int):
    def __radd__(self, other):
        return int.__sub__(other, self)
a = Nint(5)
b = Nint(3)
print(a + b)
print(1 + b)

8
-2

2.4 增量赋值运算符

正常前面加‘ i ’。

2.5 一元运算符

正、负、绝对值、按位取反

2.6 属性访问

getattr（获得属性）, getattribute , setattr(修改) 和 delattr（删除）

2.7 描述符

get(self , instance , owner ):访问属性，返回属性的值 ; set(self , instance , value )：不返回值 ; del(self , instance )：不返回值。

2.8定制序列

2.8.1 不可变：len()、getitem().

2.8.2 可变：len()、getitem()、setiitem()、delitem().

class CountList:
    def __init__(self, *args):
        self.values = [x for x in args]
        self.count = {}.fromkeys(range(len(self.values)), 0)
    def __len__(self):
        return len(self.values)
    def __getitem__(self, item):
        self.count[item] += 1
        return self.values[item]
c1 = CountList(1, 3, 5, 7, 9)
c2 = CountList(2, 4, 6, 8, 10)
print(c1[1])
print(c2[2])
print(c1[1] + c2[1])
print(c1.count)
print(c2.count)

3
6
7
{0: 0, 1: 2, 2: 0, 3: 0, 4: 0}
{0: 0, 1: 1, 2: 1, 3: 0, 4: 0}

2.9 迭代器

2.9.1 iter( ):迭代器

2.9.2 next( )：迭代下一项


def libs(n):
    a = 0
    b = 1
    while True:
        a, b = b, a+b
        if a > n:
            return
        yield  a

for each in libs(100):
    print(each, end=' ')

1 1 2 3 5 8 13 21 34 55 89

薛定谔の小花猫

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2020-09-27 Python 学习心得（类、对象与魔法方法）

1、类和对象类的实例化就是对象。类名以大写字母开头。2、面向对象（O O）封装：平常用的sort print append等函数。继承：子类共享父类的数据和方法。多态：不同对象对同一方法响应不同的行动。3、面向对象的编程魔法方法...
复制链接

扫一扫