python函数和类的区别_python-函数、类与对象

一、定义函数

在Python中可以使用def关键字来定义函数，和变量一样每个函数也有一个响亮的名字，而且命名规则跟变量的命名规则是一致的。在函数名后面的圆括号中可以放置传递给函数的参数，这一点和数学上的函数非常相似，程序中函数的参数就相当于是数学上说的函数的自变量，而函数执行完成后我们可以通过return关键字来返回一个值，这相当于数学上说的函数的因变量。

在了解了如何定义函数后，我们可以对上面的代码进行重构，所谓重构就是在不影响代码执行结果的前提下对代码的结构进行调整，重构之后的代码如下所示。

"""

输入M和N计算C(M,N)

Version: 0.1

Author: lronlin

"""

def fac(num):

"""求阶乘"""

result = 1

for n in range(1, num + 1):

result *= n

return result

m = int(input('m = '))

n = int(input('n = '))

# 当需要计算阶乘的时候不用再写循环求阶乘而是直接调用已经定义好的函数

print(fac(m) // fac(n) // fac(m - n))说明： Python的math模块中其实已经有一个名为factorial函数实现了阶乘运算，事实上求阶乘并不用自己定义函数。下面的例子中，我们讲的函数在Python标准库已经实现过了，我们这里是为了讲解函数的定义和使用才把它们又实现了一遍，实际开发中并不建议做这种低级的重复劳动。

函数的参数

函数是绝大多数编程语言中都支持的一个代码的"构建块"，但是Python中的函数与其他语言中的函数还是有很多不太相同的地方，其中一个显著的区别就是Python对函数参数的处理。在Python中，函数的参数可以有默认值，也支持使用可变参数，所以Python并不需要像其他语言一样支持函数的重载，因为我们在定义一个函数的时候可以让它有多种不同的使用方式，下面是两个小例子。

from random import randint

def roll_dice(n=2):

"""摇色子"""

total = 0

for _ in range(n):

total += randint(1, 6)

return total

def add(a=0, b=0, c=0):

"""三个数相加"""

return a + b + c

# 如果没有指定参数那么使用默认值摇两颗色子

print(roll_dice())

# 摇三颗色子

print(roll_dice(3))

print(add())

print(add(1))

print(add(1, 2))

print(add(1, 2, 3))

# 传递参数时可以不按照设定的顺序进行传递

print(add(c=50, a=100, b=200))

我们给上面两个函数的参数都设定了默认值，这也就意味着如果在调用函数的时候如果没有传入对应参数的值时将使用该参数的默认值，所以在上面的代码中我们可以用各种不同的方式去调用add函数，这跟其他很多语言中函数重载的效果是一致的。

其实上面的add函数还有更好的实现方案，因为我们可能会对0个或多个参数进行加法运算，而具体有多少个参数是由调用者来决定，我们作为函数的设计者对这一点是一无所知的，因此在不确定参数个数的时候，我们可以使用可变参数，代码如下所示。

# 在参数名前面的*表示args是一个可变参数

def add(*args):

total = 0

for val in args:

total += val

return total

# 在调用add函数时可以传入0个或多个参数

print(add())

print(add(1))

print(add(1, 2))

print(add(1, 2, 3))

print(add(1, 3, 5, 7, 9))

用模块管理函数

对于任何一种编程语言来说，给变量、函数这样的标识符起名字都是一个让人头疼的问题，因为我们会遇到命名冲突这种尴尬的情况。最简单的场景就是在同一个.py文件中定义了两个同名函数，由于Python没有函数重载的概念，那么后面的定义会覆盖之前的定义，也就意味着两个函数同名函数实际上只有一个是存在的。

def foo():

print('hello, world!')

def foo():

print('goodbye, world!')

# 下面的代码会输出什么呢？

foo()

当然上面的这种情况我们很容易就能避免，但是如果项目是由多人协作进行团队开发的时候，团队中可能有多个程序员都定义了名为foo的函数，那么怎么解决这种命名冲突呢？答案其实很简单，Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块就可以区分到底要使用的是哪个模块中的foo函数，代码如下所示。

module1.py

def foo():

print('hello, world!')

module2.py

def foo():

print('goodbye, world!')

test.py

from module1 import foo

# 输出hello, world!

foo()

from module2 import foo

# 输出goodbye, world!

foo()

也可以按照如下所示的方式来区分到底要使用哪一个foo函数。

test.py

import module1 as m1

import module2 as m2

m1.foo()

m2.foo()

但是如果将代码写成了下面的样子，那么程序中调用的是最后导入的那个foo，因为后导入的foo覆盖了之前导入的foo。

test.py

from module1 import foo

from module2 import foo

# 输出goodbye, world!

foo()

test.py

from module2 import foo

from module1 import foo

# 输出hello, world!

foo()

需要说明的是，如果我们导入的模块除了定义函数之外还中有可以执行代码，那么Python解释器在导入这个模块时就会执行这些代码，事实上我们可能并不希望如此，因此如果我们在模块中编写了执行代码，最好是将这些执行代码放入如下所示的条件中，这样的话除非直接运行该模块，if条件下的这些代码是不会执行的，因为只有直接执行的模块的名字才是"__main__"。

module3.py

def foo():

pass

def bar():

pass

# __name__是Python中一个隐含的变量它代表了模块的名字

# 只有被Python解释器直接执行的模块的名字才是__main__

if __name__ == '__main__':

print('call foo()')

foo()

print('call bar()')

bar()

test.py

import module3

# 导入module3时 不会执行模块中if条件成立时的代码 因为模块的名字是module3而不是__main__

二、类和对象

简单的说，类是对象的蓝图和模板，而对象是类的实例。这个解释虽然有点像用概念在解释概念，但是从这句话我们至少可以看出，类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义出一个叫做“类”的东西。

定义类

在Python中可以使用class关键字定义类，然后在类中通过之前学习过的函数来定义方法，这样就可以将对象的动态特征描述出来，代码如下所示。

class Student(object):

# __init__是一个特殊方法用于在创建对象时进行初始化操作

# 通过这个方法我们可以为学生对象绑定name和age两个属性

def __init__(self, name, age):

self.name = name

self.age = age

def study(self, course_name):

print('%s正在学习%s.' % (self.name, course_name))

# PEP 8要求标识符的名字用全小写多个单词用下划线连接

# 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)

def watch_movie(self):

if self.age < 18:

print('%s只能观看《小猪佩奇》.' % self.name)

else:

print('%s正在观看汪汪队.' % self.name)说明： 写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收的消息。

创建和使用对象

当我们定义好一个类之后，可以通过下面的方式来创建对象并给对象发消息。

def main():

# 创建学生对象并指定姓名和年龄

stu1 = Student('lronlin', 38)

# 给对象发study消息

stu1.study('Python程序设计')

# 给对象发watch_av消息

stu1.watch_movie()

stu2 = Student('林子', 15)

stu2.study('JAVA')

stu2.watch_movie()

if __name__ == '__main__':

main()

访问可见性问题

对于上面的代码，有C++、Java、C#等编程经验的程序员可能会问，我们给Student对象绑定的name和age属性到底具有怎样的访问权限（也称为可见性）。因为在很多面向对象编程语言中，我们通常会将对象的属性设置为私有的（private）或受保护的（protected），简单的说就是不允许外界访问，而对象的方法通常都是公开的（public），因为公开的方法就是对象能够接受的消息。在Python中，属性和方法的访问权限只有两种，也就是公开的和私有的，如果希望属性是私有的，在给属性命名时可以用两个下划线作为开头，下面的代码可以验证这一点。

class Test:

def __init__(self, foo):

self.__foo = foo

def __bar(self):

print(self.__foo)

print('__bar')

def main():

test = Test('hello')

# AttributeError: 'Test' object has no attribute '__bar'

test.__bar()

# AttributeError: 'Test' object has no attribute '__foo'

print(test.__foo)

if __name__ == "__main__":

main()

但是，Python并没有从语法上严格保证私有属性或方法的私密性，它只是给私有的属性和方法换了一个名字来妨碍对它们的访问，事实上如果你知道更换名字的规则仍然可以访问到它们，下面的代码就可以验证这一点。之所以这样设定，可以用这样一句名言加以解释，就是"We are all consenting adults here"。因为绝大多数程序员都认为开放比封闭要好，而且程序员要自己为自己的行为负责。

class Test:

def __init__(self, foo):

self.__foo = foo

def __bar(self):

print(self.__foo)

print('__bar')

def main():

test = Test('hello')

test._Test__bar()

print(test._Test__foo)

if __name__ == "__main__":

main()

在实际开发中，我们并不建议将属性设置为私有的，因为这会导致子类无法访问（后面会讲到）。所以大多数Python程序员会遵循一种命名惯例就是让属性名以单下划线开头来表示属性是受保护的，本类之外的代码在访问这样的属性时应该要保持慎重。这种做法并不是语法上的规则，单下划线开头的属性和方法外界仍然是可以访问的，所以更多的时候它是一种暗示或隐喻。

面向对象的支柱

面向对象有三大支柱：封装、继承和多态。这里我们先说一下什么是封装。我自己对封装的理解是"隐藏一切可以隐藏的实现细节，只向外界暴露（提供）简单的编程接口"。我们在类中定义的方法其实就是把数据和对数据的操作封装起来了，在我们创建了对象之后，只需要给对象发送一个消息（调用方法）就可以执行方法中的代码，也就是说我们只需要知道方法的名字和传入的参数（方法的外部视图），而不需要知道方法内部的实现细节（方法的内部视图）。