Python入门——类与对象

最新推荐文章于 2024-04-08 01:45:00 发布
最新推荐文章于 2024-04-08 01:45:00 发布
阅读量129 收藏
点赞数 1
分类专栏： python入门 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50888378/article/details/109299713
版权

目录

一、类与对象

1. 对象 = 属性 + 方法

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

  • 封装：信息隐蔽技术，**类把需要的变量（成员变量）和函数（成员函数）组合在一起，**这种包含也称之为“封装”

我们可以使用关键字 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.color  #访问的是属性 

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

2. 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 相对应的参数。即类的方法中至少有一个参数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,该死的，谁踢我...

3. Python 的魔法方法

据说，Python 的对象天生拥有一些神奇的方法，它们是面向对象的 Python 的一切…

它们是可以给你的类增加魔力的特殊方法…

如果你的对象实现了这些方法中的某一个，那么这个方法就会在特殊的情况下被 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()  #会出错，需要一个位置参数
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

4. 公有和私有

在 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

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

class Person:
    name = "小乌贼"     #公有变量

p = Person()
print(p.name)

#小乌贼


class Person:
    __name = "小乌贼"    #私有变量，

p = Person()
print(p.name)         #因为是私有变量所以会出错

'''
Traceback (most recent call last):
  File "F:/PycharmProjects/helloworld/HUAHUA.py", line 10, in <module>
    print(p.name)
AttributeError: 'Person' object has no attribute 'name'
'''



class Person:
    __name = "小乌贼"

p = Person()
print(p.__name)

'''
Traceback (most recent call last):
  File "F:/PycharmProjects/helloworld/HUAHUA.py", line 10, in <module>
    print(p.__name)
AttributeError: 'Person' object has no attribute '__name'

'''


class Person:
    __name = "小乌贼"
    def getName(self):    #获取私有变量的方法
        return self.__name
p = Person()
print(p.getName())  #小乌贼
print(p.__name)


'''

Traceback (most recent call last):
  File "F:/PycharmProjects/helloworld/HUAHUA.py", line 13, in <module>
    print(p.__name)
AttributeError: 'Person' object has no attribute '__name'
'''


class Person:
    __name = "小乌贼"
    def getName(self):
        return self.__name
p = Person()
print(p.getName())

print(p._Person__name) #伪私有

print(p.__name)

#小乌贼
#小乌贼
'''
Traceback (most recent call last):
  File "F:/PycharmProjects/helloworld/HUAHUA.py", line 14, in <module>
    print(p.__name)
AttributeError: 'Person' object has no attribute '__name'
'''

【例子】类的私有方法实例

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'

5. 继承

（继承父类的公有属性和方法，而不是父类对象的属性）

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

class DerivedClassName(BaseClassName):  #（）里面的BaseClassName为父类
    <statement-1>
    .
    .
    .
    <statement-N>

BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用：

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

【例子】如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性。

# 类定义
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)，则输出：说: 我 0 岁了，我在读 3 年级，因为子类的构造方法把父类的构造方法覆盖了。

【例子】

import random

class Fish:
    def __init__(self): #初始化 
        self.x = random.randint(0, 10)
        self.y = random.randint(0, 10)

    def move(self):
        self.x -= 1
        print("我的位置", self.x, self.y)


class GoldFish(Fish):  # 金鱼
    pass


class Carp(Fish):  # 鲤鱼
    pass


class Salmon(Fish):  # 三文鱼
    pass


class Shark(Fish):  # 鲨鱼
    def __init__(self):   #初始化鲨鱼饿不饿
        self.hungry = True

    def eat(self):  #饿的话就吃，不饿的话就不吃
        if self.hungry:
            print("吃货的梦想就是天天有得吃！")
            self.hungry = False
        else:
            print("太撑了，吃不下了！")
            self.hungry = True


g = GoldFish()  '''实例化对象'''
g.move()  # 我的位置 9 4
s = Shark()
s.eat() # 吃货的梦想就是天天有得吃！
s.move()  '''子类重写了父类的方法def __init__(self)，就会覆盖掉父类所以会报以下的错误'''
# AttributeError: 'Shark' object has no attribute 'x'

解决该问题可用以下两种方式：

  • 调用未绑定的父类方法Fish.__init__(self)
