Python高级编程 课件 第3讲 函数及调用规则

第3讲函数及调用规则深圳北理莫斯科大学姜增如16嵌套函数的使用3Python的日期和时间转换函数及使用主讲函数2其他函数及使用4匿名函数及使用5Python函数及调用规则7递归套函数8全局变量与局部变量使用9递归套函数的使用函数描述chr(x)将一个ASCII整数转换为一个字符ord(x)将一个字符转换为它的ASCII值hex(x)将一个整数转换为一个十六进制字符串oct(x)将一个整数转换为一个八进制字符串bin(x)将一个整数转换为一个二进制字符串一、转换函数及使用1、进制转换与ASCII码转换函数

Python的转换函数包括整数到进制转换、ASCII值和类型转换。结果：98D1230b1001090o36180x57Ture66例1进制转换及ASCII码转换b=ord('b');print(b)

#字符到ASCII码ch=chr(100);print(ch)#ASCII码到字符print(int('0b1111011',2))#二进制到十进制print(bin(18))#十进制到二进制print(int('011',8))#八进制到十进制print(oct(30))

#十进制到八进制print(int('0x12',16))

#十六进制到十进制print(hex(87))

#十进制到十六进制print(bool(100))#转换成布尔型print(ord(‘B’))#转换成布尔型函数描述int(x[,base])将x转换为一个整数long(x[,base])将x转换为一个长整数float(x)将x转换到一个浮点数complex(real[,imag])创建一个复数str(x)将对象x转换为字符串repr(x)将对象x转换为表达式字符串eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象tuple(s)将序列s转换为一个元组list(s)将序列s转换为一个列表set(s)转换为可变集合dict(d)转换为一个字典，d必须是一个序列(key,value)元组。frozenset(s)转换为不可变集合2、类型转换函数importmath

print(math.pi)

print(int(math.pi))A='0b1011'B='0b1000'print(A+B)

print(complex(math.pi))#转换成复数a=eval(A)#字符到数值型

b=eval(B)print(a+b)list1=list(range(10))#转换成列表print(list1)3.14159265358979330b10110b1000(3.141592653589793+0j)19[0,1,2,3,4,5,6,7,8,9]结果：例2类型转换函数的使用序号函数功能描述1divmod()除数和余数运算结果结合起来，返回一个包含商和余数的元组2range()返回一组序列数（非列表），使用list返回一个列表3all()判断列表、元组及字典的所有元素是否有一个为空，是返回False，否True4any()判断列表、元组及字典的所有元素是否空，是返回TRUE，否False5map()根据提供的函数对指定序列做映射6dir()返回模块里定义的所有模块、变量和函数7split()对一个字符串进行分割成多个字符串二、其他函数及使用

Python的其他函数可帮助完成各种数据操作，包括字符分割、判断、获取对象地址、返回模块变量和函数名等操作。1、其他函数（1）split()函数split()是用于对一个字符串进行分割成多个字符串数组的函数，语法格式：split(sep,num)#sep为分割符，num为分割次数不写sep时，默认表⽰⽤空格，\n，\t分隔字符串例如：str="abcdefine\napple"print(str.split()）结果：['abc','define','apple']有sep时按sep的值分隔：例如：str="smbuadefine\napple"print(str.split("a",1))

