python第四周小测验选择题_python第四周

一、函数

1.面向对象　　》》类 》》class

2.面向过程　　》》 过程 》def  是把一段段的逻辑或功能放入一个def中，当想用的时候可以直接调用。

3.面向函数　　》》 函数 》def

#面向函数

def fcont1(): #定义一个函数fcont1为函数名。

"test" #函数的一个说明，以后写函数一定要注明，主要是为后人写程序提供清晰的。

print(‘in the fcont1‘) #此处指的是逻辑。

return 0 #函数的结束及返回值。

#过程

def fcont2(): #面向过程的函数是没有返回值的。这了是其中的一个区别。

"test"

print(‘in the fcont2‘)

x = fcont1() #把函数里的值赋予给x

y = fcont2() #把函数里的值赋予给y

print(‘from fcont1 return is %s‘%x)

print(‘from fcont return is %s‘%y)

二、为什么要使用函数

1、可扩展性

2、减少代码的重复性

3、保持一致性

import time #调用系统时间的模块。

def logger(): #定义一个函数名。

"logfile" #函数注释，这个一定要养成良好的习惯。

time_formart = "%Y-%m-%d %X" #定义时间格式%Y year年，%m(m小写month),%d(d 小写day天)，%X 时分秒。

time_current = time.strftime(time_formart) #给时间定义一个一变量名。

with open("log.txt","a+") as f:

f.write("%s end action\n"%time_current) #套用时间的变量名。

def data1():

"dataLog1"

print("in The data1")

logger()　　#调用logger写日志操作的函数模块。

def data2():

"dataLog2"

print("in The data2")

logger()

def data3():

"dataLog2"

print("in The data3")

logger()

data1()

data2()

data3()

三、函数的调用。

1、形参

形参顺序无关

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部　　　　有效。函数调用结束返回主调用函数后则不能再使用该形参变量

2、实参.

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

def byron(x,y,z):　　#形参

"The is test1"

print(x)

print(y)

print(z)

c =byron(1,3) #实参

print(c) #实参

byron(y=2,x=1) # 此处为关键字调用 与形参顺序无关

byron(1,2) #此处为位置参数调用 与形参一一对应。

byron(3,y=2) #既有位置参数又有关键字，位置参数需在前，后面的需要形参关键字

3、#默认参数

def byron(x,y=10):

"The is test1"

print(x)

print(y)

byron(1) #默认参数的特点：调用函数的时候，默认参数非必须传递，如没有指定参数则直接输出默认参灵敏。

#默认参数的应用场景：安装软件时的自定义安装。

#连接数据库的参数。

3、多实参,参数组如何定义一个形参？？？def byron(*args): # *号可以理解成一个功能吧！只能接受位置参数。

"The is test"

print(args)

byron(1,2,3,4,5,90) #存放到一个元组里了。

byron(*[1,2,3,4,5]) # args = tuple([1,2,3,4,5])

#**kwargs 把N个关键字参数转换成字典的方式

def byron(**kwargs):

"test 字典"

print(kwargs)

print(kwargs["name"]) #单独取字典里的了个值。

print(kwargs["age"])

byron(name="byron",age=18) #关键字参数。

byron(**{"name":"byron","age":18}) #字典方式，与上面的一个方式输出结果一样。

def byron(name,**kwargs):

print(name)

byron(byron,**{"age":18,"job":"linux"})

def byron(name,age=10,*args,**kwargs):

print(name)

print(age)

print(args)

print(kwargs)

byron("xiaoming",50,job="it",salary=5000,)

四、作用域及局部变量。

在子程序中定义的变量称为局部变量.

在程序的一开始定义的变量称为全局变量。

def byron(name,age=26,**kwargs):

print(name)

print(age)

print(kwargs)

logger(byron) #调用logger

def logger(source):

print("From %s"% source)

byron("lina", 62, job="IT", salary=50000) #注意，此处应该在内置函数之后，放在之前会报错！

def byron(name):

print("Before change:",name)

name = "lishi" #局部变量，此处变量只在此函数内生效，这个函数是这个变量的作用域

print("After change:",name)

name = "Lisi"

byron(name)

print(name)

school = "ByronHe"

def Byron(name):

global school #全局变量。

school = "cbc"

print("Befter change:",name,school)

name = "LiSHI"

print("After change:",name)

name = "laowang"

Byron(name)

print(name)

print(school)

list = ["xiaoming","zhangshan","lishi"]

def Byron():

print("Befter change:",list) #在局部变量中，列表，字典,集合是可以更改的，但是整数及字符串是不能更改的

list[0] = "lao"

name = "Xiaoming"

Byron()

print(list)

五、递归。

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈(stack)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出)

def recursion(n):

print(n)

return recursion(n+1) #循环加1 加至999会结束，否则会引起主机死机，此处系统已做机制

recursion(0)

def recursion(n):

print(n)

if (int(n/2)) > 0:

return recursion(int(n/2)) #此返回值为n/2的小数，但被int整形，代表结束。

print(">>",n)

recursion(10)六、高阶函数变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

#高阶函数

def Byron(a,b,f):

print(f(a)+f(b))

res = Byron(3,-7,abs)

print(res)

原文：http://www.cnblogs.com/ByronHe/p/6850337.html