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
- Numbers类型包括如下：
- 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
- a = "xiongyingcai"
- *表示字符串的赋值倍数，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!
- String的两种索引方式
- 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，如果比较的元素是同类型的,则比较其值,返回结果。如果两个元素不是同一种类型,则检查它们是否是数字。
- 如果是数字,执行必要的数字强制类型转换,然后比较。
- 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
- 否则,通过类型名字的字母顺序进行比较。
- 如果有一个列表首先到达末尾,则另一个长一点的列表"大"。
1 tuple1, tuple2 = (123, 'xyz'), (456, 'abc') 3 print cmp(tuple1, tuple2);#-1 4 print cmp(tuple2, tuple1);#1 5 tuple3 = tuple2 + (786,); 6 print cmp(tuple2, tuple3)#-1 7 tuple4 = (123, 'xyz') 8 print cmp(tuple1, tuple4)#0
- Python中的元组其实和列表都差不多，但是有几点重要的区别
- 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类型
1 a = input("please input :") 2 print a 3 4 运行如下： 5 please input :[x*5 for x in range(1,10)] 6 [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) 设置文件当前位置
1 import os 2 file = open("./index.txt","w+") 3 print file.name 4 print file.mode 5 print file.closed 6 print file.tell() 7 file.write("xiongyingcai") 8 str = file.read(10) #这里要打开模式为r，输出的str才有有结果 9 position = file.seek(0, 0);#文件重新回到最开始 10 strs = file.read(10); 11 print str 12 print strs 13 file.close() #这里必须要先将打开的文件关闭了之后才可以重命名或者删除。WindowsError: [Error 32] 错误 14 os.rename("./index.txt","./index1.txt") 15 os.remove("./index1.txt") 16 #WindowsError: [Error 32] 是文件没有关闭前对文件进行了删除或者重命名操作，解决方法就是先关闭文件 17 #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的每一个元素上；
1 def f(x):
2 return x*x
3 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（）函数就是升序排列）
1 def reversed_cmp(x, y):
2 if x > y:
3 return -1
4 if x < y:
5 return 1
6 return 0
7 >>> sorted([36, 5, 12, 9, 21], reversed_cmp)#实现倒叙排列
8 [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
返回函数不要引用任何循环变量，或者后续会发生变化的变量
1 def count():
2 fs = []
3 for i in range(1, 4):
4 def f(i):
5 def g():
6 return i*i
7 return g
8 fs.append(f(i))
9 return fs
10
11 f1, f2, f3 = count()
12 print f1(), f2(), f3() #结果为1,4,9
13
14
15 如下：
16 def count():
17 fs = []
18 for i in range(1, 4):
19 def g():
20 return i*i
21 fs.append(f(i))
22 return fs
23
24 f1, f2, f3 = count()
25 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就是帮助我们创建一个偏函数的,以把一个参数多的函数变成一个参数少的新函数，
少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。
1 #例子 2 int('213') 3 int('123',8)#将123转换为八进制数，如果我们需要转换很多数，每个数都是用int函数来转换时就会很麻烦，所以我们可以封装这么一个函数： 4 如下，这就是一个偏函数 5 def int8(x,base=8): 6 return int(x,base) 7 functools.partial就是帮助我们创建一个偏函数的 8 所以我们可以： 9 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
继承：
1 class Person(object): 2 def __init__(self, gender, name, age): 3 self.name = name 4 self.age = age 5 self.__gender = gender 6 pass 7 8 class Teacher(Person): 9 def __init__(self, gender,name, age, course): #这里至少要保证下面的gender,name,age参数有才不会报错 10 super(Teacher, self).__init__(gender,name, age) #这里的参数必须和父类Person的参数一致，即要有gender,name,age 11 self.course = course 12 self.__gender = gender #父类的gender是私有属性，所以不会继承的，所以如果子类想要有gender，必须自己重写 13 def get(self): 14 return self.__gender 15 16 t = Teacher('Female','Alice', 24, 'English') 17 a = t.get() 18 print t.name 19 print t.course 20 print a
多态：
静态语言中的多态，（比如java,c++等）是指参数数量和类型不同的方法就是不同方法
而动态语言中的多态，（如Python，javascript等）则主要是指方法的寻找过程，即向右找到类（或者单件类），在类中找不到的话再找父类，
一直在祖先链中找到或者找不到为止，先找到的就被调用，不检查类型，只要方法存在，参数正确，就可以调用
1 #可以提供任意额外的关键字参数，并绑定到实例 2 class Person(object): 3 4 def __init__(self, name, gender, **kw): 5 self.name = name 6 self.gender = gender 7 for k, v in kw.iteritems(): 8 setattr(self, k, v) 9 10 p = Person('Bob', 'Male', age=18, course='Python') 11 print p.age 12 print p.course
14.1：math.sqrt(x)：sqrt的值的类型永远都是float类型的，即isinstance(math.sqrt(x),float)的结果永远的是True
14.2：s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符；其中当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')
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))
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
