Python学习笔记

1.python的标识符：

 

在 Python 里，标识符由字母、数字、下划线组成。

 

在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

 

Python 中的标识符是区分大小写的。

 

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；

 

以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

 

1.python的多行语句

 

Python语句中一般以新行作为为语句的结束符。

 

但是我们可以使用斜杠（ ）将一行的语句分为多行显示，比如：

total = item_one + 
        item_two + 
        item_three
语句中包含 [], {} 或 () 括号就不需要使用多行连接符，比如：

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']
当然也可以使用"""或者'''来表示多行语句，值得注意的是，如果是a = '''hello world'''则表示a是一个字符串，只有没有赋值被变量时，'''和"""就是用于多行注释的

 

1.python中输出语句print

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号

1.每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

counter
miles = 1000.0 
name = "John" 

print counter  #因为counter没有赋值，所以这里会报错
print miles
print name

2.多个变量的赋值

a = b = c = 1

a, b, c = 1, 2, "john"   #这种方式有几个变量，后面的值就要有几个，即要相对应

a, b, c = 1,,2  #这样都会报错的，SyntaxError: invalid syntax

3.五中基本的数据类型

几种类型的总结：

数据类型 分为数字型和非数字型。

数字型包括整型，长整型，浮点型，复数型；

非数字型包括字符串，列表，元组和字典 ；

非数字型的共同点：都可以使用切片、链接（+）、重复（*）、取值（a[]）等相关运算;

非数字型的不同点：

列表 可以直接赋值，元组不可以赋值，字典按照 dict[k]=v 的方式赋值

• Numbers（数字）  他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
  • 　　Numbers类型包括如下：
    • int（有符号整型）
    • long（长整型[也可以代表八进制和十六进制]）
      • 长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
    • float（浮点型）
    • complex（复数）
      • Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
    • 常用的Python数学函数：http://www.runoob.com/python/python-numbers.html（Python的方法中，就max,min,abs这三个方法，不用引入math,而其他的都必须引入math,使用方法为：math.方法名（））
    • 常用的Python随机函数：http://www.runoob.com/python/python-numbers.html
• String（字符串）
  • 　　String的两种索引方式
    • 从左到右索引默认0开始的，最大范围是字符串长度少1（0,1，2,3。。。）
    • 从右到左索引默认-1开始的，最大范围是字符串开头(即最右边为-1，依次-2，-3，-4 。。。）
      • 　　a = "xiongyingcai"
        　　b = a[1:-1]    #[:]这个运算符，默认的就是从0到最有，如果是[:]就相当于整个字符串，唯一不同的一点是，a和b的引用地址不一致
        　　print b  #iongyingca
    • *表示字符串的赋值倍数，print str * 2 # 输出字符串两次
    • +表示字符串的串联，print str + "TEST" # 输出连接的字符串
    • Python不支持单字符类型，单字符也在Python也是作为一个字符串使用。
    • Python格式化字符串：print "My name is %s and weight is %d kg!" % ('Zara', 21)     #My name is Zara and weight is 21 kg!
• List（列表）（可以简单的说，Python中的列表就相当于javascript中的数据，数列）使用方法和字符串差不多
  • 　　表示方式为： list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
• Tuple（元组）
  • 　　Python中的元组其实和列表都差不多，但是有几点重要的区别
    • 　　表示方式为： tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ),tuple的值得注意的一种表达方式：tup = 1,2,"df",34，这也是元组的一种表达方式(任意无符号的对象，以逗号隔开，默认为元组)
    • 另外一个需要注意的点是：tup = (23);print type(tup)#<type 'int'>表明这是一个整数，而tup=(23,);print type(tup)#<type,'tuple'>表明这是一个元组，所以当元组中就只有一个元素时，应该在后面加有逗号
    • 取元组的长度len((1,2,3))
    •       元组不能二次赋值，即元组时不允许更新的，相当于只读列表
    • 元组中的元素时不可以删除的，但是我们可以使用del来删除整个元组：tup=(12,34,45);del tup这样就可以删除一个元组
    • 元组常用的内置方法：
    • cmp(tup1,tup2)比较两个元组，（说白了就是如果都是number类型的话，就直接比大小，否则就从第一个字符开始比较起来）注意的一点是，Python3中已经没有该方法了，如果tup1>tup2则返回1，相反则返回-1，如果相等就返回0；比较tup1和tup2，如果比较的元素是同类型的,则比较其值,返回结果。如果两个元素不是同一种类型,则检查它们是否是数字。
      • 如果是数字,执行必要的数字强制类型转换,然后比较。
      • 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
      • 否则,通过类型名字的字母顺序进行比较。
      • 如果有一个列表首先到达末尾,则另一个长一点的列表"大"。

      tuple1, tuple2 = (123, 'xyz'), (456, 'abc')
      print cmp(tuple1, tuple2);#-1
      print cmp(tuple2, tuple1);#1
      tuple3 = tuple2 + (786,);
      print cmp(tuple2, tuple3)#-1
      tuple4 = (123, 'xyz')
      print cmp(tuple1, tuple4)#0

