Python(3)

一、函数：

1、概念和语法、返回值：

（1）、概念：函数是python为了代码最大程度地重用和最小代码冗余而提供的基本程序结构。

函数是一种设计工具，它能让程序员将复杂的系统分解为可管理的部件。

（2）、语法：

  def functionName(args):

     suite

（3）、返回值:return用于返回结果对象，其为可选；

        无return语句的函数自动返回None对象。

       返回多个值时，彼此之间使用逗号分隔，且组合为元组形式返回一个对象。

2、Python中可以创建4种函数：

（1）、全局函数：定义在模块中。

例：func1为全局函数。

#!/user/bin/python27

x=110

z="abc"

def func1():

    x="hello function 1"

    y=3

    print x,z

    def func2():

x="hello function 2"

print x,y

    func2()

func1()

（2）、局部函数：嵌套于其它函数中。

例：func2为局部函数。

#!/user/bin/python27

x=110

z="abc"

def func1():

    x="hello function 1"

    y=3

    print x,z

    def func2():

x="hello function 2"

print x,y

    func2()

func1()

（3）、lambda函数也叫匿名函数：表达式。

 语法：lambda args:expression

 例:>>>f1=lambda x,y:x+y

   >>>f1(3,4)

    7

 注意：expression必须为表达式，不能是语句。

   >>>f1=lambda x,y: print x+y报错。因print x+y为语句。

（4）、方法：定义在类中的函数，并且只能与类一起使用。

3、Python提供了很多内置函数：

（1）、filter(func,seq):调用一个布尔函数func来迭代遍历每个seq中的元素，返回一个使func返回值为true的元素的序列。

例：

l1=[1,2,32,49,20]

def f1(x):

  if x>20:

    return True

  else:

    return Flase

filter(f1,l1),则返回[32,49]

（2）、map(func,seq[,....]):其中func可以为None，即对seq不做任何操作。

将函数func作用于给定序列（s）的每个元素，并用一个列表来提供返回值；如果func为None，func表现为一个身份函数，返回一个含有每个序列中元素集合的n个元组的列表。

例1：单个seq：

>>> l1=[0,1,2,3,4,5,6]

>>> map(None,l1)

[0, 1, 2, 3, 4, 5, 6]

例2：多个seq：

>>>l1=[0,1,2,3,4,5,6]

>>>l2=['Sun','Mon','Tus','Wen','Thur','Fri','Sat']

>>>map(None,l1,l2)

[(0,'Sun'),(1,'Mon'),(2,'Tus'),(3,'Wen'),(4,'Thur'),(5,'Fri'),(6,'Sat')]

例3：定义一个具体的func，多个seq： 

>>>def f1(x,y):

>>>  return x*2,y*2

>>>map(f1,l1,l2)

[(0,'SunSun'),(2,'MonMon'),(4,'TusTus'),(6,'WenWen'),(8,'ThurThur'),(10,'FriFri'),(12,'SatSat')]

（3）、reduce(func,seq[,....]):将二元函数作用于seq序列的元素，每次携带一对（先前的结果以及序列的下一个元素），连续地将现有的结果和下一个值作用在获得的随后的结果上，最后减少我们的序列为一个单一的返回值；如果初始值init给定，第一次比较会是init和序列的第一个元素进行计算，而不是序列的头两个元素。

例1：

>>>def f(x,y):

>>> return x+y

>>>l1=[0,1,2,3,4,5,6]

>>>reduce(f,l1),结果为21

例2：

>>>def f(x,y):

>>> return x+y

>>>l1=[0,1,2,3,4,5,6]

>>>reduce(f,l1,10),结果为31

二、变量作用域：代码中变量名被赋值的位置决定了其能被访问的作用域。

1、函数定义了本地作用域，而模块定义了全局作用域。

2、每个模块都是一个全局作用域，因此，全局作用域的范围仅限于单个程序文件。

3、每次对函数的调用都会创建一个新的本地作用域，赋值的变量除非声明为全局变量，

  否则都是本地变量。

4、所有的变量名都可以归纳为本地、全局和内置(由__builtin__模块提供)。

例：

#!/user/bin/python27

x=110

z="abc"

def func1():

    x="hello function 1"

    y=3

    print x,z

    def func2():

x="hello function 2"

print x,y

    func2()

func1()

5、python的闭包：

def f1():

 x=100

 def f2():

y="hello python"

print x,y

 return f2

a1=f1()

a1()，为100,"hello python",x还是有值的,这种特性叫闭包。

