定义python中的函数和类

1.函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回

1.1 定义函数

def showshow(sex):
	if sex==1:
		return 'man'
	else:
		return 'lady'
#调用
print(showshow(2))

注意一下不是function是def

1.2 函数的参数

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

这个基本上和php的差不多, 这里的参数 n 设置了默认值。

当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。这样子可以能降低调用函数的难度

如果要参数是list，可以这样做：

def addsomthing(s=[]):
	s.append('jack')
	return s
print(addsomthing(['tom','jj']))

这里有一个特别需要注意的地方

pythond有一个奇异现象，在模块层面定义的变量（无需global修饰），如果在函数中没有再定义同名变量，可以在函数中当做全局变量使用

hehe=6
def f():
    print(hehe)
f()
print(hehe) 
#输出6和6

但如果在函数中有再赋值/定义（因为python是弱类型语言，赋值语句和其定义变量的语句一样），则会产生引用了未定义变量的错误：

hehe=6
def f():
    print(hehe)
    hehe=2
f()
print(hehe) 

抛出的错误信息为：

UnboundLocalError: local variable 'hehe' referenced before assignment

正确的做法是:

hehe=6
def f():
    global hehe
    print(hehe)
    
f()

1.3 递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def sumfun(n):
	if n==1:
		return 1
	else:
		return  n+sumfun(n-1)
print(sumfun(3))
##结果##
6

上面演示实现 3 +2 +1 算法。

2.类

2.1 类的结构

一个比较典型的打印学生成绩类

class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

ob = Student()
ob.print_score()

在Python中，定义类是通过class关键字

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去。

注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身，这个方法大概就像php的构造函数吧

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

2.2 访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改一改：

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score了：

>>> bart = Student('Bart Simpson', 59)
>>> bart.__name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'

需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名

2.3 继承和多态

一个比较典型的类继承,基本上和php差不多

class Car(object):
	def run(self):
		print('i can run very fast!')
	
class Honda(Car):
	def go(self):
		print('vtec is the best')

b=Honda()
b.go()
b.run()

这里的子类Honda继承了Car这个父类，所以能使用run这个方法

继承有什么好处？最大的好处是子类获得了父类的全部功能。由于Car实现了run()方法，因此，Honda作为它的子类，什么事也没干，就自动拥有了run()方法。

同时你可以重写父类里的run方法：

class Car(object):
	def run(self):
		print('i can run very fast!')
	
class Honda(Car):
	def go(self):
		print('vtec is the best')
    
    def run(self):
		print('Honda can run very fast')

b=Honda()
b.go()
b.run()

下面是关于多态:

class Animal(object):
    def run(self):
        print('Animal is running...')
	

class Dog(Animal):

    def run(self):
        print('Dog is running...')

    def eat(self):
        print('Eating meat...')

class Cat(Animal):

    def run(self):
        print('Cat is running...')

class Rabbit(Animal):
	pass

a = Dog()
a.run()

b = Cat()
b.run()

def run_twice(animal):
    animal.run()
    animal.run()

run_twice(Cat())
#Cat is running...
#Cat is running...
run_twice(Rabbit())
#Animal is running...
#Animal is running...

上面是一个多态的典型代码.

由于dog类和cat类都是 继承了Animal类

在python里 dog和cat都是 Animal类型

要理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样：

a = list() # a是list类型

b = Animal() # b是Animal类型

c = Dog() # c是Dog类型 ,同时c也是Animal类型

多态的好处就是，当我们需要传入Dog、Cat、Tortoise……时，我们只需要接收Animal类型就可以了，因为Dog、Cat、Tortoise……都是Animal类型，然后，按照Animal类型进行操作即可。由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思。

来一句大神的一句话总结：

派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。