Python函数基础总结

Python函数

函数就是完成特定功能的一个语句组，这组语句可以作为一个单位使用，并且给它取一个名字。可以通过函数名在程序的不同地方多次执行（这通常叫函数调用）。函数定义要在函数调用之前，否则函数调用会找不到要调用的函数。函数要写在python文件的最前面，否则提示NameError: name 'wordCount' is not defined

import os
import sys
import string
a="""hello world python"""
b=wordCount(a)    #提前调用
def wordCount(a):
chars=len(a)
words=len(a.split())
lines=a.count('\n')
print lines,words,chars

#输出结果
Traceback (most recent call last):
File "G:/py/pytest33/test123.py", line 20, in <module>
wordCount(a)
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()  #调用函数

 

函数名赋值给变量

int2give = int

print int2give('3')

函数参数

形式参数和实际参数定义:

在定义函数时，函数名后面括号中的变量名称叫做“形式参数”，或者称为“形参”

在调用函数时，函数名后面括号中的变量名称叫做“实际参数”，或者称为“实参”

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])

os.listdir()
os.listdir：列出目录下的所有文件和目录，列表形式，每个列表元素都是字符串

实例：

打印系统的所有PID，要求从/proc读取。

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)
或
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): 这个报错

fun(1,2)

fun(x=1,y=2) 传参的另一种方式，不过比较啰嗦很少用

fun(1)

函数变量

局部变量和全局变量：

Python中的任何变量都有特定的作用域

在函数中定义的变量一般只能在该函数内部使用，这些只能在程序的特定部分使用的变量我们称之为局部变量

在一个文件顶部定义的变量可以供文件中的任何函数调用，这些可以为整个程序所使用的变量称为全局变量

global语句

global 变量名

强制声明为全局变量

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

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

import sys
import os

import string
x = 100

def fun():
global x
x += 1
print x
fun()
print x

globals函数打印当前环境的所有全局变量，返回字典；locals函数打印当前环境的所有局部变量，返回字典

import sys
import os

import string
x = 100
def fun():
x = 1
y = 1
print locals()
fun()
print globals() 

函数返回值

函数被调用后会返回一个指定的值

函数调用后默认返回None

return 返回值

返回值可以是任意类型

return执行后，函数终止

多类型传值

元组传参

实参前面加一个* 传入元组，元组要放在右边

def fun(x,y,z)

    return x+y+z

t1=(2,3,4)

t=(1,2)

fun(*t1)

fun(*(1,2,3))

fun(1,*t)

 

字典传参

字典的key的名字要跟形参的名字一样，x，y，z否则会报错

def fun(x,y,z)

return x+y+z

dic = {'x':1,'y':3,'z':5}

fun(**dic)

 

冗余参数

向函数传元组和字典

处理多余实参

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)

 打印目录下所有文件：

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])
#把函数名赋值给变量

 

匿名函数

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))

 匿名函数优点：

使用python写一些脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。

对于一些抽象的，不会被别的地方再重复使用的函数，有时候函数起个名字也是个难题，使用lambda不需要考虑命名的问题。

使用lambda在某些时候让代码更容易理解。

 

内置函数

所有内置函数和内置类都在__builtin__模块（__builtin__前后双下划线）

内置函数和类：

绝对值，最大最小值

abs()

max()

max('12345','789') #字符串'789‘比字符串’12345‘大，字符串是从左到到右开始比较的，'7’比‘1'大，所以输出’789'

min()

len()  #参数是一个对象（字符串，元组，字典）不能是整数

divmod()  #参数是两个数字，返回商和余数

pow() #乘方

round() #给出小数点的精度，没有第二个参数直接四舍五入

常用函数：

callable() #可被调用的，例如类，函数

type()

isinstance() #isinstance(s,(int,tuple,str)),s是一个对象，第二个参数是元组，判断s这个对象的数据类型在不在第二个参数元组里，是返回true ，否返回false

实例：

class A(object):
pass
a=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()   map(none,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]

函数的参数不能是连字符

def f(x, **kwargs):

print(x)

print(kwargs)

f(1,a=10,b-b=20) #报错 涉及变量的命名

f(1,a=10,b_b=20) #正确