python中的函数及面向对象的知识点

本文深入探讨Python中的函数定义与调用、参数类型、变量作用域、递归、闭包及lambda表达式等内容,并详细解析类与对象的概念,包括继承、多态、封装等面向对象特性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

函数

函数的定义

在这里插入图片描述

def functionname(parameters):
	```函数文档字符串```
    functionsuite
    return [expression]
  • 函数以def关键字开头,后接函数名和圆括号
  • 函数的执行代码以冒号起始,并且缩进
  • return【表达式】结束函数,选择性地返回一个值给调用方,不代表达式return相当于返回none

函数的调用

def printme(str):
    print(str)


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

函数文档

函数内的第一条语句是字符串时,该字符串就是文档字符串,也称为 docstring

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是形参

函数参数

python的函数具有非常灵活的参数形态,既可以实现简单的调用,又可以传入非常复杂的参数,从简到繁的参数形态如下:

  • 位置参数 (positional argument)
  • 默认参数 (default argument)
  • 可变参数 (variable argument)
  • 关键字参数 (keyword argument)
  • 命名关键字参数 (name keyword argument)
  • 参数组合
  1. 位置参数

    def functionname(arg1):
    "函数文档字符串"
    function
    suite
    return [expression]

    arg1 - 位置参数 ,这些参数在调用函数 (call function) 时位置要固定。

  2. 默认参数

    def functionname(arg1, arg2=v):
    "函数文档字符串"
    function
    suite
    return [expression]

    arg2 = v - 默认参数 = 默认值,调用函数时,默认参数的值如果没有传入,则被认为是默认值。
    默认参数一定要放在位置参数 后面,不然程序会报错。

  3. 可变参数:自动封装成一个元组(只读)

    顾名思义,可变参数就是传入的参数个数是可变的,可以是 0, 1, 2 到任意个,是不定长的参数。

    def functionname(arg1, arg2=v, * args):
    "函数文档字符串"
    function
    suite
    return [expression]

    *args - 可变参数,可以是从零个到任意个,自动组装成元组。这里与c++中的数组作为函数参数的方法类似,是传递一个地址变量
    -加了星号(*)的变量名会存放所有未命名的变量参数。

    def func(agr1,*agr2):#自动封装成一个元组,与c++中的数组传递类似
    	print(agr1)
    	for i in agr2:
    		print(i,end=' ')
    func(1,1,2,3,4)
    # 1
    #1 2 3 4
    
  4. 关键字参数

    def functionname(arg1, arg2=v, args, **kw):
    "函数
    文档字符串"
    function*suite
    return [expression]

    **kw - 关键字参数,可以是从零个到任意个,自动组装成字典。

    def func1(arg,*arg1,**arg2):
    	print(arg)
    	print(arg1)
    	print(arg2)
    
    func1(1,2,3,4,5,"a","b")
    #1
    #(2, 3, 4, 5, 'a', 'b')
    #{}
    func1(1,2,3,4,5,a=1,b=2)#参数中有赋值的时候,自动编排成一个字典
    #1
    #(2, 3, 4, 5)
    #{'a': 1, 'b': 2}
    
  5. 命名关键字参数

    def functionname(arg1, arg2=v, args, *, nkw, **kw):
    "函数
    文档字符串"
    function*suite
    return [expression]

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

    def printinfo(arg1, *, nkw, **kwargs):
        print(arg1)
        print(nkw)
        print(kwargs)
    
    #必须要有nkw这个关键字的赋值,否则会报错
    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
    #没有写参数名nkw,因此10会被当成一个位置参数,而原函数只有一个位置参数,现在调用了2个,因此程序会报错
    
  6. 参数组合

    位置参数、默认参数、可变参数、命名关键字参数和关键字参数,5种中的4个可以一起使用,但是参数定义的顺序必须是:

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

    • 位置参数、默认参数、命名关键字参数和关键字参数
      要注意定义可变参数和关键字参数的语法

    • *args是可变参数,args接受的是一个tuple

    • **kw是一个关键字参数,kw接收的是一个dict(a=1的形式去传入)

    命名关键字参数是为了限制调用者可以传入的参数名,同时可以提供默认值。定义命名关键字参数不要忘了写分隔符 *,否则定义的是位置参数。