• Dictionary（字典）
  • 　   字典是由key和value组成的，其中key和value都可以是任意的类型　
  •       字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型
  •       列表是有序的对象结合，字典是无序的对象集合
  • 　　表示方式为： tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
  • 　　print tinydict.keys() #输出所有键
  • 　   print tinydict.values() # 输出所有值

  • 　　tinydict = {'name': 'john',2:6734, 'dept': 'sales'}
          print tinydict[2]    #6734
          print tinydict["dept"]    #sales

  • 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
  • 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

4.可以使用del来删除单个或多个对象的引用

a = 100

print a

del a   #这里就删除了变量a

print a   #所以这里就会报错，因为删除了变量a，变量没有赋值就使用就会报错

 5.数据类型的转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

 如int(x),float(x),long(x),tuple(x)：转为元组,list(x)：转为列表,dict(x)：转为字典,sets(x)：转为可变集合,str(x):转为字符串 等

6.运算符

/  :　　　　　表示除法，如果两个数是整数，那么结果就为整数，即求出的小数要取整，如a = 10,b = 3,print a/b  #3

如果两个数中其中有一个是小数的话，结果就为小数，即为求出的小数，如a = 10,b = 3.0,print a/b  #3.33333333333

% ：　　　　表述取余，(小数）a = 10,b = 3.0,print a%b  #1.0     （整数）a = 10,b = 3,print a%b    #1  可以看出其实小数就是相当于在整数的求解结果后面加小数点和0

**：　　　　表示幂，a = 2,b = 3,print a**b  #2^3 = 8

//:　　　　　表示取整除，返回商的整数，a = 10,b = 3,print a//b  #3       a = 10,b = 3.0,print a//b  #3.0

!=,<>: 　　不等于的两种表示方法

逻辑运算符：and, or, not,（返回的结果都为布尔值,非零即为true)简单的看来其实比较方法和javascript中&&，||,!一致

　　　　　　and:布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 

　　　　　　  or:布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。

　　　　　　not:布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

7.Python成员运算符：in,not in

　　如果在指定的序列中找到该值，就返回true，否则就返回false

　　not in(如果在指定的序列中找到该值，就返回false，否则就返回true)

8.Python身份运算符：is ,is not （简单的类型，如Number，认为值相等的话他们的地址即可以认为是相同的）

　　is 是判断两个标识符是不是引用自一个对象 ,x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

　　is not 是判断两个标识符是不是引用自不同对象 ,x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

　　 id() 函数用于获取对象内存地址。

 9.is 与 == 区别：

　　is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

10.elif语句

　　由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

python 复合布尔表达式计算采用短路规则，即如果通过前面的部分已经计算出整个表达式的值，则后面的部分不再计算。如下面的代码将正常执行不会报除零错误：

a=0
b=1
if ( a > 0 ) and ( b / a > 2 ):
    print "yes"
else :
    print "no"
而下面的语句就会报错

a=0
b=1
if ( a > 0 ) or ( b / a > 2 ):
    print "yes"
else :
    print "no"

11.查看变量的类型

可以使用type和isinstanceof来进行判断

isinstanceof:

a = 111
isinstance(a, int)
True

type:
a = 111
type(a)
<type 'int'>

type和isinstanceof的区别：

•  type()不会认为子类是一种父类类型。
•  isinstance()会认为子类是一种父类类型。

