进阶

python 第二十节 内置函数第二节，复杂点的

#字符串内置函数，功能只限于对字符串的操作。

#死追硬儿
string 字符串函数：
变量名.capitalize()#开普特来自 : #把字符串首字母替换为大写。
>>> f = 'hello world'
>>> f.capitalize()
'Hello world'
>>> f
'hello world'        #调用函数的时候会切换大写，但字符串本身不会做改变

变量名.replace()#瑞普雷斯  #调用函数时修改字符串里面的内容，但不会实际更改字符串本身。
>>> help(str.replace)  #查看使用帮助的时候，要加上类别的前缀，str为字符串函数类别的名称，回车就能看到用法，字符串函数都这样查帮助。

>>>help(list.append)  #列表类别名称为list ，  此帮助为查看列表内置函数的用法。前缀要加上列表名称、。
>>>
帮助方法描述符：



追加（…）

L.append（对象）——追加对象到结束

（结束）

>>> ss = '456456456'        #定义字符串ss
>>> ss
'456456456'
>>> ss.replace("4",'a')        #把字符串中所有的4替换a
'a56a56a56'
>>> ss.replace("4",'a',1)     #把字符串中的4替换a,只替换一个4
'a56456456'
>>> ss.replace("4",'a',2)        #把字符串中的4替换a,只替换两个4
'a56a56456'
>>> ss.replace("4",'a',3)         #把字符串中的4替换a,替换三个4
'a56a56a56'
>>> ss = '456456456,asdada'          
>>> ss.replace("456456456",'caoya')    #调用函数时更改字符串内的部分值，字符串本身不会改变
'caoya,asdada'
>>> ss
'456456456,asdada'

变量名.split()#思不理特   ： #用来做切割的字符串内置函数；（内置参数 ： '.' , 1,2,3,4,5...    来切割）

>>> ip = "192.168.1.130"   #定义一个ip的字符串
>>> ip.split('.')                     #用split函数把字符串用 . 号拆分成一个列表。
['192', '168', '1', '130']
>>> ip.split('#')                     #下面这些切割符号都是没用的只会返回一个完整的列表。
['192.168.1.130']
>>> ip.split('%')
['192.168.1.130']
>>> ip.split('/')
['192.168.1.130']
>>> ip.split(',')
['192.168.1.130']
>>> ip.split('+')
['192.168.1.130']
>>> ip.split('.')
['192', '168', '1', '130']
>>> ip.split('.',1)              #切割一次字符串
['192', '168.1.130']
>>> ip.split('.',2)              #切割两次
['192', '168', '1.130']
>>> ip.split('.',3)              #切割三次，已经切完了，所以第四次是没作用的！
['192', '168', '1', '130']
>>> ip.split('.',4)
['192', '168', '1', '130']
>>>
 参考：
import string  （import#爱木pe特，调用字符串模块string，然后上米昂所有对字符串的替换，切割，替换，都不用指定具体的变量名。string.内置函数名，就可以直接运用。）
>>> f = 'hello world'
>>> ss = '456456456' 
>>> ip = "192.168.1.130"

>>> import string
>>> string.capitalize(f)
'Hello world'
>>> string.replace(ss,'456456456','caoya')
'caoya,asdada'
>>> string.split(ip,'.',1)
['192', '168.1.130']
>>> string.split(ip,'.')
['192', '168', '1', '130']
>>>


################################################################################################################
序列 内置处理函数 ：
len()     max()    min()    其他。
>>> f = [2131,4567,'abc']
>>> len(f)   #取序列内有几个元素，元素是用逗号分开的
3
>>> max(f)    #取序列内最大的元素
'abc'
>>> min(f)     #取序列内最小的元素
2131
>>>


filter()    zip()  map()   reduce()

filter() #富有特     #用来筛选和过滤的内置函数。
>>> help(filter)

模块内置函数筛选帮助

过滤器（…）

过滤器（函数或无，序列）->列表、元组或字符串

返回函数（项）为真的序列项。如果

函数为“否”，返回真实的项。如果序列是元组

或字符串，返回相同类型，否则返回列表。

