python-迭代器-函数-异常处理

迭代器

可迭代对象
可迭代对象：可以直接作用于for循环的对象统称为可迭代对象（Iterable）可以直接用isinstance()去判断一个对象是否是Iterable对象

可以直接作用于for的数据类型一般分为两种
1， 集合数据类型，如list,tuple,dict,set,string
2， 是generator，包括生成器和带yield的generator function

from collection import Iterable
from collection import Iterator

print(isinstance([],Iterable))
print(isinstance((),Iterable))
print(isinstance({},Iterable))
print(isinstance("",Iterable))
print(isinstance((x for x in range(10)),Iterable))
print(isinstance(1,Iterable))

迭代器
迭代器：不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后跑出一个StopIteration错误表示无法继续返回下一个值

可以被next()函数调用并不断返回下一个值的对象称为迭代器（Iterator对象）

可以使用isinstance()函数判断一个对象是否是Iterator对象

print(isinstance((),Iterator))
print(isinstance((),Iterator))
print(isinstance({},Iterator))
print(isinstance(“”,Iterator))
print(isinstance((x for x in range(10)),Iterator))
print(isinstance(1,Iterator))

l = (x for x in range(5))
print(next1)
print(next1)
print(next1)
print(next1)
print(next1)
#print(next1)

#转成Iterator对象
a = iter([1,2,3,4,5])
print(next(a))

print(isinstance(iter([]), Iterator)
print(isinstance(iter(()), Iterator)
print(isinstance(iter({}), Iterator)
print(isinstance(iter(‘ ’), Iterator)
print(isinstance(iter[]), Iterator)

'''自定义结束符
endstr = “end”
str = “”
for line in iter(input, endstr):
	str += line + “\n”
print(str)
'''

函数

定义、引用省略，稍提函数的参数

#函数的参数

#编写一个函数，给函数一个字符串和一个年龄，在函数内部打印出来

#形参：定义函数时小括号中的变量，本质是变量
#参数必须按顺序传递
def myPrint(str, age, hobby):
	print(str, age)

#实参：调用函数时给函数传递的数据，本质是值
myPrint(“sunck”, 18)

#返回值
#编写函数，给函数两个数，返回这两个数的和

def mySum(num1, num2)
	#将结果返回给函数的调用者
	return num1 + num2

res = mySum(1, 2)

#传递参数 

#值传递：传递的是不可变类型
#string\tuple\number

def func1(num):
	num = 10

temp = 20
func1(temp)	#num = temp 
print(temp)

引用传递：传递的可变类型
list\dict\set

def func2(lis)
	lis[0] = 100
li = [1,2,3,4,5]
func2(li)
print(li)

使用关键字参数

概念：允许函数调用时参数的顺序与定义时不一致

def myPrint(str, age):
	print(str, age)

myPrint(age = 18, str = "sunck")

默认参数
概念：调用函数时，如果没有传递参数，则使用默认参数

要用默认参数，最好将默认参数放到最后

def myPrint(str = “sunck is a good man”, age = 18):
	print(str, age)

myPrint(“kaige ”, 17)

不定长参数

概念：能处理比定义时更多的参数

加了*的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，它就是一个空元组

def func(name, *arr)
	print(name)
	for x in arr:
		print(x)

func(“sunck”, ”good”, ”nice”)

#**代表键值对的参数字典，和*所代表的意义类似
def func2(**kwargs):
	print(kwards)
	print(type(kwards))

func2(x = 1, y = 2, z = 3)


def func3(*args, **kwards):
	pass	#代表一个空语句

#匿名函数
概念：不使用def语句定义函数，使用lambda来创建匿名函数

特点
1、 lambda只是一个表达式，函数体比def简单
2、 lambda主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的 逻辑
3、 lambda函数有自己的命名空间，且不能访问自有参数列表之外的或全局命名空间里的参数
4、 虽然lambda是一个表达式，且看起来只能写一行，与C和C++内联函数不同

格式：lambda 参数1,参数2, ······, 参数n:expression

sum = lambda num1, num2: num1 + num2
print(sum(1, 2))

异常处理

当程序遇到问题时不让程序结束，而越过错误继续向下执行

try……except……else
格式：

try:
	语句t
except 错误码 as e:
	语句1
except 错误码 as e:
	语句2
……
except 错误码 as e:
	语句n
else:
	语句e

注意：else语句可有可无

作用：用来检测try语句块中的错误，从而让except语句捕获错误信息并处理

逻辑：当程序执行到try-except-else语句时
1、 如果当try语句t执行出现异常，匹配第一个错误码，如果匹配上，就执行对应的语句
2、 如果当try语句t执行出现异常，没有匹配的异常，错误将会被提交到上一层的try语句，或者到程序的最上层
3、 如果当try语句t执行没有出现错误，执行else下语句e

print(num)
try:
	print(3/0)
except NameError as e:
	print(“没有该变量”)
except ZeroDivisionError as e:
	print(“除数为0”)
else:
	print(“代码没有问题”)

print(“**************”)

#使用except而不使用任何错误类型
try:
	print(4/0)
except:
	print(“程序异常”)

#使用except带着多种异常
try:
	pass
except (NameError, ZeroDivisionError):
	print(“出现了NameError 或ZeroDivisionError”)

特殊情况

#1、错误其实是class(类)，所以错误都继承自BaseException，所以捕获时，它捕获了该类型的错误，还把子类一网打尽
try:
	print(5/0)
except BaseException as e:
	print(“异常1”)
except ZeroDivisionError as e:
	print(“异常2”)

#2、跨越多层调用
def func1(num):
	print(1/num)
def func2(num):
	func1(num)
def main():
	func2(0)
try:
main()
except ZeroDivisionError as e:
	print(“*******”)

try……except……finally
格式：
try:
语句t
except 错误码 as e:
语句1
except 错误码 as e:
语句2
……
except 错误码 as e:
语句n
finally:
语句f
作用：语句t无论是否有错都将执行最后的语句f

try:
	print(1/0)
except ZeroDivisionError as e:
	print(“0”)
finally:		#关闭文件
	print(“final”)

断言 assert()

def func(num, div)
	assert (div != 0), “div不能为0”
	return num / div

print(func(10, 0))