Python学习之 函数篇

释放双眼,带上耳机,听听看~!

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:列出目录下的所有文件和目录,列表形式,每个列表元素都是字符串

Python学习之  函数篇

打印系统的所有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

Python学习之  函数篇

 


 

函数的参数不能是连字符

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

【转自慕课】https://www.imooc.com

Python

http你不得不知道的那些事(二)--CSRF

2022-3-3 6:53:44

Python

python 元组的基础知识

2022-3-3 6:59:45

搜索