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 '0123456789':
            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 '0123456789':
        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

nonlocal是在Python3.2之后引入的一个关键字，它是用在封装函数中的。

首先，要明确 nonlocal 关键字是定义在闭包里面的（不定义在闭包里会抛异常SyntaxError: nonlocal declaration not allowed at module level）

x = 0
def outer():
    x = 1
    def inner():
        nonlocal x
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

结果：

inner: 2
outer: 2
global: 0

这是一个函数里面再嵌套了一个函数；

当使用 nonlocal 时，就声明了该变量不只在嵌套函数inner()里面才有效，而是在整个大函数里面都有效。

而global 是对整个环境下的变量起作用，而不是对函数类的变量起作用

关于global 和 nonlocal 的作用域
python引用变量的顺序：当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量

Python3中global与nonlocal区别
用一句话来解释：
nonlocal，如果在闭包内给该变量赋值，那么修改的其实是闭包外那个作用域中的变量。global，用来表示对该变量的赋值操作，将会直接修改模块作用域里的那个变量。（nonlocal与global互为补充）

global语句
global 变量名
强制声明为全局变量

全局变量在函数外声明，在函数里面global引用全局变量
在函数里面global声明全局变量，在函数外可以引用这个全局变量

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

posted @ 2017-01-18 21:24 桦仔阅读(1544) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

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

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

公告

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

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

公告

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

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