#按a进行分割1次结果：['smbu','define\napple']2、split()函数的使用当分隔符在字符串第⼀个或最后⼀个位置时，需要注意结果（当不写sep时，没有该影响），前后多了空字符：str="abcdefine\napplea"print(str.split("a"))#首部和尾部出现分割符用空格结果：['','bcdefine\n','pple','']当分隔符连续出现多次时，分割符所在处用空格替代str="aabcaaadefine\nappleaa"print(str.split("a"))结果：['','','bc','','','define\n','pple','','']多次分隔，获取需要的结果：str="/"print(str.split("//")[1].split("/")[0].split("."))结果：['smbu','edu','cn']3、map()函数map()对指定序列做映射。语法格式：map(function,iterable)#function为函数，iterable为一个或多个序列。例如：（1）将元组转换成整数列表map(int,(1,2,3))结果：[1,2,3]（2）将字符串转换成整数列表map(int,‘1234’)结果：[1,2,3,4]（3）提取字典的key，并将结果存放在一个list中map(int,{1:姓名,2:性别,3:专业})结果：[1,2,3]（4）字符串转换成元组，并将结果以列表的形式返回map(tuple,‘agdf’)结果：[('a',),('g',),('d',),('f',)]将2个列表形成字典方法：list1=['name','age','sex']list2=['张三','10','男']dict_all=dict(map(lambdakey,value:[key,value],list1,list2))print(dict_all)结果：{'name':'张三','age':'10','sex':'男'}（1）输入三个整数分别赋给a,b,c，使用空格隔开，则方法是：a,b,c=map(int,input('请输入方程的系数a,b,c=?').split())print("a=",a,",b=",b,",c=",c)结果：请输入方程的系数a,b,c=?345a=3,b=4,c=5（2）输入三个浮点数分别赋给a,b,c，使用逗号隔开，则方法是：a,b,c=map(float,input('请输入方程的系数a,b,c=?').split(','))

print("a=",a,",b=",b,",c=",c)结果：请输入方程的系数a,b,c=?3.56,7.89,2.61a=3.56,b=7.89,c=2.61例如：defsquare(x):#计算平方数函数

returnx**2map(square,[1,2,3,4,5])#返回迭代器print(list(map(square,[1,2,3,4,5])))#使用list()转换为列表print(divmod(7,2))print(divmod(76,12))print(type(10.78),type('Python'))list1=['a','b','c','d']print(all(list1))list2=['a','b','','d']print(all(list2))print(any(list1))print(any([0,'',False]))[1,4,9,16,25](3,1)(6,4)<class'float'><class'str'>TrueFalseTrueFalse结果：例3常用函数的使用dir()函数dir()函数返回模块里定义过的字符串列表名字。返回的列表容纳了在一个模块里定义的所有模块、变量和函数。例如：#导入内置math模块importmathprint(dir(math))结果：['__doc__','__file__','__name__','acos','asin','atan','atan2','ceil','cos','cosh','degrees','e','exp','fabs','floor','fmod','frexp','hypot','ldexp','log','log10','modf','pi','pow','radians','sin','sinh','sqrt','tan','tanh']在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。l1=[1,2,3,4,5]l2=['北京','上海','深圳','广州','南京']dict1=dict(zip(l1,l2))#使用zip将l2插入到l1中打包成字典print(dict1)#或使用下面语句实现dict2=dict(map(lambdakey,value:[key,value],l1,l2))#l1为键，l2为值print(dict2)例4将下列两个列表形成字典，l1为键，l2为值。{1:'北京',2:'上海',3:'深圳',4:'广州',5:'南京'}{1:'北京',2:'上海',3:'深圳',4:'广州',5:'南京'}结果：Python程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。它提供了datetime（表示日期和时间的结合）、

time（时间）和calendar（日历）模块用于格式化日期和时间。时间间隔是以秒为单位的浮点小数。每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示，获取日期或时间时，需要导入函数：

（1）importdatetime#引入日期和时间模块

（2）importtime#引入时间模块。

（3）importcalendar#引入日历模块三、Python的日期和时间1、datetime内置方法1datetime.today()返回一个表示当前本地时间的datetime对象2datetime.now()返回一个表示当前本地时间的datetime对象3datetime.date提供year,month,day属性4datetime.datetime提供year,month,day,hour,minute,second用于将对象从字符串转换为datetime对象5datetime.strptime(date_string,format)将格式字符串转换为datetime对象6datetime.timedelta对象表示一个时间长度，两个日期或者时间的差值datetime.strftime用来获得当前时间，可以将时间格式化为字符串2、Time内置方法序号函数及描述1time.altzone返回西欧夏令时启用地区时间2time.asctime([tupletime])接受时间元组并返回一个可读的形式为时间日期字符串3time.clock()以浮点数计算秒数返回当前CPU时间衡量不同程序的耗时4time.ctime([secs])相当于asctime(localtime(secs))，未给参数相当于asctime()5time.gmtime([secs])

