Python第七天 函数 函数参数 函数里的变量 函数返回值 多类型传值 函数递归调用 匿名函数 内置函数
目录
Python第二天 变量 运算符与表达式 input()与raw_input()区别 字符编码 python转义符 字符串格式化
Python第三天 序列 5种数据类型 数值 字符串 列表 元组 字典
Python第四天 流程控制 if else条件判断 for循环 while循环
Python第五天 文件访问 for循环访问文件 while循环访问文件 字符串的startswith函数和split函数
Python第七天 函数 函数参数 函数变量 函数返回值 多类型传值 冗余参数 函数递归调用 匿名函数 内置函数 列表表达式/列表重写
Python第八天 模块 包 全局变量和内置变量__name__ Python path
Python第九天 面向对象 类定义 类的属性 类的方法 内部类 垃圾回收机制 类的继承 装饰器
Python第十天 print >> f,和fd.write()的区别 stdout的buffer 标准输入 标准输出 标准错误 重定向 输出流和输入流
Python第十二天 收集主机信息 正则表达式 无名分组 有名分组
Python第十四天 序列化 pickle模块 cPickle模块 JSON模块 API的两种格式
Python第十五天 datetime模块 time模块 thread模块 threading模块 Queue队列模块 multiprocessing模块 paramiko模块 fabric模块
Python函数
函数就是完成特定功能的一个语句组，这组语句可以作为一个单位使用，并且给它取一个名字。
可以通过函数名在程序的不同地方多次执行（这通常叫函数调用）。
函数定义要在函数调用之前，否则函数调用会找不到要调用的函数 跟编译型语言不一样！！！！！！！！！
函数要写在python文件的最前面，否则NameError: name 'wordCount' is not defined
import os
import sys
import 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)
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 os
import sys
import string def isNum(s):
for i in s:
if i in '':
pass
else: # print "%s is not a number" %s
break
else:
print s for i in os.listdir('/proc'):
isNum(i) 或
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
""" import os
import sys
import string def isNum(s):
if s in '':
print s for 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 os
import sys
import string x = 100 def 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 os
import sys
import string x = 100
def fun():
x = 1
y = 1
print locals() fun()
print globals()
-------------------------------------------------------------------------------------------------------------
函数返回值
而 Python 和大多数其它语言不同，可以返回多个返回值，当 Python 返回多个值的时候，python 解释器把这些值放进一个 tuple 里面，所以 Python 的函数返回多值其实就是返回一个 tuple，该 tuple 本质上也是一个值。
def myfunc():
return "ruhua", "xingxing", "zhaoritian" rst = myfunc()
print(rst) # 可以看到是一个 tuple
print(type(rst)) # tuple 类型
当 python 返回多个值的时候，接收变量个数只能为一个或返回值的个数， 因为一个变量接收的是整个 tuple，而多个变量接收的是 tuple 里面成员的个数。
def myfunc():
return "ruhua", "xingxing", "zhaoritian" rst = myfunc() # ok
one, two, three = myfunc() # ok
one, two = myfunc() # 错误
函数体内部的语句在执行时，一旦执行到 return 时，函数就执行完毕，并将结果返回， 如果没有 return 语句，函数执行完毕后也会返回结果，只是结果为 None
- 函数被调用后会返回一个指定的值
- return 返回值
- 返回值可以是任意类型
- return执行后，函数终止
- return与print区别
--------------------------------------------------------------------------------------------------------------
多类型传参
元组传参
形参前面加一个* 传入元组，元组要放在右边
至少要3个参数，如果只传入元组，里面元组一定至少要有3个元素，填充形参x，y，z
def 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，z
def fun(x,y,z,**args):
print x+y+z
print args if __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 args if __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 args if __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 args if __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 say(a,b,*args,**kwargs):
print a,b,args,kwargs
a：位置参数
b:位置参数
*args：不固定的位置参数
**kwargs：关键字参数
pack：打包
unpack：解包
命名关键字参数，不推荐用
命名关键字参数是在 Python 3 中新增加的一种语法，它和关键字参数 **kw 不同，命名关键字参数需要一个特殊分隔符 * ，* 后面的参数被视为命名关键字参数。例如，只接收 sex 和 lover 作为关键字参数，这种方式定义的函数如下。
def Human(name, age, *, sex, lover):
print(name, age, sex, lover) #调用方式
Human('ruhua', 18, sex='f', lover='tangbohu')
---------------------------------------------------------
函数递归调用
计算阶层
递归调用
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 os
import sys
import string def 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):
pass a=A()
print isinstance(a,A)
cmp() 如果是字符串，则逐个字符比较，一旦有字符比较出来就不往下比较，返回值：-1 左边比右边大，0 相等，1 右边比左边大，
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')
从python3开始，序列处理函数和高阶函数用itertools模块来代替，垃圾猿课python
zip()，map()，filter()，slice()
提示
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