python学习笔记03

最新推荐文章于 2021-10-25 20:59:51 发布
最新推荐文章于 2021-10-25 20:59:51 发布
阅读量269 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nnxxx/article/details/113063294
版权

Task3

12. 函数与Lambda表达式

函数

定义

  • 函数以def关键词开头，后接函数名和圆括号()。
  • 函数执行的代码以冒号起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。

在这里插入图片描述

调用

def printme(str):
    print(str)


printme("我要调用用户自定义函数!")  # 我要调用用户自定义函数!
printme("再次调用同一函数")  # 再次调用同一函数
temp = printme('hello') # hello
print(temp)  # None

函数文档

Function.__ doc __（双下划线）

def MyFirstFunction(name):
    "函数定义过程中name是形参"
    # 因为Ta只是一个形式，表示占据一个参数位置
    print('传递进来的{0}叫做实参，因为Ta是具体的参数值！'.format(name))


MyFirstFunction('老马的程序人生')  
# 传递进来的老马的程序人生叫做实参，因为Ta是具体的参数值！

print(MyFirstFunction.__doc__)  
# 函数定义过程中name是形参

help(MyFirstFunction)
# Help on function MyFirstFunction in module __main__:
# MyFirstFunction(name)
#    函数定义过程中name是形参

函数参数

1.位置参数
在这里插入图片描述
arg1 - 位置参数 ，这些参数在调用函数 (call function) 时位置要固定。

2.默认参数
在这里插入图片描述

  • arg2 = v - 默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。
  • 默认参数一定要放在位置参数 后面，不然程序会报错。
  • Python 允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

3.可变参数
在这里插入图片描述

  • *args - 可变参数，可以是从零个到任意个，自动组装成元组。
  • 加了星号（*）的变量名会存放所有未命名的变量参数。

4.关键字参数
在这里插入图片描述
**kw - 关键字参数，可以是从零个到任意个，自动组装成字典。

def printinfo(arg1, *args, **kwargs):
    print(arg1)
    print(args)
    print(kwargs)


printinfo(70, 60, 50)
# 70
# (60, 50)
# {}
printinfo(70, 60, 50, a=1, b=2)
# 70
# (60, 50)
# {'a': 1, 'b': 2}

注：

  • 可变参数允许传入零个到任意个参数，它们在函数调用时自动组装为一个元组 (tuple)。
  • 关键字参数允许传入零个到任意个参数，它们在函数内部自动组装为一个字典 (dict)。

5.命名关键字参数
在这里插入图片描述

  • *, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。
  • 如果要限制关键字参数的名字，就可以用「命名关键字参数」
  • 使用命名关键字参数时，要特别注意不能缺少参数名。
def printinfo(arg1, *, nkw, **kwargs):
    print(arg1)
    print(nkw)
    print(kwargs)


printinfo(70, nkw=10, a=1, b=2)
# 70
# 10
# {'a': 1, 'b': 2}

printinfo(70, 10, a=1, b=2)
# TypeError: printinfo() takes 1 positional argument but 2 were given

6.参数组合

参数定义的顺序必须是：

  • 位置参数、默认参数、可变参数和关键字参数。
  • 位置参数、默认参数、命名关键字参数和关键字参数。

变量作用域

局部变量 全局变量

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

  • global关键字用来在函数或其他局部作用域中使用全局变量。
  • nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量。
num = 1


def fun1():
    global num  # 需要使用 global 关键字声明
    print(num)  # 1
    num = 123
    print(num)  # 123


fun1()
print(num)  # 123

def nonlocal_test():
    count = 0
    def test2():
        nonlocal count
        count += 1
        return count
    return test2
 
val = nonlocal_test()
print(val()) # 1
print(val()) # 2
print(val()) # 3
闭包
  • 是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。
  • 如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。
  • 通过闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。
def funX(x):
    def funY(y):
        return x * y

    return funY


i = funX(8)
print(type(i))  # <class 'function'>
print(i(5))  # 40

闭包的返回值通常是函数。

def make_counter(init):
    counter = [init]

    def inc(): counter[0] += 1

    def dec(): counter[0] -= 1

    def get(): return counter[0]

    def reset(): counter[0] = init

    return inc, dec, get, reset


inc, dec, get, reset = make_counter(0)
inc()
inc()
inc()
print(get())  # 3
dec()
print(get())  # 2
reset()
print(get())  # 0