class Shark(Fish):  # 鲨鱼
    def __init__(self):
        Fish.__init__(self)   '''调用父类的方法，但是self是子类Shark的实例对象'''
        self.hungry = True

    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有得吃！")
            self.hungry = False
        else:
            print("太撑了，吃不下了！")
            self.hungry = True
  • 使用super函数super().__init__() ,这是更好的方法，好处在于不用给定父类的名字
class Shark(Fish):  # 鲨鱼
    def __init__(self):
        super().__init__()
        self.hungry = True

    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有得吃！")
            self.hungry = False
        else:
            print("太撑了，吃不下了！")
            self.hungry = True

Python 虽然支持多继承的形式，但我们一般不使用多继承，因为容易引起混乱。

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，Python 从左至右搜索，即方法在子类中未找到时，从左到右查找父类中是否包含方法。

【例子】

# 类定义
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))


# 另一个类，多重继承之前的准备
class Speaker:
    topic = ''
    name = ''

    def __init__(self, n, t):
        self.name = n
        self.topic = t

    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s" % (self.name, self.topic))


# 多重继承
class Sample01(Speaker, Student):
    a = ''

    def __init__(self, n, a, w, g, t):
        Student.__init__(self, n, a, w, g)
        Speaker.__init__(self, n, t)

# 方法名同，默认调用的是在括号中排前地父类的方法
test = Sample01("Tim", 25, 80, 4, "Python")
test.speak()  
# 我叫 Tim，我是一个演说家，我演讲的主题是 Python

class Sample02(Student, Speaker):
    a = ''

    def __init__(self, n, a, w, g, t):
        Student.__init__(self, n, a, w, g)
        Speaker.__init__(self, n, t)

# 方法名同，默认调用的是在括号中排前地父类的方法
test = Sample02("Tim", 25, 80, 4, "Python")
test.speak()  
# Tim 说: 我 25 岁了，我在读 4 年级

6. 组合

【例子】

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))  #.num得到的是一个整型变量


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

7. 类、类对象和实例对象

类对象和实例对象

(如果属性的名字和方法的名字相同，属性会覆盖方法。最好的方法是属性用名词命名，方法用动词命名)

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

# 类对象
class A(object):
    pass

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

【例子】

# 实例化对象 a、b、c都属于实例对象。
a = A()
b = A()
c = A()

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

【例子】

class A():
    a = 0  # 类属性

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

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

【例子】

class 类名():
    __init__(self)：
        self.name = xx #实例属性

类属性和实例属性区别

  • 类属性：类外面，可以通过实例对象.类属性和类名.类属性进行调用。类里面，通过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

8. 什么是绑定？

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__) #实例化.__dict__
# {}

print(vars(dd))
# {}



print(CC.__dict__) #类对象.__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)   #实际上是以dd.setXY(dd,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}

9. 一些相关的内置函数（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   '''obeject被认为是所有类的基类'''
  • 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)用于判断对象是否包含对应的属性。注意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', '您所访问的属性不存在'))  # 您所访问的属性不存在
print(getattr(a, 'bar2'))
# AttributeError: 'A' object has no attribute 'bar2'

【例子】这个例子很酷！

class A(object):
    def set(self, a, b):
        x = a
        a = b
        b = x
        print(a, b)


a = A()
c = getattr(a, 'set')
c(a='1', b='2')  # 2 1
  • 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 Coordinate:
    x = 10
    y = -5
    z = 0


point1 = Coordinate()

print('x = ', point1.x)  # x =  10
print('y = ', point1.y)  # y =  -5
print('z = ', point1.z)  # z =  0

delattr(Coordinate, 'z')

print('--删除 z 属性后--')  # --删除 z 属性后--
print('x = ', point1.x)  # x =  10
print('y = ', point1.y)  # y =  -5

# 触发错误
print('z = ', point1.z)
# AttributeError: 'Coordinate' object has no attribute 'z'
  • 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'

练习题：

1、以下类定义中哪些是类属性，哪些是实例属性？

class C:
    num = 0      #类属性
    def __init__(self):
        self.x = 4   #实例属性
        self.y = 5   #实例属性
        C.count = 6  #类属性

2、怎么定义私有方法？
访问私有变量、方法：
私有变量:实例._类名__变量名
私有方法:实例._类名__方法名()

定义私有变量和方法：

class Dog():
    def __init__(self,name):
        self.name = name
        self.__age = 0  #定义可一个私有属性，属性的名字为__age

    def __test1(self):     #私有方法，核心的方法不想暴露，可以这样操作
        print("核心方法")

    def test2(self):       #共有方法
        self.__test1()     #可以在类里调用私有方法
        print("-------2--------")

