自定义函数及内置函数

动态参数：元组、字典的传值

//直接使用名称调用相当于把元组、字典整个传递给了一个形参

//元组前面加*，使元组里面的值分别传递给形参

//字典前面加**，使字典里面的值分别传递给形参

返回值

//函数被调用后会返回一个指定的值

//函数被调用后默认返回None

//return 返回值

//返回值可以是任意类型

//return执行后，函数终止

//区分返回值和打印

局部变量、全局变量

//函数内部的变量为局部变量，函数外定义的变量为全局变量

局部变量前加 global 把局部变量变为全局变量 （引用之前声明）

lambda函数(匿名函数)

//lambda函数是一种快速定义单行的最小函数

定义：

名称=lambda 形参，形参，..... ：返回值的表达式（不需要写return）

使用：

名称（实参，实参，......）

自定义函数

//定义函数时参数的名称叫形式参数

//定义函数时参数给形式参数赋了值则叫做缺省参数（默认参数）

//调用函数时参数的名称叫实际参数

形参定义： 使用传递 元组和字典的方法可以解决沉余问题

名称  一个变量

*名称  元组 格式例：1,2,3,4......  格式例2：*tuple

**名称 字典 格式例：a=1,b=2,c=3......   格式例2：**dict

 

def 函数名(参数列表)：//参数列表可以没有

函数体

预定义函数"[]"里面的参数可以不加

type()  //查看数据类型

id()  //查看变量存储的id(接近内存地址)

文件操作：

open(name[, mode[, buffering]]) name:路径/文件名 mode:模式 buffering:缓存 返回文件对象  作用打开文件

file(name[, mode[, buffering]]) name:路径/文件名 mode:模式 buffering:缓存  作用打开文件

with open(name[, mode[, buffering]]) as var name:路径/文件名 mode:模式 buffering:缓存 返回文件对象  作用打开文件赋予变量

with as 方法不需要close()

 

>>> with file('test.pkl','wb') as f:

...     pickle.dump(d,f)

... 

>>> os.system('ls -a')

.              iRedMail-0.9.2         .pythonhistory     test.pkl

>>> test=open('/root/te1.txt','w')  对把打开的te1.txt赋予文件对象test，模式为写入

>>> test.write('hell word')    文件对象.write(str)   对test对象进行写操作，把str写入对象

>>> test.close()    文件对象.close()  关闭对象（对文件操作完成后，需要关闭文件，习惯问题）

>>> test=open('/root/te1.txt','r')

>>> test.read()     文件对象.read()   对对象读操作

'hell word'

>>> test.close()     

readlines:

区别readline 他是全部读取，返回行为单位的元组

fileinput 模块(修改内容)

fileinput.input(files=None, inplace=0, backup='', bufsize=0, mode='r', openhook=None) 返回能够用于for循环遍历的对象 files:文件对象 inplace: 原文件是否修改（0表示不修改，1表示修改）backup:备份文件后缀 

>>> test=fileinput.input('/root/python/auth',1,'_bak')

>>> for aa in test:

...     aa=aa.replace('hjd','hjdd')

...     print aa

cat /root/python/auth

hjdd 1 123456

huang 0 123456 

jin 1 123456

/root/python/auth_bak

hjd 1 123456

huang 0 123456

jin 1 123456

fileobject.tell() 返回当前所在指针位置

help(函数名) 获取函数帮助信息

dir(类) 返回所有方法

vars(类) 返回所有方法和返回值

callable(object) 测试函数是否能用 object对象：函数名  变量会返回假

id() 查看内存中占用空间

isinstance(object, class-or-type-or-tuple) 判断对象是否是某个类型

type() 查看类型

cmp(x,y) 比较两个序列的值知否相同

range(i,j,[,步进值])用于生成整数序列，只适用整数对象，i为初始值默认为0，j为终止值（结果中不包含终止值，结果最后的值为终止值前一个值），步进值默认为1

xrange(i,j,[,步进值])

