一、self的使用方法

---

class Student(object):def _init_(self, x, y):self.name = xself.age = ydef say_hello(self):print('大家好，我是', self.name)   s1 = Student('张三', 18)
print('s1的名字是', s1.name)
s1.say_hello()

输出：
s1的名字是 张三
大家好，我是 张三

student('张三‘,18)这段代码具体做了什么

  1.调用 __ __new__方法 ，申请内存空间2.调用__init____，传入参数并让self指向申请好的内存空间，填充数据3.让变量  s1 也指向创建好的内存空间

注：
1如果类中没有指向的属性，则报错
2如果直接使用等号给属性赋值，如果这个属性以前不存在，会给对象添加一个新属性；如果这个属性以前存在，会修改这个属性对应的值

class Student(object):def _init_(self, x, y):self.name = xself.age = ydef say_hello(self):print('大家好，我是', self.name) s = Student('张三', 18)
s.city = '上海'#给对象添加一个city属性
print(s.city)
s.name = 'jack'
print(s.name)

输出
上海
jack

谁调用self，self就指向谁

二、__ slots__属性的使用

__ slots__=()
这个属性直接定义在类里，不被定义在__init__中，是一个元组，用来规定可以存在的属性

代码如下（示例）：

class Student(object):__slots__ = ('name', 'age')def _init_(self, x, y):self.name = xself.age = ydef say_hello(self):print('大家好，我是', self.name)

slots = (‘name’, ‘age’)允许类中有name，age属性，不允许添加其他属性

三、魔法方法（魔术方法）

是类里的特殊的一些方法
特点：1.不需要手动调用（也可以手动调用）会在合适的时机自动调用
2.这些方法都是__开始，___结束
3.方法名都是系统规定好的，在合适的时机自己的调用

1.__ init__(self) __ def__(self)

class Person(object):
#当对象在创建时，会自动调用这个方法def __init__(self, name, age):print('__init__方法被调用了')self.name = nameself.age = agedef __del__(self):#当对象被销毁时，会自动调用这个方法print('__del__方法被调用了')p = Person('zhangsan', 18)

输出
__init__方法被调用了
__del__方法被调用了

2.__ str__(self): __ repr__(self)

如果不做任何修改，直接打印一个对象，打印出的是对象的类型及内存地址

class Person(object):def __init__(self, name, age):print('__init__方法被调用了')self.name = nameself.age = agep = Person('zhangsan', 18)
print(p)

__init__方法被调用了
<__main__.Person object at 0x0000012E3D1D64F0>

当大一一个对象的时候，会调用这个对象的 __ str __ 和 __repr __方法

class Person(object):def __init__(self, name, age):print('__init__方法被调用了')self.name = nameself.age = agedef __repr__(self):return 'hello'def __str__(self):return 'good'p = Person('zhangsan', 18)
print(p)

输出
__init__方法被调用了
good

如果两个方法都有，选择__ str __
当然也可以手动调用

print(repr({'name': 'zhangsan', 'age': 18}))
print(repr(p))
print(p.__repr__())

输出：
{'name': 'zhangsan', 'age': 18}
hello
hello

如果直接输入对象，则代码为：

class Person(object):def __init__(self, name, age):print('__init__方法被调用了')self.name = nameself.age = agedef __repr__(self):return 'hello'def __str__(self):return '姓名：{}，年龄：{}'. format(self.name, self.age)p = Person('zhangsan', 18)
print(p)

输出：
__init__方法被调用了
姓名：zhangsan，年龄：18

两种方法都会修改一个对象转换成为字符串的结果，一般来说__str__方法的结果更加在意可读性，而__repr__方法的结果更加在意正确性。

3 __ call__(self, *args, **kwargs)

对象名（）=>调用这个对象的p. __ __call____方法
args 是一个元组
kwargs是一个字典

class Person(object):def __init__(self, name, age):print('__init__方法被调用了')self.name = nameself.age = agedef __call__(self, *args, **kwargs):print('__call__方法被调用了')print('args={},kwargs={}'.format(args, kwargs))fn = kwargs['fn']return(fn(args[0], args[1]))
p = Person('zhangsan', 18)
n = p(1, 2, fn=lambda x, y: x + y)
print(n)

输出
__init__方法被调用了
__call__方法被调用了
args=(1, 2),kwargs={'fn': <function <lambda> at 0x000001C9272FFAF0>}
3

4运算符相关的魔法方法

比较运算符

is身份运算符，可以用来判断两个对象是否是同一个对象（比较两个对象的内存地址）
’==‘会调用对象的__ __eq____方法，获取这个方法的比较结果

class Person(object):def __init__(self, name, age):self.name = nameself.age = agedef __eq__(self, other):print('__eq__方法被调用了，other=', other)if self.name == other.name and self.age == other.age:return Truereturn Falsedef __ne__(self, other):return'hello'def __gt__(self, other):return self.age > other.agedef __ge__(self, other):return self.age >= other.agedef __lt__(self, other):return self.age < other.agedef __le__(self, other):return self.age <= other.agep1 = Person('zhangsan', 18)
p2 = Person('zhangsan', 18)
p3 = Person('lisi', 19)
print('0x%X' % id(p1))
print('0x%X' % id(p2))
print('p1 is p2', p1 is p2)
print('p1==p2', p1 == p2)#p1 ==p2  本质就是调用p1.__eq__(p2),获取这个方法的返回结果
print('p1 != p2', p1 != p2)#p1 != p2  调用p1.__ne__(p2)或 p1.__eq__（p2)方法取反
print('p1 > p3', p1 > p3)#p1 > p3   调用p1.__gt__(p3)
print('p1 >= p2', p1 >= p2)#p1 >=p3 调用p1.__ge__(p2)
print('p1 < p3', p1 < p3)#p1<p3  调用p1.__lt__(p3)
print('p1 <= p2', p1 <= p2)#p1<=p2  调用p1.__le__(p2)

输出：
0x17903A064F0
0x17903B52D60
p1 is p2 False
__eq__方法被调用了，other= <__main__.Person object at 0x0000017903B52D60>
p1==p2 True
p1 != p2 hello
p1 > p3 False
p1 >= p2 True
p1 < p3 True
p1 <= p2 True

算数运算符

class Person(object):def __init__(self, name, age):self.name = nameself.age = agedef __add__(self, other):return self.age + other.agedef __sub__(self, other):return self.age - other.agedef __mul__(self, other):return self.age * other and self.name * 3def __truediv__(self, other):return self.age / otherdef __mod__(self, other):return self.age % otherdef __pow__(self, power, modulo=None):return self.age ** powerp1 = Person('zhangsan', 18)
p2 = Person('zhangsan', 18)
p3 = Person('lisi', 19)
print('p1 + p2', p1 + p2)#p1+p2 调用p1.__add__(p2)
print('p3 - p2', p3 - p2)#p3-p2  调用p3.__sub__(p2)
print('p1 * 3', p1 * 3)#p1*3  调用p1.__mul__(3)
print('p1 / 3', p1 / 3)#p1/3  调用p1.__truediv__(3)
print('p1 % 4=', p1 % 4)#p1%4  调用p1.__mod__(4)
print('p1 ** 2=', p1 ** 2)#幂运算p1**2  调用p1.__pow__(2)

输出
p1 + p2 36
p3 - p2 1
p1 * 3 zhangsanzhangsanzhangsan
p1 / 3  6.0
p1 % 4= 2
p1 ** 2= 324

类型转换

class Person(object):def __init__(self, name, age):self.name = nameself.age = agedef __str__(self):return 'hello'def __int__(self):return  20def __float__(self):return 1100.5p1 = Person('zhangsan', 18)
p2 = Person('zhangsan', 18)
p3 = Person('lisi', 19)
print(str(p1))#转换成字符串。默认会转换成类型+内存地址
print(int(p1))#转换成整型
print(float(p1))#转换成浮点型

输出
hello
20
1100.5

注：

print(int(p1))#只调用了__int__,没有调用__str__
print(p1)#调用了__str__

四、内置属性

1相关内置属性

class Person(object):'''这是一个人类'''def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print(self.name + '正在吃饭')p = Person('zhangsan', 18)
print(dir(p))
print(p.__class__)#<class '__main__.Person'>
print(p.__dict__)#将对象属性及其值转换成一个字典
# print(p.__dir__())  等价于print(dir(p))
print(p.__doc__)#查看文档内容   对象名.__doc__
print(Person.__doc__)#         类名.__doc__
print(p.__module__)#模块名

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'eat', 'name']
<class '__main__.Person'>
{'name': 'zhangsan', 'age': 18}这是一个人类这是一个人类__main__

