Python学习总结【第三篇】:Python之函数(自定义函数、内置函数、lambda表达式、装饰器、迭代器&生成器)
1、函数
1.1 自定义函数
背景需求:
在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑从上到下实现功能,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,也就是将之前实现的代码块复制到现需功能处,如下:
while True: if cpu利用率 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 内存占用 > 80%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
上述代码,if条件语句下的内容可以被提取出来公用,如下:
def 发送邮件(内容) #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 while True: if cpu利用率 > 90%: 发送邮件('CPU报警') if 硬盘使用空间 > 90%: 发送邮件('硬盘报警') if 内存占用 > 80%:
对于上述的两种实现方式,第二次必然比第一次的重用性和可读性要好,其实这就是函数式编程和面向过程编程的区别:
函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可
面向对象:对函数进行分类和封装,让开发“更快更好更强...”
函数式编程最重要的是增强代码的重用性和可读性
自定义函数练习
1、写函数,计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def func(get_str): """ 计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数 :param get_str: :return: """ digit, alpha, space, other = 0, 0, 0, 0 # 数字 字母 空格 其他 for i in get_str: if i.isdigit(): digit += 1 elif i.isalpha(): alpha += 1 elif i.isspace(): space += 1 else : other += 1 return digit, alpha, space, other def main(): get_str = input("请输入一个字符串:") result = func(get_str) # print(result) print( """ ============================ 数字:%s 字母:%s 空格:%s 其他:%s ============================""" % result) if __name__ == '__main__': main()
2、写函数,判断用户传入的对象(字符串、列表、元组)长度是否大于5
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def func(get_obj): """ 判断用户传入的对象(字符串、列表、元组)长度是否大于5 :param get_obj: :return: """ ret = False if isinstance(get_obj, str) or isinstance(get_obj, list) or isinstance(get_obj, tuple): if len(get_obj) > 5: ret = True return len(get_obj), ret def main(): # get_obj = "dsfwerqwer" # get_obj = (1, 2, 3, 4,) get_obj = [1, 2, 3, ] result = func(get_obj) print("长度为:%s,是否大于5:%s" % result) if __name__ == '__main__': main()
3、写函数,检查用户传入的对象(字符串、列表、元组)的每一个元素是否含有空内容
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def func(get_obj): """ 检查用户传入的对象(字符串、列表、元组)的每一个元素是否含有空内容 :param get_obj: :return: """ ret = False if isinstance(get_obj, str) or isinstance(get_obj, list) or isinstance(get_obj, tuple): for i in get_obj: if i == '': ret = True break return ret def main(): get_obj = "ds fwerqwer" # get_obj = (1, 2, 3, 4, '',) # get_obj = (1, 2, 3, 4,) # get_obj = [1, 2, 3, '', 5, ] result = func(get_obj) print("该对象是否含有空元素%s" % result) if __name__ == '__main__': main()
4、写函数,检查传入列表的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者。
5、写函数,检查获取传入列表或元组对象的所有奇数位索引对应的元素,并将其作为新列表返回给调用者。
6、写函数,检查传入字典的每一个value的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者。
7、写函数,利用递归获取斐波那契数列中的第 10 个数,并将该值返回给调用者。
地址:http://www.cnblogs.com/Wxtrkbc/p/5466082.html
1.2 函数的定义与使用
def 函数名(参数): ... 函数体 ...
函数的定义主要有如下要点:
def:表示函数的关键字
函数名:函数的名称,日后根据函数名调用函数
函数体:函数中进行一系列的逻辑计算,如:发送邮件、计算出 [11,22,38,888,2]中的最大数等...
参数:为函数体提供数据
返回值:当函数执行完毕后,可以给调用者返回数据。
以上要点中,比较重要有参数和返回值:
1.2.1 返回值
函数是一个功能块,该功能到底执行成功与否,需要通过返回值来告知调用者。
def 发送短信(): 发送短信的代码... if 发送成功: return True else: return False while True: # 每次执行发送短信函数,都会将返回值自动赋值给result # 之后,可以根据result来写日志,或重发等操作 result = 发送短信() if result == False: 记录日志,短信发送失败...
1.2.2 参数
1)为什么要使用参数?
2)参数类型
普通参数(多个参数将严格按照顺序将实际参数赋值给形式参数)
# 函数定义:name叫做函数func的形式参数,简称:形参 >>> def func(name): ... print(name) ... # 函数的调用执行 # 'alex' 叫做函数func的实际参数,简称:实参 >>> func('alex') alex
默认参数
>>> def func(name, age = 18): ... print "%s:%s" %(name,age) ... # 指定参数 >>> func('wupeiqi', 19) wupeiqi:19 # 使用默认参数 >>> func('alex') alex:18 注:默认参数需要放在参数列表最后
指定参数赋值
>>> def show(a1,a2): ... print(a1,a2) ... >>> show(100,111) # 按照顺序将多个实参赋值给形参 (100, 111) >>> show(a2=111,a1=100) # 指定参数进行赋值,不按照顺序进行赋值 (100, 111)
动态参数
动态参数一:默认将传入的参数,全部放置在元组中, f1(*[1`1,22,33,44]) >>> def func(*args): ... print(args) ... # 执行方式一 >>> func(11,33,4,4454,5) (11, 33, 4, 4454, 5) # 执行方式二 >>> li = [11,33,4,4454,5] # 元组,列表,字典都要做类似处理 >>> func(*li) (11, 33, 4, 4454, 5) # 错误执行方法 >>> func(li) # 这样并非正确的动态传参,这样函数会把整个列表当做元组的一个元素进行处理 ([11, 33, 4, 4454, 5],) 动态参数二:默认将传入的参数,全部放置在字典中 f1(**{"kl":"v1", "k2":"v2"}) >>> def func(**kwargs): ... print(kwargs) ... # 执行方式一 >>> func(name='wupeiqi',age=18) {'name': 'wupeiqi', 'age': 18} # 执行方式二 >>> li = {'name':'wupeiqi', "age":18, 'gender':'male'} >>> func(**li) {'name': 'wupeiqi', 'gender': 'male', 'age': 18} 动态参数三:把元组和字典结合进行传参(元组在前,字典在后) >>> def show(*args,**kwargs): ... print(args,type(args)) ... print(kwargs,type(kwargs)) ... >>> show(11,22,33,100,a1=11,abc=100) (11, 22, 33, 100) <class 'tuple'> {'abc': 100, 'a1': 11} <class 'dict'> #str.format()格式化输出 讲解动态参数 *args ,**kwargs s1 = "I am {0},age {1}".format("alex",18) # 利用*args进行传参 print(s1) lis = ["alex",18] s1 = "I am {0},age {1}".format(*lis) # 利用*args进行传参 print(s1) s1 = "I am {name},age {age}".format(name="alex",age=18) # 利用**kwargs进行传参 print(s1) dic = {"name":"alex","age":18} s1 = "I am {name},age {age}".format(**dic) # 利用**kwargs进行传参 print(s1) 输出结果都为: I am alex,age 18
邮件代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def sendmail(xxoo, content): # xxoo = alex try: import smtplib from email.mime.text import MIMEText from email.utils import formataddr msg = MIMEText(content, 'plain', 'utf-8') msg['From'] = formataddr(["武沛齐",'wptawy@126.com']) msg['To'] = formataddr(["走人",'424662508@qq.com']) msg['Subject'] = "主题" server = smtplib.SMTP("smtp.126.com", 25) server.login("wptawy@126.com", "WW.3945.59") server.sendmail('wptawy@126.com', [xxoo,], msg.as_string()) server.quit() except: # 发送失败 return "失败" else: # 发送成功 return "cc" while True: em = input("请输入邮箱地址:") result = sendmail(em, "SB") if result == "cc": print("发送成功") else: print("发送失败")
1.2.3 函数与变量定义
1、 def f1 def f1 (生效) 2、函数传递引用 3、全局变量 全局变量定义要大写 读,都可读 赋值,globals() 字典,列表等全局变量,可以修改,但是无法重新赋值 全局变量定义位置:将全局变量在代码开始即进行定义,也可以在函数体内定义,但是不友好,需要阅读全部的代码,找出在各个函数体内定义的全局变量
# 补充问题1: def f1(a1,a2): return a1+a2 def f1(a1,a2): return a1*a2 res = f1(8,8) print(res)
# 问题:结果多少为什么? # 解答:结果是64 代码是顺序执行,f1被重新指向,第一个f1定义失效,f2生效
# 补充问题2: def f1(a1): a1.append(999) li = [11,22,33,44] f1(li) print(li)
# 问题:结果多少,为什么? # 解答:结果为[11, 22, 33, 44, 999] # 即:Python是传递一个引用 并非复制一份内容 a1和li的指向是同一块内存地址,修改了a1即修改了li
# 补充问题3: # 各个函数内定义变量的引用问题:没有结果,name变量只在f1内定义及使用 def f1(): name = "alex" print(name) def f2(): print(name)
f1()
alex
f2()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in f2
NameError: name 'name' is not defined # 全局变量,所有作用域都能读 name = "alex" def f1(): age =18 print(age,name) def f2(): age =19 print(age,name)
>>> f1()
18 alex
>>> f2()
19 alex # 对全局变量进行重新赋值,需要global #全局变量和函数体内变量都定义了,优先使用自己函数体内定义的变量
# global说明:
# 1、global---将变量定义为全局变量。可以通过定义为全局变量,实现在函数内部改变变量值。
# 2、一个global语句可以同时定义多个变量,如 global x, y, z
# 执行方式1
>>> NAME = None
>>> def f1():
... age = 18
... global NAME
... NAME = "123"
... print(age, NAME)
...
>>> def f2():
... age = 19
... print(age, NAME)
...
...
>>> f1()
18 123
>>> f2()
19 123
# 执行方式 2
>>> NAME = None
>>> def f1():
... age = 18
... global NAME
... NAME = "123"
... print(age, NAME)
...
>>> def f2():
... age = 19
... print(age, NAME)
...
>>> f2()
19 None
>>> f1()
18 123
# 特殊:列表字典,可修改,不可重新赋值 name = [11,22,33,44] # 可以在函数体内增加值(name.append(55)),当时无法重新赋值(name = "123") def f1(): age =18 name = "123" print(age,name) def f2(): age =19 name.append(55) print(age,name)
函数应用范例
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#!/usr/bin/env python # -*- coding:utf-8 -*- # Author:Alex Li def login(username, password): """ 用于用户登录 :param username: 用户输入的用户名 :param password: 用户输入的密码 :return: true,表示登录成功;false,登录失败 """ f = open("db", 'r') for line in f: line_list = line.strip().split("|") if line_list[0] == username and line_list[1] == password: return True return False def register(username, password): """ 用于用户注册 :param username: 用户名 :param password: 密码 :return: 默认None """ f = open("db", 'a') temp = "\n" + username + "|" + password f.write(temp) f.close() def main(): t = input("1:登录;2:注册") if t == "1": user = input("请输入用户名:") pwd = input("请输入密码:") r = login(user, pwd) if r: print("登录成功") else: print("登录失败") elif t == "2": user = input("请输入用户名:") pwd = input("请输入密码:") register(user, pwd) main()
1.3 内置函数
官网:http://data.digitser.net/python_3.4.2/zh-CN/library/functions.html
如何查看Python当前版本的内置函数有哪些,可以用下面的指令查看:
C:\Users\Administrator>python
Python 2.7.11 (v2.7.11:6d1b6a68f775, Dec 5 2015, 20:32:19) [MSC v.1500 32 bit (
Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> dir(sys.modules['__builtin__'])
Python 2.x内置函数列表
地址:http://python.usyiyi.cn/python_278/library/functions.html
![](data:image/png;base64,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)
Python 3.x 内置函数列表
地址:http://python.usyiyi.cn/python_343/library/functions.html
'__package__', 'abs','all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
# abs--求绝对值 >>> print(abs(100)) 100 >>> print(abs(-100)) 100 # all--集合中的元素都为真的时候为真 >>> n = all([1,2,3,None]) >>> print(n) False >>> n = all([1,2,3,34]) >>> print(n) True # any--集合中的元素有一个为真的时候为真 常见为假的对象:[],{},None,0,"",() >>> n = any([[],0,"",None]) # 全为假 >>> print(n) False >>> n = any([[],0,"",1]) # 1 为真 >>> print(n) True # cmp(x,y)--如果x < y ,返回负数;x == y, 返回0;x > y,返回正数 # ascii--自动执行对象的 __repr__ python 2.7没有 Python 3.0才有 >>> class Foo: ... def __repr__(self): ... return "444" ... >>> n = ascii(Foo()) >>> print(n) 444 # apply--过期不再叙述 # basestring--str和unicode的超类,不能直接调用,可以用作isinstance判断 # bin--将一个整数转换成一个二进制字符串 # oct--将整数x转换为八进制字符串 # hex-- 将整数x转换为十六进制字符串 >>> n = 20 >>> print(bin(n)) 0b10100 >>> print(oct(n)) 0o24 >>> print(hex(n)) 0x14 # bool--将x转换为Boolean类型 # buffer--过期的内置函数,故不说明 # bytearray--过期的内置函数,故不说明 # bytes--字符串转字节类型(重点) >>> n = bytes("李杰", encoding="utf-8") >>> print(n) b'\xe6\x9d\x8e\xe6\x9d\xb0' >>> n = bytes("李杰", encoding="gbk") >>> print(n) b'\xc0\xee\xbd\xdc' # str--字节转化成字符串 >>> new_str = str(bytes("李杰", encoding="utf-8"), encoding="utf-8") >>> print(new_str) 李杰 # callable(object)--如果 object 参数可调用,返回True;否则返回False。如果返回True,仍有可能调用失败,但是如果返回False,调用object将永不成功 >>> def f1(): ... print(123) ... >>> f2 = 123 >>> print(callable(f1)) True >>> print(callable(f2)) False # chr()--返回整数i对应的ASCII字符 # ord()--返回ASCII字符对应的整数 # 应用案例:生成一个随机的6位验证码,包含大写字母、数字 最终版本: import random li = [] # 使用列表用于存储完整的验证码 for i in range(6): # 用于生成六位的验证码 r = random.randrange(0, 5) # 在0-6位的验证码中,随机生成一个数字,用于指定验证码的第几个位用于生成数字序列 if r == 2 or r == 4 : # 进行判断,如果为指定行,则进行如下操作 num = random.randrange(0, 10) # 用于在指定序列的生成随机数,即生成1-9之间的一个数字 li.append(str(num)) # 将生成的随机数字存放到列表中 else: tmp = random.randrange(65, 91) # 用于在指定序列的生成随机数 c = chr(tmp) # ascii数字-->大写字母 li.append(c) # 将生成的随机大写字母存放到列表中 result = "".join(li) # 将列表拼接成字符串 print("你的随机验证码:", result) # classmethod(function)--将function包装成类方法 暂时无需了解 # compile()--把字符串编译为Python代码 # eval()--执行Python表达式 有返回值 子集 # exec()--执行Python代码或者字符串 没有返回值 父集 >>> s = "print(123)" >>> r = compile(s, "<string>", "exec") # 将字符串编译成Python代码 编译,single,eval,exec >>> print(r) <code object <module> at 0x02A2C5C0, file "<string>", line 1> >>> exec(r) # 执行代码 123 >>> s = "8*8" >>> res = eval(s) >>> print(res) 64 # complex()--返回一个复数 # delattr()--删除object对象名为name的属性 # hasattr(object, name) # setattr() # getattr(object, name[, default])--返回object的属性值 # divmod(a,b)--参数为两个数值(非复数),返回它们相除后的的商和余数 应用场景:博客分页 (重要) >>> r = divmod(97, 10) >>> print(r) (9, 7) >>> n1, n2 = divmod(97, 10) >>> print(n1, n2) 9 7 # enumerate(iterable, start=0)--返回一个枚举对象。iterable 必须是序列、迭代器,或者其他支持迭代的对象 # exit()--退出 # filter(函数,可迭代的对象)--函数返回Ture,将元素添加到结果中 # 需求:有一个列表,要进行筛选,大于22的返回给我
# 自定义方法实现
def f1(args):
result = []
for item in args:
if item > 22:
result.append(item)
return result
li = [11, 22, 33, 44, 55]
ret = f1(li)
print(ret)
# 通过filter功能实现需求 def f2(a): if a > 22: return True li = [11, 22, 33, 44, 55] res = filter(f2, li) print(list(res)) # filter和lambda实现需求 li = [11, 22, 33, 44, 55, ] result = filter(lambda a: a > 33, li) print(list(result)) # float--将一个字符串或数转换为浮点数。如果无参数将返回0.0 # format--格式化输出字符串,格式化的参数顺序从0开始,如“I am {0},I like {1}” # frozenset()--内置类,暂时忽略 # locals()--更新并返回表示当前局部符号表的字典。当locals在函数块中而不是类块中被调用时,locals()返回自由变量 # globals()--返回表示当前全局符号表的字典。它总是当前模块的字典(在函数或者方法中,它指定义的模块而不是调用的模块) NAME = "ALEX" def f1(): age = 10 return NAME, age print(f1()) print(locals()) print(globals()) # hash()--返回对象的hash值, 应用场景:字典的key值进行hash,存hash值作为字典key,其他语言也适用 s = "adsafsd" print(hash(s)) # help()--获取详细帮助信息 # dir()--返回对象的功能方法列表 # id()--返回对象的唯一标识 # input([prompt])--如果有prompt参数,则将它输出到标准输出且不带换行。该函数然后从标准输入读取一行,将它转换成一个字符串(去掉一个末尾的换行符),然后返回它 # int()--返回一个由数值或字符串 x 转换而成的整数,如果省略参数,则返回 0 # isinstance()--判断对象是否是某个类的实例,与type()区别 s = "alex" print(isinstance(s, str)) print(isinstance(s, list)) # issubclass--如果class是classinfo的子类(直接的,间接的,或者virtual) ,返回真。忽略 # iter(object[, sentinel])--返回一个iterator对象 # len()--返回一个对象的长度 (元素的个数) . 参数可以是序列(如字符串,字节,元组,列表或者范围)或者集合(如字典,集合或者固定集合) s = "李杰" print(len(s)) # Python 3.x 默认按照字符统计,可以按照字节统计 结果:2 b = bytes(s, encoding="utf-8") # Python 3.x 也可以按照字节统计 结果:6 print(len(b)) print(len(s)) # Python 2.x 按照字节统计 结果:6
)
# Python 2.x
>>> name = "李杰"
>>> for i in name:
... print(i)
...
>>>
# Python 3.x
>>> name = "李杰"
>>> for i in name:
... print(i)
...
李
杰
# map(函数,可迭代的对象(可以for循环))--将函数返回值添加到结果中 # 需求:给一个列表,所有元素+100,返回给我。即:一批数据进行统一的一类操作
# 自己实现 li = [11, 22, 33, 44, 55, ] def f1(args): result = [] for i in args: result.append(100+i) return result print(f1(li)) # map实现 li = [11, 22, 33, 44, 55, ] def f1(a): return a + 100 result = map(f1, li) print(list(result)) # map和lambda功能实现 li = [11, 22, 33, 44, 55, ] result = map(lambda a: a + 100, li) result = map(f1, li) print(list(result))
[111, 122, 133, 144, 155]
# 其他应用场景:字符串,列表的应用
>>> li_list = ['shuaige','nihao',]
>>> result = map(lambda a: "%s is string" % a,li_list)
>>> print(list(result))
['shuaige is string', 'nihao is string']
>>> li_str = 'abcdefg'
>>> result = map(lambda a: "%s is string" % a,li_str)
>>> print(list(result))
['a is string', 'b is string', 'c is string', 'd is string', 'e is string', 'f i
s string', 'g is string']
# sum(iterable[, start])--将start以及iterable的元素从左向右相加并返回总和。start默认为0 # max()--返回可迭代的对象中的最大的元素,或者返回2个或多个参数中的最大的参数 # min()--返回可迭代的对象中的最小的元素,或者返回2个或多个参数中的最小的参数
>>> r = sum([11,22,33,1])
>>> print(r)
67
>>> r = max([11,22,33,1])
>>> print(r)
33
>>> r = min([11,22,33,1])
>>> print(r)
1 # memoryview()--返回给定参数的“内存视图” # next() # object--返回一个新的无特征的对象 # open--文件操作(重点) # pow(x, y[, z])--返回x 的 y次方; 如果 z 提供的时候,返回 x 的 y 次方,然后对 z取模。(这样比 pow(x, y) % z) 更高效。 pow(x, y)的效果类似于: x**y. >>> print(2**10) 1024 >>> print(pow(2, 10)) 1024 # print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) # 打印 objects 到文本流对象 file,以 sep 为分隔符,以 end 为结尾符。如果要提供 sep, end 和 file 这三个参数的话,必须使用键值对的形式
# property()--返回一个property 属性
# range(stop) # range(start, stop[, step])--返回一个指定范围内的不可变的序列 # xrange() # raw_input()--接收用户输入 Python 2.7.x # repr(object)--返回一个字符串 >>> r = repr("alex") >>> print(r) 'alex' # reversed(seq)--返回一个反向迭代器 >>> li = [11, 22, 1, 1, ] >>> li.reverse() >>> print(li) [1, 1, 22, 11] >>> li = [11, 22, 1, 1, ] >>> reversed(li) <list_reverseiterator object at 0x02A1F530> >>> print(list(reversed(li))) [1, 1, 22, 11] >>> print(li) [11, 22, 1, 1] # round(number[, ndigits])--返回浮点数 number 四舍五入到小数点之后 ndigits 位的结果 >>> r = round(1.9) >>> print(r) 2 >>> r = round(1.4) >>> print(r) 1 # type()--查看数据类型 # tuple()--元组 # set()--set集合 无序不重复 # list()--列表 # dict()--字典 # slice()--返回一个slice对象 http://i.cnblogs.com/EditArticles.aspx?postid=5515410&update=1 # sorted(iterable[, key][, reverse])--依据iterable中的元素返回一个新的列表 # staticmethod(function)--返回function的一个静态方法# super([type[, object-or-type]])--返回一个代理对象,这个对象指派方法给一个父类或者同类. # vars([object])--返回模块 # zip(*iterables)--利用每个可迭代元素,制作一个迭代器来聚合元素。 >>> l1 = ["alex", 11, 22, 33] >>> l2 = ["is", 11, 22, 33] >>> l3 = ["sb", 11, 22, 33] >>> >>> r = zip(l1, l2, l3) >>> print(list(r)) [('alex', 'is', 'sb'), (11, 11, 11), (22, 22, 22), (33, 33, 33)] # __import__()
1.3.1 reduce(Python 2.x)
对于序列内所有元素进行累计操作
>>> li = [1,2,3,4,5,6,7,8] >>> result = reduce(lambda a1,a2:a1+a2,li) #累乘、除、加、减 >>> print result 36 # reduce的第一个参数,函数必须要有两个参数,因为他是两两进行操作 # reduce的第二个参数,要循环的序列 # reduce的第三个参数,初始值 #初始值 >>> li = [1,2,3,4,5,6,7,8] >>> result = reduce(lambda a1,a2:a1+a2,li,100000) #累乘、除、加、减 >>> print result 100036
默认参数:
常见的内置函数又分为如下几类,详细介绍参考:http://jianfeihit.iteye.com/blog/1835272
总结:
内置函数,一般都是因为使用频率比较频繁或是是元操作,所以通过内置函数的形式提供出来,通过对python的内置函数分类分析可以看出来:基本的数据 操 作基本都是一些数学运算(当然除了加减乘除)、逻辑操作、集合操作、基本IO操作,然后就是对于语言自身的反射操作,还有就是字符串操作,也是比较常用 的,尤其需要注意的是反射操作。
2、lambda表达式
学习条件运算时,对于简单的 if else 语句,可以使用三元运算来表示,即:
# 普通条件语句 if 1 == 1: name = 'wupeiqi' else: name = 'alex' # 三元运算 name = 'wupeiqi' if 1 == 1 else 'alex'
对于简单的函数,也存在一种简便的表示方式,即:lambda表达式
####################### 普通函数 ###################### # 定义函数(普通方式) >>> def func(arg): ... return arg + 1 ... # 执行函数 >>> result = func(123) >>> print(result) 124 ####################### lambda ###################### # 定义函数(lambda表达式) >>> my_lambda = lambda arg : arg + 1 # 执行函数 ... result = my_lambda(123) >>> print(result) 124
lambda存在意义就是对简单函数的简洁表示
3、yield生成器
3.1 yield介绍
您可能听说过,带有 yield 的函数在 Python 中被称之为 generator(生成器),何谓 generator ?我们先抛开 generator,以一个常见的编程题目来展示 yield 的概念。
如何生成斐波那契數列?
斐波那契(Fibonacci)數列是一个非常简单的递归数列,除第一个和第二个数外,任意一个数都可由前两个数相加得到。用计算机程序输出斐波那契數列的前 N 个数是一个非常简单的问题,许多初学者都可以轻易写出如下函数:
清单 1. 简单输出斐波那契數列前 N 个数
def fab(max): n, a, b = 0, 0, 1 while n < max: print b a, b = b, a + b n = n + 1
执行 fab(5),我们可以得到如下输出:
>>> fab(5) 1 1 2 3 5
结果没有问题,但有经验的开发者会指出,直接在 fab 函数中用 print 打印数字会导致该函数可复用性较差,因为 fab 函数返回 None,其他函数无法获得该函数生成的数列。要提高 fab 函数的可复用性,最好不要直接打印出数列,而是返回一个 List。以下是 fab 函数改写后的第二个版本:
清单 2. 输出斐波那契數列前 N 个数第二版
def fab(max): n, a, b = 0, 0, 1 L = [] while n < max: L.append(b) a, b = b, a + b n = n + 1 return L 可以使用如下方式打印出 fab 函数返回的 List: >>> for n in fab(5): ... print n ... 1 1 2 3 5
改写后的 fab 函数通过返回 List 能满足复用性的要求,但是更有经验的开发者会指出,该函数在运行中占用的内存会随着参数 max 的增大而增大,如果要控制内存占用,最好不要用 List来保存中间结果,而是通过 iterable 对象来迭代。例如,在 Python2.x 中,代码:
清单 3. 通过 iterable 对象来迭代
for i in range(1000): pass 会导致生成一个 1000 个元素的 List,而代码: for i in xrange(1000): pass
则不会生成一个 1000 个元素的 List,而是在每次迭代中返回下一个数值,内存空间占用很小。因为 xrange 不返回 List,而是返回一个 iterable 对象。利用 iterable 我们可以把 fab 函数改写为一个支持 iterable 的 class,以下是第三个版本的 Fab:
清单 4. 第三个版本
class Fab(object): def __init__(self, max): self.max = max self.n, self.a, self.b = 0, 0, 1 def __iter__(self): return self def next(self): if self.n < self.max: r = self.b self.a, self.b = self.b, self.a + self.b self.n = self.n + 1 return r raise StopIteration() Fab 类通过 next() 不断返回数列的下一个数,内存占用始终为常数: >>> for n in Fab(5): ... print n ... 1 1 2 3 5
然而,使用 class 改写的这个版本,代码远远没有第一版的 fab 函数来得简洁。如果我们想要保持第一版 fab 函数的简洁性,同时又要获得 iterable 的效果,yield 就派上用场了:
清单 5. 使用 yield 的第四版
def fab(max): n, a, b = 0, 0, 1 while n < max: yield b # print b a, b = b, a + b n = n + 1 ''' 第四个版本的 fab 和第一版相比,仅仅把 print b 改为了 yield b,就在保持简洁性的同时获得了 iterable 的效果。 调用第四版的 fab 和第二版的 fab 完全一致: ''' >>> for n in fab(5): ... print n ... 1 1 2 3 5
简单地讲,yield 的作用就是把一个函数变成一个 generator,带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator,调用 fab(5) 不会执行 fab 函数,而是返回一个 iterable 对象!在 for 循环执行时,每次循环都会执行 fab 函数内部的代码,执行到 yield b 时,fab 函数就返回一个迭代值,下次迭代时,代码从 yield b 的下一条语句继续执行,而函数的本地变量看起来和上次中断执行前是完全一样的,于是函数继续执行,直到再次遇到 yield。
也可以手动调用 fab(5) 的 next() 方法(因为 fab(5) 是一个 generator 对象,该对象具有 next() 方法),这样我们就可以更清楚地看到 fab 的执行流程:
清单 6. 执行流程
>>> f = fab(5) >>> f.next() 1 >>> f.next() 1 >>> f.next() 2 >>> f.next() 3 >>> f.next() 5 >>> f.next() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
当函数执行结束时,generator 自动抛出 StopIteration 异常,表示迭代完成。在 for 循环里,无需处理 StopIteration 异常,循环会正常结束。
我们可以得出以下结论:
一个带有 yield 的函数就是一个 generator,它和普通函数不同,生成一个 generator 看起来像函数调用,但不会执行任何函数代码,直到对其调用 next()(在 for 循环中会自动调用 next())才开始执行。虽然执行流程仍按函数的流程执行,但每执行到一个 yield 语句就会中断,并返回一个迭代值,下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次,每次中断都会通过 yield 返回当前的迭代值。
yield 的好处是显而易见的,把一个函数改写为一个 generator 就获得了迭代能力,比起用类的实例保存状态来计算下一个 next() 的值,不仅代码简洁,而且执行流程异常清晰。
如何判断一个函数是否是一个特殊的 generator 函数?可以利用 isgeneratorfunction 判断:
清单 7. 使用 isgeneratorfunction 判断
>>> from inspect import isgeneratorfunction >>> isgeneratorfunction(fab) True
要注意区分 fab 和 fab(5),fab 是一个 generator function,而 fab(5) 是调用 fab 返回的一个 generator,好比类的定义和类的实例的区别:
清单 8. 类的定义和类的实例
>>> import types >>> isinstance(fab, types.GeneratorType) False >>> isinstance(fab(5), types.GeneratorType) True fab 是无法迭代的,而 fab(5) 是可迭代的: >>> from collections import Iterable >>> isinstance(fab, Iterable) False >>> isinstance(fab(5), Iterable) True 每次调用 fab 函数都会生成一个新的 generator 实例,各实例互不影响: >>> f1 = fab(3) >>> f2 = fab(5) >>> print 'f1:', f1.next() f1: 1 >>> print 'f2:', f2.next() f2: 1 >>> print 'f1:', f1.next() f1: 1 >>> print 'f2:', f2.next() f2: 1 >>> print 'f1:', f1.next() f1: 2 >>> print 'f2:', f2.next() f2: 2 >>> print 'f2:', f2.next() f2: 3 >>> print 'f2:', f2.next() f2: 5
return 的作用
在一个 generator function 中,如果没有 return,则默认执行至函数完毕,如果在执行过程中 return,则直接抛出 StopIteration 终止迭代。
另一个例子
另一个 yield 的例子来源于文件读取。如果直接对文件对象调用 read() 方法,会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。通过 yield,我们不再需要编写读文件的迭代类,就可以轻松实现文件读取:
清单 9. 另一个 yield 的例子
def read_file(fpath): BLOCK_SIZE = 1024 with open(fpath, 'rb') as f: while True: block = f.read(BLOCK_SIZE) if block: yield block else: return
以上仅仅简单介绍了 yield 的基本概念和用法,yield 在 Python 3 中还有更强大的用法,我们会在后续文章中讨论。
注:本文的代码均在 Python 2.7 中调试通过
3.2 range和xrange的区别
# Python 2.x >>> print(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> print(xrange(10)) xrange(10)
# range会在内存中创建所有指定的数字,而xrange不会立即创建,只有在迭代循环时,才去创建每个数组
# Python 3.x >>> print(range(10)) range(0, 10) >>> print(xrange(10)) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'xrange' is not defined
http://i.cnblogs.com/EditArticles.aspx?postid=5515410&update=1
3.3 文件操作的read和xreadlinex的区别
xreadlines则只有在循环迭代时才获取
def func():
print("111")
yield 1
print("222")
yield 2
print("333")
yield 3
ret = func()
# print(list(ret))
r1 = ret.__next__() # 执行到 yield 1 停止
print(r1)
r2 = ret.__next__() # 执行到 yield 2 停止
print(r2)
r3 = ret.__next__() # 执行到 yield 3 停止
print(r3)
# 结果
111
1
222
2
333
3
def my_range(arg):
start = 0
while True:
if start > arg:
return
yield start
start += 1
ret = my_range(4)
r1 = ret.__next__()
print(r1)
r1 = ret.__next__()
print(r1)
r1 = ret.__next__()
print(r1)
结果:
0
1
2
#######基础平台函数库######### def func1(): print('功能1') def func2(): print('功能2') def func3(): print('功能3') def func4(): print('功能4') # 测试组 def func1() def func2() def func3() # 设计组 def func1() def func2() def func3()
需求:基础平台函数库的调用要添加验证机制,只能验证通过才能进行函数调用,在完成这个需求的前提下要满足如下条件
1)各个部门修改自己的代码
2)在每个部门实行的功能上添加最少的代码完成改造
3)追求开放封闭原则,尽可能的不改变原基础函数库内部实现的方法解决方案:利用装饰器功能解决该需求
def login(func): def inner(): # 验证1 # 验证2 # 验证3 return func() return inner
@login def func1(): print '功能1' @login def func2(): print '功能2' @login def func3(): print '功能3' @login def func4(): print '功能4'
当各个组执行各自功能的时候,可以先调用基础平台提供的装饰器函数,完成验证需求
def login(func): def inner(): # 验证1 return func() return inner @login def func1(): print('功能1')
功能:
1. 自动执行login函数并且将其下面的函数名func1当作参数传递
2. 将login函数的返回值,重复赋值给 func1
当调用功能1的时候 会先把功能1的函数名带入内存地址,之后会执行login函数,func为功能1,之后inner会将功能1的参数带入等待执行inner的验证功能后,会将参数交给func执行功能1的命令。
# 装饰器如何装饰多个参数个数不同的函数 def outer(func): def inner(*args, **kwargs): print("func before") result = func(*args, **kwargs) print("func after") return result return inner @outer def f1(arg): print(arg) # return "f1函数返回值" @outer def f2(arg1,arg2): print(arg1,arg2) # return "f1函数返回值"
LOGIN_USER = {"is_login": False} def outer(func): def inner(*args, **kwargs): if LOGIN_USER['is_login']: r = func() return r else: print("请登录") return inner def outer1(func): def inner(*args, **kwargs): if LOGIN_USER['is_login'] and LOGIN_USER['user_type'] == 2: r = func() return r else: print("请登录,或者权限不够") return inner @outer1 def order(): print("欢迎%s登录" % LOGIN_USER['current_user']) @outer def changepwd(): print("欢迎%s登录" % LOGIN_USER['current_user']) @outer def manager(): print("欢迎%s登录" % LOGIN_USER['current_user']) def login(user, pwd): if user == "alex" and pwd == "123": LOGIN_USER['is_login'] = True LOGIN_USER['current_user'] = user manager() def main(): while True: inp = input("1,后台管理;2,登录") if inp == '1': manager() elif inp == '2': username = input("请输入用户名") pwd = input("请输入密码") login(username, pwd) if __name__ == '__main__': main()
# 执行结果:
USER_INFO = {} def check_login(func): def inner(*args, **kwargs): if USER_INFO.get("is_login", None): # ret = func(*args, **kwargs) func(*args, **kwargs) else: print("请先登录") return inner def check_admin(func): def inner(*args, **kwargs): if USER_INFO.get("user_type", None): # ret = func(*args, **kwargs) func(*args, **kwargs) else: print("请管理员") return inner def login(): print("登录成功") USER_INFO["is_login"] = True @check_login def home(): print("普通查看信息") @check_login @check_admin def admin(): print("管理员权限") def main(): while True: choice_num = input("1、登录 2、查看信息 3、管理员权限 请选择") if choice_num == "1": login() elif choice_num == "2": home() elif choice_num == "3": admin() if __name__ == '__main__': main()
特点:
1)访问者不需要关心迭代器内部的结构,仅需通过next()方法不断去取下一个内容
2)不能随机访问集合中的某个值 ,只能从头到尾依次访问
3)访问到一半时不能往回退
4)便于循环比较大的数据集合,节省内存
>>> a = iter([1,2,3,4]) >>> a.__next__() 1 >>> a.__next__() 2 >>> a.__next__() 3 >>> a.__next__() 4 >>> a.__next__() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
需求:请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序
思路:相邻两个值进行比较,将较大的值放在右侧,依次比较!
7、递归
特点
递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中,递归算法对解决一大类问题是十分有效的,它往往使算法的描述简洁而且易于理解。
递归算法解决问题的特点:
(1) 递归就是在过程或函数里调用自身。
(2) 在使用递归策略时,必须有一个明确的递归结束条件,称为递归出口。
(3) 递归算法解题通常显得很简洁,但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。
要求
递归算法所体现的“重复”一般有三个要求:
一是每次调用在规模上都有所缩小(通常是减半);
二是相邻两次重复之间有紧密的联系,前一次要为后一次做准备(通常前一次的输出就作为后一次的输入);
三是在问题的规模极小时必须用直接给出解答而不再进行递归调用,因而每次递归调用都是有条件的(以规模未达到直接解答的大小为条件),无条件递归调用将会成为死循环而不能正常结束。
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368
>>> def func(arg1, arg2): ... if arg1 == 0: ... print(arg1, arg2) ... arg3 = arg1 + arg2 ... print(arg3) ... if arg3 < 1000: ... func(arg2, arg3) ... >>> func(0, 1) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
def func(n): print(n) n += 1 if n >= 4: return "end" return func(n) r = func(1) print(r) 结果: 1 2 3 end
案例3:实现 1*2*3*4*5*6
>>> def fact(n): ... if n == 1: ... return 1 ... return n*fact(n-1) ... >>> >>> res = fact(3) >>> print(res) 6
出处:http://www.cnblogs.com/madsnotes/
声明:本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接。