变量作用域

  • Python 中,程序的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量是在哪里赋值的。
  • 定义在函数内部的变量拥有局部作用域,该变量称为局部变量。
  • 定义在函数外部的变量拥有全局作用域,该变量称为全局变量。
  • 局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。
  • 当内部作用域想修改外部作用域的变量时,就要用到globalnonlocal关键字了。
num = 1 #这是一个全局变量
num1 = 2 

def fun1():
    global num  # 需要使用 global 关键字声明
    print(num)  # 1
    num = 123#此时全局变量的值被更改
    print(num)  # 123
    nums1=234  #234局部变量更改

fun1()
print(num)  # 123
print(num1) # 2,全局变量仍然没有被更改

内嵌函数

为什么内部函数只能在内部被调用?

  • 因为函数内部的变量是有生命周期的,当函数运行结束之后就会被释放掉,所以无法在外部使用
  • 当我想在外部使用时,可以将内部函数返回,用一个地址变量去接收,然后再去调用,这也就是闭包的使用
def func():
	print("func函数被调用")
	def func1():
		print("func1函数被调用")

func()#func函数被调用
#此时没有调用到内嵌函数

def func():
	print("func函数被调用")
	def func1():
		print("func1函数被调用")
    func1()#该函数只能在内部被调用
func()
#func函数被调用
#func1函数被调用

闭包(闭包返回值通常都是一个函数)

  • 是函数式编程的一个重要的语法结构,是一种特殊的内嵌函数。
  • 如果在一个内部函数里对外层非全局作用域的变量进行引用,那么内部函数就被认为是闭包。
  • 通过闭包可以访问外层非全局作用域的变量,这个作用域称为 闭包作用域
def line_conf(a, b):
    def line(x):#内嵌函数使用的变量不属于自己,而在外部,形成了闭包
        return a * x + b
 
    return line#返回的对象是一个函数
# 定义两条直线
line_A = line_conf(2, 1)  # y=2x+b
line_B = line_conf(3, 2)  # y=3x+2
 
# 打印x对应y的值
print(line_A(1))  # 3
print(line_B(1))  # 5
  • 如果要修改闭包作用域中的变量则需要nonlocal关键字
def func():
	num=10
	print("func:",num)
	def func1():
		nonlocal num  #用nonlocal关键字声明我要修改这个变量
		num=100
		print("func1",num)
	
	func1()#此时变量已经被修改
	print(num)#100

func()

递归

  • 如果一个函数在内部调用自己本身,这个函数就是递归函数
#求n!
#用循环来写
def func(n):
	if n==0:
		return 1
	i,sum=1,1
	while i<n+1:
		sum=sum*i
		i=i+1
	return sum

print(func(4))#24


#用递归来写

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(4))#24

#斐波那契数列 f(n)=f(n-1)+f(n-2), f(0)=0 f(1)=1
#用递归来写

def func(n):
	if n<2:
		return n
	return func(n-1)+func(n-2)

lis=list()
for i in range(10):
	lis.append(func(i))
print(lis)

lambda-表达式

lambda函数的定义

在python里有两类函数:

  • 第一类:用def关键字定义的正规函数
  • 第二类:用lambda关键字定义的匿名函数

python使用lambda关键字来创建匿名函数,而非def关键字

lambda argument_list:expression

  • lambda-定义匿名函数的关键词
  • argument_list-函数参数,可以是位置参数、默认参数、关键词参数,和正规函数里的参数类型一样
  • :-冒号,在函数参数和表达式中间要加一个冒号
  • expression-只是一个表达式,输入函数参数,输出一些值
    • expression中没有return语句,因为lambda不需要它来返回,表达式本事结果 就是返回值
    • 匿名函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数
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

匿名函数的应用

函数式编程 是指代码中每一块都是不可变的,都由纯函数的形式组成。这里的纯函数,是指函数本身相互独立、互不影响,对于相同的输入,总会有相同的输出,没有任何副作用。

#非函数式编程
def f(x):
    for i in range(0, len(x)):
        x[i] += 10
    return x


x = [1, 2, 3]
f(x)
print(x)#x本身发生了变化,这里是用的地址传递的方式
# [11, 12, 13]

#函数式编程
def f(x):
    y=[]
    for item in x:
        y.append(item+10)
    print(y)#[11,12,13]
    return y
x=[1,2,3]
f(x)
print(x)#[1,2,3]