2把对象当作字典用

可以将对象转成字典，但不能将对象当作字典来使用

class Person(object):def __init__(self, name, age, city):self.name = nameself.age = ageself.city = city#    def __setitem__(self, key, value):
#       print('setitem方法被调用，key = {}, value = {}'.format(key, value))     输出结果：setitem方法被调用，key = name, value = jackdef __setitem__(self, key, value):p1.__dict__[key] = value#先转换成字典，在用字典的的方法修改def __getitem__(self, item):#获取将对象转变成字典后，字典中的值return self.__dict__[item]p1 = Person('zhangsan', 18, '山西')
print(p1.__dict__)#将对象转换成字典
p1['name'] = 'jack'#[]调用__setitem__,__setitem__用来设置值
print(p1.name)#  输出结果：jack
print(p1['name'])#获取将对象转变成字典后，字典中的值

输出：
{'name': 'zhangsan', 'age': 18, 'city': '山西'}
jack

3类属性和对象属性

1.对象属性

class Person(object):def __init__(self, name, age):self.name = nameself.age = age
#对象 p1和 p2 是通过 Person 类创建出来的实例对象
#name 和 age是对象属性，在__inie__里以参数形式定义的
#实例对象属性之间互不干扰
p1 = Person('zhangsan', 18)
p2 = Person('lisi', 19)
x = p1#定义一个变量x，=的赋值是内存地址的赋值，x指向p1的内存地址print('0x%0X' % (id(Person)))#0x2152C698380

