Python面向对象编程——类的学习
面向对象编程
面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。
在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。
通过例子来说明面向过程和面向对象在程序流程上的不同之处：
面向过程：处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示并通过函数实现打印成绩：
std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }def print_score(std): print('%s: %s' % (std['name'], std['score']))面向对象：首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。
class Student(object):def __init__(self, name, score):self.name = nameself.score = scoredef print_score(self):print('%s: %s' % (self.name, self.score))给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法（Method）。面向对象的程序写出来就像这样：
bart = Student('Bart Simpson', 59)
bart.print_score()小结： 面向对象的设计思想是抽象出Class，根据Class创建Instance。 面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法。数据封装、继承和多态是面向对象的三大特点
一、类和实例
1.定义类：
class Student(object):pass使用class定义一个类，类名通常是大写开头的单词，(object)，表示该类是从哪个类继承下来的，在类里面复制的变量是类的变量，即类的属性
2.类的实例化：
>>>bart = Student()
>>>bart
<__main__.Student object at 0x10a67a590>
>>> Student
<class '__main__.Student'>左边创建一个变量，右边写上类的名称 ，称之为类的实例化，被实例化后的对象称之为实例（instance）。变量bart指向的就是一个Student的实例，后面的0x10a67a590是内存地址，每个object的地址都不一样，而Student本身则是一个类。
3.“魔术方法”__init__( ) ：
__init__( )如果在类里定义了，在创建实例的时候它就能帮你自动地处理很多事情——比如新增实例属性，__init__( )是initialize（初始化）的缩写，因此即使在创建实例的时候不去引用_init_()方法，其中的命令也会先被自动地执行。
class Student(object):def __init__(self, name, score):self.name = nameself.score = scoredef print_score(self):print('%s: %s' % (self.name, self.score))除了必写的self参数之外，__init__( )同样可以有自己的参数，在实例化的时候往类后面的括号中放进参数，相应的所有参数都会传递到__init__( )方法中，和函数的参数用法完全相同。
class CocaCola:formula = ['caffeine','sugar','water','soda']def __init__(self,logo_name):self.local_logo = logo_name #左边是变量作为类的属性，右边是传入的这个参数作为变量def drink(self):print('Energy!')
coke = CocaCola('可口可乐')
coke.local_logo
>>> 可口可乐二、数据封装
面向对象编程的一个重要特点就是数据封装。在上面的Student类中，每个实例就拥有各自的name和score这些数据。要访问这些数据，可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法。
类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。
1.类属性引用：（公有、私有）
公有
>>> bart = Student('Bart Simpson', 98)
>>> bart.score
98
>>> bart.score = 59
>>> bart.score
59类的属性会被该类的实例共享，类的属性与正常变量并无区别
私有
如果要让内部属性不被外部访问，可以把 属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个 私有变量（private），只有内部可以访问，外部不能访问
class Student(object):def __init__(self, name, score):self.__name = nameself.__score = scoredef print_score(self):print('%s: %s' % (self.__name, self.__score))>> bart = Student('Bart Simpson', 98)
>>> bart.__name
Traceback (most recent call last):File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'外部代码要获取私有属性name和score，给Student类增加get_name和get_score方法，修改score增加set_score方法， 增加方法的原因是在方法中，可以对参数做检查，避免传入无效的参数：
class Student(object):...def get_name(self):return self.__namedef get_score(self):return self.__scoredef set_score(self, score):if 0 <= score <= 100:self.__score = scoreelse:raise ValueError('bad score')在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。
以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定，当看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
2.实例属性（Instance Atrribute）：
class CocaCola:formula = ['caffeine','sugar','water','soda']
coke_for_China = CocaCola()
coke_for_China.local_logo = '可口可乐' #创建实例属性
print(coke_for_China.local_logo) #打印实例属性引用结果在创建了类之后，通过object.new_attr的形式进行一个赋值，即可得到新的实例的变量，专有术语即实例属性,引用方式上，引用实例属性和引用类属性完全一样，但是二者却有本质上的差异
3.实例方法（Instance Method）：
类的实例可以引用属性，也可以使用方法（函数）
class CocaCola:formula = ['caffeine','sugar','water','soda']def drink(self):print('Energy!')
coke = CocaCola()
coke.drink()
>>> Energy!self这个参数名称实际上是可以任意修改的，但是按照Python的规矩，还是统一使用self
给属性指定默认值
类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。在有些情况下，如设置默认值时，在方法__init__() 内指定这种初始值是可行的；如果你对某个属性这样做了，就无需包含为它提供初始值的形参。
class Car():"""一次模拟汽车的简单尝试"""
❶ def __init__(self, make, model, year):"""初始化描述汽车的属性"""self.make = makeself.model = modelself.year = yearself.odometer_reading = 0
❷ def get_descriptive_name(self):"""返回整洁的描述性信息"""long_name = str(self.year) + ' ' + self.make + ' ' + self.modelreturn long_name.title()def read_odometer(self):"""打印一条指出汽车里程的消息"""print("This car has " + str(self.odometer_reading) + " miles on it.")my_new_car = Car('audi', 'a4', 2016)print(my_new_car.get_descriptive_name())my_new_car.read_odometer()
修改属性的值
可以以三种不同的方式修改属性的值：直接通过实例进行修改；通过方法进行设置；通过方法进行递增（增加特定的值）
1.直接修改属性的值
要修改属性的值，最简单的方式是通过实例直接访问它
class Car():--snip--my_new_car = Car('audi', 'a4', 2016)print(my_new_car.get_descriptive_name())❶ my_new_car.odometer_reading = 23my_new_car.read_odometer()2. 通过方法修改属性的值
如果有更新属性的方法，就无需直接访问属性，而可将值传递给一个方法，由它在内部进行更新
class Car():--snip--❶ def update_odometer(self, mileage):"""将里程表读数设置为指定的值"""self.odometer_reading = mileagemy_new_car = Car('audi', 'a4', 2016)print(my_new_car.get_descriptive_name())❷ my_new_car.update_odometer(23)my_new_car.read_odometer()3. 通过方法对属性的值进行递增
有时候需要将属性值递增特定的量，而不是将其设置为全新的值。假设我们购买了一辆二手车，且从购买到登记期间增加了100英里的里程，下面的方法让我们能够传递这个增量，并相应地增加里程表读数：
class Car():--snip--def update_odometer(self, mileage):--snip--❶ def increment_odometer(self, miles):"""将里程表读数增加指定的量"""self.odometer_reading += miles❷ my_used_car = Car('subaru', 'outback', 2013)print(my_used_car.get_descriptive_name())❸ my_used_car.update_odometer(23500)my_used_car.read_odometer()❹ my_used_car.increment_odometer(100)my_used_car.read_odometer()三、继承和多态
1.类的继承（Inheritance）
在OOP程序设计中，当定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
class Animal(object):def run(self):print('Animal is running...')class Dog(Animal):pass
class Cat(Animal):pass新的类Dog后面的括号中放入Animal，表示这个类继承于Animal这个父类，Dog成为Animal子类。类中的变量和方法可以完全被子类继承
dog = Dog()
dog.run()
>>>Animal is running...但如需有特殊的改动也可以进行覆盖（Override）
class Dog(Animal):def run(self):print('Dog is running...')def eat(self):print('Eating meat...')当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，我们就获得了继承的另一个好处：多态。
多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：
对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的函数。（即函数作参数）
练习：
❶ class Car():"""一次模拟汽车的简单尝试"""def __init__(self, make, model, year):self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):long_name = str(self.year) + ' ' + self.make + ' ' + self.modelreturn long_name.title()def read_odometer(self):print("This car has " + str(self.odometer_reading) + " miles on it.")def update_odometer(self, mileage):if mileage >= self.odometer_reading:self.odometer_reading = mileageelse:print("You can't roll back an odometer!")def increment_odometer(self, miles):self.odometer_reading += miles❷ class ElectricCar(Car):"""电动汽车的独特之处"""❸ def __init__(self, make, model, year):"""初始化父类的属性"""
❹ super().__init__(make, model, year)❺ my_tesla = ElectricCar('tesla', 'model s', 2016)print(my_tesla.get_descriptive_name())首先是Car 类的代码（见❶）。创建子类时，父类必须包含在当前文件中，且位于子类前面。在❷处，我们定义了子类ElectricCar 。定义子类时，必须在括号内指定父类的名称。方法__init__() 接受创建Car 实例所需的信息（见❸）。❹处的super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用ElectricCar 的父类的方法__init__() ，让ElectricCar 实例包含父类的所有属性。父类也称为超类 （superclass），名称super因此而得名。
Python 2.7中的继承
在Python 2.7中，继承语法稍有不同，ElectricCar 类的定义类似于下面这样：
class Car(object):def __init__(self, make, model, year):--snip--class ElectricCar(Car):def __init__(self, make, model, year):super(ElectricCar, self).__init__(make, model, year)函数super() 需要两个实参：子类名和对象self 。为帮助Python将父类和子类关联起来，这些实参必不可少。另外，在Python 2.7中使用继承时，务必在定义父类时在括号内指定object 。
2.给子类定义属性和方法
让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法。
class Car():--snip--class ElectricCar(Car):"""Represent aspects of a car, specific to electric vehicles."""def __init__(self, make, model, year):"""电动汽车的独特之处初始化父类的属性，再初始化电动汽车特有的属性"""super().__init__(make, model, year)
❶ self.battery_size = 70❷ def describe_battery(self):"""打印一条描述电瓶容量的消息"""print("This car has a " + str(self.battery_size) + "-kWh battery.")3.重写父类的方法
对于父类的方法，只要不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个方法，与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。假设Car 类有一个名为fill_gas_tank() 的方法，它对全电动汽车来说毫无意义，因此你可能想重写它。下面演示了一种重写方式：
class ElectricCar(Car):--snip--def fill_gas_tank():"""电动汽车没有油箱"""print("This car doesn't need a gas tank!")4.将实例用作属性
使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。你可以将大型类拆分成多个协同工作的小类。不断给ElectricCar类添加细节时，我们可能会发现其中包含很多专门针对汽车电瓶的属性和方法。在这种情况下，我们可将这些属性和方法提取出来，放到另一个名为Battery的类中，并将一个Battery实例用作ElectricCar 类的一个属性：
class Car():--snip--❶ class Battery():"""一次模拟电动汽车电瓶的简单尝试"""❷ def __init__(self, battery_size=70):"""初始化电瓶的属性"""self.battery_size = battery_size❸ def describe_battery(self):"""打印一条描述电瓶容量的消息"""print("This car has a " + str(self.battery_size) + "-kWh battery.")class ElectricCar(Car):"""电动汽车的独特之处"""def __init__(self, make, model, year):"""初始化父类的属性，再初始化电动汽车特有的属性"""super().__init__(make, model, year)
❹ self.battery = Battery()四、获取对象信息
1.使用type()
判断一个对象是否是函数可以使用types模块中定义的常量：
import types
>>> def fn():
... pass
...
>>> type(fn)==types.FunctionType
True
>>> type(abs)==types.BuiltinFunctionType
True
>>> type(lambda x: x)==types.LambdaType
True
>>> type((x for x in range(10)))==types.GeneratorType
True2.使用isinstance()
isinstance()判断的是一个对象是否是该类型本身，或者位于该类型的父继承链上。
继承关系是：object -> Animal -> Dog -> Husky
>>> a = Animal()
>>> d = Dog()
>>> h = Husky()
>>> isinstance(h, Husky)
True
>>> isinstance(h, Dog)
True
>>> isinstance(d, Husky)
False3.使用dir()
获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：
>>> dir('ABC')
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 类似__xxx__的属性和方法在Python中都有特殊用途，比如__len__方法返回长度。在Python中，调用len()函数获取一个对象的长度，实际上，在len()函数内部，会自动调用该对象的__len__()方法，下面的代码是等价的：
>>> len('ABC')
3
>>> 'ABC'.__len__()
3配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态：
>>> class MyObject(object):
... def __init__(self):
... self.x = 9
... def power(self):
... return self.x * self.x
...
>>> obj = MyObject()测试该对象的属性：
>>> hasattr(obj, 'x') # obj实例有属性'x'吗？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
False
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'
19
>>> obj.y # 获取属性'y'
19如果试图获取不存在的属性，会抛出AttributeError的错误：
>>> getattr(obj, 'z') # 获取属性'z'
Traceback (most recent call last):File "<stdin>", line 1, in <module>
AttributeError: 'MyObject' object has no attribute 'z'可以传入一个default参数，如果属性不存在，就返回默认值：
>>> getattr(obj, 'z', 404) # 获取属性'z'，如果不存在，返回默认值404
404小结：通过内置的一系列函数，我们可以对任意一个Python对象进行剖析，拿到其内部的数据。要注意的是，只有在不知道对象信息的时候，我们才会去获取对象信息。
如果可以直接写：
sum = obj.x + obj.y就不要写：
sum = getattr(obj, 'x') + getattr(obj, 'y')正确的用法的例子如下：
def readImage(fp):if hasattr(fp, 'read'):return readData(fp)return None假设我们希望从文件流fp中读取图像，我们首先要判断该fp对象是否存在read方法，如果存在，则该对象是一个流，如果不存在，则无法读取。hasattr()就派上了用场。
五、从模块导入类
1从一个模块中导入一个或多个类，一个模块可以储存多个类
可根据需要在程序文件中导入任意数量的类。如果我们要在同一个程序中创建普通汽车和电动汽车，就需要将Car 和ElectricCar 类都导入：
❶ from car import Car, ElectricCar #car模块是car.py，Car、ElectriCar类❷ my_beetle = Car('volkswagen', 'beetle', 2016)#实例化print(my_beetle.get_descriptive_name())❸ my_tesla = ElectricCar('tesla', 'roadster', 2016)print(my_tesla.get_descriptive_name())2.导入整个模块
你还可以导入整个模块，再使用句点表示法访问需要的类。这种导入方法很简单，代码也易于阅读。由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称发生冲突。
❶ import car❷ my_beetle = car.Car('volkswagen', 'beetle', 2016)print(my_beetle.get_descriptive_name())❸ my_tesla = car.ElectricCar('tesla', 'roadster', 2016)print(my_tesla.get_descriptive_name())3不推荐使用导入模块中所有类
from module_name import *其原因有二。首先，如果只要看一下文件开头的import 语句，就能清楚地知道程序使用了哪些类，将大有裨益；但这种导入方式没有明确地指出你使用了模块中的哪些类。这种导入方式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。
需要从一个模块中导入很多类时，最好导入整个模块，并使用
module_name.class_name语法来访问类。这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知道在程序的哪些地方使用了导入的模块；你还避免了导入模块中的每个类可能引发的名称冲突。
4在一个模块中导入另一个模块
有时候，需要将类分散到多个模块中，以免模块太大，或在同一个模块中存储不相关的类。将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下，可在前一个模块中导入必要的类。
❶ from car import Carfrom electric_car import ElectricCarmy_beetle = Car('volkswagen', 'beetle', 2016)print(my_beetle.get_descriptive_name())my_tesla = ElectricCar('tesla', 'roadster', 2016)print(my_tesla.get_descriptive_name())类编码风格
1.类名应采用驼峰命名法 ，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
2.对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。
3.可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。
4.需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import 语句，再添加一个空行，然后编写导入你自己编写的模块的import 语句。在包含多条import 语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方。
疑问：
1、类属性被重新赋值，是否会影响到类属性的引用？<<<42
class TestA:
attr = 1
obj_a = TestA()
TestA.attr = 42
print(obj_a.attr)2、实例属性被重新赋值，是否会影响到类属性的引用？<<<1
class TestA:
attr = 1
obj_a = TestA()
obj_b = TestA()
obj_a.attr = 42
print(obj_b.attr)3、类属性实例属性具有相同名称，那么 . 后面引用的将会是什么？<<<42
class TestA:
attr = 1
def __init__(self):self.attr = 42
obj_a = TestA()
print(obj_a.attr)__dict__ 是一个类的特殊属性，它是一个字典，用于存储类或者实例的属性。即使不去定义，也会存在于每一个类中，是默认隐藏的。在问题3中添加以下两行代码：
print(TestA.__dict__)
print(obj_a.__dict__)>>> {‘__module__': '__main__', '__doc__':
None, '__dict__': <attribute '__dict__' of
'TestA' objects>, '__init__': <function
TestA.__init__ at 0x1007fc7b8>, 'attr': 1,
'__weakref__': <attribute '__weakref__' of
'TestA' objects>}
>>> {'attr': 42}类TestA和类的实例obj_a各自拥有各自的attr属性，是完全独立的Python中属性的引用机制是自外而内的，当你创建了一个实例之后，准备开始引用属性，这时候编译器会先搜索该实例是否拥有该属性，如果有，则引用；如果没有，将搜索这个实例所属的类是否有这个属性，如果有，则引用，没有则报错
类的扩展理解
obj1 = 1
obj2 = 'String!'
obj3 = []
obj4 = {}
print(type(obj1),type(obj2),type(obj3),type(obj4))Python中任何种类的对象都是类的实例，上面的类型被称作 内建类型，它们并不需要像上面一样实例化如果你安装了Beautifulsoup4第三方库，可以试着这样：
from bs4 import Beautifulsoup
soup = BeautifulSoup
print(type(soup))然后按住ctrl点击Beautifulsoup查看soup对象的完整型定义。
Python面向对象编程——类的学习相关推荐
- python 面向对象（类）--学习笔记
面向对象是一种编程方式, 主要集中在类和对象的两个概念 python 中的类符合封装, 继承, 多态的特征 类 是一个模板, 是n多函数的集成 对象 是类的实例化 类的成员分为三大类:字段.方法.属性 ...
- python多个对象调用类方法、且之间有联系_趣味解读Python面向对象编程 (类和对象)...
一.面向对象简介 考虑现实生活中,我们的思维方式是放在学生这个个人上,是学生做了自我介绍.而不是像我们刚刚写出的代码,先有了介绍的行为,再去看介绍了谁. 用我们的现实思维方式该怎么用程序表达呢? 面向 ...
- 【轻松学】Python面向对象编程——类的设计、基础语法、继承、多态、类属性和类方法、单例设计
文章目录 1. 类的设计 大驼峰命名法 1.1 类名的确定 1.2 属性和方法的确定 练习 1.1 练习 1.2 2. 面相对象基础语法 2.1 定义简单的类(只包含方法) 2.1.1 定义只包含方法 ...
- python面向对象图片_趣味解读Python面向对象编程 (类和对象)
一.面向对象简介 考虑现实生活中,我们的思维方式是放在学生这个个人上,是学生做了自我介绍.而不是像我们刚刚写出的代码,先有了介绍的行为,再去看介绍了谁. 用我们的现实思维方式该怎么用程序表达呢?面向过 ...
- python编程例子-Python面向对象编程 - 类和实例
一.preface 面向对象编程OOP:object oriented programming. OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数.Python是一门面向对象的编程语 ...
- Python面向对象编程(类编程)中self的含义详解(简单明了直击本质的解释)
以下是博主认为的对self讲解得比较透彻又简洁明了的资料. 上面的资料把这个问题说得简单明了,大家认真看一遍相信就对self有个深入的了解了. 总结一下: 在Python为面向对象编程中,成员函数被调 ...
- python面向对象编程项目_Python学习之==面向对象编程（一）
一.面向对象与面向过程 面向对象与面向过程是两种不同的编程范式,范式指的是按照什么方式去编程.去实现一个功能.不同的编程范式本质上代表对各种不同类型的任务采取不同的解决问题的思路. 1.面向过程编程 ...
- python对象编程例子-python 面向对象编程 类和实例
class Student(object): #class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的.通常,如果没有合适的继承 ...
- python面向对象编程类的成员总结
类.对象的三大成员之一字段,静态字段,动态字段 1.静态字段与普通字段的区别,静态字段属于类,普通字段属于有类生成的对象, 2.在内存中的存储方式也不一样,静态字段在内存中存储一份,普通字段每个对象存 ...
最新文章
- Stanford cs224n 第三课： GloVe 代码解读
- MYSQL安装出现could not start the service mysql error:0处理
- ARC132D-Between Two Binary Strings【贪心】
- note.. redis五大数据类型
- 拓端tecdat|R语言中自编基尼系数的CART回归决策树的实现
- spring cloud微服务分布式云架构-Gateway入门 1
- c# json 汉字乱码_C# 读取Json内的数据,中文乱码,怎么解决
- dubbo服务层面上的负载均衡和高可用
- 与孩子一起学编程07章
- windows ping 端口测试
- LibEvent中文帮助文档
- oracle 校验 统一社会信用代码 函数
- CentOS Frp内网穿透：Frps+Nginx反向代理
- 容斥原理 A-1e9个兵临城下
- prepare for 快手
- Python 数值计算库scipy 统计模块stats用法入门
- 6 FI配置-财务会计-定义总账科目组(Account Group)
- LoadRunner使用教程
- Django框架简介-初级（简单留言板）
- Unix下C语言开发工具