12.pyhon中关于is运算符的一些理解：
1.在Python中，如果使用脚本的话：(使用.py文件来编写)
变量a和b相同且为Number,Tuple(只有第一个时，例如a = ('nibushi')这样，如果是a = ('xiong','ying')这样的话就不行),String时，这样 a is b 的结果就会为True
如果他们是List,Dictionary时 a is b的结果就会为Flase
例如：
a = 22222;b = 22222; a is b #True
a = 2.3333;b = 2.33333;a is b #True  可以看出使用脚本的话，只要是number的都可以看成是同一个对象
a = 'nibushizhenzheng';b = 'nibushizhenzheng'; a is b #True    只要是字符串都可以看成是同一个对象
a = ('xiongyingcai');b = ('xiongyingcai'); a is b #True    对于tuple，如果只有第一个元素，那么是同一个对象，如果有多个a is b返回Flase
a = ['xiong']; b = ['xiong']; a is b #Flase    只要是list的都不是同一个对象
a = {}; b = {};a is b #Flase    只要是dic的都不是同一个对象
2.如果是使用交互模式的话：
对于Tuple和String和使用脚本一样的，但是如果是Number,那么如果a和b没有在同一行且a和b的值为小数或者比较大的整数值时，a is b 就会为Flase
比如：

>>>a=2.0
>>>b=2.0
>>>a is b # 结果为False 可以看出使用交互模式的话，用小数a is b 就会返回Flase
>>>a == b # 结果为True

>>>a=4444
>>>b=4444
>>>a is b # 结果为False，可以看出使用交互模式的话，用比较大的数的话，a is b 就会返回Flase

>>>a == b # 结果为True

但是：但是为了提高内存利用效率对于一些简单的对象，如一些数值较小的int对象，python采取重用对象内存的办法，如指向a=2，b=2时，由于2作为简单的int类型且数值小，
python不会两次为其分配内存，而是只分配一次，然后将a与b同时指向已分配的对象：
比如：

>>>a=2
>>>b=2
>>>a is b # 结果为True
>>>a == b # 结果为True

 >>>a=4444; b=4444;   #True 可以看出,使用交互模式，如果大的数或者小数写在同一行，返回的结果为True
 >>>a is b #结果为True

13.python 中fabs和abs的区别：
首先，fabs()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法,即：
import math
a = 123
print type(math.fabs(a))
那么fabs和abs究竟有什么区别呢？
import math
a = 123
b = abs(a)
c = math.fabs(a)
print type(b)  #<type 'int'>
print type(c)  #<type 'float'>
从中我们可以看出，abs是返回a的数值类型，而fabs不管是int或者float，都会返回的是float

fabs絕對是float，abs返回參數的類型

14.Python文件I/O
键盘输入：input,raw_input
文件：file object = open(file_name [, access_mode][, buffering])

• file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
• access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
• buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

使用input和raw_input都可以读取控制台的输入，input 和 raw_input的区别：
需要记住的一点是：

1、在python2.x中raw_input( )和input( )，两个函数都存在，其中区别为：

raw_input( )---将所有输入作为字符串看待，返回字符串类型

input( )-----只能接收“数字”的输入，在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）

2、在python3.x中raw_input( )和input( )进行了整合，去除了raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

1.input只能接收int,float类型的值，要么是单个的值，要么是表达式，如果输入的是字符串就会报错
2.input会计算在字符串中的数字表达式，而raw_input不会，raw_input是原样输出，输入的是什么，输出的就是什么
3.input返回的是数值类型，如int,float
4.raw_inpout返回的是字符串类型，string类型

a = input("please input :")
print a

运行如下：
please input :[x*5 for x in range(1,10)]
[5, 10, 15, 20, 25, 30, 35, 40, 45]

文件的几个方法：

1.打开文件 file = open("xiong.txt","r+")

2.查看打开文件的文件名：print file.name

3.查看打开文件的访问模式： print file.mode

4.查看打开文件是否关闭：print file.closed

5.关闭文件： file.close()

6.查看文件内的当前位置：file.tell();换句话说，下一次的读写会发生在文件开头这么多字节之后

7.向打开的文件写入字符串:file.write("sssss")  首先要确定文件的模式为： w  的

8.重命名：import os   os.rename("xiong.txt","index.txt")

9.删除文件：import os   os.remove("xiong.txt")

10.读取文件：file.read(10),如果未给定或为负则读取所有,首先要确定文件的模式为：r   的

11.设置文件的位置：file.seek(0,0)   设置文件当前位置