匿名函数 常常应用于函数式编程的高阶函数 (high-order function)中,主要有两种形式:

  • 参数是函数 (filter, map)
  • 返回值是函数 (closure)

如,在 filtermap函数中的应用:

  • filter(function, iterable) 过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象,如果要转换为列表,可以使用 list() 来转换。
  • map(function, *iterables) 根据提供的函数对指定序列做映射。
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]

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

类与对象

对象=属性+方法

对象是类的实例。换句话说,类主要定义对象的结构,然后我们以类为模板创建对象。类不但包含方法定义,而且还包含所有实例共享的数据。

  • 封装:信息隐蔽技术

我们可以使用关键字 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'>

继承:子类自动共享父类之间数据和方法的机制

Python 同样支持类的继承,派生类的定义如下所示:

class DerivedClassName(BaseClassName):
statement-1
.
.
.
statement-N

BaseClassName(基类名)必须与派生类定义在一个作用域内。除了类,还可以用表达式,基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):
statement-1
.
.
.
statement-N

  • 如果子类中定义与父类同名的方法或属性,则会自动覆盖父类对应的方法或属性。
class MyList(list):#继承list的数据和方法
    pass


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

# [1, 2, 5, 7, 8, 9]

# 类定义
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
        #如果上面的程序去掉:people.__init__(self, n, a, w),则输出:说: 我 0 岁了,我在读 3 年级,因为子类的构造方法把父类的构造方法覆盖了。

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


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

多态:不同对象对同一方法响应不同的行动

class Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')
#raise关键字是用来抛出异常的

class People(Animal):#继承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指针

class Test:
    def prt(self):
        print(self)
        print(self.__class__)


t = Test()
t.prt()
# <__main__.Test object at 0x000000BC5A351208>
# <class '__main__.Test'>

类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称(对应于该实例,即该对象本身),按照惯例它的名称是 self。在调用方法时,我们无需明确提供与参数 self 相对应的参数。

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

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


a = Ball()#这里的a就是额外的一个参数名称,也就是类必须要实例化才可以使用
a.setName("球A")
b = Ball()
b.setName("球B")
c = Ball()
c.setName("球C")
a.kick()
# 我叫球A,该死的,谁踢我...
b.kick()
# 我叫球B,该死的,谁踢我...

构造函数L:__ init __(self[, param1, param2…])

类有一个名为__init__(self[, param1, param2...])的魔法方法,该方法在类实例化时会自动调用。(c++中的构造函数?)

class Person:
	def __init__(self,name):#类似c++中的构造函数,会自动调用
		self.name=name


a=Person("k")
print(a.name)#不需要定义也可以直接引用?

公有和私有

在 Python 中定义私有变量只需要在变量名或函数名前加上“__”两个下划线,那么这个函数或变量就会为私有的了。(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 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(object):
pass

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

什么是绑定?

Python 严格要求方法需要有实例才能被调用,这种限制其实就是 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

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

  • type()不会认为子类是一种父类类型,不考虑继承关系。

  • isinstance()会认为子类是一种父类类型,考虑继承关系。

  • 如果第一个参数不是对象,则永远返回False

  • 如果第二个参数不是类或者由类对象组成的元组,会抛出一个TypeError异常。

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

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

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

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

  • class property([fget[, fset[, fdel[, doc]]]])
    

    用于在新式类中返回属性值。

    • fget – 获取属性值的函数
    • fset – 设置属性值的函数
    • fdel – 删除属性值函数
    • doc – 属性描述信息

魔法方法

魔法方法总是被双下划线包围,例如__init__

魔法方法是面向对象的 Python 的一切,如果你不知道魔法方法,说明你还没能意识到面向对象的 Python 的强大。

魔法方法的“魔力”体现在它们总能够在适当的时候被自动调用。

魔法方法的第一个参数应为cls(类方法) 或者self(实例方法)。

  • 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 时(比如int, str, tuple), 提供给你一个自定义这些类的实例化过程的途径。

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

Python 采用自动引用计数(ARC)方式来回收对象所占用的空间,当程序中有一个变量引用该 Python 对象时,Python 会自动保证该对象引用计数为 1;当程序中有两个变量引用该 Python 对象时,Python 会自动保证该对象引用计数为 2,依此类推,如果一个对象的引用计数变成了 0,则说明程序中不再有变量引用该对象,表明程序不再需要该对象,因此 Python 就会回收该对象。

大部分时候,Python 的 ARC 都能准确、高效地回收系统中的每个对象。但如果系统中出现循环引用的情况,比如对象 a 持有一个实例变量引用对象 b,而对象 b 又持有一个实例变量引用对象 a,此时两个对象的引用计数都是 1,而实际上程序已经不再有变量引用它们,系统应该回收它们,此时 Python 的垃圾回收器就可能没那么快,要等专门的循环垃圾回收器(Cyclic Garbage Collector)来检测并回收这种引用循环。

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):
    • 当你打印一个对象的时候,触发__str__
    • 当你使用%s格式化的时候,触发__str__
    • str强转数据类型的时候,触发__str__
  • __repr__(self)
    • reprstr的备胎
    • __str__的时候执行__str__,没有实现__str__的时候,执行__repr__
    • repr(obj)内置函数对应的结果是__repr__的返回值
    • 当你使用%r格式化的时候 触发__repr__