如果要修改闭包作用域中的变量则需要 nonlocal 关键字

在这里插入图片描述

Lambda表达式

匿名函数定义

Python 使用 lambda 关键词来创建匿名函数，而非def关键词，它没有函数名，其语法结构如下：
在这里插入图片描述

  • argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
  • expression - 表达式，输入函数参数，输出一些值。（没有 return 语句，表达式本身结果就是返回值。）
def sqr(x):
    return x ** 2


print(sqr)
# <function sqr at 0x000000BABD3A4400>

y = [sqr(x) for x in range(10)]
print(y)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

lbd_sqr = lambda x: x ** 2
print(lbd_sqr)
# <function <lambda> at 0x000000BABB6AC1E0>

y = [lbd_sqr(x) for x in range(10)]
print(y)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]


sumary = lambda arg1, arg2: arg1 + arg2
print(sumary(10, 20))  # 30

func = lambda *args: sum(args)
print(func(1, 2, 3, 4, 5))  # 15

匿名函数应用

在这里插入图片描述

filter(function, iterable)
过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist))  # [1, 3, 5, 7, 9]

map(function, *iterables)
根据提供的函数对指定序列做映射。

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))  
# [1, 4, 9, 16, 25]

m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))  
# [3, 7, 11, 15, 19]

自定义高阶函数

def apply_to_list(fun, some_list):
    return fun(some_list)

lst = [1, 2, 3, 4, 5]
print(apply_to_list(sum, lst))
# 15

print(apply_to_list(len, lst))
# 5

print(apply_to_list(lambda x: sum(x) / len(x), lst))
# 3.0

13.类与对象

对象 = 属性 + 方法

  • 封装：信息隐蔽技术

使用关键字 class 定义 Python 类

class Turtle:  # Python中的类名约定以大写字母开头
    """关于类的一个简单例子"""
    # 属性
    color = 'green'
    weight = 10
    legs = 4
    shell = True
    mouth = '大嘴'

    # 方法
    def climb(self):
        print('我正在很努力的向前爬...')

    def run(self):
        print('我正在飞快的向前跑...')

    def bite(self):
        print('咬死你咬死你!!')

    def eat(self):
        print('有得吃，真满足...')

    def sleep(self):
        print('困了，睡了，晚安，zzz')


tt = Turtle()
print(tt)
# <__main__.Turtle object at 0x0000007C32D67F98>

print(type(tt))
# <class '__main__.Turtle'>

print(tt.__class__) 
# <class '__main__.Turtle'>

print(tt.__class__.__name__)
# Turtle

tt.climb()
# 我正在很努力的向前爬...

tt.run()
# 我正在飞快的向前跑...

tt.bite()
# 咬死你咬死你!!

# Python类也是对象。它们是type的实例
print(type(Turtle))
# <class 'type'>
  • 继承：子类自动共享父类之间数据和方法的机制
class MyList(list):
    pass


lst = MyList([1, 5, 2, 7, 8])
lst.append(9)
lst.sort()
print(lst)

# [1, 2, 5, 7, 8, 9]
  • 多态：不同对象对同一方法响应不同的行动
class Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')


class People(Animal):
    def run(self):
        print('人正在走')


class Pig(Animal):
    def run(self):
        print('pig is walking')


class Dog(Animal):
    def run(self):
        print('dog is running')


def func(animal):
    animal.run()


func(Pig())
# pig is walking

self

Python 的 self 相当于 C++ 的 this 指针。

类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称（对应于该实例，即该对象本身），按照惯例它的名称是 self。在调用方法时，我们无需明确提供与参数 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("球C")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

python的魔方方法

类有一个名为__init__(self[, param1, param2…])的魔法方法，该方法在类实例化时会自动调用。


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

    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)


a = Ball("球A")
b = Ball("球B")
c = Ball("球C")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

公有和私有

Python 中定义私有变量只需要在变量名或函数名前加上“__”（两个下划线）。

# 类的私有属性实例

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

# Python的私有为伪私有
print(counter._JustCounter__secretCount)  # 2 
print(counter.__secretCount)  
# AttributeError: 'JustCounter' object has no attribute '__secretCount'

# 类的私有方法实例

class Site:
    def __init__(self, name, url):
        self.name = name  # public
        self.__url = url  # private

    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)

    def __foo(self):  # 私有方法
        print('这是私有方法')

    def foo(self):  # 公共方法
        print('这是公共方法')
        self.__foo()