import os
file = open("./index.txt","w+")
print file.name
print file.mode
print file.closed
print file.tell()
file.write("xiongyingcai")
str = file.read(10) #这里要打开模式为r，输出的str才有有结果
position = file.seek(0, 0);#文件重新回到最开始
strs = file.read(10);
print str
print strs
file.close() #这里必须要先将打开的文件关闭了之后才可以重命名或者删除。WindowsError: [Error 32] 错误
os.rename("./index.txt","./index1.txt")
os.remove("./index1.txt")
#WindowsError: [Error 32] 是文件没有关闭前对文件进行了删除或者重命名操作，解决方法就是先关闭文件
#WindowsError: [Error 183] 是文件已经存在错误,要更改成的文件的名字已经存在，换一个不冲突的名称就可以了。

另外这里附加一个window 的错误代码全解：http://blog.csdn.net/grf123/article/details/42003469
另外发现了一个很奇怪的问题，就是
str1 = file.read()
str2 = file.readline()
str3 = file.readlines()
然后我们分别打印出各个字符串，奇怪的是我们的str1打印出内容后，后面的str2,str3就没有内容了，所以我想的是因为第一次读取了文件，文件位置为最后，第二次读的时候就为空了，
同样，第三次读取一样就为空了，所以解决的方法为：

fi = open("xiongs.txt","r")
str1 = fi.read()
fi.seek(0,0)
str2 = fi.readline()
fi.seek(0,0)
str3 = fi.readlines()
print str1
print str2
print str3

 
14.Python进阶
高阶函数：能接受函数为参数的函数就可以定义为高阶函数
变量可以指向函数，如f = abs
map()函数：接受一个函数f和一个列表list，并通过将函数f依次作用在list的每一个元素上；

def f(x):
 return x*x
print map(f,[1,2,3])

注意：map()函数不改变原有的 list，而是返回一个新的 list；

由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。

reduce()函数：reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

def f(x,y):
    return x+y
print reduce(f,[1,2,3,4])#结果为1+2+3+4=10  可以这样看：返回的结果给x,列表中的值给y

#还可以使用第三个参数来表示初始值，如果没有初始值，那么就是后面列表中的第一个参数给X，第二个参数给y
print reduce(f,[1,2,3,4],100)#100+1+2+3+4=110

当然求和我们也可以使用sum(),如：sum([1,2,3,4])的结果为10

filter()函数：filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

#取数列中的奇数
def is_odd(x):
    return x % 2 == 1
print filter(is_odd,[1,2,3,4])#结果为[1,3]

def is_not_empty(s):
    return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])

sorted()函数： 它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0（默认的sorted（）函数就是升序排列）

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0
>>> sorted([36, 5, 12, 9, 21], reversed_cmp)#实现倒叙排列
[36, 21, 12, 9, 5]

返回函数：Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！

def myabs():
    return abs   # 返回函数
def myabs2(x):
    return abs(x)   # 返回函数调用的结果，返回值是一个数值
如果返回一个函数，就可以“延迟计算”

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum
# 调用calc_sum()并没有计算出结果，而是返回函数:

>>> f = calc_sum([1, 2, 3, 4])
>>> f
<function lazy_sum at 0x1037bfaa0>
# 对返回的函数进行调用时，才计算出结果:

>>> f()
10

内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）
闭包的特点：返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum      #返回的函数使用外层函数的变量lst
返回函数不要引用任何循环变量，或者后续会发生变化的变量

 def count():
     fs = []
     for i in range(1, 4):
         def f(i):
             def g():
                 return i*i
             return g
         fs.append(f(i))
     return fs

 f1, f2, f3 = count()
 print f1(), f2(), f3()    #结果为1,4,9


如下：
 def count():
     fs = []
     for i in range(1, 4):
     def g():
          return i*i
     fs.append(f(i))
     return fs

 f1, f2, f3 = count()
 print f1(), f2(), f3()    #结果为9,9,9  （因为引用改了循环变量，后续发生了变化）

匿名函数：

匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果

 lambda x: x * x    关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。 相当于：

def f(x):
    return x * x
使用匿名函数，可以不必定义函数名，直接创建一个函数对象，很多时候可以简化代码

sorted([1, 3, 9, 5, 0], lambda x,y: -cmp(x,y))  #cmp(x,y)表示升序排列
[9, 5, 3, 1, 0]

偏函数：functools.partial就是帮助我们创建一个偏函数的,以把一个参数多的函数变成一个参数少的新函数，
少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。

