责任编辑分为如下表所示两个部分
具体内容来说表明程序语言是甚么，接着因地制宜范例表明程序语言的如下表所示两个缺点方便快捷表达式管理数据PCB第一类操作方式最后归纳呵呵程序语言的益处基本概念
谈及程序语言，很多开发人员会放出三个词：PCB、承继和隐式；换句话说抽象化、在我看来第一类等等的话，然而这会让新手更为困惑。下面我想通过两个小范例来表明呵呵
程序语言一般是和面向全国操作方式过程做对照的，下面是两个单纯机能的面向全国操作方式过程和程序语言方式
a = 2
# 要同时实现 a+2
# 面向全国操作方式过程的方式
sum(a, 3)
# 程序语言的方式(那条在R中还不容继续执行，而已类似于那个原意)
a.sum(3)
看起来而已初始化的方式相同，其本质没甚么差异，不过当标识符量比较大的时候，程序语言就会让他们程式设计的路子更为明晰。他们先根据下面的方式传授呵呵面向全国操作方式过程和程序语言的差异。
差异一：侧重相同
他们能把初始化表达式认知为主谓宾的结构
面向全国操作方式过程是他们平常初始化的表达式，一般来说是这种方式：姿势（主语，主语） ，姿势是主要的，主语和主语分别做为模块传至进行排序而程序语言的重点则是那个主语，是那个主语初始化了某一的姿势，再把主语做为模块同时实现演算。差异二：表述方式相同
面向全国操作方式过程只要表述两个表达式sum，选定它有两个模块，接着return两者的和方可程序语言则繁杂一些。具体内容来说要表述两个类，在那个类中表述那个类型能使用的各种方式（能认知为表达式）。接着产生两个类的示例，用那个示例初始化那个方式完成排序举两个浅显的范例，这里的类和我们生活中的类没甚么差别。比如说表述两个“鸟”类，再选定那个Chlorophyta“翱翔”那个方式（即表达式、姿势）。接着他们抓到一头具体内容的鸟，这只鸟是“鸟”类的两个示例，它就能初始化“翱翔”那个方式。如果这边一头狗，它不属于“鸟”类，就不能初始化“翱翔”那个方式。狗可能属于“狗”类，经过表述就能初始化“叫”那个方式。在sum的范例中，a是两个整数，它是”整数“那个类的两个示例，你也能表述b=3则是另外两个示例。它们就具备”整数“那个类能使用的所有方式，比如说加两个数，减两个数等等的。而如果 c=”hello”，它就属于“字符串”那个类，能初始化字符串的方式这样做有两个益处，相当于自动对变量进行分类，每两个变量都是两个第一类，属于两个某一的类，它能初始化的方式也都是固定的，这样他们拿到两个字符串，就知道能对它进行哪些处理。差异三：初始化
在实际使用中，如果要对许多第一类进行相同的操作方式
面向全国操作方式过程是表述两个表达式，或者许多表达式，接着对每两个第一类都套用那个表达式方可同时实现而程序语言则是表述两个类，选定类的方式，接着每两个第一类创建为那个类的示例，示例再初始化方式进行排序当这种需求多起来
面向全国操作方式过程会出现这种情况，今天对A类数据创建了一些表达式，明天对B类数据创建了另外一些表达式，可能第二天的表达式还初始化了第一天的表达式，表达式全部放在一起，拿到数据看哪个好用就拿来用，这样容易乱套。而且每次拿到两个数据都要审视呵呵之前的那个表达式能处理那个数据吗，处理完能得到想要的结果吗而程序语言则每两个类型的第一类的方式都放在一起进行管理，都在那个类之下进行表述，这样他们只要看那个第一类是那个类的，就自然能初始化那个类的方式。有的人可能会想，这样面向第一类岂不是每两个类都要重新同时实现那些表达式，本来能初始化之前表述好了的表达式的。然而类的承继很好地解决了那个问题。比如说表述了“鸟”和“狗”类，它们都有“吃”那个方式，但是动物能“飞”，纳氏林能“跑”，那么“吃”那个方式其实不需要在两个类中分别表述一次。因为能先表述两个”动物”类，那个Chlorophyta“吃”“睡”等方式，接着“鸟”和“狗”类分别从那个类承继下来，便获得了“动物”那个类的所有方式，接着它们能在自己的类中表述自己某一的方式“飞”“跑”等接下来他们用python下的范例更具体内容地表明程序语言的益处
方便快捷表达式管理
表述三个类
class bird(object): # 表述鸟那个类
def __init__(self, name): # 表述类时需要传至的模块，这里指创建示例时需要传至name模块
self.name = name # 将模块赋值给self.name，成为属性，后面表述方式时会初始化
def move(self): # 每个类同时实现一次move方式
print(“The bird named”,self.name,“is flying”)
class dog(object): # 表述狗那个类
def __init__(self, name):
self.name = name
def move(self):
print(“The dog named”,self.name,“is running”)
class fish(object): # 表述鱼那个类
def __init__(self, name):
self.name = name
def move(self):
print(“The fish named”,self.name,“is swimming”)
产生示例
bob = bird(“Bob”) # 给bob那个变量（第一类）传至“姓名”name模块
john = bird(“John”) # 产生两个bird的示例来对照
david = dog(“David”)
fabian = fish(“Fabian”)
每个示例分别初始化move方式
bob.move() # 1 标号（方便快捷文字表明）
john.move() # 2
david.move() # 3
fabian.move() # 4
# 得到结果如下表所示
# The bird named Bob is flying
# The bird named John is flying
# The dog named David is running
# The fish named Fabian is swimming
具体内容来说表明一点，创建示例时要传至那个第一类的各种属性值，属性用于存储那个第一类的数据，也是两个第一类差别于其他第一类的标准。比如说下面bob那个第一类的name是Bob，john则是John，他们正因为传至的模块相同才是两个相同的第一类，用相同的方式处理后结果才有差异。他们用同两个表达式处理相同的数据也体现在这里，数据都是通过模块传至的，表述那个第一类时就把数据传至了，之后再初始化方式进行处理，其实是方式在表述时初始化了这些属性（也是你创建示例时传至的数据）。
在那个范例中，move方式其实就通过self.name初始化了name属性，运行后”Bob”等才会出现在结果中。实际使用时，传至的模块肯定不会这么单纯，可能不会是name这样的姓名最后输出出来而已，而是两个数据框，或者两个非常长的待处理字符串，他们都会被后面的方式初始化，同时实现诸如去除缺失值、描述数据、绘图、建模等方式。
从下面的结果中他们能看到
234的对照表明，相同第一类初始化同两个方式move，却得到相同的结果，“鸟”类都是以”the bird named”开头，“狗”类the dog，“鱼”类fish。这是因为它们初始化了相同的表达式。这样，两个类似于的机能，能表述两个同名的表达式方便快捷记忆，同时在相同类中还能分别得到妥当的处理12的对照表明，同一类传至相同数据，也能定制出差异化的结果。这就和两个表达式处理相同数据得到相同结果一样如果使用面向全国操作方式过程的方式，则要如下表所示同时实现
def movebird(name):
print(“The bird named”,name,“is flying”)
def movedog(name):
print(“The dog named”,name,“is running”)
def movefish(name):
print(“The fish named”,name,“is swimming”)
bob = “Bob”
john = “John”
david = “David”
fabian = “Fabian”
movebird(bob)
movebird(john)
movedog(david)
movefish(fabian)
# 得到结果
# The bird named Bob is flying
# The bird named John is flying
# The dog named David is running
# The fish named Fabian is swimming
这样他们拿到两个变量bob，还要分清楚它表示“鸟”还是“狗”，接着在决定用movebird表达式还是movedog表达式。一般他们不会只同时实现move这一种机能，倘若有一二十种，四五十个表达式堆在那里，得到的数据也有几十个，还要一一对应就很麻烦。除此之外，这些表达式可能相互初始化，如果想要将那个表达式用到其他项目中，还要去找它初始化了哪些表达式一起复制到新项目中。如果那个标识符很久没看了，再回来看更要花费很大的精力来对应。
而程序语言表述那个变量时是通过类产生示例，要想知道用甚么方式处理只要直接去找那个类的表述，甚至在编辑器的标识符提示中就会直接列出来供你挑选。
所以程序语言无论在程式设计处理的操作方式过程，还是标识符的管理上都有非常大的优势。
数据PCB
当他们要表述很多表达式要初始化相同模块时，程序语言的使用会明显更方便快捷，他们看下面两个范例
表述类如下表所示
class Person:
细心的读者可能注意到这里的表述和前面方式不一样，没object，在这里表明呵呵
python第一类系统分为经典类和新式类，py2中不加object默认经典类，加了是新式类 py3中则默认不加也是新式类，所以以后他们表述时都不加object（虽然加也是一样的）
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height
def description(self):
print(“Description: name is %s, age is %s, height is%s“% (self.name,self.age,self.height))
def my(self):
print(“My name is %s, and height is %s, and age is%s. “% (self.name,self.height,self.age))
初始化示例
bob = Person(“Bob”,24,170)
mary = Person(“Mary”,10,160)
bob.description()
bob.my()
mary.description()
mary.my()
# Description: name is Bob, age is 24, height is 170
# My name is Bob, and height is 170, and age is 24.
# Description: name is Mary, age is 10, height is 160
# My name is Mary, and height is 160, and age is 10.
他们能看到，创建第一类时将数据传至，之后初始化方式则不需要再赋值，每个方式在表述时就已将模块传至
下面的操作方式过程他们用面向全国操作方式过程来同时实现，下面提供两种同时实现方式，都有一定的弊端
第一种，最直接的传至模块
def description(name, age, height):
print(“Description: name is%s, age is %s, height is %s“% (name,age,height))
def my(name, age, height):
print(“My name is %s, and height is%s, and age is %s. “% (name,height,age))
description(“Bob”,24,170)
description(“Mary”,20,160)
my(“Bob”,24,170)
my(“Mary”,20,160)
# Description: name is Bob, age is 24, height is 170
# Description: name is Mary, age is 20, height is 160
# My name is Bob, and height is 170, and age is 24.
# My name is Mary, and height is 160, and age is 20.
下面这一种每次初始化表达式都要传至相同的模块，非常麻烦，如果模块更多，第一类更多，则非常麻烦
第二种能不用每次都传至
bob = dict(name=Bob,age=24,height=170)
mary = dict(name=Mary,age=20,height=160)
def my(dict):
print(“My name is %s, and height is %s, and age is %s. “% (dict[name],dict[height],dict[age]))
def description(dict):
print(“Description: name is%s, age is %s, height is %s“% (dict[name],dict[age],dict[height]))
my(bob)
description(bob)
my(mary)
description(mary)
# My name is Bob, and height is 170, and age is 24.
# Description: name is Bob, age is 24, height is 170
# My name is Mary, and height is 160, and age is 20.
# Description: name is Mary, age is 20, height is 160
这种方式其实是把模块变化呵呵，但是有两个很大的弊端，这两个表达式的表述中，默认了传至的字典有name age height这三个键，如果没就会发生各种错误。所以说那个表达式的应用其实非常局限，几乎无法应用在其他地方，这种表达式其实比较适合的是PCB在两个类里面。
第一类操作方式
有时候他们要同时实现两个第一类的动态操作方式过程，即两个第一类做了甚么，再做甚么，面向全国操作方式过程就很难同时实现了，看下面两个范例
class Individual:
def __init__(self,full=10): # 默认值则创建示例时能不用传至
self.full = full
def fruit(self):
self.full += 1
return self # 使作用完那个方式后还能初始化其他方式
def meat(self):
self.full += 2
return self
def run(self):
self.full -= 3
return self
下面表述了两个个体的类，他有两个属性能认知成能量，他的方式有吃水果、吃肉、跑步，每两个方式初始化后都会改变他的能量值。下面创建两个示例来初始化
anyone = Individual()
anyone.full # 10
anyone.meat() # 让他吃一次肉
anyone.full # 12
anyone.run() # 让他跑一次
anyone.full # 9
anyone.meat().run() # 吃完再跑
anyone.full # 8
他们还能进行区分，表述两个类，承继下面的类
class Boy(Individual):
表述男生一天吃肉跑，再吃再跑再吃
def oneday(self):
self.meat().meat().run().meat().fruit().run().meat()
print(self.full)
class Girl(Individual):
表述女生每天吃的少但是不跑
def oneday(self):
self.meat().fruit()
print(self.full)
下面两个类表述了男生、女生一天的姿势，通过初始化oneday返回他们做一天后剩余的能量
bob = Boy()
bob.oneday() # 13
mary = Girl()
mary.oneday() # 13
下面那个操作方式过程，如果使用面向全国操作方式过程的方式，则需要对每个第一类表述两个专门表示他们能量的变量，再表述表达式对这些值进行修改，这会造成变量和模块的极大冗余，这里就不再举范例
用程序语言很多时候初始化方式的时候都非常符合人的思维习惯，如下面的做完一件事再做一件事就用.连着写下去。这样的类还有很多，比如说下表所示面的字符串范例
程序语言 a.casefold().join([a,b]).strip().find(c)面向全国操作方式过程 find(strip(join(casefold(a),[a,b])),c)假设下面的表达式都是可用的，程序语言一步一步非常明晰：大小写转换-连接ab-去除两边空格-找到c，而面向全国操作方式过程则层层嵌套，标识符非常不易读，如果不嵌套则可能产生许多无用的中间变量（虽然R里面有管道操作方式能解决这个问题，但是不是所有面向全国操作方式过程的语言都有同时实现这样的机能的）
归纳程序语言程式设计的益处
将第一类进行分类，分别PCB它们的数据和能初始化的方式，方便快捷了表达式、变量、数据的管理，方便快捷方式的初始化（减少重复模块等），尤其是在编写大型程序时更有帮助。用程序语言的程式设计能把变量当成第一类进行操作方式，让程式设计路子更为明晰简洁，而且减少了很多冗余变量的出现专栏信息
专栏主页：python程式设计
专栏目录：目录
版本表明：软件及包版本表明