x = Site('老马的程序人生', 'https://blog.csdn.net/LSGO_MYP')
x.who()
# name  :  老马的程序人生
# url :  https://blog.csdn.net/LSGO_MYP

x.foo()
# 这是公共方法
# 这是私有方法

x.__foo()
# AttributeError: 'Site' object has no attribute '__foo'

继承

派生类的定义
在这里插入图片描述
BaseClassName（基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用：
在这里插入图片描述
如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性。

# 类定义
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


s = student('小马的程序人生', 10, 60, 3)
s.speak()
# 小马的程序人生 说: 我 10 岁了，我在读 3 年级

上述代码中使用people.__init__(self, n, a, w) 继承父类的构造函数，使用super函数 super().__init__() 也可以

python支持多继承形式，但一般不使用，容易引起混乱
在这里插入图片描述
圆括号中父类的顺序，方法在子类中未找到时，从左到右查找父类中是否包含方法。

组合

class Turtle:
    def __init__(self, x):
        self.num = x


class Fish:
    def __init__(self, x):
        self.num = x


class Pool:
    def __init__(self, x, y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)

    def print_num(self):
        print("水池里面有乌龟%s只，小鱼%s条" % (self.turtle.num, self.fish.num))


p = Pool(2, 3)
p.print_num()
# 水池里面有乌龟2只，小鱼3条

类、类对象和实例对象

在这里插入图片描述
类对象只有一个，实例对象可以有多个
类属性：类里面方法外面定义的变量称为类属性。类属性所有的通过该类实例化的对象都能共享。

class A():
    a = 0  #类属性
    def __init__(self, xx):
        A.a = xx  #使用类属性可以通过 （类名.类属性）调用。

实例属性：实例属性和具体的某个实例对象有关系，并且一个实例对象和另外一个实例对象是不共享属性的，说白了实例属性只能在自己的对象里面使用，其他的对象不能直接使用，因为self是谁调用，它的值就属于该对象。

类属性和实例属性区别：

  • 类属性：类外面，可以通过实例对象.类属性和类名.类属性进行调用。类里面，通过self.类属性和类名.类属性进行调用。
  • 实例属性 ：类外面，可以通过实例对象.实例属性调用。类里面，通过self.实例属性调用。
  • 实例属性就相当于局部变量。出了这个类或者这个类的实例对象，就没有作用了。
  • 类属性就相当于类里面的全局变量，可以和这个类的所有实例对象共享。
# 创建类对象
class Test(object):
    class_attr = 100  # 类属性

    def __init__(self):
        self.sl_attr = 100  # 实例属性

    def func(self):
        print('类对象.类属性的值:', Test.class_attr)  # 调用类属性
        print('self.类属性的值', self.class_attr)  # 相当于把类属性 变成实例属性
        print('self.实例属性的值', self.sl_attr)  # 调用实例属性


a = Test()
a.func()

# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

b = Test()
b.func()

# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

a.class_attr = 200
a.sl_attr = 200
a.func()

# 类对象.类属性的值: 100
# self.类属性的值 200
# self.实例属性的值 200

b.func()

# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

Test.class_attr = 300
a.func()

# 类对象.类属性的值: 300
# self.类属性的值 200
# self.实例属性的值 200

b.func()
# 类对象.类属性的值: 300
# self.类属性的值 300
# self.实例属性的值 100

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

class A:
    def x(self):
        print('x_man')


aa = A()
aa.x()  # x_man
aa.x = 1
print(aa.x)  # 1
aa.x()
# TypeError: 'int' object is not callable

绑定

Python 严格要求方法需要有实例才能被调用（所谓绑定概念）

Python 对象的数据属性通常存储在名为.__ dict__的字典中，我们可以直接访问__dict__，或利用 Python 的内置函数vars()获取.__ dict__。

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__)
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000C3473DA048>, 'printXY': <function CC.printXY at 0x000000C3473C4F28>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

dd.setXY(4, 5)
print(dd.__dict__)
# {'x': 4, 'y': 5}

print(vars(CC))
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000632CA9B048>, 'printXY': <function CC.printXY at 0x000000632CA83048>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

print(CC.__dict__)
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000632CA9B048>, 'printXY': <function CC.printXY at 0x000000632CA83048>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

内置函数（BIF）

issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

  • 一个类被认为是其自身的子类。
  • classinfo可以是类对象的元组，只要class是其中任何一个候选类的子类，则返回True。
class A:
    pass


class B(A):
    pass


print(issubclass(B, A))  # True
print(issubclass(B, B))  # True
print(issubclass(A, B))  # False
print(issubclass(B, object))  # True

isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型，类似type()。

  • type()不会认为子类是一种父类类型，不考虑继承关系。
  • isinstance()会认为子类是一种父类类型，考虑继承关系。
  • 如果第一个参数不是对象，则永远返回False。
  • 如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常。
a = 2
print(isinstance(a, int))  # True
print(isinstance(a, str))  # False
print(isinstance(a, (str, int, list)))  # True


class A:
    pass


class B(A):
    pass


print(isinstance(A(), A))  # True
print(type(A()) == A)  # True
print(isinstance(B(), A))  # True
print(type(B()) == A)  # False

hasattr(object, name) 用于判断对象是否包含对应的属性。

class Coordinate:
    x = 10
    y = -5
    z = 0


point1 = Coordinate()
print(hasattr(point1, 'x'))  # True
print(hasattr(point1, 'y'))  # True
print(hasattr(point1, 'z'))  # True
print(hasattr(point1, 'no'))  # False

getattr(object, name[, default]) 用于返回一个对象属性值。

class A(object):
    bar = 1


a = A()
print(getattr(a, 'bar'))  # 1
print(getattr(a, 'bar2', 3))  # 3
print(getattr(a, 'bar2'))
# AttributeError: 'A' object has no attribute 'bar2'

setattr(object, name, value) 对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

class A(object):
    bar = 1


a = A()
print(getattr(a, 'bar'))  # 1
setattr(a, 'bar', 5)
print(a.bar)  # 5
setattr(a, "age", 28)
print(a.age)  # 28

delattr(object, name) 用于删除属性。

class property([fget[, fset[, fdel[, doc]]]]) 用于在新式类中返回属性值。

  • fget – 获取属性值的函数
  • fset – 设置属性值的函数
  • fdel – 删除属性值函数
  • doc – 属性描述信息
class C(object):
    def __init__(self):
        self.__x = None

    def getx(self):
        return self.__x

    def setx(self, value):
        self.__x = value

    def delx(self):
        del self.__x

    x = property(getx, setx, delx, "I'm the 'x' property.")


cc = C()
cc.x = 2
print(cc.x)  # 2

del cc.x
print(cc.x)
# AttributeError: 'C' object has no attribute '_C__x'

cc.x调用getx；cc.x = value调用setx；del cc.x调用delx。

魔方方法

  • 总是被双下划线包围，例如__init__
  • 总能够在适当的时候被自动调用
  • 魔方方法的第一个参数应为cls（类方法 一个类的名称） 或者self（实例方法 一个实例对象的名称）。

基本的魔方方法

__init__(self[, …]) 构造器，当一个实例被创建的时候调用的初始化方法

__new__(cls[, …]) 在一个对象实例化的时候所调用的第一个方法，在调用__init__初始化前，先调用__new__。

  • __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由 Python 解释器自动提供，后面的参数直接传递给__init__。
  • __new__对当前类进行了实例化，并将实例返回，传给__init__的self。但是，执行了__new__，并不一定会进入__init__，只有__new__返回了，当前类cls的实例，当前类的__init__才会进入。
class A(object):
    def __init__(self, value):
        print("into A __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into A __new__")
        print(cls)
        return object.__new__(cls)


class B(A):
    def __init__(self, value):
        print("into B __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into B __new__")
        print(cls)
        return super().__new__(cls, *args, **kwargs)


b = B(10)

# 结果：
# into B __new__
# <class '__main__.B'>
# into A __new__
# <class '__main__.B'>
# into B __init__

class A(object):
    def __init__(self, value):
        print("into A __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into A __new__")
        print(cls)
        return object.__new__(cls)


class B(A):
    def __init__(self, value):
        print("into B __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into B __new__")
        print(cls)
        return super().__new__(A, *args, **kwargs)  # 改动了cls变为A


b = B(10)

# 结果：
# into B __new__
# <class '__main__.B'>
# into A __new__
# <class '__main__.A'>

注：若__new__没有正确返回当前类cls的实例，那__init__是不会被调用的，即使是父类的实例也不行，将没有__init__被调用。