2类属性

类属性只能通过类对象修改，实例对象无法修改。
类属性修改，实例对象里的类属性也会被修改

class Person(object):type = '人类'#这个属性为类属性，在类中定义，函数之外def __init__(self, name, age):self.name = nameself.age = age
p1 = Person('zhangsan', 18)
p2 = Person('lisi', 19)
print(Person.type)#可以通过类对象获取类属性
print('p1.type', p1.type)#可以通过实例对象来获取类属性#类属性修改
Person.type = 'monkey'
print('Person.type', Person.type)
print('p1.type', p1.type)

人类
p1.type 人类
Person.type monkey
p1.type monkey

总结：

4私有属性

以两个下划线开始的属性是私有属性，私有属性在类里是可以被访问到的，而在外部，需要一些方式才可以被访问的。
获取私有变量的方式：
1 使用 对象名._类名__私有变量名（第一个为一个下划线，第二个为两个下划线）
2.定义get和set方法来获取
3.使用property来获取（）

私有函数
以两个下划线开头的函数是私有函数，外部不能调用,只能在类的内部调用，
获取私有函数方法：
可以使用 对象名._类名__私有函数名 进行调用

import datetime
class Person(object):def __init__(self, name, age):self.name = nameself.age = ageself.__money = 1000#以两个下划线开始的变量是私有变量# def test(self):#    self.__money += 10   #在这里私有属性是可以被访问的def get_money(self):#该方法可以用于记录print('{}查询了余额'.format(datetime.datetime.now()))return self.__moneydef set_money(self, qian):if type(qian) != int:print('余额不合法')return Falseprint('修改余额')self.__money = qiandef __demo(self):print('我是demo函数，name={}'.format(self.name))#以两个下划线开头的函数是私有函数，外部不能调用,只能在类的内部调用p = Person('zhangsan', 18)
print(p.name, p.age)#name ，age 可以直接获取
#print(p.__money)   #不能通过对象直接获取到私有变量
#p.test()
p._Person__demo()#可以使用 对象名._类名__私有函数名 进行调用  #输出结果：我是demo函数，name=zhangsan
#获取私有变量的方式：
#1  使用 对象名._类名__私有变量名（第一个为一个下划线，第二个为两个下划线）
#print(p._Person__money)   输出结果：1010#2.定义get和set方法来获取
print(p.get_money())  #输出结果：2022-12-19 15:40:09.902182查询了余额 1000
p.set_money(100)#输出结果：修改余额
print(p.get_money())#输出结果：2022-12-19 15:40:09.902182查询了余额   100#3.使用property来获取（）

