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 <module>
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 <module>
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<x<256 返回ascii字符
ord() 输入ascii的单个字母，返回数字
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)
# <type 'list'>
# [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)
<type 'int'>
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 "<ipython-input-1-35f95bb06c84>", line 4
f(1,a=10,b-b=20)
SyntaxError: keyword can't be an expression
随时随地看视频
