python学习笔记11-python内置函数

In [14]: def fun(x):
    ...:     if x < 0:
    ...:         return -x
    ...:     return x
    ...: 
In [15]: fun(10)
Out[15]: 10
In [16]: fun(-10)
Out[16]: 10
In [17]: abs(-10)
Out[17]: 10
In [18]: abs(10)
Out[18]: 10
In [19]: abs(-100)
Out[19]: 100

In [22]: max([1,2,3,4,5])
Out[22]: 5
In [23]: min([1,2,3,4,5])
Out[23]: 1
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value  #可迭代的对象
    max(a, b, c, ...[, key=func]) -> value    
    With a single iterable argument, return its largest item.#返回最大的参数
    With two or more arguments, return the largest argument.
In [26]: max('hsdhsjd','5687','12') #最长的一个
Out[26]: 'hsdhsjd'

In [27]: s='1234'
In [28]: len(s)  #取字符创的长度
Out[28]: 4
help(len）
Help on built-in function len in module __builtin__:
len(...)
    len(object) -> integer    #处理对象，返回整数 
    Return the number of items of a sequence or collection.
In [31]: len([1,2])#取列表的元素个数，2个
Out[31]: 2   
In [30]: len(('a',)) #取元祖的元素个数，1个
Out[30]: 1
In [32]: len({'a':3,'d':4})  #len（）统计字典有几对key,value
Out[32]: 2

In [35]: help(divmod)
divmod(...)
    divmod(x, y) -> (quotient, remainder)    
    Return the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x.
(END) 
In [36]: divmod(5,2)  
Out[36]: (2, 1)    #商和余数

In [37]: help(pow)
Help on built-in function pow in module __builtin__:
pow(...)
    pow(x, y[, z]) -> number    
    With two arguments, equivalent to x**y.  With three arguments,
    equivalent to (x**y) % z, but may be more efficient (e.g. for longs).
(END) 
In [38]: pow(2,3)   #两个参数，结果是x的y次方
Out[38]: 8

In [40]: pow(2,3,3) #三个参数，结果是x的y次方之后，2^3=8,8%3=2,再取个余结果是2，也就是取模
Out[40]: 2
In [39]: pow(2,3,4)
Out[39]: 0

In [41]: help(round)
Help on built-in function round in module __builtin__:
round(...)
    round(number[, ndigits]) -> floating point number    
    Round a number to a given precision in decimal digits (default 0 digits).
    This always returns a floating point number.  Precision may be negative.
(END) 
In [53]: print round(12.145) #默认是
12.0
In [15]: round(12.145,1)
Out[15]: 12.1
In [14]: round(12.145,2)
Out[14]: 12.14
In [54]: print round(12.145,3) 
12.145
In [55]: print round(12.145,4) 
12.145

In [63]: help(callable)  
Help on built-in function callable in module __builtin__:
callable(...)
    callable(object) -> bool #返回一个bool值   
    Return whether the object is callable (i.e., some kind of function).
    Note that classes are callable, as are instances with a __call__() method.

In [64]: a = 123
In [65]: callable(a)  #字符a不可调用
Out[65]: False

In [66]: def b():
    ...:     pass
    ...: 
In [67]: callable(b)#函数b可调用
Out[67]: True
    
In [69]: class A(object):  #定义了一个对象也是可调用的，返回true
    ...:     pass
    ...: 
In [70]: callable(A)
Out[70]: True

In [66]: def b():
    ...:     pass
In [73]: print type(b)  #b为function函数类型
<type 'function'>

In [64]: a = 123
In [74]: print type(a) #a是int×××
<type 'int'>
In [75]: print type([])
<type 'list'>

In [19]: isinstance(a,int)
Out[19]: True
In [25]: l = [1,32]
In [28]: if type(l) == type([]):
    ...:     print 'ok'
    ...:     
ok
In [29]: isinstance(l,list)
Out[29]: True

In [30]: isinstance(l,tuple)
Out[30]: False

In [36]: isinstance(l,(list,tuple,str)) #l是list或者tuple或者str吗？是的，就返回True
Out[36]: True

In [55]: cmp(2,5)
Out[55]: -1

In [56]: cmp(2,2)
Out[56]: 0

In [57]: cmp(2,1)
Out[57]: 1

In [61]: cmp('hello','hello') #字符串相同，返回0
Out[61]: 0
In [63]: cmp('zello','hello')#首字母，z>h的ASCII值，所以，返回1
Out[63]: 1
In [62]: cmp('hello,world','hello')#逗号，的ASCII值大于null=0，返回1，
Out[62]: 1
In [65]: cmp('aellohello','hello')#ASCII值a<h，返回-1
Out[65]: -1

In [75]: a=range(10) #直接分配内存，消耗资源

In [76]: a
Out[76]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [77]: b=xrange(10)

In [78]: b
Out[78]: xrange(10)  #在循环遍历的时候再分配资源，节约资源

In [79]: for i in b:print i
0
1
2
3
4
5
6
7
8
9

In [123]: int(0x12)
Out[123]: 18
In [1]: int('54')
Out[1]: 54


In [124]: int('0x12') #错，字符串包含了非数字x，只能是‘12’才能转为int  12
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-124-d8b06269903d> in <module>()
----> 1 int('0x12')

ValueError: invalid literal for int() with base 10: '0x12'

In [85]: int('12.479')#错，字符串包含了非数字 '.'，只能是‘12479’才能转为int 12479，
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-85-4191248f183f> in <module>()
----> 1 int('12.479')

ValueError: invalid literal for int() with base 10: '12.479'

In [87]: long(12.4)
Out[87]: 12L

In [88]: long(12.5678)
Out[88]: 12L

In [89]: long('12')
Out[89]: 12L

In [90]: long('12.4')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-90-5122883443e4> in <module>()
----> 1 long('12.4')

ValueError: invalid literal for long() with base 10: '12.4'

hex(...)
    hex(number) -> string  #返回16进制的字符串，参数是int或者长×××Long int
    Return the hexadecimal representation of an integer or long integer.
In [117]: hex(12)
Out[117]: '0xc'

In [98]: float('123')
Out[98]: 123.0

In [99]: float(123)
Out[99]: 123.0

In [100]: complex(123)
Out[100]: (123+0j)

In [104]: str(123)
Out[104]: '123'

In [105]: str('123')
Out[105]: '123'

In [106]: str([1,2])
Out[106]: '[1, 2]'

In [107]: str({'1':1})
Out[107]: "{'1': 1}"

In [108]: str((1,[2,3]))
Out[108]: '(1, [2, 3])'

class list(object)
 |  list() -> new empty list #参数为空，返回空列表
 |  list(iterable) -> new list initialized from iterable's items#参数是可迭代对象，返回迭代元素的新列表
In [110]: list('123')  参数是可迭代对象，返回迭代元素的新列表
Out[110]: ['1', '2', '3']

In [111]: list()#参数为空，返回空列表
Out[111]: []

In [112]: list((3,4,[56]))
Out[112]: [3, 4, [56]]

In [113]: list((3,4,[5,6]))#把元祖变为列表
Out[113]: [3, 4, [5, 6]]

In [114]: tuple([3, 4, [5, 6]])#把列表变为元祖
Out[114]: (3, 4, [5, 6])

In [127]: eval('0xa')
Out[127]: 10
In [2]: type(eval('0xa'))#注意转换后类型是int
Out[2]: int
In [129]: eval("['a','b',1]")
Out[129]: ['a', 'b', 1]

In [131]: oct(10)
Out[131]: '012'

In [148]: chr(65)
Out[148]: 'A'

In [143]: ord('a')
Out[143]: 97

In [144]: ord('A')
Out[144]: 65

In [159]: s='hello,world'
In [160]: help(s.capitalize)
capitalize(...)
    S.capitalize() -> string #返回字符串，首字母大写
    Return a copy of the string S with only its first character
    capitalized.
In [161]: s.capitalize()
Out[161]: 'Hello,world'    #H已经变为大写

replace(...)
    S.replace(old, new[, count]) -> string #用新字符串替换旧字符串，count定义替换几次
    
    Return a copy of string S with all occurrences of substring
    old replaced by new.  If the optional argument count is
    given, only the first count occurrences are replaced.
    
In [172]: s.replace('h','H')  #用H替换所有h
Out[172]: 'Hello,world,H'  
In [169]: s.replace('h','H',1)#用H替换所有h，如果为1，只替换第一次出现的h
Out[169]: 'Hello,world,h'

In [170]: s.replace('h','H',2)#用H替换所有h，如果为2，只替换前2次出现的h
Out[170]: 'Hello,world,H'

split(...)
    S.split([sep [,maxsplit]]) -> list of strings
    
    Return a list of the words in the string S, using sep as the
    delimiter string.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified or is None, any
    whitespace string is a separator and empty strings are removed
    from the result.

In [176]: s1='abc'
In [177]: s1.split()
Out[177]: ['abc']

In [174]: s = 'hello  a\tb\nc'
In [175]: s.split()  #默认空格、tab、enter换行都会作为分隔符切分字符串
Out[175]: ['hello', 'a', 'b', 'c']    

#分别以换行\n,空格' ',tab为分割符切换字符串
In [180]: s.split('\n')
Out[180]: ['hello  a\tb', 'c']

In [181]: s.split(' ')
Out[181]: ['hello', '', 'a\tb\nc']

In [182]: s.split('\t')
Out[182]: ['hello  a', 'b\nc']
In [183]: ip = '192.168.1.1'
In [185]: ip.split('.')
Out[185]: ['192', '168', '1', '1']
In [186]: ip.split('.',2)
Out[186]: ['192', '168', '1.1']

In [187]: ip.split('.',1)
Out[187]: ['192', '168.1.1']

In [188]: help(str.join)
join(...)
    S.join(iterable) -> string#参数是可迭代的对象，返回的是字符串
    
    Return a string which is the concatenation of the strings in the
    iterable.  The separator between elements is S.
In [189]: s1='abc'

In [190]: s1.join('12') #在1,2之间使用abc去连接
Out[190]: '1abc2'

In [191]: s1.join('123')#在1,2,3之间用abc去连接
Out[191]: '1abc2abc3'

In [194]: ''.join(str(i) for i in range(10))#把列表的每个元素通过列表重写变为字符串
Out[194]: '0123456789'

In [195]: ' '.join(str(i) for i in range(10))
Out[195]: '0 1 2 3 4 5 6 7 8 9'
In [197]: int(''.join(str(i) for i in range(10)))
Out[197]: 123456789

In [198]: import string

In [199]: string.upper('abc')
Out[199]: 'ABC'

In [200]: string.lowercase
Out[200]: 'abcdefghijklmnopqrstuvwxyz'

In [201]: string.uppercase
Out[201]: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

In [202]: help(string.capitalize)


In [203]: string.capitalize('hello')
Out[203]: 'Hello'

In [204]: help(string.replace)


In [205]: string.replace('hello','o','O')
Out[205]: 'hellO'

In [206]: s
Out[206]: 'hello  a\tb\nc'

In [207]: s.replace('h','H')
Out[207]: 'Hello  a\tb\nc'

filter(...)
    filter(function or None, sequence（序列）) -> list, tuple, or string#序列的元素都会被函数处理
    
    Return those items of sequence for which function(item) is true.  If
    function is None, return the items that are true.  If sequence is a tuple
    or string, return the same type, else return a list
In [275]: filter(None,range(10))  #function是None，不处理直接返回range（10）
Out[275]: [1, 2, 3, 4, 5, 6, 7, 8, 9]
In [271]: def f(x):
     ...:     if x %2 == 0:
     ...:         return True
     ...:     
In [273]: filter(f,range(10)) #把range（10）通过函数f处理，偶数显示在列表中
Out[273]: [0, 2, 4, 6, 8]

#filter使用匿名函数lambda
In [303]: filter(lambda x: x%2==0,range(10))#表示，lambda x成立的条件是：x%2==0并且x属于range（10）
Out[303]: [0, 2, 4, 6, 8]

zip(...)
    zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
    
    Return a list of tuples, where each tuple contains the i-th element
    from each of the argument sequences.  The returned list is truncated
    in length to the length of the shortest argument sequence.#最小的参数
In [277]: l1 = [1,2,3]
In [278]: l2 = ['a','b','c']
In [279]: zip(l1,l2)
Out[279]: [(1, 'a'), (2, 'b'), (3, 'c')]
In [280]: dict(zip(l1,l2))
Out[280]: {1: 'a', 2: 'b', 3: 'c'}

In [284]: l3 = ['I','II']#l3的长度少一个，结果也会少一个

In [285]: zip(l1,l2,l3)
Out[285]: [(1, 'a', 'I'), (2, 'b', 'II')]

map(...)
    map(function, sequence[, sequence, ...]) -> list
    
    Return a list of the results of applying the function to the items of
    the argument sequence(s).  If more than one sequence is given, the
    function is called with an argument list consisting of the corresponding
    item of each sequence, substituting None for missing values when not all
    sequences have the same length.  If the function is None, return a list of
    the items of the sequence (or a list of tuples if more than one sequence).
In [287]: map(None,l1,l2,l3)
Out[287]: [(1, 'a', 'I'), (2, 'b', 'II'), (3, 'c', None)]

In [288]: def f(x):
     ...: return x**2
     ...: 
In [289]: map(f,l1)  #通过函数f对l1的每个参数处理，一个序列，对应函数的一个参数
Out[289]: [1, 4, 9]

In [294]: l1
Out[294]: [1, 2, 3]
In [290]: l2=[4,5,6]
In [292]: def f(x,y):    #定义函数，返回乘积，两个序列，对应函数的两个参数
     ...:     return x*y
     ...: 
In [293]: map(f,l1,l2) #给了两个序列，则这两个序列都会被函数f处理，并返回结果
Out[293]: [4, 10, 18]

注意：如果需要处理的是三个序列，对应函数的三个参数，以此类推。
#map使用匿名函数lambda
In [304]: map(lambda x,y: x*y,range(10),range(10))
Out[304]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

In [295]: help(reduce)
reduce(...)
    reduce(function, sequence[, initial]) -> value
    
    Apply a function of two arguments cumulatively to the items of a sequence,
    from left to right, so as to reduce the sequence to a single value.
    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
    of the sequence in the calculation, and serves as a default when the
    sequence is empty.

In [305]: [i for i in range(10)]
Out[305]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [306]: [i*2 for i in range(10)]
Out[306]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

In [307]: [i**2 for i in range(10)]
Out[307]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]


In [308]: [i for i in range(10) if i %3==0]
Out[308]: [0, 3, 6, 9]

In [309]: [i*2 for i in range(10) if i %3==0]
Out[309]: [0, 6, 12, 18]

In [310]: [i*2+10 for i in range(10) if i %3==0]
Out[310]: [10, 16, 22, 28]