输出：
zhangsan 18
我是demo函数，name=zhangsan
2022-12-19 15:40:09.902182查询了余额
1000
修改余额
2022-12-19 15:40:09.902182查询了余额
100

五、类方法和静态方法

（1）对象方法

class Person(object):def __init__(self, name, age):self.name = nameself.age = agedef eat(self, food):#对象方法有一个参数  self  它指的是实例对象print(self.name + '正在吃' + food)p1 = Person('zhangsan', 18)
p2 = Person('lisi', 19)
#实例对象在调用实例方法时，不需要给形参self传参，会自动的把实例对象传递给selfprint(p1.eat)#输出：<bound method Person.eat of <__main__.Person object at 0x0000024D52AF4670>>   **p1 对eat进行了绑定**
print(p2.eat)#输出：<bound method Person.eat of <__main__.Person object at 0x0000024D529964F0>>   **p2对eat进行了绑定**
print(p1.eat is p2.eat)#输出：False   说明两个实例中用的eat函数不一样，daneat函数存放在Person类中，p1 和 p2 对eat函数用绑定方式，不同的对象绑定不同的
print(Person.eat)#输出：<function Person.eat at 0x0000015CA1D70C10>#对象方法
#eat 是对象方法，可以直接使用  实例对象.方法名（参数）  调用
#使用  对象名.方法名（参数）  调用的方式，不需要传递self，会自动将对象名传递给self
p1.eat('红烧牛肉面')#直接使用实例对象调用方法#对象方法还可以使用  类对象来调用
#  类名.方法名（）   这种方式不会自动给self传参，需要手动的指定self
Person.eat(p2, '西红柿鸡蛋面')
print(Person.eat)#输出：lisi正在吃西红柿鸡蛋面

输出：
<bound method Person.eat of <__main__.Person object at 0x0000024D52AF4670>>
<bound method Person.eat of <__main__.Person object at 0x0000024D529964F0>>
False
<function Person.eat at 0x0000015CA1D70C10>
zhangsan正在吃红烧牛肉面
lisi正在吃西红柿鸡蛋面

（2）静态对象

静态方法不需要用到实例对象中的任何属性，所以静态方法可以直接通过类调用不需要创建实例对象再通过实例对象调用
静态方法举例：

#静态方法
#如果一个方法里没有用到实例对象的任何一个属性，可以将这个方法成staticmethod
class Person(object):@staticmethoddef demo():   #静态方法print('hello')
class Calculator(object):@staticmethoddef add(a, b):return a + b@staticmethoddef minus(a, b):return a - b
#静态方法的调用
Person.demo()
p1.demo()print(Calculator.add(1, 2))
print(Calculator.minus(1, 4))

输出：
hello
hello
3
-3

（3）类方法

#如果这个函数只用到了类属性，可以定义成一个类方法
class Person(object):type = 'human'@classmethoddef test(cls):#如果这个函数只用到了类属性，可以定义成一个类方法#类方法会有一个参数  cls  ，也不需要手动的传参，会自动传参#cls  指的是类对象print(cls.type)print('yes')#类方法可以使用实例对象和类对象调用
p1.test()
Person.test()

输出：
yes
human
yes

总结：

六、单例设计模式

class Singleton(object):__instance = None#私有属性，只能在类里使用__is_first = True@classmethoddef __new__(cls, *args, **kwargs):# 申请内存，创建一个对象，并把对象的类型设置为clsif cls.__instance is None:cls.__instance = object.__new__(cls)return cls.__instancedef __init__(self, a, b):if self.__is_first:#如果是第一次执行   **防止内存内容被修改**self.a = aself.b = bself.__is_first = False#调用__new__方法申请内存
#如果不重写__new__方法，会调用 object 的__new__方法
#object 的__new__方法会申请内存
#如果重写了__new__方法，需要自己手动的申请内存
s1 = Singleton('hh', 'xx')
s2 = Singleton('cc', 'dd')
print(type(s1))
print(s1 is s2)

输出：
<class '__main__.Singleton'>
True
hh xx