>>> def f(a):              #定义一个函数f 形参为a,判断当a大于10的时候返回值为True,其它则为空None(没有，空) 
...     if a>10:
...             return True
...
>>> l = range(8,20)    #定义一个元素为8到19的列表。
>>>
>>> l
[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> f(15)              
True
>>> f(10)
>>>
>>> filter(f,l)               #用filter(函数,序列也就是l) 函数取筛选出序列中大于10的元素，自定义函数怎么定义，内置函数filter()就会根据所设置的内容来使用。
[11, 12, 13, 14, 15, 16, 17, 18, 19]
>>>


zip() map() #并行遍历几个列表或者字典的序列里，对应取值

#定义三个列表 name姓名, age年龄, tel电话
>>> name = ['caoya','dengcan','qiqi']
>>> age = ['29','26','3']
>>> tel = ['188','187','199']
>>>
>>> zip(name,age,tel)   #zip()函数会依次并行把三个列表的元素遍历出来。
[('caoya', '29', '188'), ('dengcan', '26', '187'), ('qiqi', '3', '199')]
>>>
>>> test = [1,2]     #如果新增加一个列表，而元素只有两个值，在使用zip()函数的时候，会先取所有列表所对应的完整元素的前两个值的遍历
>>> zip(name,age,tel)
[('caoya', '29', '188'), ('dengcan', '26', '187'), ('qiqi', '3', '199')]
>>> zip(name,age,tel,test)
[('caoya', '29', '188', 1), ('dengcan', '26', '187', 2)]
>>>
>>> map(None,name,age,tel)  #函数map() 也是并行遍历的函数，不过在遍历的时候，要在括号第一位加上None,也可以换成一个函数。
[('caoya', '29', '188'), ('dengcan', '26', '187'), ('qiqi', '3', '199')]

#map()函数在同样多出一个只有两个元素的列表并行遍历的时候，会把所有并行遍历的元素打印出来，在没有元素对应的组里自动用None来填充。
>>> map(None,name,age,tel,test)
[('caoya', '29', '188', 1), ('dengcan', '26', '187', 2), ('qiqi', '3', '199', None)]
>>>

map() 并行遍历函数中的None参数还可以把列表遍历出来的值全部储存到map()函数中，可以来做另一种用法！
>>> a = [13,23,33,43]    #定义两个列表
>>> b = [14,24,34,44]
>>> map(None,a,b)      #并行遍历出两个列表依次对应的元素
[(13, 14), (23, 24), (33, 34), (43, 44)]
>>> def sf(x,y):             #定义函数sf，返回值为x*y.
...     return x*y
...
>>> map(None,a,b)   
[(13, 14), (23, 24), (33, 34), (43, 44)]
>>> map(sf,a,b)    #并行遍历的时候None参数已经把列表a和b的元素储存到map()函数中了，这里a和b的值就是[(13, 14), (23, 24), (33, 34), (43, 44)]，依次做为sf 的实参值，结果得出实参相乘的结果。

[182, 552, 1122, 1892]

>>> def sf(x,y):
...     return x+y
...
>>> map(sf,a,b)  #函数sf定义返回值为形参x+y。 结果就得出实参的相加值。
[27, 47, 67, 87]
>>>

#ruai丢思
reduce()   #递归，函数自己调用自己，实现比for循环更简单明了的代码。

先来看for i in (变量名) 循环:   
>>> l = range(1,101)  #定义一个1到100的列表
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> n = 0              #定义一个循环相加的值，可以是任何。
>>> for i in l:
...     n+=i
...     print n             #等于打印出n依次+的值然后在赋给n的值0+1，1+2，3+4...................依次
...
1
3
6
10
15
21
28
36
45
55
66
78
91
105
120
136
153
171
190
210
231
253
276
300
325
351
378
406
435
465
496
528
561
595
630
666
703
741
780
820
861
903
946
990
1035
1081
1128
1176
1225
1275
1326
1378
1431
1485
1540
1596
1653
1711
1770
1830
1891
1953
2016
2080
2145
2211
2278
2346
2415
2485
2556
2628
2701
2775
2850
2926
3003
3081
3160
3240
3321
3403
3486
3570
3655
3741
3828
3916
4005
4095
4186
4278
4371
4465
4560
4656
4753
4851
4950
5050

#过程看着有些繁琐。   所以我们来用reduce()  函数

>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> def cb(x,y):     #定义函数cb，返回值为x+y
...     return x+y
...
>>> reduce(cb,l)   #递归函数，把 l 列表内的1到100全部相加得出的结果。
5050
>>> l = range(8,30)  #定义一个8到29的列表
>>> l
[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
>>> def cb(x,y):     #函数cb 返回值为x*y
...     return x*y
...
>>> reduce(cb,l)   #reduce() 函数把 列表 l 内的8到29全部相乘得出结果。
1754317855900734514790400000L
>>>

#因为函数cb 定义的只有一行代码，我们可以用更简单的匿名函数lambda() 来操作这段代码。  前提都是提前定义一个列表。
>>> reduce(lambda x,y:x*y,l)  
1754317855900734514790400000L
>>> reduce(lambda x,y:x/y,l)
0
>>> reduce(lambda x,y:x+y,l)
407
>>> reduce(lambda x,y:x-y,l)
-391
>>> l            #列表l   里面的值为  range(8,30)
[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
>>>

#########################################
filter(lambda   )  #用法

>>>l=range(8,30)
>>> l
[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
#取列表内所有除以2余0的值，取偶数
>>> filter(lambda x:x%2==0,l) 
[8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]
#取列表内所有除以2余1的值，取奇数
>>> filter(lambda x:x%2==1,l)
[9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]

map(lambda     )  #用法
>>> l
[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
#取列表内每个值乘以2再加上10的结果
>>> map(lambda x:x*2+10,l)
[26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68]
>>> filter(lambda x:x*2+10,l) #filter 在这里没作用。
[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
#取列表内每个值乘以2再减去10的结果
>>> map(lambda x:x*2-10,l)
[6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48]
#取列表内每个值乘以2再乘以10的结果
>>> map(lambda x:x*2*10,l)
[160, 180, 200, 220, 240, 260, 280, 300, 320, 340, 360, 380, 400, 420, 440, 460, 480, 500, 520, 540, 560, 580]
>>>


####################
lambda -> 列表表达式

map() 的例子，可以写成：
#定义了列表 l 以后 可以直接用下面格式实现map(lambda : )
>>> print [x*2+10 for x in l]
[26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68]

filter() 的例子：
#定义了列表l以后 可以直接用下面格式实现filter(lambda : , )
取列表内所有的值除以3取余为0的结果。
>>> print [x for x in l if x%3==0]
[9, 12, 15, 18, 21, 24, 27]