# 利用__new__实现单例模式。

class Earth:
    pass


a = Earth()
print(id(a))  # 260728291456
b = Earth()
print(id(b))  # 260728291624

class Earth:
    __instance = None  # 定义一个类属性做判断

    def __new__(cls):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance


a = Earth()
print(id(a))  # 512320401648
b = Earth()
print(id(b))  # 512320401648

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

class CapStr(str):
    def __new__(cls, string):
        string = string.upper()
        return str.__new__(cls, string)


a = CapStr("i love lsgogroup")
print(a)  # I LOVE LSGOGROUP

__del__(self) 析构器，当一个对象将要被系统回收之时调用的方法。

在这里插入图片描述

class C(object):
    def __init__(self):
        print('into C __init__')

    def __del__(self):
        print('into C __del__')


c1 = C()
# into C __init__
c2 = c1
c3 = c2
del c3
del c2
del c1
# into C __del__

__str__(self)
打印一个对象；使用%s格式化；str强转数据类型 时触发

__repr__(self) str的备胎
没有__str__的时候，执行__repr__
repr(obj)内置函数对应的结果是__repr__的返回值
使用%r格式化的时候 触发__repr__

class Cat:
    """定义一个猫类"""

    def __init__(self, new_name, new_age):
        """在创建完对象之后 会自动调用, 它完成对象的初始化的功能"""
        self.name = new_name
        self.age = new_age

    def __str__(self):
        """返回一个对象的描述信息"""
        return "名字是:%s , 年龄是:%d" % (self.name, self.age)
        
    def __repr__(self):
        """返回一个对象的描述信息"""
        return "Cat:(%s,%d)" % (self.name, self.age)

    def eat(self):
        print("%s在吃鱼...." % self.name)

    def drink(self):
        print("%s在喝可乐..." % self.name)

    def introduce(self):
        print("名字是:%s, 年龄是:%d" % (self.name, self.age))


# 创建了一个对象
tom = Cat("汤姆", 30)
print(tom)  # 名字是:汤姆 , 年龄是:30
print(str(tom)) # 名字是:汤姆 , 年龄是:30
print(repr(tom))  # Cat:(汤姆,30)
tom.eat()  # 汤姆在吃鱼....
tom.introduce()  # 名字是:汤姆, 年龄是:30
  • __str__(self) 的返回结果可读性强，str 的意义是得到便于人们阅读的信息。
  • __repr__(self) 的返回结果应更准确，repr 存在的目的在于调试，便于开发者使用。
import datetime

today = datetime.date.today()
print(str(today))  # 2021-01-27
print(repr(today))  # datetime.date(2021, 01, 27)
print('%s' %today)  # 2021-01-27
print('%r' %today)  # datetime.date(2021, 01, 27)
print('%s' %today)  # 2021-01-27

算术运算符

类型工厂函数，指的是“不通过类而是通过函数来创建对象”。

class C:
    pass


print(type(len))  # <class 'builtin_function_or_method'>
print(type(dir))  # <class 'builtin_function_or_method'>
print(type(int))  # <class 'type'>
print(type(list))  # <class 'type'>
print(type(tuple))  # <class 'type'>
print(type(C))  # <class 'type'>
print(int('123'))  # 123

# 这个例子中list工厂函数把一个元祖对象加工成了一个列表对象。
print(list((1, 2, 3)))  # [1, 2, 3]

__add__(self, other) 定义加法的行为：+
__sub__(self, other) 定义减法的行为：-

class MyClass:

    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

    # 两个对象的长相加，宽不变.返回一个新的类
    def __add__(self, others):
        return MyClass(self.height + others.height, self.weight + others.weight)

    # 两个对象的宽相减，长不变.返回一个新的类
    def __sub__(self, others):
        return MyClass(self.height - others.height, self.weight - others.weight)

    # 说一下自己的参数
    def intro(self):
        print("高为", self.height, " 重为", self.weight)


def main():
    a = MyClass(height=10, weight=5)
    a.intro()

    b = MyClass(height=20, weight=10)
    b.intro()

    c = b - a
    c.intro()

    d = a + b
    d.intro()


if __name__ == '__main__':
    main()

# 高为 10  重为 5
# 高为 20  重为 10
# 高为 10  重为 5
# 高为 30  重为 15