dog = Dog("keke")
#dog.test1()   无法再调用test1()
dog.test2()

3、尝试执行以下代码，并解释错误原因：

class C:
    def myFun():
        print('Hello!')
    c = C()   #应该采用缩进格式
    c.myFun() #应该采用缩进格式
    
class C:
    def myFun(self):  #且添加self
        print('Hello!')
c = C()   #应该采用缩进格式
c.myFun() #应该采用缩进格式

4、按照以下要求定义一个游乐园门票的类，并尝试计算2个成人+1个小孩平日票价。

要求:

  • 平日票价100元
  • 周末票价为平日的120%
  • 儿童票半价
class Ticket():

    def usual(self,x,y):
        self.adult = 100*x
        self.child = 50*y
        ufare = self.adult + self.child
        print('%d个成人+%d个小孩的平日票价为：%d'%(x,y,ufare))

    def weekend(self,x,y):
        self.adult = 120 * x
        self.child = 60 * y
        wfare = self.adult + self.child
        print('%d个成人+%d个小孩的周末票价为：%d'%(x,y,wfare))

fare1 = Ticket()
fare1.usual(2,1)

fare2 = Ticket()
fare2.weekend(2,1)


'''
2个成人+1个小孩的平日票价为：250
2个成人+1个小孩的周末票价为：300
'''
小橙子喜欢吃果冻
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java Lambda表达式引用类方法
weixin_45966674的博客
01-11 379
因为我们 numberFl 拿到参数 其实也就是把参数给了里面的 Integer类的parseInt方法 然后返回 parseInt给出的返回值。我们这里 利用了 Lambda 的原则 当Lambda被类的静态方法引用时 则 Lambda的参数全部传给静态方法。可以看到 我们在接口中定义了一个抽象方法 这个方法 接收一个字符串类型的参数 然后返回一个数字类型的值。而引用类方法是Lambda支持的方法引用中的一种。我们将测试类的main方法修改如下。
刻意练习：Python基础 -- Task10. 类与对象
老马的程序人生
10-07 807
背景 提出问题 Python 基础语法 1. 对象 = 属性 + 方法 对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。 封装：信息隐蔽技术 我们可以使用关键字class定义Python类，关键字后面紧跟类的名称、分号和类的实现。 class Turtle: # Python中的类名约定以大写字母开头 ...
【Python技术栈】02 Python3 Code 函数、类与继承、装饰器
E.W的博客
10-17 1066
12
python3: 类，实例和type 的关系， 类的继承关系
上海 彭彭
10-18 849
1.类，实例，type 的关系 类一共有两种 ， 第一是内置的 比如 str, int, list 第二种就是 自定义的， 比如 Class Student: pass 比如 ： int 1 通过 type(1) 可以得到 1 就是 int 类 的一个实例 对象， 同样 通过 type（int） 可以得出， int 是type 类的实例对象 type, 通过type（object）同...
python笔记4 内置函数,匿名函数.递归函数 面向对象(基础, 组合,继承)
weixin_30559481的博客
12-19 162
内置函数 eval和exec eval :执行字符串中的代码并将结果返回给执行者,有返回值 exec:执行字符串中的代码,往往用于执行流程语句,没有返回值. s1 = '1+2' s2 = 'print(666)' print(eval(s1)) eval(s2) print(exec(s1)) exec(s2) 3 666 None 666 compile...
Python入门——类，面向对象的编程
12-21
【Python入门——类，面向对象的编程】 面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计中的实体抽象为对象，通过对象来封装数据和行为，实现代码的复用和模块化。在Python中，类是...
Python入门——组合数据类型
12-21
【Python入门——组合数据类型】 Python 是一门高级编程语言，其强大的数据结构使得它易于学习和使用。在Python中，组合数据类型是指可以容纳多个不同类型数据的容器，主要包括列表（List）、元组（Tuple）、字典...
Python进阶学习之——类和对象
01-20
Python进阶学习之——类和对象 微信关注公众号：夜寒信息 致力于为每一位用户免费提供更优质技术帮助与资源供给，感谢支持！     在原来我发布过Python入门学习的学习笔记，到迟迟没有更新进阶学习的博客。今天...
Python入门——基础篇
06-27
Python语言入门，基础篇，思维导图格式，精简版（输入输出、数据类型、条件语句、循环、字符串等常用操作、文件操作、函数、类和对象，异常、模块和包），仅供参考
Python入门——四大容器解析
01-21
在Python中，有四大数据结构：列表List、元组Tuple、集合Set、字典Dict 因为软件需要大量的代码去解决需求，简单的代码不一定能解决问题，四大数据结构的结合调用可以完成需要的功能。 一.列表 List 1.什么是列表？ ...
Python学习之-私有变量、方法
最新发布
Summer的博客
04-08 991
在Python中，不像一些其他编程语言如Java或C++，并没有严格意义上的“私有”函数。不过，Python有一种约定俗成的做法来指示一个函数是私有的，这意味着它不应该被外部访问。在Python中，如果你想定义一个私有函数，你可以在函数名称前加上两个下划线__。这会触发一个名字改编（name mangling）的过程，使得这个函数在外部不容易被直接访问。这种机制的目的是为了“伪私有”，实际上是提供了一种弱保护措施来避免子类意外覆盖基类的方法。
类中函数定义和声明时关键字用法
u014088674的专栏
08-14 1605
函数的const型需要在声明和定义处都写上 关键字inline可在声明和定义的任意一处或两处都标注 explicit只能用在类的定义体内部，当要在外部定义函数时不再重复 mutable指明可变成员，即使后来定义了一个const的对象，其他成员不能改变，但mutable成员依然可以改变 关键字friend只能出现在类定义体内，在类定义体内的位置可以随意，其性质不受其声明位置的访问控制标示符控
0基础,跟我一起学python--基础篇(3)
奇点
08-02 816
类(Class)用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。就是对对象共有属性的抽象。类中定义的函数。（第一个参数上self）类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。类变量或者实例变量用于处理类及其实例对象的相关的数据。如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。定义在方法中的变量，只作用于当前实例的类。...
python类的学习（1）
m0_54939753的博客
01-04 765
类(Class):用来描述具有相同的属性和方法的对象的集合。 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。 类的创建​​​​ class ClassName: '类的帮助信息' #比如用于..功能，过ClassName.__doc__查看。 class_suite #类体，由类成员，方法，数据属性组成。 ...
python-day25(正式学习)
Wjx510010104的博客
08-28 152
目录 组合 多态 多态性 好处 封装 两个层面 property 组合 组合就是一个类的对象具备某一个属性，该属性的值是指向另外外一个类的对象 组合是用来解决类与类之间代码...
python_Day07||Lambda表达式&类与对象上
rphyllis的博客
04-13 140
Lambda表达式 1.匿名函数的定义 python中有两类函数，一是用def关键词定义的正规函数，二是用关键词lambda定义的匿名函数 #lambda argument_list: expression # 1.lambda - 定义匿名函数的关键词。 # 2.argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。 # 3.: - 冒号，在函数参数和表达式中间要加个冒号。 # 4.expression - 只是一个表达式，输入函数参数，输出一些值
Python中的类（class）、属性、继承和方法
qq_36362028的博客
09-04 2133
# 多态的三个例子： 1、x.count() str.count() 2、 1+2 'he'+'xianmin' 3、 repr(x) 无论x传什么都是原样 # 类 ： 将 首字母大写的单数 为类的名称 # 创建实例时实例的存储空间 以及 实例外调用类内的属性 的 例子 class MemberCounter: #创建一个类 ！！...
Python中lambda 函数详解与运用
热门推荐
chl183的博客
06-07 1万+
Python中lambda 函数详解与运用一、lambda表达式介绍二、lambda语法三、lambda 特性四、lambda 常见用法五、lambda 结合其它函数 一、lambda表达式介绍 python中有一种灵活，便捷的且具有函数功能的表达式：lambda表达式！ lambda表达式，又称匿名函数，是现代各种编程语言争相引入的一种语法，其功能堪比函数，设计却比函数简洁。 二、lambda语法 lambda [parameter_list] : expression 根据其语法格式可以得到lamb
小甲鱼《零基础学习Python》课后笔记（三十七）：类和对象——面向对象编程
小火柴棒的博客
11-07 1634
本篇是学习Python的第三十七课。介绍面向对象编程。
Python入门：面向对象编程与类的基础
标题："快速学习Python：面向对象编程基础入门" 在这个关于快速学习Python的指南中，重点讲解了面向对象编程（Object-Oriented Programming, OOP）的基础概念。Python作为一种高度面向对象的语言，其设计思想本身就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值