系统管理►python实战

python内置函数

内置函数

_builtin_表示内置函数，可直接使用。

常用函数

  • abs() 返回数字的绝对值。
  • max() 返回数字或序列最大值。
  • min() 返回数字或序列最小值。
  • len() 返回序列长度。

  • divmod(x,y) 返回一个元组，元组第一个元素为x/y的商，第二个元素为x%y。

    1
    2
    3
    4
    5
    In [34]: divmod(8,4)
    Out[34]: (2, 0)

    In [35]: divmod(10,4)
    Out[35]: (2, 2)

  • pow(x,y) 返回一个数字，x**y。

    1
    2
    In [37]: pow(2,3)
    Out[37]: 8

  • power(x,y,z) 返回一个数字，(x**y)%z。

    1
    2
    3
    4
    5
    In [38]: pow(2,3,4)
    Out[38]: 0

    In [39]: pow(2,3,3)
    Out[39]: 2

  • round(x[,y]) 返回一个浮点数，其中x为需转换的数字，y为精度，默认为0。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    In [41]: print round(12)
    12.0

    In [42]: print round(12.445)
    12.0

    In [43]: print round(12.545)
    13.0

    In [44]: print round(12.545,3)
    12.545

    In [45]: print round(12.545,2)
    12.55

  • callable() 判断一个对象是否可调用，返回布尔值。函数和类都是可被调用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    In [48]: a = '123'

    In [49]: callable(a)
    Out[49]: False

    In [50]: def a():
       ....:     pass
       ....: 

    In [51]: callable(a)
    Out[51]: True

    In [52]: class a():
       ....:     pass
       ....: 

    In [53]: callable(a)
    Out[53]: True

  • type() 返回对象的类型。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    In [55]: s = '123'

    In [56]: type(s)
    Out[56]: str

    In [57]: print type([])
    <type 'list'>

    In [58]: print type({})
    <type 'dict'>

  • isinstance() 返回布尔值，判断对象是否为指定的类型。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    In [59]: s = '123'

    In [60]: isinstance(s,list)
    Out[60]: False

    In [61]: isinstance(s,str)
    Out[61]: True

    In [65]: isinstance(s,(list,str,dict,tuple))
    Out[65]: True

对于class的判断较为方便

1
2
3
4
5
6
7
8
In [66]: class A(object):
   ....:     pass
   ....: 

In [67]: a = A()

In [68]: isinstance(a,A)
Out[68]: True

  • cmp(x,y) 返回数字，x > y返回正数，x=y返回0，x < y返回负数。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    In [70]: cmp(1,3)
    Out[70]: -1

    In [71]: cmp(3,3)
    Out[71]: 0

    In [72]: cmp(5,3)
    Out[72]: 1

    In [73]: cmp('zll','hello')
    Out[73]: 1

字符串比较，比较字符，而不是字符串长度

  • range() 返回一个数字列表。

    1
    2
    In [74]: range(1,10)
    Out[74]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

  • xrange() 返回一个对象。

    1
    2
    In [75]: xrange(1,10)
    Out[75]: xrange(1, 10)

xrange()结果保存在对象中，必须遍历才能读取至内存；range直接返回保存至内存，故xrange更节省资源。

1
2
3
4
5
6
7
8
9
10
11
12
In [76]: a = xrange(1,10)

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

类型转换函数

  • int() 转换为int类型。

  • long() 转换为long类型。

    1
    2
    3
    4
    5
    In [80]: long(123)
    Out[80]: 123L

    In [81]: long('123')
    Out[81]: 123L

  • float() 转换为float类型。

    1
    2
    3
    4
    5
    In [82]: float('123')
    Out[82]: 123.0

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

  • complex() 转换为复数。

    1
    2
    3
    4
    5
    In [84]: complex(123)
    Out[84]: (123+0j)

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

  • str() 转换为字符串。

  • list() 转换为列表。

    1
    2
    In [89]: list('23444')
    Out[89]: ['2', '3', '4', '4', '4']

  • tuple() 转换为元组。

  • hex() 转换为16进制，返回字符串。

    1
    2
    In [91]: hex(10)
    Out[91]: '0xa'

  • oct() 转换为8进制，返回字符串。

    1
    2
    In [92]: oct(10)
    Out[92]: '012'

  • chr() 返回当前字符对应的ANSCII码。

    1
    2
    3
    4
    5
    In [99]: chr(10)
    Out[99]: '\n'

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

  • ord() 返回ANSCII码对应的数字。

    1
    2
    3
    4
    5
    In [101]: ord('\n')
    Out[101]: 10

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

  • eval() 字符串当做有效表达式求值。

    1
    2
    3
    4
    5
    6
    7
    8
    In [94]: eval('0xa')
    Out[94]: 10

    In [95]: eval('012')
    Out[95]: 10

    In [96]: eval("['a','b',1]")
    Out[96]: ['a', 'b', 1]