接收时间戳（1970纪元后经过的浮点秒数）并返回西欧天文时间元组t。注：t.tm_isdst始终为06time.localtime([secs])接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）7time.mktime(tupletime)接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）8time.sleep(secs)推迟调用线程的运行，secs指秒数9time.strftime(fmt[,tupletime])接收时间元组并返回可读字符串的当地时间，格式由fmt决定10time.strptime(str,fmt='%a%b%d%H:%M:%S%Y')根据fmt的格式把一个时间字符串解析为时间元组11time.time()返回当前时间的时间戳（1970纪元后经过的浮点秒数）。12time.tzset()根据环境变量TZ重新初始化时间相关设置序号格式符表示1%y两位数的年份表示（00-99）2%Y四位数的年份表示（000-9999）3%m%m月份（01-12）4%d%d月内中的一天（0-31）5%H24小时制小时数（0-23）6%I12小时制小时数（01-12）7%M分钟数（00-59）8%S秒数（00-59）9%a本地简化星期名称10%A本地完整星期名称11%b本地简化月份名称3、Python时间日期格式化符号：序号格式符表示12%B本地完整月份名称13%U一年中的星期数（00-53）星期天为星期的开始14%j年内的一天（001-366）15%W一年中的星期数（00-53）星期一为星期的开始16%c本地相应的日期表示和时间表示17%x本地相应的日期表示18%X本地相应的日期表示19%Z当前时区的名称Pythond的时间函数用一个元组装起来的9组数字处理时间:序号字段值04位数年20081月1到122日1到313小时0到234分钟0到595秒0到61(60或61是闰秒)6一周的第几日0到6(0是周一)7一年的第几日1到366(儒略历)8夏令时-1,0,1,-1是决定是否为夏令时的旗帜4、时间元组时间元组就是struct_time元组，该结构具有如下属性：序号属性值0tm_year20211tm_mon1到122tm_mday1到313tm_hour0到234tm_min0到595tm_sec0到61(60或61是闰秒)6tm_wday0到6(0是周一)7tm_yday1到366(儒略历)8tm_isdst-1,0,1,-1是决定是否为夏令时的旗帜

calendar内置函数序号函数及描述1calendar.calendar(year,w=2,i=1,c=6)

返回字符串格式年历，3个月一行，间隔距离为c。每日宽度间隔为w字符。每行长度为21*W+18+2*C。i是每星期行数2calendar.firstweekday()返回当前每周起始日期，默认情况下，首次载入calendar模块时返回0，即星期一3calendar.isleap(year)闰年返回True，否则为False4calendar.leapdays(y1,y2)返回在Y1，Y2两年之间的闰年总数5calendar.month(year,month,w=2,l=1)

返回字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7*w+6。l是每星期的行数6calendar.monthcalendar(year,month)返回整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始

5、日历（Calendar）模块函数7calendar.monthrange(year,month)

返回两个整数。第一是该月的星期几的日期码，第二是该月的日期。日从0（星期一）到6（星期日）;月从1到128calendar.prcal(year,w=2,l=1,c=6)相当于

printcalendar.calendar(year,w=2,l=1,c=6)9calendar.prmonth(year,month,w=2,l=1)相当于

printcalendar.month(year,month,w=2,l=1)

10calendar.setfirstweekday(weekday)设置每周的起始日期，0（星期一）到6（星期日）11calendar.timegm(tupletime)

和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）12calendar.weekday(year,month,day)返回给定日期的日期码。0（星期一）到6（星期日）。月份为1（一月）到12（12月）其中：setfirstweekday(firstweekday)：通过常量MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY和SUNDAY设置星期；其中0表示星期一，以此类推6表示星期日输出星期一到星期日的方法一：importcalendar

calendar.setfirstweekday(calendar.MONDAY)

print(calendar.firstweekday()+1)calendar.setfirstweekday(calendar.TUESDAY)

print(calendar.firstweekday()+1)……calendar.setfirstweekday(calendar.SUNDAY)

