python学习记录（七）

0904--https://www.cnblogs.com/fnng/archive/2013/04/24/3039335.html

0904--https://www.cnblogs.com/fnng/archive/2013/04/26/3043856.html

将语句组织成函数

下面编写一小段代码计算婓波那契数列（前两个数的和是第三个数）

因为赋完值fibs已经有两个数了（0，1），所以循环8次之后，列表有10个数，两个数相加等于第3个数。

由我们输入来控制打印多少个数，num-2

fibs = [0,1]  #定义一个列表，初始内容为0,1
num  = int(input('How many fibonacci numbers do you want?'))
for i in range(num-2):  #循环num-2次
    fibs.append(fibs[-1]+fibs[-2])
print(fibs)
#输入
How many fibonacci numbers do you want?14
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]

创建函数

函数是可以调用的，它执行某种行为并且返回一个值。内建的callable函数可以用来判断函数是否可调用：

>>> import math
>>> x = 1
>>> y = math.sqrt
>>> callable(x)
False
>>> callable(y)
True

使用def语句定义函数

>>> def hello(name):
    return 'hello.'+name+'!'
#输出
>>> print(hello('world'))
hello.world!

将婓波那契数列定义成一个函数

def fibs(num):
    a = [0,1]
    for i in range(num):
        a.append(a[-1]+a[-2])
    return a
#调用fibs函数
>>> fibs(5)
[0, 1, 1, 2, 3, 5, 8]

局部变量

当在函数内定义变量的时候，函数内定义的变量只在其函数内有效，与函数外具有相同名称的其他变量没有任何关系

#局部变量
def func(x):
    print ('x is ',x)
    x = 2
    print ('changed local x to',x)

x = 50
func(x)  #func函数并没有返回数据
print ('x is still',x)
#输出
x is  50
changed local x to 2
x is still 50

global 语句

如果想把一个变量声名为 全局的，则可以使用global语句。

#全局变量
def func():
    global x
    print ('x is',x)
    x = 2
    print ('changed local x to',x)

x = 50
func()
print ('value of x is',x)
#输出
x is 50
changed local x to 2
value of x is 2

默认参数

对于一些参数，我们希望它的一些参数是可选的，如果用户不想要为这些参数提供值的话，这些参数就使用默认值。

定义的say函数的第二个参数就是可选的，默认为times=1；也就是将两个参数相乘输出。

注意：只有在形参表末尾的那些参数可以有默认参数，如def func(a=5,b) 是无效的。

def say(message,times=1):
    print (message*times)

say('hello')
say('world',5)
#输出
hello
worldworldworldworldworld

关键参数

如果某个函数有许多参数，而我们只想指定其中的一部分，那么可以使用名字（关键字）而不是位置来给函数指定实参。----这被称作 关键参数（这样做，就不必担心参数的顺序，使用函数变得更加简单。假设其它函数都有默认值，我们可以只给自己想要的参数赋值。）

def func(a,b=5,c=10):
    print ('a is',a,'and b is',b,'and c is',c)
func(3,7)
func(24,c=32)
func(c=32,a=14)
#输出
a is 3 and b is 7 and c is 10
a is 24 and b is 5 and c is 32
a is 14 and b is 5 and c is 32

递归：

有用的递归函数包含以下几个部分：

• 当函数直接返回值时有基本实例（最小可能性问题）
• 递归实例，包括一个或者多个问题最小部分的递归调用。

def f(n):
    if n == 1:
       return 1
    else:
        return n*f(n-1)

创建对象

面向对象概念：继承、封装、多态（具体区别，可以参考：https://www.cnblogs.com/qiuting/p/5347655.html）

• 多态：可对不同类的对象使用同样的操作
• 封装：对外部世界隐藏对象的工作细节
• 继承：以普通的类为基础建立专门的类对象

多态

多态的意思是“有多种形态”。多态意味着就算不知道变量所引用的对象类是什么，还是能对它进行操作，而它也会根据对象（或类）类型的不同而表现出不同的行为。

从最简单的开始

任何不知道对象到底是什么类型，但是又要对对象“做点什么”的时候，都会用到多态。这不仅限于方法--很多内建运算符和函数都有多态的性质，参考以下的例子：

>>> 1+2
3
>>> 'hello'+'world'
'helloworld'