__mul__(self, other) 定义乘法的行为：*
__truediv__(self, other) 定义真除法的行为：/
__floordiv__(self, other) 定义整数除法的行为：// （取整）
__mod__(self, other) 定义取模算法的行为：%
__divmod__(self, other) 定义当被 divmod() 调用时的行为
divmod(a, b) 把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

在这里插入图片描述

反算术运算符

反运算的魔法方法多了一个“r”

a + b 这里加数是a，被加数是b，因此是a主动，反运算就是如果a对象的__add__()方法没有实现或者不支持相应的操作，那么 Python 就会调用b的__radd__()方法。
在这里插入图片描述

class Nint(int):
    def __radd__(self, other):
        return int.__sub__(other, self) # 注意 self 在后面


a = Nint(5)
b = Nint(3)
print(a + b)  # 8
print(1 + b)  # -2

增量赋值运算符

在这里插入图片描述

  • __ add__ 方法接收两个参数，返回它们的和，两个参数的值均不会改变。
  • __ iadd__方法同样接收两个参数，但它是属于 in-place 操作，就是说它会改变第一个参数的值，因为这需要对象是可变的，所以对于不可变对象没有__iadd__方法。

一元运算符

在这里插入图片描述

属性访问

在这里插入图片描述

class C:
    def __getattribute__(self, item):
        print('__getattribute__')
        return super().__getattribute__(item)

    def __getattr__(self, item):
        print('__getattr__')

    def __setattr__(self, key, value):
        print('__setattr__')
        super().__setattr__(key, value)

    def __delattr__(self, item):
        print('__delattr__')
        super().__delattr__(item)


c = C()
c.x
# __getattribute__
# __getattr__

c.x = 1
# __setattr__

del c.x
# __delattr__

描述符

[1] 12. 函数与Lambda表达式
[2] 13.类与对象