字符串处理函数

  • str.capitalize() 字符串首字母大写并返回。

    1
    2
    3
    4
    In [106]: s = 'abc'

    In [107]: s.capitalize()
    Out[107]: 'Abc'

  • str.replace(old,new[,count]) 字符串中old字符串替换为new字符串，count为替换次数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    In [113]: s = 'HexH'

    In [114]: s.replace('H','h')
    Out[114]: 'hexh'

    In [115]: s.replace('H','h',1)
    Out[115]: 'hexH'

    In [116]: s.replace('H','h',2)
    Out[116]: 'hexh'

  • str.split() 字符串拆分，默认为空格拆分，也可以自定义分隔符，返回列表。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    In [118]: s = 'hello a\tb\nc'

    In [119]: s.split()
    Out[119]: ['hello', 'a', 'b', 'c']
    In [120]: s = '192.168.1.1'

    In [121]: s.split()
    Out[121]: ['192.168.1.1']

    In [122]: s.split('.',1)
    Out[122]: ['192', '168.1.1']

    In [123]: s.split('.',3)
    Out[123]: ['192', '168', '1', '1']

  • str.join() 返回字符串，该字符串使用str连接。

    1
    2
    3
    4
    In [125]: ''.join([str(i) for i in range(10)])
    Out[125]: '0123456789'
    In [128]: '-'.join([str(i) for i in range(10)])
    Out[128]: '0-1-2-3-4-5-6-7-8-9'

string模块
方法同上，但是使用方式不同，使用时需要import string。

序列处理函数

  • len()
  • max()
  • min()
  • filter() 根据条件判断是否处理，True则返回处理后序列，False返回原序列。
    1
    2
    3
    4
    5
    6
    7
    8
    In [131]: filter(None,[1,2,3,4,5,])
    Out[131]: [1, 2, 3, 4, 5]
    In [134]: def f(x):
       .....:     if x % 2 == 0:
       .....:         return True
       .....:     
    In [136]: filter(f,range(10))
    Out[136]: [0, 2, 4, 6, 8]

使用匿名函数

1
2
In [152]: filter(lambda  x: x%2 ==0 ,range(1,10))
Out[152]: [2, 4, 6, 8]

  • zip() 多个序列返回一个列表，列表包含多个序列。
    1
    2
    3
    4
    5
    6
    In [137]: l1 = [1,2,3]

    In [138]: l2 = ['a','b','c']

    In [139]: zip(l1, l2)
    Out[139]: [(1, 'a'), (2, 'b'), (3, 'c')]

用此方法可以创建字典

1
2
In [142]: dict(zip(l1, l2))
Out[142]: {1: 'a', 2: 'b', 3: 'c'}

当序列长度不一致时，取最小的

1
2
3
4
5
6
7
8
In [137]: l1 = [1,2,3]

In [138]: l2 = ['a','b','c']

In [140]: l3 = ['I','II']

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

  • map()
    1
    2
    In [143]: map(None, l1, l2, l3)
    Out[143]: [(1, 'a', 'I'), (2, 'b', 'II'), (3, 'c', None)]

使用多个序列的情况

1
2
3
4
5
6
7
8
9
10
In [146]: def f(x,y):
   .....:     return x * y
   .....: 

In [147]: l1 = [1,2,3]

In [148]: l3 = [4,5,6]

In [149]: map(f, l1, l3)
Out[149]: [4, 10, 18]

使用匿名函数

1
2
In [153]: map(lambda x, y: x * y, range(1,10), range(1,10))
Out[153]: [1, 4, 9, 16, 25, 36, 49, 64, 81]

  • reduce(): 根据传入reduce的函数，对序列中的元素进行处理。
    1
    2
    In [155]: reduce(lambda x, y: x + y,(1,2,3,4,5,6))
    Out[155]: 21

列表表达式

相比较于for循环，列表表达式更加高效。

1
2
3
4
5
In [156]: [i*2+1 for i in range(10)]
Out[156]: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

In [157]: [i*2+1 for i in range(10) if i % 3 == 0]
Out[157]: [1, 7, 13, 19]

Recommended Posts