Python第七天 函数 函数参数 函数里的变量 函数返回值 多类型传值 函数递归调用 匿名函数 内置函数

Python第七天   函数  函数参数   函数里的变量   函数返回值  多类型传值     函数递归调用   匿名函数   内置函数

目录

Pycharm使用技巧（转载）

Python第一天  安装  shell  文件

Python第二天  变量  运算符与表达式  input()与raw_input()区别  字符编码  python转义符  字符串格式化

Python第三天 序列  5种数据类型  数值  字符串  列表  元组  字典

Python第四天   流程控制   if else条件判断   for循环 while循环

Python第五天   文件访问    for循环访问文件    while循环访问文件   字符串的startswith函数和split函数

Python第六天   类型转换

Python第七天   函数  函数参数   函数变量   函数返回值  多类型传值    冗余参数   函数递归调用   匿名函数   内置函数   列表表达式/列表重写

Python第八天  模块   包   全局变量和内置变量__name__    Python path

Python第九天  面向对象  类定义   类的属性    类的方法    内部类   垃圾回收机制   类的继承 装饰器

Python第十天   print >> f,和fd.write()的区别    stdout的buffer  标准输入 标准输出  标准错误   重定向 输出流和输入流

Python第十一天    异常处理  glob模块和shlex模块    打开外部程序和subprocess模块  subprocess类  Pipe管道  operator模块   sorted函数   生成器  walk模块   hashlib模块

Python第十二天     收集主机信息     正则表达式  无名分组   有名分组

Python第十三天   django 1.6   导入模板   定义数据模型   访问数据库   GET和POST方法    SimpleCMDB项目   urllib模块   urllib2模块  httplib模块  django和web服务器整合  wsgi模块   gunicorn模块

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