三、类：

1、Python中创建类：

(1)、python使用class关键字创建类，语法格式如下：

class ClassName([bases]):

    '类文档'

    class_suite

(2)、类体可以包含：声明语句、类成员定义、数据属性、方法。

因此定义class的语句的一般格式如下：

class ClassName([bases]):

   data=value

   def method(self,...):

      self.member=value

(3)、注意点：

类属性：class语句中的复制语句会创建“类属性”。

实例属性：在类方法中对传递给方法的特殊参数self进行复制会创建“实例属性”。

因此，类中每个方法必须具有self参数，它隐含当前实例之意。

在方法内对self属性做赋值运算会产生每个实例自己的属性。

python规定，没有实例，方法不允许被调用。

(4)、例子：

例1：

>>>class TestClass():

>>>   pass

>>>type(TestClass)

>>>classobj

>>>obj1=TestClass();

>>>type(obj1)

>>>instance

例2：

>>>class FirstClass():

>>>   data="hello FirstClass"

>>>   def printData(self):

>>>  print "Content from method:%s." % self.data

>>>inst1=FirstClass()

>>>inst1.data

 hello FirstClass

>>>inst1.printData()

 Content from method:hello FirstClass.

例3：

>>>class SencClass():

>>>   data="hello SecondClass"

>>> def setData(self,x):

>>>    self.name=x

>>> def printData(self):

>>>    print self.name

>>>inst2=SencClass()

>>>inst2.data

 hello SecondClass

>>>inst2.setData("abc");

>>>inst2.printData()

 abc

>>>inst3=SencClass()

>>>inst3.data

 hello SecondClass

>>>inst3.setData("xyz");

>>>inst3.printData()

 xyz

2、Python中构造器：

创建实例时，Python会自动调用类中的__init()__方法，以隐性的方式为实例提供属性。__init()__方法被称作构造器。

如果类中没有定义__init()__方法，实例创建时仅是一个简单的名称空间。

>>>class ThirdClass():

>>>    data="test init class"

>>>    def _init_(self,x):

>>>        self.memberOne=x

>>>inst4=ThirdClass('abc')

>>>inst4.data

  test init class

>>>inst4.memberOne

  abc

>>>inst5=ThirdClass('xyz')

>>>inst5.data

  test init class

>>>inst5.memberOne

  xyz

3、Python中类的继承：

(1)、python支持多级继承，且子类可以继承父类的任何属性，包括数据属性和方法。

(2)、继承会先在子类中寻找变量名，然后才查找父类。因此，子类可以对父类的属性进行重新定义，即通过重新定义来取代继承来的行为，并可以通过重写覆盖父类继承来的方法。

(3)、也可以通过已覆盖的方法回调父类来扩展父类的方法。(如 例3)

例1：

>>>class ParentClass(object):

   'Parent Class'

   gender='Male'

   def setName(self,x):

    self.name=x

>>>class ChildClass(ParentClass):

    'Child Class'

   def disPlayInfo(self):

    print self.gender,self.name

>>>c1=ChildClass()

>>>c1.setName('tom')

>>>c1.setPlayInfo()

Male tom

例2：

>>>class PClass():

    def setInfo(self,sex='Male'):

     self.gender=sex

>>>class CClass(PClass):

    def setInfo(self,x)

     self.name=x

>>>c1=CClass()

>>>c1.setInfo('cat')

>>>c1.name

'cat'

>>>c1.gender 报错，报CClass object has no attribute 'gender'

例3：

>>>class PClass():

    def setInfo(self,sex='Male'):

     self.gender=sex

>>>class CClass(PClass):

    def setInfo(self,x)

        self.name=x

        PClass.setInfo(self)

>>>c1=CClass()

>>>c1.setInfo('cat')

>>>c1.name

'cat'

>>>c1.gender

'Male'

四、Python模块：

（1）、可以将代码量较大的程序分隔成多个有组织的、彼此独立但又能相互交互的代码片段，

这些自我包含的有组织的代码段就是模块。

（2）、模块在物理形式上表现为以.py结尾的代码文件。

一个文件被看作一个独立的模块，一个模块也可以被看作一个文件。

每个模块都有自己的名称空间。

（3）、Python允许导入其它模块以实现代码重用，从而也实现了将独立的代码文件组织成更大的程序系统。

python中，模块也是对象。

在一个模块的顶层定义的所有变量都在被导入时成为了被导入模块的属性。

（4）、在导入模块时，只能使用模块名。如：import os