图示：

七、继承

封装： 函数是对语句的封装；类是对函数和变量的封装
继承：类和类之间可以人为地建立父子关系，父类的属性和方法子类都可以使用
多态：是一种技巧，提高代码灵活度

（1）基本使用

class Animal(object):def __init__(self, name, age):self.name = nameself.age = agedef sleep(self):print(self.name + '正在睡觉')class Dog(Animal):# def __init__(self, name, age):#     self.name = name#     self.age = age## def sleep(self):#     print(self.name + '正在睡觉')def bark(self):print(self.name + '正在叫')class Student(Animal):# def __init__(self, name, age):#     self.name = name#     self.age = age## def sleep(self):#     print(self.name + '正在睡觉')def study(self):print(self.name + '正在学习')#Dog() 调用 __new__ 方法，再调用 __init__方法
#Dog（）里没有__new__方法会查看父类有没有重写了__new__方法
#父类里也没有重写__new__方法，会查找父类的父类，找到了objectd1 = Dog('dahuang', 10)
print(d1.name)#父类里定义的属性，子类可以直接使用
d1.sleep()#父类的方法子类实例对象可以直接调用
d1.bark()s1 = Student('小明', 18)
s1.study()
s1.sleep()
#s1.bark()   错误，子类之间不能互相使用

输出：
dahuang
dahuang正在睡觉
dahuang正在叫
小明正在学习
小明正在睡觉

（2）注意事项

class A(object):def demo_a(self):print('我是A里的方法  demo_a')def foo(self):print('我是A里的方法  foo')class B(object):def demo_b(self):print('我是B里的方法  demo_b')def foo(self):print('我是B里的方法  foo')class C(A,B):#允许多继承   #如果不写父类，默认继承objectpassc = C()
c.demo_a()
c.demo_b()
c.foo()#如果两个不同的父类有同名方法，有一个类属性可以查看方法的调用顺序说明<先到先得>
print(C.__mro__)

输出：
我是A里的方法  demo_a
我是B里的方法  demo_b
我是A里的方法  foo
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

（3）__mro __属性

class A(object):passclass B(object):def foo(self):print('我是B类里的foo方法')class C(A):def foo(self):print('我是C类里的foo方法')class D(B):passclass X(D, C):passx = X()
x.foo()
print(X.__mro__)

