标签：input port ret person http size htm 直接 学习记录
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(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.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
标签：input port ret person http size htm 直接 学习记录
原文地址：https://www.cnblogs.com/lu-test/p/9585141.html