input()   获取到键盘输入的值可以加入“str”在屏幕显示字符串提示 如下：

raw_input("please input num:")

strip()

enumerate(object,[起始值]) 枚举 可以获取到索引值

>>> q=enumerate('123456')

>>> for i in q:

...     print i

...

(0, '1')

(1, '2')

(2, '3')

(3, '4')

(4, '5')

(5, '6')

globals() 获取所有的全局变量

locals() 获取所有的局部变量

数学运算类：

pow(x,y[,z]) 返回x的y次方，再和z求余数

round(number[, ndigits]) 返回浮点数 number:数字 ndigits:位数

divmod(被除数，除数) 返回（商，余数）

abs() 返回绝对值

类型转换类：

int() 转换成整数

long() 转换成长整型

float() 转换成浮点型

complex() 转换成复数

list() 转换成列表

tuple() 转换成元组

str() 转换成字符串

bin() 返回二进制字符串

hex() 整数转换成十六进制字符串

oct() 整数转换成八进制字符串

chr() 整数转换成字符

ord() 字符转换成它的整数

unichr() 整数转换成unicode字符 

all(序列) 序列的所有值为真则返回真

any(序列) 

序列的值有为真的则返回真

ascii() 相当于类下的__repr__()方法

bool() 返回bool值

字符串对象函数：

str.capitalize() 使字符串 首字母大写

str.replace(old, new[, count]) 返回原字符串中的old替换成new old:摸个字符串 new:摸个字符串 count:替换个数

（原字符串不变，知识返回替换后的字符串）

str.split([sep [,maxsplit]]) 返回原字符串用sep切割后的一个列表 wep:用来切割的标志 maxsplit:分割次数

str.strip([chars])  返回一个去掉前后

chars（默认空格）

的字符串   

chars:字符  

序列对象函数：

len() 求序列长度

max() 返回序列最大的值

min() 返回序列最小的值

filter(function or None, sequence)  function or None:函数或者none sequence:序列 当函数作用序列后，返回返回值为True的对应值生成一个新序列

>>> a=[1,2,3,4,5,6,7,8,9]

>>> def fun02(x):

...     if x>3 and x<8:

...         return True

... 

>>> filter(None,a)

[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> filter(fun02,a)

[4, 5, 6, 7]

zip(seq1 [, seq2 [...]])  seq1:序列1 seq2:序列2

>>> a=[1,1,1]

>>> b=[1,2,3]

>>> c=[1,10,100]

>>> e=[5,5]

>>> zip(a,b,c)

[(1, 1, 1), (1, 2, 10), (1, 3, 100)]

zip(a,b,c,e)

[(1, 1, 1, 5), (1, 2, 10, 5)]

map(function or None, sequence[, sequence, ...])   function or None:函数或者none sequence:序列 返回当函数作用序列后一个新序列

>>> a=[1,1,1]

>>> b=[1,2,3]

>>> c=[1,10,100]

>>> e=[5,5]

>>> ce=lambda x,y,z:x*y*z

>>> map(None,a,b,c)

[(1, 1, 1), (1, 2, 10), (1, 3, 100)]

>>> map(None,a,b,c,e)

[(1, 1, 1, 5), (1, 2, 10, 5), (1, 3, 100, None)]

>>> map(ce,a,b,c)

[1, 20, 300]

reduce(function or None, sequence[, initial])    function or None:函数或者none sequence:序列 initial:初始值 

reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 相当于  ((((1+2)+3)+4)+5)

reduce(lambda x, y: x+y, [1, 2, 3, 4, 5],3) 相当于  3+((((1+2)+3)+4)+5)

reduce(lambda x, y: x*y, [1, 2, 3, 4, 5]) 相当于  ((((1*2)*3)*4)*5)

reduce(lambda x, y: x*y, [1, 2, 3, 4, 5],3) 相当于  3*((((1*2)*3)*4)*5)

>>> a=range(1,101)

>>> a

[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]

>>> fun01=lambda x,y:x+y

>>> reduce(fun01,a)

5050