输出：
我是B类里的foo方法
(<class '__main__.X'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

（4）私有属性的继承特点

私有属性和方法不能被继承

class Animal(object):def __init__(self, name, age):self.name = nameself.age = ageself.__money = 1000def eat(self):print(self.name + '正在吃东西')def __test(self):print('我是Animale类里的test私有方法')class Person(Animal):def __demo(self):print('我是Person里的私有方法')p = Person('zhangsan', 18)
print(p.name)
p.eat()
p._Person__demo()#在自己类里的私有方法   对象名._类名__私有方法名
p._Animal__test()#父类里的私有方法，子类没有继承
print(p._Animal__money)#私有属性也不能被继承

输出：
zhangsan
zhangsan正在吃东西
我是Person里的私有方法
我是Animale类里的test私有方法
1000

八、新式类和经典类

新式类：继承自object的类
经典类：不继承自object的类

在python2里，如果不手动的指定一个类的父类为object，则这个类就是经典类，只有在python2中存在经典类
在python3中，如果不手动的指定一个类的父类为object，则这个类默认父类为object，不存在经典类

九、is和isinstance的使用

isinstance用来判断一个对象是否由指定的类（或者父类）实例化出来的
issubclass用来判断一个类是否是另一个类的子类

class Person(object):def __init__(self, name, age):self.name = nameself.age = ageclass Student(Person):pass
s = Student('lisi', 19)
p1 = Person('zhangsan', 18)
p2 = Person('zhangsan', 18)
#type判断类型
print(type(s) == Student)#True
print(type(s) == Person)#False#isinstance用来判断一个对象是否由指定的类（或者父类）实例化出来的
print(isinstance(s, Student))#True
print(isinstance(s, Person))#True
print(isinstance(s, (Student, X)))#True   可以有多个参数
print(isinstance(p1, Student))#False
print(isinstance(p1, Person))#True#issubclass（S, P)用来判断S类是否是P类的子类
print(issubclass(Student, Person))#True
print(issubclass(Person, Student))#False

输出：
True
False
True
True
True
False
True
True
False

十、子类重写父类的方法

1、子类的实现与父类的实现不一样，子类可以选择重写父类的方法
2、子类在父类的基础上，又有了更多的实现
调用父类方法：
1、父类名.方法名（self， 参数列表）
2、使用super直接调用父类方法（推荐使用）

class Person(object):def __init__(self, name, age):self.name = nameself.age = agedef sleep(self):print(self.name + '正在睡觉')class Student(Person):def __init__(self, name, age, school):# self.name = name# self.age = age#子类在父类实现的基础上，又添加了自己新的功能#调用父类方法：#1、父类名.方法名（self， 参数列表）#Person.__init__(self, name, age)#2、使用super直接调用父类方法  **推荐使用**super(Student, self).__init__(name, age)self.school = schooldef sleep(self):print(self.name + '正在课间休息时睡觉')def study(self):print(self.name + '正在学习')#调用了父类的__init__方法
s = Student('jack', 20, '幼稚园')
s.sleep()   #调用了父类的 sleep 方法
print(Student.__mro__)

输出：
jack正在课间休息时睡觉
(<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>)

十一、多态的使用

多态基于继承，通过子类重写父类的方法，达到不同的子类对象调用相同的父类方法，得到不同的结果。提高代码灵活度

（1）不使用多态

class Person(object):def __init__(self, name, dog):self.name = nameself.dog = dogdef work_with_pd(self):print(self.name + '正在工作')self.dog.attack_enemy()class PoliceDog(object):def attack_enemy(self):print(('警犬在攻击坏人'))pd = PoliceDog()
police = Person('张警官', pd)
police.work_with_pd()print(hex(id(police)), hex(id(pd)))

输出：
张警官正在工作
警犬在攻击坏人
0x1f3c2335040 0x1f3c21776d0

代码图示：

class Person(object):def __init__(self, name):self.name = namedef work_with_pd(self):print(self.name + '正在工作')self.dog.attack_enemy()def work_with_bd(self):self.dog.lead_road()def work_with_dd(self):self.dog.search_drug()class PoliceDog(object):def attack_enemy(self):print(('警犬在攻击坏人'))class BlindDog(object):def lead_road(self):print('导盲犬正在领路')class DrugDog(object):def search_drug(self):print('缉毒犬正在搜毒')p = Person('张三')pd = PoliceDog()
p.dog = pd
p.work_with_pd()bd = BlindDog()
p.dog = bd
p.work_with_bd()dd = DrugDog()
p.dog = dd
p.work_with_dd()

输出：
张三正在工作
警犬在攻击坏人
导盲犬正在领路
缉毒犬正在搜毒

代码图示：

（2）使用多态

代码灵活性会变强

class Person(object):def __init__(self, name, dog):self.name = nameself.dog = Nonedef work_with_dog(self):if self.dog is not None and isinstance(self.dog, Dog):self.dog.work()class Dog(object):def work(self):print('狗正在工作')class PoliceDog(Dog):def work(self):print('警犬在攻击敌人')class BlindDog(Dog):def work(self):print('导盲犬正在领路')class DrugDog(Dog):def work(self):print('缉毒犬正在搜毒')p = Person('张三')pd = PoliceDog()
p.dog = pd
p.work_with_dog()bd = BlindDog()
p.dog = bd
p.work_with_dog()dd = DrugDog()
p.dog = dd
p.work_with_dog()

警犬在攻击敌人
导盲犬正在领路
缉毒犬正在搜毒

python---面向对象（类）相关推荐

1. python面向对象类属性_python面向对象之类属性和类方法案例分析

   本文实例讲述了python面向对象之类属性和类方法.分享给大家供大家参考,具体如下: 目标 类的结构 类属性和实例属性 类方法和静态方法 01. 类的结构 1.1 术语 -- 实例 使用面相对象开发, ...

2. Python面向对象---类的基本使用

   1.面向对象 类(class):是一种用来描述具有相同属性和方法的对象的集合. 类变量:类变量在整个实例化的对象中是公用的.一般定义在类中且在函数体之外. 方法:类中的函数 数据成员:类变量或者实例变 ...

3. python面向对象类的成员_Python面向对象中类的成员

   Python面向对象中类的成员总共有三种,分别是字段.方法和属性 Python Version: 3.5+ 字段 普通字段1 2 3 4 5 6 7 8class A: def __init__(se ...

4. python面向对象类创建人物类包含姓名、职业_Python面向对象思想与应用入门教程【类与对象】...

   本文实例讲述了Python面向对象思想与应用.分享给大家供大家参考,具体如下: 面向对象思想 1.面向对象的设计思想 面向对象是基于万物皆对象这个哲学观点. 2.面向对象和面向过程的区别 面向过程 在 ...

5. python面向对象 —— 类和对象（一）

   文章目录 一.面向对象的概念 二.类和对象 (一)类 (二)对象 (三)从对象抽象出类 三.创建类 (一)类属性 类变量和实例变量 (二)类的方法 参数 :self 的理解 __init__(初始化方 ...

6. python面向对象类创建人物类包含姓名、职业_python面向对象类

   面向对象变成介绍 面向过程编程 核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西.主要应用在一旦完成很少修改的地方,如linux ...

7. python面向对象类_python:面向对象(类)

   #!usr/bin/env python # -*- coding:utf-8 -*- __author__ = "Samson" ###类变量与实例变量 class Role: ...

8. python面向对象类_python面向对象-类和对象

   一. 类的定义 class类名(): 代码 #定义类 classWasher():defwash(self):print("洗衣服") 注意:类名要满足标识符命名规则,同时遵循大驼 ...

9. Python面向对象(类的成员之属性)

   day24 类的成员之属性 1 class Foo(): 2 def bar(self): 3 print("bar") 4 5 @property 6 def per(self) ...

10. python 面向对象 类的内置方法

    判断是不是类cls的对象 class A:passa = A() print(isinstance(a,A)) 判断类sub是不是super的子类 class A:passclass B(A):pas ...

最新文章

1. P1640 [SCOI2010]连续攻击游戏 匈牙利算法
2. BlockChain：Python一步一步实现(流程最清楚)区块链底层技术流程图(理解一目了然，值得收藏)
3. MFC Edit控件 error:“DDX_Control”: 不能将参数 3 从“int”转换为“CWnd ”
4. linux操作命令comm,Linux
5. 想在边缘运行计算机视觉程序？先来迎接挑战！
6. 可变大小、颜色边框、样式的UISwitch
7. 【FFMPEG系列】之工具调试：gprof性能分析
8. TensorFlow 辨异 —— tf.add(a, b) 与 a+b（tf.assign 与 =）、tf.nn.bias_add 与 tf.add
9. Google C++ unit test 在ARM Android 2.3 上的编译与使用
10. python电子书合集
11. 南邮历午计算机复试题,南京邮电大学2011年考研计算机复试流程
12. tem_search_shop-获得店铺的所有商品
13. 卡尔曼滤波原理及公式推导
14. 基于人脸识别的门禁系统设计PPT汇报
15. 数据抓取软件火车采集器如何导入TXT 、EXCEL数据
16. 计算机英语期末考试方案,【计算机英语论文】计算机实训考核方法改革方案(共4649字)...
17. 图像修复必读的10篇论文
18. 数独游戏（回溯算法）
19. 一个简单的加壳解壳程序
20. Codeforces 200A Cinema 并查集 + 思维 (看题解)

热门文章

1. http 和 https 有何区别？
2. DNP开发出用于半导体封装的TGV玻璃芯基材
3. 海思低功耗IP门铃方案（Hi3518EV200+Hi1131s+MCU+LiteOS)
4. 【Unity2D】实现人物跳跃二段跳以及掉落的动画和代码
5. Python 获取网易云音乐热门评论，周杰伦歌曲晴天
6. 单位张量叉乘_张量笔记2 并矢与张量
7. 简述servlet生命周期
8. vue js 前端导出 下载 打印 图片 pdf html 局部打印
9. android 屏幕适配框架,Android屏幕适配
10. changyan main.php,zblog畅言插件不能用，代码实现安装畅言评论zblog主题安装畅言评论代码...