print(calendar.firstweekday()+1)输出结果为:12…7先获取年、月、日的整数，再使用calendar即可获得。y=int(datetime.datetime.now().strftime("%Y"))m=int(datetime.datetime.now().strftime("%m"))d=int(datetime.datetime.now().strftime("%d"))print("今天是星期：",calendar.weekday(y,m,d)+1)importcalendar

importdatetime

y=int(datetime.datetime.now().strftime("%Y"))

m=int(datetime.datetime.now().strftime("%m"))

d=int(datetime.datetime.now().strftime("%d"))

print("今天是星期：",calendar.weekday(y,m,d)+1)输出星期方法二例55结果：Week=(datetime.date.today().weekday())+1

print("现在的时间是：",Week)输出星期方法三：importdatetime

Week=(datetime.date.today().weekday())+1

print("今天是星期",Week)今天是星期5例6使用datetime.date.today()函数完成：结果：例7日期时间函数的使用1importdatetime

t1=datetime.datetime.now()

print("当前的日期和时间是

{}".format(t1))

print("当前的年份是{}".format(t1.year),'年')

print("当前的月份是{}".format(t1.month),'月')

print("当前的日期是{}".format(t1.day),'日')

print("当前小时数是{}".format(t1.hour),'时')

print("当前分钟数是{}".format(t1.minute),'分')

print("当前秒数是{}".format(t1.second),'秒')

print("今天日期是：{}-{}-{}".format(t1.year,t1.month,t1.day))

print("当前时间是：{}:{}:{}".format(t1.hour,t1.minute,t1.second))当前的日期和时间是2022-04-0115:50:39.268173当前的年份是2022年当前的月份是4月当前的日期是1日当前小时数是15时当前分钟数是50分当前秒数是39秒今天日期是：2022-4-1当前时间是：15:50:39结果：importdatetimenow=datetime.datetime.now()print("现在的日期和时间是:{}".format(now))year=now.yearprint("今年是:{}".format(year),'年')month=now.monthprint("本月是:{}".format(month),'月')day=now.dayprint("今天是:{}".format(day),'日')hour=now.hourprint("现在的时间小时是:{}".format(hour),'时')minute=now.minuteprint("现在时间的分钟是:{}".format(minute),'分')second=now.secondprint("现在的时间秒是:{}".format(second),'秒')例8日期时间函数的使用2importtimeimportcalendarticks=time.time()print("当前时间戳为:",ticks)localtime=time.localtime(time.time())print("无格式获取本地时间:",localtime)localtime=time.asctime(time.localtime(time.time()))print("有格式获取本地时间为:",localtime)print(time.strftime("%Y-%m-%d%H:%M:%S",time.localtime()))print(time.strftime("%a%b%d%H:%M:%S%Y",time.localtime()))cal=calendar.month(2023,12)print("以下输出2023年12月份的日历:")print(cal)例9时间和日历函数的使用3结果：当前时间戳为:1662722058.7514527无格式获取本地时间:time.struct_time(tm_year=2022,tm_mon=9,tm_mday=9,tm_hour=19,tm_min=14,tm_sec=18,tm_wday=4,tm_yday=252,tm_isdst=0)有格式获取本地时间为:FriSep919:14:1820222022-09-0919:14:18FriSep0919:14:182022以下输出2023年12月份的日历:December2023MoTuWeThFrSaSu12345678910111213141516171819202122232425262728293031importdatetime

now=datetime.datetime.now()

print('未转换的类型是:{}'.format(type(now)))

print('现在未转换的日期和时间是:{}'.format(now))

now_string=now.strftime('%Y-%m-%d%H:%M:%S')

print('转换后类型是:{}'.format(type(now_string)))

print('现在转换后的日期和时间字符串:{}'.format(now_string))例10时间日期函数的转换importdatetime

now=datetime.datetime.now()

time_date=now.strftime('%Y-%m-%d%H:%M:%S')

print('原始时间:\t\t\t\t{}'.format(time_date))

add_info=datetime.timedelta(days=1,hours=2,minutes=3,seconds=4)

time_date1=datetime.datetime.strptime(time_date,'%Y-%m-%d%H:%M:%S')

add_end=add_info+time_date1

print('加上1天2个小时3分钟4秒后:\t{}'.format(add_end))

add_info1=datetime.timedelta(days=-1,hours=-2,minutes=-3,seconds=-4)

dec_end=time_date1+add_info1

print('减去1天2个小时3分钟4秒后:\t{}'.format(dec_end))例11改变时间日期importcalendar

#输入指定年月

yy=int(input("输入年份:"))

mm=int(input("输入月份:"))

#显示日历print(calendar.month(yy,mm))输入年份:2022输入月份:3March2022MoTuWeThFrSaSu12345678910111213141516171819202122232425262728293031例12结果：显示出一年12个月份的日历importcalendaryear=int(input('输入年份:'))forainrange(1,13):print('---------------------')print(calendar.month(year,a))例13输入年份:2023---------------------January2023MoTuWeThFrSaSu12345678910111213141516171819202122232425262728293031---------------------结果：importcalendarimportdatetimeprint("今天的日期是：",datetime.date.today())print("今天的日期是：",datetime.date.today().strftime("%Y年%m月%d日"))print(datetime.datetime.today())print(datetime.datetime.now().strftime("%Y-%m-%d%H:%M:%S%A"))print("现在的时间是：",datetime.datetime.now().strftime("%H时%M分%S秒"))print("昨天日期时间是：",datetime.datetime.now()-datetime.timedelta(days=1))print("明天日期时间是：",datetime.datetime.today()+datetime.timedelta(days=1))#1天后print("5天后时间是：",datetime.datetime.today()+datetime.timedelta(hours=5*24))#5*24小时print("2小时后时间是：",datetime.datetime.today()+datetime.timedelta(minutes=2*60))#2*60分day2023=datetime.datetime.strptime('2023-1-10:0:0','%Y-%m-%d%H:%M:%S')now1=datetime.datetime.today()delta=day2023-now1day=delta.days#获取两个时间之间的天数print("距离2023年元旦还有："+str(day)+"天")print(“显示指定时间：”,datetime.time(hour=20,minute=10,second=25))#time的使用print("2022年是闰年为真，否则为假：",calendar.isleap(2022))例14datetime函数的使用四、匿名函数及使用匿名函数是一种通过单个语句生成函数的方式,其结果是返回值。其规则为：（1）Python使用lambda来创建匿名函数。lambda只是一个表达式，函数体比def简单很多。它的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。（2）lambda函数拥有自己的命名空间，且不能访问有参数列表之外或全局命名空间里的参数。（3）lambda函数看只能写一行，却不等同于C或C++的内联函数，目的是调用函数时不占用栈内存，增加运行效率。语法格式：lambda[arg1[,arg2,.....argn]]:expression例如：defsquare1(n):returnn**2print(square1(10))可写成：square1=lambdan:n**2print(square1(10))或print((lambdax:x**2)(10))若多个变量使用匿名函数时：mul=lambdax,y,z:x*y*zprint(mul(2,5,8))输出结果：80根据字符串中不同字母的数量进行排序，将最多的字符串放在最后str=['father','mather','sister','brother','uncle']str.sort(key=lambdax:len(list(x)))print(str)结果：['uncle','father','mather','sister','brother']说明：lambda和def关键字声明的函数不同，匿名函数对象自身并没有一个显示的__name__属性，这是lambda函数被称为匿名函数的一个原因。结论：lambda函数⾸先减少了代码的冗余，其次，⽤lambda函数不⽤去命名⼀个函数也可快速实现函数功能，且lambda函数使代码的可读性更强，程序看起来更加简洁。例15lis=[{"name":"张三","age":20},

{"name":"李四","age":19},

{"name":"王五","age":21},

{"name":"赵六","age":18}]