#例子
int('213')
int('123',8)#将123转换为八进制数，如果我们需要转换很多数，每个数都是用int函数来转换时就会很麻烦，所以我们可以封装这么一个函数：
如下，这就是一个偏函数
def int8(x,base=8):
    return int(x,base)
functools.partial就是帮助我们创建一个偏函数的
所以我们可以：
int8 = functools.partial(int,base=8)#效果就是如上面的int8函数
int8('10101011')

其中需要注意的几点：
1.偏函数的第一个参数是一个函数
2.偏函数第一个参数以后的参数其实就是第一个参数的可选参数
3.因为第二点，所以后面传入的参数必须是第一个参数（函数）的可选参数名，如第一个参数为sorted，那么后面的参数就只能是cmp,key,reverse
4.后面传入的参数要手动添加默认值的

偏函数中的除了第一个参数外，其他剩下的参数其实就是第一个参数（其实是个函数）的可选参数（比如int2=functool.partial(int,base=2)，后面的base参数其实是int（）函数的一个可选参数），这样来看，我们就要先了解sorted函数了：

sorted函数有四个参数，sorted(iterable, cmp=None, key=None, reverse=False)

可以看到其中第一个参数是可迭代对象，后面的参数都是具有默认值的，重点阐述如下：

1、cmp，比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0

2、key，主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序

3、reverse，是否反转，默认情况下不反转

由此看来我们的偏函数后面就必须为cmp,key或者reverse这三个，否则就会报test不是这个函数的关键字的错误

sorted_ignore_case = functools.partial(sorted,cmp = lambda x,y: cmp(x.upper(),y.upper()))

包与模块：
包就是文件夹，而模块就是xxx.py文件，模块名就是xxx.py的文件名，同样包可以有多级

包下面有个__init__.py，每层都必须要有，只有这样Python才会将它当做包来处理
引用模块
import math
from math import power,pi sin
from math import power as p,pi as p

继承：

class Person(object):
    def __init__(self, gender, name, age):
        self.name = name
        self.age = age
        self.__gender = gender        
    pass
 
class Teacher(Person):
    def __init__(self, gender,name, age, course):              #这里至少要保证下面的gender,name,age参数有才不会报错
        super(Teacher, self).__init__(gender,name, age)            #这里的参数必须和父类Person的参数一致，即要有gender,name,age
        self.course = course
        self.__gender = gender            #父类的gender是私有属性，所以不会继承的，所以如果子类想要有gender，必须自己重写
    def get(self):
        return self.__gender
 
t = Teacher('Female','Alice', 24, 'English')
a = t.get()
print t.name
print t.course
print a

多态：
静态语言中的多态，（比如java,c++等）是指参数数量和类型不同的方法就是不同方法
而动态语言中的多态，（如Python，javascript等）则主要是指方法的寻找过程，即向右找到类（或者单件类），在类中找不到的话再找父类，
一直在祖先链中找到或者找不到为止，先找到的就被调用，不检查类型，只要方法存在，参数正确，就可以调用

#可以提供任意额外的关键字参数，并绑定到实例
class Person(object):

    def __init__(self, name, gender, **kw):
        self.name = name
        self.gender = gender
        for k, v in kw.iteritems():
            setattr(self, k, v)

p = Person('Bob', 'Male', age=18, course='Python')
print p.age
print p.course

14.1：math.sqrt(x)：sqrt的值的类型永远都是float类型的，即isinstance(math.sqrt(x),float)的结果永远的是True
14.2：s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符；其中当rm为空时，默认删除空白符（包括'
', '
', '	', ' ')
14.3:sorted函数默认是从低到高的顺序来排列的，所以如果我们需要降序来排列：def f(x,y):if x>y return -1 if x<y return 0 else return 0 然后sorted(List,f)
这样我们就可以将列表List进行降序排列了

def f(x,y):
if x>y:
return -1
if x<y:
return 1
else:
return 0
print sorted([1,43,42,2],f)

14.4:map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。(由于list包含的元素可以是任何类型，
因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。)

def f(x):
    return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
14.5:reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，
reduce()对list的每个元素反复调用函数f，并返回最终结果值。

def prod(x, y):
return x*y

print reduce(prod, [2, 4, 5, 7, 12])

14.6:sum()也可以用来对列表或者元组进行求和；sum([1,2,3,4])或者sum((1,2,3,4))

14.7:filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

import math
def is_sqr(x):
r = int(math.sqrt(x))
return r**2 == x
print filter(is_sqr, range(1, 101))