zzsn
关注
解析ELF文件
05-11
解析ELF文件，将ELF文件中的内容显示出来。
几种网格平滑算法的实现
热门推荐
u013339596的专栏
02-13 1万+
网格平滑 网格平滑属于数字几何处理领域的问题，计算机图形学和计算机辅助设计中，用多边形网格可以表示复杂的三维实体。随着三维扫描和曲面重建技术的发展，得到这些实体表面的多边形网格表示已经不是难事，但所得到的表面往往包含含噪声。在形状设计领域，在散乱点拟合和光滑形伏、纹理映射等应用领域，都有对平滑曲面的极大需求。故产生了网格平滑这一个研究点。   平滑前
M-Sphere - Floating
ciyi7065的博客
03-30 188
M-Sphere - Floating (2008) 艺人: M-Sphere名称: Floa...
float 不能用==,>=,<=
yazhouren的专栏
01-05 1786
因为如果a与b差不多时，得出的是大于呢？还是小于？ 所以只能用abs(a-b) 参考：c语言中float为什么不能直接用==与0比较 Floating point math is not exact. Simple values like 0.2 cannot be precisely represented using binary floating point num
Python地理数据处理库shapely支持函数总结
日进一步
12-21 1万+
Shapely是一个Python库，用于操作和分析笛卡尔坐标系中的几何对象。 本文通过部分示例介绍了空间处理库Shape的部分概念与操作函数。 官方文档：https://shapely.readthedocs.io/en/latest/manual.html#introduction 1、函数列表 函数类型 算子名称 Shapely包提供...
Python学习笔记(干货) 中文PDF完整版.pdf
最新发布
05-23
这份"Python学习笔记"涵盖了从环境搭建到基础语法，再到数据类型和控制结构等关键知识点，旨在为初学者提供全面的学习指导。 首先，1.1章节介绍了Python的基础，包括Python的起源和历史。Python是由Guido van ...
皮大庆Python学习笔记
04-16
Python基础入门教程，适合Python初学者，文档内容包括， 目录 前言 i 第一章 程序 1 1.1 程序 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 什么是调试 . . . . . . . . . . . . . . . ....
Python学习笔记
11-24
【Python学习笔记】这篇文档是作者根据个人学习经历和体会整理出的一份全面的Python学习指南，涵盖了从环境搭建到高级应用的多个方面。以下是各部分的详细内容： 1. Python环境搭建：这部分介绍了Python的基本信息...
python学习笔记.pdf
03-09
在这份《python学习笔记.pdf》中，记录了Python编程的基础知识和一些技巧，内容涵盖了字符串处理、变量操作、数据结构、循环、条件判断等方面。以下是对学习笔记中提到知识点的详细说明。 ### 字符串处理 在Python...
Python学习笔记--皮大庆.pdf.zip
10-11
【Python学习笔记--皮大庆.pdf.zip】是一个针对初学者的Python编程教程，源自英文书籍《How to think like a computer scientist》。这本书以易懂的方式介绍了Python语言的基础知识，旨在帮助没有编程背景的人快速...
24.Swap Nodes in Pairs (List; Two-Pointers)
weixin_30371875的博客
08-12 95
Given a linked list, swap every two adjacent nodes and return its head. For example,Given1->2->3->4, you should return the list as2->1->4->3. Your algorithm should use only const...
LeetCode 题解（186): Palindrome Linked List
08-17 296
题目： Given a singly linked list, determine if it is a palindrome. Follow up: Could you do it in O(n) time and O(1) space? 题解： O(1)space需要in-place的reverse后半拉list，然后比较，用两个指针找到后半拉的起始位置。 C++版：
掌握Android图像显示原理（中）
子者不语的专栏
09-19 4216
前言 在上一篇文章《Android图形渲染原理（上）》中，详细的讲解了图像消费者，我们已经了解了Android中的图像元数据是如何被SurfaceFlinger，HWComposer或者OpenGL ES消费的，那么，图像元数据又是怎么生成的呢？这一篇文章就来详细介绍Android中的图像生产者——SKIA，OPenGL ES，Vulkan，他们是Android中最重要的三支画笔。 图像生产者 OpenGL ES 什么是OpenGL呢？OpenGL是一套图像编程接口，对于开发者来说，其实就是一套C语言编写
华为编程规范
weixin_43083799的博客
08-29 3652
华为C/C++编程规范 1 排版 1-1：程序块要采用缩进风格编写，缩进的空格数为4个。 说明：对于由开发工具自动生成的代码可以有不一致。 1-2：相对独立的程序块之间、变量说明之后必须加空行。如下例子不符合规范： if (!valid_ni(ni)) { … // program code } repssn_ind = ssn_data[index].repssn_index;...
day20_Map
br的博客
10-25 111
day_20 Map hashSet 散列表 : 可以理解为数组保存元素是个链表 散列表中保存的是键值对(K和V) hashCode : hash算法,是把不定长的数据改变为定长的数据,是一种安全的加密算法,但不保证唯一 同一个对象生成多次hash值,那么值一定是相同的, 不同对象也有可能生成相同的hash值 添加过程 : 1 先调用添加的K,调用hashCode生成hash值 2 根据hash值计算数组下标 3 判断数组中该下标对应的位置上是否有元素 3.1 如果没有保存数据,就把该对象放到对应的下
Python演讲笔记1
weixin_33819479的博客
08-21 205
参考： 1.The Clean Architecture in Python (Brandon Rhodes) 2.Python Best Practice Patterns (Vladimir Keleshev) 3.Transforming Code into Beautiful, Idiomatic Python (Raymond Hettinger) 4. How to Wr...
C语言解析FLM(ELF)格式文件
^_^
04-10 8935
运行效果 flmparse.c /* * flmparse.c * * Created on: 2021年4月10日 * Author: hello */ #include <stdio.h> #include <stdint.h> #include <fcntl.h> #include <unistd.h> #include <ctype.h> #include "elf.h" #define FILENAME "..
TensorFlow学习笔记——MNIST数字识别问题
日积月累，天道酬勤
01-27 1393
本文通过一个实际问题来验证上篇文章中介绍的方法。
Java基础--List
weixin_39124328的博客
08-29 808
　　List是集合容器的一种，在分析List之前，我们先来了解一下集合体系的架构： Why–为什么需要集合 　　首先，Java是一门面向对象的语言，奉承一切皆对象的思想，在实际开发过程中，免不了要经常操作对象，而且会同时操作多个甚至大量对象，这时就需要一个专门存储这些对象的容器，这样就可以利用容器对象的特性来方便的进行操作。 　　其次，在Java中还有数组，也是一种容器，但和集合相比，数...
Python编程入门：Python学习笔记精华
"Python学习笔记由Java学习笔记作者撰写，旨在为Python初学者提供一份详细的教程。笔记强调Python的编程哲学，如简洁性、明确性和可读性，并涵盖Python的基础知识，包括基本环境与互动、内建特性、内建型态与操作、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值