Python函数
函数就是完成特定功能的一个语句组，这组语句可以作为一个单位使用，并且给它取一个名字。
可以通过函数名在程序的不同地方多次执行（这通常叫函数调用）。
函数定义要在函数调用之前，否则函数调用会找不到要调用的函数 跟编译型语言不一样！！！！！！！！！
函数要写在python文件的最前面，否则NameError: name 'wordCount' is not defined
import osimport sysimport string
s="""hello world python"""wordCount(s)def wordCount(s):
chars=len(s)
words=len(s.split())
lines=s.count('n') print lines,words,chars
Traceback (most recent call last):
File "G:/py/pytest33/test123.py", line 20, in
wordCount(s)
NameError: name 'wordCount' is not defined 预定义函数
可以直接使用
自定义函数
用户自己编写
函数的定义和调用
//定义
def 函数名([参数列表]):
函数名：如果由多个单词组成，第二个单词的首字母应该大写
//调用
函数名([参数列表])
#!/usr/bin/python
def fun():
sth = raw_input("Please input something: ")
try:
if type(int(sth)) == type(1):
print "%s is a number" %sth
except ValueError:
print "%s is not number" %sth
fun()
最好这样写if type(int(num)) == type(1)
type返回的不是字符串，是type对象。
函数名赋值给变量
int2give = int
print int2give('3')
------------------------------------------
函数参数
形式参数和实际参数
- 在定义函数时，函数名后面括号中的变量名称叫做“形式参数”，或者称为“形参”
- 在调用函数时，函数名后面括号中的变量名称叫做“实际参数”，或者称为“实参”
形参和实参一定要一一对应
def connect(host,port)
a=sum(127.0.0.7,3306) 127.0.0.1对应host，3306对应port，不能够a=connect(3306,127.0.01)
或者指定参数
fun(1,2)
fun(x=1,y=2) 传参的另一种方式，指定参数，不过很少用
fun(1)
in的用法
if i in '0123456789'
if plus_one in range(10)
sys.argv跟shell内置变量一样
sys.argv[0] 相当于 $0表示脚本本身
sys.argv[1] 相当于 $1 第一个参数
sys.argv[2] 相当于 $2 第二个参数
sys.argv 返回所有参数列表['memory.py', '2', 'uu']
len(sys.argv) 参数的个数
#!/usr/bin/python
import sys
import os
def isNum(s):
for i in s:
if i in '0123456789':
pass
else:
#print "%s is not a number" %s
break
else:
print s
isNum(sys.argv[1])
----------------------------------
练习
打印系统的所有PID
要求从/proc读取。
os.listdir()
os.listdir：列出目录下的所有文件和目录，列表形式，每个列表元素都是字符串
打印系统的所有PID
要求从/proc读取。
os.listdir()
os.listdir：列出目录下的所有文件和目录，列表形式，每个列表元素都是字符串#!/usr/bin/env python# -*- coding:utf-8 -*-# __author__="huazai""""pycharm 使用指南
Date:2016.08.12"""import osimport sysimport stringdef isNum(s): for i in s: if i in '0123456789': pass
else: # print "%s is not a number" %s
break
else: print sfor i in os.listdir('/proc'):
isNum(i)
或#!/usr/bin/env python# -*- coding:utf-8 -*-# __author__="huazai""""pycharm 使用指南
Date:2016.08.12"""import osimport sysimport stringdef isNum(s): if s in '0123456789': print sfor i in os.listdir('/proc'):
isNum(i)
----------------------------------------------------------
函数默认参数
缺省参数（默认参数）
def fun(x, y=100):
print x,y
默认参数只能写在最右边，否则会报错 def fun(y=100,x): 这个报错
---------------------------------------------------------
函数里的变量
局部变量和全局变量
- Python中的任何变量都有特定的作用域
- 在函数中定义的变量一般只能在该函数内部使用，这些只能在程序的特定部分使用的变量我们称之为局部变量
- 在一个文件顶部定义的变量可以供文件中的任何函数调用，这些可以为整个程序所使用的变量称为全局变量
global语句
global 变量名
强制声明为全局变量
全局变量在函数外声明，在函数里面global引用全局变量
在函数里面global声明全局变量，在函数外可以引用这个全局变量
#!/usr/bin/env python# -*- coding:utf-8 -*-# __author__="huazai""""pycharm 使用指南 Date:2016.08.12"""import osimport sysimport string x = 100def fun(): global x x += 1 print x fun()print x
globals函数打印当前环境的所有全局变量，返回字典
locals函数打印当前环境的所有局部变量，返回字典
#!/usr/bin/env python# -*- coding:utf-8 -*-# __author__="huazai""""pycharm 使用指南 Date:2016.08.12"""import osimport sysimport string x = 100def fun(): x = 1 y = 1 print locals() fun()print globals()
-------------------------------------------------------
函数返回值
- 函数被调用后会返回一个指定的值
- 函数调用后默认返回None
- return 返回值
- 返回值可以是任意类型
- return执行后，函数终止
- return与print区别
------------------------------
多类型传值
元组传参
形参前面加一个* 传入元组，元组要放在右边
至少要3个参数，如果只传入元组，里面元组一定至少要有3个元素，填充形参x，y，zdef fun(x, y, *z): print x print y print z print x+y+z[0] if __name__ == '__main__': t1 = (1,2,3,4) t = (1,2,3) fun(*t1) 返回：1 2 (3, 4) 6 fun(*(1, 2, 3)) 返回： 1 2 (3,) 6 fun(1, *t) 返回： 1 1 (2,3) 4
字典传参
字典的key的名字要跟形参的名字一样，x，y，z否则会报错
跟元组传参一样，至少要3个参数，如果只传入字典，字典里面一定至少要有3个元素，填充形参x，y，zdef fun(x,y,z,**args): print x+y+z print argsif __name__ == '__main__':
dic = {'x': 1, 'y': 3, 'z': 5,'a':6} # 字典的key必须要加引号，否则报错
fun(**dic)
返回： 9{'a': 6}def fun(x,y,z,**args): print x+y+z print argsif __name__ == '__main__':
fun(x=1,y=2,z=3,a=6)
返回： 6{'a': 6}def fun(x,y,z,**args): print x+y+z print argsif __name__ == '__main__':
dic = {'a': 1, 'b': 3, 'c': 5,'c':6} # 字典的key必须要加引号，否则报错
fun(1,2,3,**dic)
注意： def fun(x,y,z,**args): print x+y+z print argsif __name__ == '__main__':
dic = {'x': 1, 'y': 3, 'z': 5,'a':6} # 字典的key必须要加引号，否则报错
fun(1,2,3,**dic)
注意：输入了默认参数，那么字典的key就不能跟参数一样，不能用x，y，z，否则会报错
Traceback (most recent call last):
File "C:/Users/Administrator/Desktop/Գ��python�༶5��/python��ϰ/aa.py", line 23, in
fun(1,2,3,**dic)
TypeError: fun() got multiple values for keyword argument 'y'
冗余参数
向函数传元组和字典
处理多余实参
def fun(x,y,*args,**kwargs)
fun(1,2,'a',[2,4],y=2,z=3)
fun(1,2,'a',[2,4],*t,y=2,**{'u'：12})
--------------------------------
函数递归调用
计算阶层
递归调用
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
print factorial(5)
注意事项
必须有最后的默认结果： if n == 0
递归参数必须向默认结果收敛的： factorial(n-1)
打印目录下所有文件
#!/usr/bin/env python# -*- coding:utf-8 -*-# __author__="huazai""""pycharm 使用指南 Date:2016.08.12"""import osimport sysimport stringdef print_files(path): # isdir, isfile, join = os.path.isdir, os.path.isfile, os.path.join # print isdir,isfile,join lsdir = os.listdir(path) dirs = [i for i in lsdir if os.path.isdir(os.path.join(path, i))] files = [i for i in lsdir if os.path.isfile(os.path.join(path, i))] if dirs: for d in dirs: print_files(os.path.join(path, d)) if files: for f in files: print os.path.join(path, f) print_files(sys.argv[1]) 把函数名赋值给变量# isdir, isfile, join = os.path.isdir, os.path.isfile, os.path.join# print isdir,isfile,join
---------------------------------------------------------------------------
匿名函数
lambda函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方。
lambda语句中，冒号前是参数，可以有多个，逗号隔开，冒号右边是返回值。
lambda语句构建的其实是一个函数对象
def fun(x, y):
return x*y
fun(2, 3)
r = lambda x,y: x*y
r(2, 3)
def add(x, y):
return x + y
sum = reduce(add, [1, 2, 3])
reduce(lambda x,y:x+y, range(1,4))
匿名函数优点：
- 1.使用python写一些脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。
- 2. 对于一些抽象的，不会被别的地方再重复使用的函数，有时候函数起个名字也是个难题，使用lambda不需要考虑命名的问题。
- 3. 使用lambda在某些时候让代码更容易理解。
-------------------------------------------
内置函数
所有内置函数和内置类都在__builtin__模块（__builtin__前后双下划线）
查询内置函数和类
https://docs.python.org/2/library/index.html
绝对值，最大最小值
abs()
max()
max('12345','789')
字符串'789‘比字符串’12345‘大，字符串是从左到到右开始比较的，'7’比‘1'大，所以输出’789'
min()
len() 参数是一个对象（字符串，元组，字典）不能是整数
divmod() 参数是两个数字，返回商和余数
pow() 乘方
round() 给出小数点的精度，没有第二个参数直接四舍五入，round(12.367,3)保留三位小数
先进行四舍五入的运算，如果小数点精度最后一位是偶数复合条件，如果小数点精度的最后一位四舍五入是奇数，则舍弃原小数点精度后的所有数字，以及保证
小数点精度最后一位必须是偶数
常用函数
callable() 可被调用的，例如类，函数
type()
isinstance() isinstance(s,(int,tuple,str)),s是一个对象，第二个参数是元组，判断s这个对象的数据类型在不在第二个参数元组里，是返回true ，否返回false
class A(object): passa=A()print isinstance(a,A)
cmp() 如果是字符串，则逐个字符比较，一旦有字符比较出来就不往下比较
range()
xrange()
类型转换函数
int() 参数如果是字符串，只能是纯数字字符串，不能带小数
long() 参数如果是字符串，只能是纯数字字符串，不能带小数
float() 参数如果是字符串，只能是纯数字字符串，不能带小数
complex()
str()
list()
tuple()
hex()
oct()
chr() 输入0
eval() 将有效表达式求值，其实就是去掉字符串
字符串处理函数
下面函数实例化一个string对象或声明一个string变量
str.capitalize() 将字符串里的第一个字符大写并返回
str.replace() replace(old，new，count)
str.split() 字符串切成列表 不指定分隔符，那么默认以空格，tab键，换行符作为分隔 split('.',1) 点为分隔，切1次
str.join() 列表连接为字符串 ''.join([str(i) for i in range(10)]) join会在被插入字符中间插入 ','.join([str(i) for i in range(10)]) 逗号变为的分隔符
s= 'sdf'
s.join('22')
'2sdf2'
静态函数，不需要实例化一个string对象
string模块 import string
string.capitalize('hello')
string.replace('wecan','a','t')
string.split('we,w,e',',')
string.join('ww','tt')序列处理函数
len()
max()
min()
filter() filter(none/func, seq) 如果不是none，func这个函数依次对sequence里的元素做处理，最后返回一个list, tuple, or string。
zip() 合并多个列表、元组
l1=[1,2,3]
l2=['a','b','c']
zip(l1,l2)
[(1, 'a'), (2, 'b'), (3, 'c')]
dict(zip(l1,l2)) 从中创建字典
l1=(1,2,3)
l2=['a','b','c']
print zip(l1,l2)
[(1, 'a'), (2, 'b'), (3, 'c')]
高阶函数
map()函数，第一个参数为自定义函数，第二个参数为一个可迭代对象（元组，列表），返回一个列表
def f2(x):
return x*x
if __name__ == '__main__':
lt = (1, 2, 3, 4, 5)
m1 = map(f2, lt)
print(type(m1))
print (m1)
#
# [1, 4, 9, 16, 25]
reduce()函数
把可迭代对象的前两个参数作为函数的实参，传入到f函数中
把每次f运算的结果作为第一个实参，可迭代对象的下一个元素作为另一个实参，传入函数f中
以此类推，最终得到结果
def f2(x,y):
return x*y
if __name__ == '__main__':
m1 = reduce(f2,[1,2,3],10)
print(type(m1))
print (m1)
60
filter()函数
每次把可迭代对象的元素传入进去，进行处理，返回可以迭代对象的类型，比如可迭代对象是列表那么就返回列表，可迭代对象是元组那么就返回元组
def is_odd(x):
return x%2==1
if __name__ == '__main__':
a = [1,2]
print (filter(is_odd,a))
[1]
map() map(none/func,l1,l2,l3)跟zip函数一样，元素最少的那个序列以none补充，map(func,seq)对序列的每个元素都放进去函数里去处理，并且函数参数要与序列元素个数相同
与filter(func, seq)类似，但是filter(func, seq)只能处理单个序列
reduce() 函数， reduce(func,seq)
使用lambda代入序列处理函数
filter(lambda x:x %2 ==0, range(10))
[0, 2, 4, 6, 8]
map(lambda x,y:x*y, range(5),range(5))
[0, 1, 4, 9, 16]
reduce(lambda x,y:x+y, range(1,101))
5050
列表表达式/列表重写
[i*2+10 for i in range(10)]
[i for i in range(10) if i%3 == 0]
提示
16行报错，vim +16 xx.py
函数的参数不能是连字符
def f(x, **kwargs):
print x
print kwargs
f(1,a=10,b-b=20) 报错 涉及变量的命名
f(1,a=10,b_b=20) 正确
变量的命名
- 变量名由字母、数字、下划线组成。
- 变量不能以数字开头
- 不可以使用关键字
In [1]: def f(x, **kwargs):
...: print x
...: print kwargs
...: f(1,a=10,b-b=20)
File "
f(1,a=10,b-b=20)
SyntaxError: keyword can't be an expression
