python学习记录（七），,0904--http

python学习记录（七），,0904--http

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,1num  = 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 = 50func(x)  #func函数并没有返回数据print (‘x is still‘,x)#输出x is  50changed local x to 2x is still 50

global语句

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

#全局变量def func():    global x    print (‘x is‘,x)    x = 2    print (‘changed local x to‘,x)x = 50func()  print (‘value of x is‘,x)#输出x is 50changed local x to 2value of x is 2

默认参数

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

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

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

def say(message,times=1):    print (message*times)say(‘hello‘)say(‘world‘,5)#输出helloworldworldworldworldworld

关键参数

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

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 10a is 24 and b is 5 and c is 32a 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+23>>> ‘hello‘+‘world‘‘helloworld‘

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

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

>>> def add(x,y):    return x+y>>> add(1,2)3>>> 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.singbirdsong()#输出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

python学习记录（七）