print("列表通过age升序排序:")

print(sorted(lis,key=lambdai:i['age']))例16列表通过age升序排序:[{'name':'赵六','age':18},{'name':'李四','age':19},{'name':'张三','age':20},{'name':'王五','age':21}]按照年龄排序字典结果：Python函数是组织好的、可重复使用的，用来实现单一或相关联功能的代码段。函数分系统函数和自定义函数，系统函数是系统内置的函数，用于提高应用模块效率和代码的重复利用率。用户自定义函数是根据自己需求的功能定义的，简单的规则：（1）函数代码块以def关键词开头，后接函数标识符名称和圆括号()。任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。（2）函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。（3）函数内容以冒号起始，并且缩进。（4）return[表达式]结束函数，选择性地返回一个值给调用方。不带return相当于返回None。五、函数及调用规则1、自定义函数语法deffunctionname(parameters):"函数_文档字符串"function_suitereturn[expression]默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。例如：自定义函数将一个字符串作为传入参数，再打印到标准显示设备上。defprintme(str):

print("打印传入的字符串到标准显示设备上“)print(str)return2、函数调用定义一个函数只给了函数一个名称，指定了函数里包含的参数、代码块结构。这个函数的基本结构完成以后，可通过另一个函数调用执行，也可以直接从Python提示符执行。如下实例调用了printme()函数：例如：

defprintme(str):#定义函数

print("打印任何传入的字符串")

print(str)

returnprintme("我要调用用户自定义函数!")#调用函数printme("再次调用同一函数")打印任何传入的字符串我要调用用户自定义函数!打印任何传入的字符串再次调用同一函数结果：姓名:葛明数学:90Python语言95defstudent(name,mathematics=90,python=95):print(‘姓名:',name)print('数学:',mathematics)print('Python语言',python)student('葛明',100,100)姓名:葛明数学:100Python语言100结果：结果：defstudent(name,mathematics=90,python=95):

print('姓名:',name)

print('数学:',mathematics)

print('Python语言',python)

student('葛明')3、参数传递在python中，类型属于对象，变量是没有类型的：a=[1,2,3]#是List类型a=“鲁滨逊“#是String类型而变量a是没有类型，她仅仅是一个对象的引用（一个指针），可以是List类型对象，也可以指向String类型对象。python中一切都是对象，它分不可变对象和可变对象：其中：strings,tuples,和numbers是不可更改的对象，而list,dict等则是可以修改的对象。不可变类型：若a=5再赋值a=10，是改变a的值，相当于新生成了a。可变类型：若la=[1,2,3,4]

再赋值la[2]=5则是将listla的第3个值更改，la没有动，只是其内部的一部分值被修改了。python函数的参数传递：不可变类型：类似c++的值传递，如整数、字符串、元组。a=10

defsum(n):

n+=a

print('a=',a,end=',')

print('n=',n)

sum(3)例如：defMyFirstFunction(name_city):

print('我喜欢的城市:'

+name_city)MyFirstFunction('南京')我喜欢的城市:南京a=10,n=13结果：结果：deffoodsprice(per_price,number):

sum_price=per_price*number

print('变量PER_PRICE_1的值：',PER_PRICE_1)

returnsum_pricePER_PRICE_1=float(input('请输入单价：'))NUMBER_1=float(input('请输入斤数：'))SUM_PRICE_1=foodsprice(PER_PRICE_1,NUMBER_1)print('蔬菜的价格是：',SUM_PRICE_1)输入单价及数量，计算总价请输入单价：40请输入斤数：6全局变量PER_PRICE_1的值：40.0蔬菜的价格是：240.0例17结果：defarea(width,height):returnwidth*heightdefprint_welcome(name):print(“欢迎",name)print_welcome(“张三峰")w=eval(input(“输入矩形的宽度"))h=eval(input(“输入矩形的长度"))print(“宽度=”,w,“长度=”,h,“矩形面积是：",area(w,h))计算面积函数例18例如：欢迎

张三峰输入矩形的宽度20输入矩形的长度26宽度=20长度=26长方形面积是：520deffuck(x,y):

x1=x**2

y1=y/4

result=x1+y1

print("Theresultis:",str(result))

fuck(3,5)Theresultis:10.25.结果：结果：实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：defchangeme(mylist):print("修改传入的列表")mylist.append([1,2,3,4])print("函数内取值:",mylist)return#调用changeme函数mylist=[10,20,30]changeme(mylist)print('函数外取值：',mylist)传可变对象修改传入的列表函数内取值:[10,20,30,[1,2,3,4]]函数外取值:[10,20,30,[1,2,3,4]]结果：例19以下是调用函数时可使用的正式参数类型：必备参数关键字参数默认参数不定长参数必备参数:必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用printme()函数，你必须传入一个参数，不然会出现语法错误：例如：def

printme(str):print(str)returnprintme()#调用4、参数以上实例输出结果：Traceback(mostrecentcalllast):File"test.py",line11,in<module>printme()TypeError:printme()takesexactly1argument(0given)关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值，它允许函数调用时参数顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。例如：5、关键字参数defprintme(str):print("打印任何传入的字符串")print(str)return#调用printme函数printme(str="定义我的字符串")打印任何传入的字符串定义我的字符串结果：不指定关键字参数：defprintinfo(name,age):#"打印任何传入的字符串"print("Name:",name)print("Age",age)return#调用printinfo函数printinfo(age=50,name=“Lucy")Name:LucyAge50结果：例20调用函数时，默认参数的值若没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入,例如：6、默认参数Name:LucyAge50Name:lucyAge35结果：defprintinfo(name,age=35):#"打印任何传入的字符串"print("Name:",name)print("Age",age)return#调用printinfo函数printinfo(age=50,name=“Lucy")printinfo(name="lucy")若不知传递的参数多少,称为不定长度，可以用*和**来实现。加了*的参数会以元组(tuple)的形式传入，例如：deffunction(*args):print(args)function(12,35,65)运行结果：(12,35,65)加了两个星号**的参数会以字典的形式传入；deffunction(**kwargs):print(kwargs)function(a=12,b=35,c=65)结果为：

{'a':12,'b':35,'c':65}这里传入的参数需要注意，是键值对。当一个星号，和两个星号同时出现，一个星号必须在两个星号前面，列如：deffunction(*args,**kwargs):print(args)print(kwargs)7、不定长参数结果：例21未命名的变量参数的使用deffun(a,b,*args):

print(a)

print(b)

print(args)

print("="*9)

ret=a+b

ret1=args

returnret,ret1

print(fun(1,2,3,4,5))12(3,4,5)=========(3,(3,4,5))字典形式参数：例22deffun(a,b,*args,**kwargs):

print(a)

print(b)

print(args)

print(kwargs)

fun(1,2,3,4,name="hello",age=20)12(3,4){'name':'hello','age':20}结果：deffun(a,b,*args,**kwargs):print(a)print(b)print(args)print(kwargs)tup=(11,22,33)dic={"name":"hello","age":20}fun(1,2,*tup,**dic)12(11,22,33){'name':'hello','age':20}例23传入元组和字典形式参数：结果：return语句[表达式]是返回函数，不带参数值的return语句返回None。若函数里出现return，表示这个函数运行到这里结束了，后面不管有多少多不会再执行。9、return语句deffunction():

print("apple")

return"banana"

print("bb")

print(function())Python函数可以返回多个值，多个值以元组的方式返回，例如：deffun(a,b):

returna,b,a+b

print(fun(10,20))102030结果：applebanana结果：defsum(arg1,arg2):#返回2个参数的和

total=arg1+arg2print(“函数返回值:",total)returntotal

print(arg1)total=sum(100,200)#调用sum函数返回值:300结果：例24return的使用defchangeme(mylist):

mylist.append([1,2,3,4])

print("函数内取值:",mylist)

return

#调用changeme函数

mylist=[10,20,30]

changeme(mylist)

print("函数外取值:",mylist)例25函数内取值:[10,20,30,[1,2,3,4]]函数外取值:[10,20,30,[1,2,3,4]]结果：六、嵌套函数及使用格式：def函数名1(参数列表)

def函数名1(参数列表)return

return例如：defmul(factor):defmul2(number):

returnnumber*factorreturnmul2mul(3)(3)

defpy():

print("python")

defmat():

print("matlab")

mat()

py()结果：ans=9pythonmatlab结果：defadd1(x,y):returnx+ydefadd2(x):defadd(y):returnx*

yreturnaddg=add2(2)print(add1(2,3))print(add2(2)(3))print(g(3))566结果：例26嵌套函数的使用1x=10defouter():x=1definner():x=2print("x1=",x)inner()print("x2=",x)outer()print("x3=",x)x1=2x2=1x3=10例27嵌套函数的使用2结果：

七、递归函数

在一个函数体内调用它自身，被称为函数递归。函数递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。函数内部可以调用其他函数，当然在函数内部也可以调用自己。调用函数自身要设置正确的返回条件，其特点：1）函数内部的代码是相同的，只是针对参数不同，处理的结果不同；2）当参数满足某一个条件时，函数不再执行，通常被称为递归的出口，否则会出现死循环。说明：Python默认递归深度100层（Python限制），使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出，且占用内存比较大。例如：己知有一个数列：14922…即：fn(0)=1fn(1)=4。。。fn(n)=2*fn(n-1)+fn(n-2)，其中n是大于等于2的整数，求fn(10)的值。可以使用递归程序将定义一个fn(n)函数，用于计算fn(10)的值。fn(10)等于2*fn(9)+fn(8)，其中fn(9)又等于2*fn(8)+fn(7)……依此类推，最终会计算到fn(2)等于2*fn(1)+fn(0)，即fn(2)是可计算的，这样递归带来的隐式循环就能自动结束。顺着这个递推回去，最后就可以得到fn(10)的值。一般递归函数定义规则是：defsum_number(num):print(num)#递归的出口，当参数满足某个条件时，不再执行函数ifnum==1:return#自己调用自己sum_number(num-1)递归函数一般和循环联合使用，案例见第4部分程序设计（1）定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。八、全局变量与局部变量函数内是局部变量:30函数外是全局变量:0结果：total=0#定义一个全局变量defsum(arg1,arg2):#可写函数说明total=arg1+arg2#total局部变量.print("函数内是局部变量:",total)returntotalsum(10,20)#调用sum函数print("函数外是全局变量:",total)例28命名空间是一个包含了变量名称（键）和它们各自相应的对象（值）的字典。一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。每个函数都有自己的命名空间。类方法的作用域规则和通常函数一样。Python默认任何在函数内赋值的变量都是局部的，若在函数内定义全局变量并赋值，必须使用global语句：globalVarName例如，若命名一个全局命名变量Money，在函数内给变量Money赋值，会出现一个UnboundLocalError的错误。此时需要取消global语句。（2）命名空间和作用域Money=2000defAddMoney():globalMoneyMoney=Money+1#调用print(Money)AddMoney()print(Money)结果：20002001例29全局变量与局部变量的使用2、reload()函数

九、globals()和locals()函数及使用

1、globals()和locals()函数

globals()和locals()函数可被用来返回全局和局部命名空间里的名字。如果在函数内部调用locals()，返回的是所有能在该函数里访问的命名。如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。两个函数的返回类型都是字典。所以名字们能用keys()函数摘取。reload()函数用于重新执行模块里顶层部分的代码，会重新导入之前导入过的模块。语法格式：reload(module_name)module_name要直接放模块的名字，例如：重载hello模块：reload(hello)num=20defouter():num=10definner():globalnumprint(num)num=100print(num)inner()print(num)outer()print(num)例30global

关键字会跳过中间层直接将嵌套作用域内的局部变量变为全局变量:20100101003、作用域与命名空间变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称（键）和它们各自相应的对象（值）的字典。一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。Python在函数内赋值的变量都是局部变量。若在函数内定义全局变量赋，必须使用global语句。globalVarName的表达式会告诉Python，VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。Money=2000

defAddMoney():

globalMoney

Money=Money+1

print(Money)

AddMoney()

print(Money)20002001若不加global结果会出错total=0#定义全局变量

defsum(arg1,arg2):

#返回2个参数的和.“

total=arg1+arg2#total此处是局部变量.

print("函数内是局部变量:",total)

returntotal

#调用sum函数

sum(100,200)

print("函数外是全局变量:",total)函数内是局部变量:300函数外是全局变量:0例