__str__(self) 的返回结果可读性强。也就是说,__str__ 的意义是得到便于人们阅读的信息,就像下面的 ‘2019-10-11’ 一样。

__repr__(self) 的返回结果应更准确。怎么说,__repr__ 存在的目的在于调试,便于开发者使用。

import datetime

today = datetime.date.today()
print(str(today))  # 2019-10-11
print(repr(today))  # datetime.date(2019, 10, 11)
print('%s' %today)  # 2019-10-11
print('%r' %today)  # datetime.date(2019, 10, 11)

算术运算符

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

c++中的运算符重载?

  • __add__(self, other)定义加法的行为:+
  • __sub__(self, other)定义减法的行为:-
  • __mul__(self, other)定义乘法的行为:*
  • __truediv__(self, other)定义真除法的行为:/
  • __floordiv__(self, other)定义整数除法的行为://
  • __mod__(self, other) 定义取模算法的行为:%
  • __divmod__(self, other)定义当被 divmod() 调用时的行为
  • divmod(a, b)把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)
  • __pow__(self, other[, module])定义当被 power() 调用或 ** 运算时的行为
  • __lshift__(self, other)定义按位左移位的行为:<<
  • __rshift__(self, other)定义按位右移位的行为:>>
  • __and__(self, other)定义按位与操作的行为:&
  • __xor__(self, other)定义按位异或操作的行为:^
  • __or__(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

反算术运算符

反运算魔方方法,与算术运算符保持一一对应,不同之处就是反运算的魔法方法多了一个“r”。当文件左操作不支持相应的操作时被调用。

  • __radd__(self, other)定义加法的行为:+
  • __rsub__(self, other)定义减法的行为:-
  • __rmul__(self, other)定义乘法的行为:*
  • __rtruediv__(self, other)定义真除法的行为:/
  • __rfloordiv__(self, other)定义整数除法的行为://
  • __rmod__(self, other) 定义取模算法的行为:%
  • __rdivmod__(self, other)定义当被divmod()调用时的行为
  • __rpow__(self, other[, module])定义当被 power() 调用或 ** 运算时的行为
  • __rlshift__(self, other)定义按位左移位的行为:<<
  • __rrshift__(self, other)定义按位右移位的行为:>>
  • __rand__(self, other)定义按位与操作的行为:&
  • __rxor__(self, other)定义按位异或操作的行为:^
  • __ror__(self, other)定义按位或操作的行为:|

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

增量赋值运算符

  • __iadd__(self, other)定义赋值加法的行为:+=
  • __isub__(self, other)定义赋值减法的行为:-=
  • __imul__(self, other)定义赋值乘法的行为:*=
  • __itruediv__(self, other)定义赋值真除法的行为:/=
  • __ifloordiv__(self, other)定义赋值整数除法的行为://=
  • __imod__(self, other)定义赋值取模算法的行为:%=
  • __ipow__(self, other[, modulo])定义赋值幂运算的行为:**=
  • __ilshift__(self, other)定义赋值按位左移位的行为:<<=
  • __irshift__(self, other)定义赋值按位右移位的行为:>>=
  • __iand__(self, other)定义赋值按位与操作的行为:&=
  • __ixor__(self, other)定义赋值按位异或操作的行为:^=
  • __ior__(self, other)定义赋值按位或操作的行为:|=

一元运算符

  • __neg__(self)定义正号的行为:+x
  • __pos__(self)定义负号的行为:-x
  • __abs__(self)定义当被abs()调用时的行为
  • __invert__(self)定义按位求反的行为:~x

属性访问

  • __getattr__(self, name): 定义当用户试图获取一个不存在的属性时的行为。
  • __getattribute__(self, name):定义当该类的属性被访问时的行为(先调用该方法,查看是否存在该属性,若不存在,接着去调用__getattr__)。
  • __setattr__(self, name, value):定义当一个属性被设置时的行为。
  • __delattr__(self, name):定义当一个属性被删除时的行为。

描述符

描述符就是将某种特殊类型的类的实例指派给另一个类的属性。

  • __get__(self, instance, owner)用于访问属性,它返回属性的值。
  • __set__(self, instance, value)将在属性分配操作中调用,不返回任何内容。
  • __del__(self, instance)控制删除操作,不返回任何内容。

定制序列

协议(Protocols)与其它编程语言中的接口很相似,它规定你哪些方法必须要定义。然而,在 Python 中的协议就显得不那么正式。事实上,在 Python 中,协议更像是一种指南。

容器类型的协议

  • 如果说你希望定制的容器是不可变的话,你只需要定义__len__()__getitem__()方法。
  • 如果你希望定制的容器是可变的话,除了__len__()__getitem__()方法,你还需要定义__setitem__()__delitem__()两个方法。

迭代器

  • 迭代是 Python 最强大的功能之一,是访问集合元素的一种方式。
  • 迭代器是一个可以记住遍历的位置的对象。
  • 迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。
  • 迭代器只能往前不会后退。
  • 字符串,列表或元组对象都可用于创建迭代器:

  • 迭代器有两个基本的方法:iter()next()
  • iter(object) 函数用来生成迭代器。
  • next(iterator[, default]) 返回迭代器的下一个项目。
  • iterator – 可迭代对象
  • default – 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。
links = {'B': '百度', 'A': '阿里', 'T': '腾讯'}

it = iter(links)#生成一个迭代器
while True:
    try:
        each = next(it)#指向下一个
    except StopIteration:
        break
    print(each)

# B
# A
# T

it = iter(links)
print(next(it))  # B
print(next(it))  # A
print(next(it))  # T
print(next(it))  # StopIteration

把一个类作为一个迭代器使用需要在类中实现两个魔法方法 __iter__()__next__()

  • __iter__(self)定义当迭代容器中的元素的行为,返回一个特殊的迭代器对象, 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
  • __next__() 返回下一个迭代器对象。
  • StopIteration 异常用于标识迭代的完成,防止出现无限循环的情况,在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

生成器

  • 在 Python 中,使用了 yield 的函数被称为生成器(generator)。
  • 跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。
  • 在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
  • 调用一个生成器函数,返回的是一个迭代器对象。
def myGen():
    print('生成器执行!')
    yield 1
    yield 2
    
myG = myGen()
for each in myG:
    print(each)

'''
生成器执行!
1
2
'''

myG = myGen()
print(next(myG))  
# 生成器执行!
# 1

print(next(myG))  # 2
print(next(myG))  # StopIteration
 = {'B': '百度', 'A': '阿里', 'T': '腾讯'}

it = iter(links)#生成一个迭代器
while True:
    try:
        each = next(it)#指向下一个
    except StopIteration:
        break
    print(each)

# B
# A
# T

it = iter(links)
print(next(it))  # B
print(next(it))  # A
print(next(it))  # T
print(next(it))  # StopIteration

把一个类作为一个迭代器使用需要在类中实现两个魔法方法 __iter__()__next__()

  • __iter__(self)定义当迭代容器中的元素的行为,返回一个特殊的迭代器对象, 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
  • __next__() 返回下一个迭代器对象。
  • StopIteration 异常用于标识迭代的完成,防止出现无限循环的情况,在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

生成器

  • 在 Python 中,使用了 yield 的函数被称为生成器(generator)。
  • 跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。
  • 在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
  • 调用一个生成器函数,返回的是一个迭代器对象。
def myGen():
    print('生成器执行!')
    yield 1
    yield 2
    
myG = myGen()
for each in myG:
    print(each)

'''
生成器执行!
1
2
'''

myG = myGen()
print(next(myG))  
# 生成器执行!
# 1

print(next(myG))  # 2
print(next(myG))  # StopIteration
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值