这里的加运算符对于数字（本例中为整数）和字符串（以及其他类型的序列）都能起作用。假设有个叫做叫做add的函数，它可以将两个对象相加。那么可以直接将其定义成上面的形式，对于很多类型的参数都可以用，如下：

参数可以是任何支持加法的对象。

>>> def add(x,y):
    return x+y

>>> add(,)

>>> add('hello.','world')
'hello.world'

如果需要编写打印对象长度消息的函数，则只需对象具有长度（len函数可用）即可。

repr() 函数将对象转化为供解释器读取的形式。

repr用于放置函数的内容；repr函数是多态特性的代表之一---可以对任何东西使用。

>>> def length_message(x):
    print ("The length of",repr(x),"is",len(x))

#输出
>>> length_message('liulu')
The length of 'liulu' is 5
>>> length_message('hello,world')
The length of 'hello,world' is 11

封装

封装是对全局作用域中其他区域隐藏多余信息的原则。

封装听起来有些像多态，因为他们都是 抽象的原则---他们都会帮助处理程序组件而不用过多关心多余细节，就像函数做的一样。

但是封装并不等同于多态。多态的可以让用户对于不知道是什么类（或对象类型）的对象进行方法调用，而封装是可以不用关心对象是如何构建的而直接进行使用。

创建一个对象（通过像调用函数一样调用类）后，将变量c绑定到该对象上。可以使用setName 和 getName 方法（假设已经有）

>>> c = closedObject()
>>> c.setName('sir lancelot')
>>> c.getName()
‘sir lancelot’

继承

我们不想把同一段代码写好几遍，之前使用的函数避免了这种情况。但现在又有个更微妙的问题。如果已经有了一个类，又想建立一个非常类似的类，只是添加几个方法。

比如有动物类，我们又想在动物类的基础上建立鸟类、鱼类，哺乳动物类。

创建类

_metaclass_ = type #确定新式类
class Person:
    def setname(self,name):
        self.name = name
    def getname(self):
        return self,name
    def greet(self):
        print ("hello,world!I'm %s"%self.name)
#输出
>>> liulu = Person()
>>> liulu.setname('liulu')
>>> liulu.greet()
hello,world!I'm liulu

应该能说明self的用处了，在调用liulu的setName 和 greet 函数时，liulu自动将自己作为第一个参数传入函数中----因此形象地命名为self。每个人可能都会有自己的叫法，但是因为它总是对象自身，所以习惯上总是叫做self 。

特性可以在外部访问

>>> liulu.name
'liulu'
>>> liulu.name = 'lulu'
>>> liulu.greet()
hello,world!I'm lulu

特性、函数和方法

self参数事实上正是方法和函数的区别。方法将它们的第一个参数绑定到所属的实例上，因此这个参数可以不必提供。可以将特性绑定到一个普通函数上，这样就不会有特殊的self参数了。

class bird:
    song = 'qiuqiqu~~'
    def sing(self):
        print (self.song)
bird1 = bird()
bird1.sing()
birdsong = bird1.sing
birdsong()
#输出
qiuqiqu~~
qiuqiqu~~

指定超类

子类可以扩展超类的定义。将其他类名写在class语句后的圆括号内可以指定超类：

Filter 类的用户在于它可以用作其他类的基类（超类，“java中叫父类”），比如SPAMFilter类，可以将序列中的“SPAM”过滤出来。

class Filter:
    def init(self):
        self.blocked = []
    def filter(self,sequence):
        return [x for x in sequence if x not in self.blocked]
class SPAMFilter(Filter):    #SPAMFilter是Filer的子类
    def init(self):          #重写Flier类中的init方法
        self.blocked = ['SPAM']
#f = Filter()
#f.init()
#f.filter([1,2,3])
s = SPAMFilter()
s.init()
print(s.filter(['SPAM','SPAMS','SPAM','HELLO','WORLD','SPAM']))

#输出
['SPAMS', 'HELLO', 'WORLD']

Filter 是个用于过滤序列的通用类，事实上它不能过滤任何东西：

>>> f = Filter()
>>> f.init()
>>> f.filter([1,2,3])
[1, 2, 3]

调查继承

如果想要查看一个类是否是另一个的子类。可以使用内建的issubclass函数：

>>> issubclass(SPAMFilter,Filter)
True
>>> issubclass(Filter,SPAMFilter)
False