第四章迭代器等

最新推荐文章于 2024-06-07 18:08:55 发布

零零后菜鸟

最新推荐文章于 2024-06-07 18:08:55 发布

阅读量243

点赞数

文章标签： python

本文链接：https://blog.csdn.net/m0_58425034/article/details/121544665

版权

迭代器

定义

迭代器是一个可以遍历容器的一个对象

迭代器返回一个对象
那些东西可以进行迭代

容器类型的---list set 字典字符串

方法

"""

迭代器

#注意是两个下划线

list01.__iter__() 返回一个迭代器对象

<list_iterator object at 0x0000024037E0C588>

"""

list01 = [1,2,3,4]

#注意是两个下划线

a = list01.__iter__()

print(a) #<list_iterator object at 0x0000024037E0C588>

"""

1.我听要他何用，他是一个对象，我想要的是值

迭代器对象.__next__() 返回一个值

2.他只能返回第一个值吗 no

因为next()可以记忆位置，每次你调用一次，他会记住这位置，然后下一次从下一个位置开始

3.我要是一直调用，可以吗

报错StopIteration，没有数据了

我们的next没有办法回头，不会从头开始，他只会从记忆的位置的开始

"""

print(a.__next__()) #1

print(a.__next__()) #2

print(a.__next__()) #3

print(a.__next__()) #4

print(a.__next__()) #报错

迭代

list01 = [1,2,3,4]

#注意是两个下划线

a = list01.__iter__()

"""

迭代对象的遍历

1.__next__() 不会从头开始，每次从记忆的位置开始

2.for循环就相当于是不断的打印__next__()。但是为什么没报错

自己抛出StopIteration，然后停止循环

"""

for i in list01:

print(i)

迭代对象

那些东西可以进行迭代

容器类型的---list set 字典字符串

为什么是两个下划线

有些方法以双下划线 “__” 开头和结尾，它们是Python的魔法函数，用于特殊用途

Next()

.next()

.__Next__()

__init__()

__iter__()

Func_sum()

生成器

定义

生成器也是一种迭代器，但是你只能对其迭代一次。

>>> a = func_add01([2,3,5,7,9])

>>> a

>>> for i in a:

print(i)

>>> a.__next__()

Traceback (most recent call last):

File "<pyshell#18>", line 1, in <module>

a.__next__()

StopIteration

>>> b = func_add01([2,3,5,7,9])

>>> b.__next__()

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个特殊的迭代器。

>>> func_add01([1,2,3,4])

<generator object func_add01 at 0x000001AD11F8D148

生成器可以一边循环一边计算

优点是节省内存

关键字是：yield

代码

>>> def func_add(list01):

list02 = []

for i in list01:

list02.append(i+1)

return list02

>>> func_add([1,2,3,4])

[2, 3, 4, 5]

>>> def func_add01(list01):

for i in list01:

yield i+1

>>> func_add01([1,2,3,4])

>>> list(func_add01([1,2,3,4]))

[2, 3, 4, 5]

>>> a = func_add01([2,3,5,7,9])

>>> a

>>> for i in a:

print(i)

>>> a.__next__()

Traceback (most recent call last):

File "<pyshell#18>", line 1, in <module>

a.__next__()

StopIteration

>>> b = func_add01([2,3,5,7,9])

>>> b.__next__()

>>>

语法

由于生成器是一个返回迭代器的函数

生成器一边循环一边计算

关键字是yield

def func_name(canshu):

for i in canshu:

yield luoji

总结

生成器都是迭代器，迭代器不一定是生成器
字符串，列表，元组，字典，集合都可以被for循环，说明他们都是可迭代对象
迭代器的两个方法：1.有__iter__() 2. 有__next__()
isinstance() 类型判断。isinstance(a,Iterable) 判断a 是否是可迭代对象。

推导式

引入

"""

普通循环

"""

for i in [1,2,3,4]:

print(i)

"""

推导式

"""

[print(i) for i in [1,2,3,4]]

定义

推导式是从一个或者多个迭代器快速创建序列的一种方法。

语法

[逻辑/结果 for i in 序列类型的变量]

你想要什么类型，就在外层包裹什么

序列类型

[] () {k,v} {}

用法

列表类型

"""

推导式

"""

list01 = [1,2,3,4]

a= [i+1 for i in list01]

print(a) #[2, 3, 4, 5]

print(type(a)) #<class 'list'>

元组类型

list01 = [1,2,3,4]

#把里面的代码看成一个整体，一个对象

#利用我们的tuple()函数

a= tuple(i+1 for i in list01)

print(a) #(2, 3, 4, 5)

print(type(a)) #<class 'tuple'>

#把3+2变成一个整体

(3+2)/9

集合类型

list01 = [1,2,3,4]

a= {i+1 for i in list01}

print(a) #{2, 3, 4, 5}

print(type(a)) #<class 'set'>

字典类型

dict01 = {"王五":20,"张三":50,"李四":80,"赵六":18}

for k,v in dict01.items():

print(k,v)

{print(k,v) for k,v in dict01.items()}

参数传递

参数传递机制

"""

函数参数传递机制和赋值机制是一样的，其本质就是传递内存地址，这就是引用传递

a传进来的时候传进来的是内存地址

如果实在不理解，你可以以为是 x= a

"""

def isid(x):

#打印参数的内存地址

print(id(x))

a = 10

#变量的内存地址

print(id(a)) #140731588047408

#a变成的参数，打印参数内存地址

isid(a) #140731588047408

默认参数

#定义一个带有默认参数的函数

def add(x,y=10):

sum01 = x+y

return sum01

"""

1.add(2) x=2 y=10

2.add(2,3) x=2 y=3

"""

print(add(2)) #12

print(add(2,3)) #5

"""

能不能传参传入一个序列类型，比如list，让他默认是[]

"""

def add(list01 = []):

list01.append(1)

return list01

#第一调用

print(add()) #[1]

#第二次调用

print(add()) #[1, 1]

#第三次调用

print(add()) #[1, 1, 1]

不定数目的参数

一个 *

"""

一个* ：代表的是可变参数（就是可以是多个值）

"""

def add(x,*y):

sum01 = x

for i in y:

sum01 += i

return sum01

print(add(1,2,3,4,5)) #15

两个*

"""

**y代表可以使用任意键值（字典）作为参数

**y就相当于字典类型

"""

def func_add(x,**y):

sum01 = x

#切记这里是字典的循环

for k,v in y.items():

print(k,v)

#把v（值）进行和x相加

sum01 += v

return sum01

"""

调用

a=3,b=4,c=5 ----> {"a":3,"b":4,"c":5}

"""

print(func_add(1,a=3,b=4,c=5)) #13

name

执行本文件的时候，name==main

#打印name这个属性

#执行本文件的时候，打印的是main，__name__ == __main__

print("1、"+__name__) #1、__main__

2.在被import导入到别的文件的时候，name==文件名字

"""

一个文件就是一个模块，导入模块，就相当于导入文件，可以直接写

import 文件名字

"""

import 本文件 as bwj

#在其他类中运行导入的文件名字，__name__==文件名字

print(bwj.__name__) #本文件

高阶函数

定义

高阶函数是一个（以函数为参数，或者以函数为返回值的）函数

函数可以是参数，参数是变量，那么函数可以是变量吗

参数其实就是变量进行了赋值，函数能不能是变量

函数为变量（补充）

函数为变量并不是高阶函数，只是和大家补充这个知识点

"""

函数为变量

"""

#定义一个函数，传入一个参数，求这个参数的平方

def func_pf(x):

return pow(x,2)

#字典

#已知李四的年龄是5的平方，求李四的年龄

dict01 = {"张三":20,"李四":func_pf}

"""

调用

1.func_pf = dict01["李四"] 根据key获取value,vaule是一个函数对象

2.age02 = func_pf(5) #调用函数就能获取年龄

"""

#字典的特点是根据key获取value

age01 = dict01["张三"]

print(age01) #20

#顾名思义，通过李四，我们可以拿到函数func_pf

#拿到的是函数对象，我们不能直接打印

func_pf = dict01["李四"]

print(func_pf) #<function func_pf at 0x000001E25A23D048>

age02 = func_pf(5)

print(age02) #25

函数为参数

定义

#普通函数

def func_pf(x):

return x**2

#高阶函数，以函数为参数

def func_add(func_pf):

#x**2+10

return func_pf+10

#2**2+10

a = func_add(func_pf(2))

print(a) #14

常用的高阶函数

这些常用的高阶函数是以函数为参数的高阶函数

map()

定义

"""

map(fun,x) 转换，接受一个序列，按照fun的函数逻辑转换成新的序列，返回一个map对象

x必须是一个序列
返回一个map对象

"""

执行流程

代码

"""

map(fun,x) 转换，接受一个序列，按照fun的函数逻辑转换成新的序列，返回一个map对象

1. x必须是一个序列

2.返回一个map对象

"""

def func_add(x):

return x+1

"""

把原来的数据，经过func_add函数以后，每一个都加1，然后输出新的列表

"""

m = map(func_add,[1,2,3,4,5])

print(m) #<map object at 0x00000248E965C788>

print(list(m)) #[2, 3, 4, 5, 6]

filter()

定义

"""

filter(func,x) 过滤，接受一个序列x，按照func函数要求进行转换,

func函数返回 True 或 False，最后将返回 True 的元素放到新列表中。

返回filter对象

"""

执行流程

代码

"""

filter(func,x) 过滤，接受一个序列x，按照func函数要求进行转换,

func函数返回 True 或 False，最后将返回 True 的元素放到新列表中。

返回filter对象

"""

def func_ifScore(x):

#比较运算符，本身就是返回布尔值的

#如果大于等于60就是Ture，否则就是False

return x>=60

f = filter(func_ifScore,[80,98,70,34,60,59,10])

print(f) #<filter object at 0x00000232CC78C808>

print(list(f)) #[80, 98, 70, 60]

reduce()

定义

"""

reduce(func,x) 计算，接受一个序列，把列表中的每一个值按照函数进行累加或者别的运算

返回一个计算数值

1.因为是计算，所以我们的func是两个参数

2.必须要导包

"""

执行流程

代码

from functools import reduce

"""

reduce(func,x) 计算，接受一个序列，把列表中的每一个值按照函数进行累加或者别的运算

返回一个计算数值

1.因为是计算，所以我们的func是两个参数

2.必须要导包

"""

#累加 1+2+3+4+5

def func_add(x,y):

return x+y

a = reduce(func_add,[1,2,3,4,5])

print(a) #15

zip()

定义

"""

zip(list01,list02) 拉链、压缩

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，返回一个对象

1.参数必须是可迭代的序列类型

2.对象里面放的是一个一个的元组

3.返回一个zip对象

"""

代码

ist01 = [1,3,5,7,9]

list02 = [2,4,6,8,10]

z = zip(list01,list02)

print(z) #<zip object at 0x00000292EE17C7C8>

#print(list(z)) #[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

"""

数据不一样多了，拉链不一样长了，结果该怎么办呢

以短的为基础

"""

list03 = [1,3,5,7,9,11,13]

list04 = [2,4,6]

a = zip(list03,list04)

#print(list(a)) #[(1, 2), (3, 4), (5, 6)]

"""

a是一个压缩、拉链数据，能不能解压呢，

1.符号是*

2.zip(*list类型)

3.声明两个变量去承接

4.zip对象如果执行过了，就不存在了

"""

b = list(a)

list05,list06 = zip(*b)

print(list05) #(1, 3, 5)

print(list06) #(2, 4, 6)

sorted()

定义

"""

sorted(序列类型的对象,key=函数,reverse=True/False) 排序

1.reverse=True/False 升序是False 降序是Ture

"""

执行流程

代码

#list里面可以放任何数据类型

list01 = [{"name":"张三","age":20},

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

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

{"name":"小明","age":8}

]

#按照年龄进行排序

#定义一个函数，返回一个年龄

def func_age(list01):

#根据key（age）获取value（年龄）

age01 = list01["age"]

return age01

s = sorted(list01,key=func_age,reverse=False)

print(s)

#[{'name': '小明', 'age': 8}, {'name': '王五', 'age': 18}, {'name': '张三', 'age': 20}, {'name': '李四', 'age': 30}]

函数为返回值

语法

"""

def func_name01(参数1)：

def func_name02(参数2)：

return 逻辑

return fun_name02

"""

执行流程图

代码

#x的y次方

def func01(x,y):

return x**y

#x=2不变，y不断在改变

#print(func01(2,2)) #4

#print(func01(2,3)) #8

#print(func01(2,4)) #16

#print(func01(2,5)) #32

#print(func01(2,6)) #64

"""

简化1

以函数为返回值进行简化

1.闭包。函数里面的子函数，叫做闭包

"""

#f01 高阶函数

def f01(x):

#f02是f01的子函数，又叫做闭包函数

def f02(y):

return x**y

#把闭包函数返回出来

return f02

"""

调用

1.f = f01(2) f是谁，f就是f02(y),相当于f=f02(y)

"""

f = f01(2) #意义就是x=2

a = f(3) #意义就是y=3

#a=x**y=2**3 = 8

print(a) #8

偏函数（补充）

语法

"""

from functools import partial

partial(fun,x)

fun:你的函数

x：你要固定的函数中参数

"""

代码

#x的y次方

def func01(x,y):

return x**y

"""

简化2

上面的这种这能固定x，没办法固定y，使用偏函数解决这个bug

偏函数

1.partial(fun,你要固定的那个参数x) 可以固定函数中的任意一个参数

2.导包 from functools import partial

def func01(x,y=2):

return x**y

"""

from functools import partial

#func = func01(x,y=2)

func = partial(func01,y=2)

a = func(3) #x=3

#a = x**2=3**2=9

print(a) #9

#可以固定多个参数，可以把x和y都固定住

from functools import partial

#func = func01(x=10,y=2)

func = partial(func01,y=2,x=10)

a = func()

print(a) #100

lambda表达式

定义

lambda表达式是一行函数。在其他语言中叫做匿名函数

语法

"""

lambda 参数1,参数2,参数n : 逻辑

"""

代码

"""

lambda表达式：一行函数

理解为函数的简写

"""

def func01(x,y):

return x**y

lambda x,y:x**y

第一种普通函数

"""

def func_add01(list01):

list02 = []

for i in list01:

list02.append(i+1)

return list02

"""

第二种生成器

"""

def func_add02(list01):

for i in list01:

yield i+1

"""

第三种高阶函数

map(func,list01) 转换

"""

def func_add04(x):

return x+1

map(func_add04,list01)

"""

第四种lambda表达式

1.把函数进行简写

2.利用高阶函数map()

"""

#把add04进行简写---lambda x:x+1

A = map(lambda x:x+1,list01)

List(A)

函数的递归

定义

"""

递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己

1.自己调用自己

2.一定要有一个条件，进行退出调用

"""

代码

"""

递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己

1.自己调用自己

2.一定要有一个条件，进行退出调用

"""

阶乘：

比如说给一个数据5，阶乘5*4*3*2*1

n = 5*(5-1)

n =n*(4-1)

n =n*(3-1)

n =n*(2-1)

总结规律

n! = n*(n-1)

"""

def func_jc(n):

if n==1:

return 1

else:

return n*func_jc(n-1)

print(func_jc(5)) #120

流程

"""

函数递归

"""

def func_fb(n):

if n==0 or n==1:

return 1

else:

return func_fb(n-2)+func_fb(n-1)

print(func_fb(5) ) #8

"""

非递归

#下标是从0开始的

"""

def func(n):

#初始化两个变量

a,b=1,1

#range(5) ---->0,1,2,3,4

for i in range(n):

a,b=b,a+b

return a

print(func(5)) #8

效率的比较

"""

我能用普通函数写出来，为什么非要学递归，

"""

import time

"""

函数递归

"""

def func_fb(n):

if n==0 or n==1:

return 1

else:

return func_fb(n-2)+func_fb(n-1)

"""

非递归

#下标是从0开始的

"""

def func(n):

#初始化两个变量

a,b=1,1

#range(5) ---->0,1,2,3,4

for i in range(n):

a,b=b,a+b

return a

#perf_counter 以秒为单位进行记时间

start01 = time.perf_counter()

func_fb(10)

stop01= time.perf_counter()

print("递归函数的调用时间 %s" %(stop01-start01))

#process_time 以秒为单位进行记时间

start02 = time.perf_counter()

func(10)

stop02= time.perf_counter()

print("非递归函数的调用时间%s"%(stop02-start02))

"""

递归函数的调用时间 5.050000000000193e-05

非递归函数的调用时间7.3000000000017495e-06

"""

装饰器

定义

"""

1.装饰器是一个函数

2.装饰器是一个为函数添加新的属性的函数

3.通过闭包对函数添加新的属性

"""

语法

"""

语法

1.def func_a() #带有新特新的闭包函数

@def func_a

2.def func_b() #被修饰的函数

相当于func_a(func_b)

可以是多个@，如果是多个@的话，从下往上运行

"""

代码1

"""

1.装饰器是一个函数

2.装饰器是一个为函数添加新的属性的函数

3.通过闭包对函数添加新的属性

闭包函数:函数的子函数就是闭包函数

"""

#装饰器

def zhuangxiudui(a):

#闭包函数

def zhuangxiufangan():

print("贴瓷砖")

a()

print("隔音棉")

return zhuangxiufangan

@zhuangxiudui

def qiang():

print("来看看，就是这三面强")

#16-18行相当于 zhangxiudui(qiang)

#把qiang作为参数，传给了装修队这个函数

@zhuangxiudui

def men():

print("我是门")

"""

22-24行代表 zhangxiudui(men)

"""

#一周之后我来验货，来看看强弄好了没

qiang()

"""

贴瓷砖

来看看，就是这三面强

隔音棉

"""

代码2

#装饰器

def zhuangxiudui(a):

#闭包函数

def zhuangxiufangan():

print("贴瓷砖")

a()

print("隔音棉")

return zhuangxiufangan

def gaojizhuangxidui(b):

def zhuangxiufangan():

#你现在的墙是由瓷砖由隔音棉

b()

print("拆除瓷砖")

print("拆除隔音棉")

print("刷粉漆")

return zhuangxiufangan

"""

本来把墙给装修队，结果他装修坏了，我有找了一个高级装修队，进行重新装修

gaojizhuangxiudui(zhuangxiudui(qiang))

b=zhuangxiudui(qiang)

a=qiang

"""

@gaojizhuangxidui

@zhuangxiudui

def qiang():

print("来看看，就是这三面强")

qiang()

"""

贴瓷砖

来看看，就是这三面强

隔音棉

拆除瓷砖

拆除隔音棉

刷粉漆

"""

执行流程

Wraps()函数

定义

"""

1. @wraps(gaoyuanyuan) 保留高圆圆这个函数的所有属性和方法

2. from functools import wraps

Wraps(被修饰的物体) 保留被修饰物体的属性和函数

Wraps(化妆师（男人）) 保留性别这个属性

"""

代码

from functools import wraps

def ziji(gaoyuanyuan):

@wraps(gaoyuanyuan)

def huanxiang():

print("有一个有气质的前女友")

gaoyuanyuan()

print("找个富婆，有私房钱")

return huanxiang

@ziji

def gaoyuanyuan():

print("我是高圆圆，长得好看,但是脾气不好")

#gaoyuanyuan()

#__name__ 是个属性，可以拿到函数的名字，在调用的时候函数不要加()

"""

高圆圆的名字变成"自己"，就是说gaoyuanyuan这个函数变成了huangxiang这个函数名字

这就意味这，我们使用@的时候，吧修饰函数(ziji)中的属性和函数给了被修饰物体(gaoyuanyaun)

女朋又也是有灵魂的，你强制把你的思想给女朋友

"""

1. @wraps(gaoyuanyuan) 保留高圆圆这个函数的所有属性和方法

2. from functools import wraps

"""

print(gaoyuanyuan.__name__) #gaoyuanyuan

函数中有参数

定义

"""

1.通过闭包函数进行传参

2.万能参数：参数可以是任何数据类型，也可以是多个参数

*args,**kwargs

"""

代码

import time

#定义一个装饰器

#1.注意作为参数传递不能使用(n)

def youhua(func_fb):

#通过闭包函数，把n给闭包函数

def jisuanshijian(*a,**b):

start01 = time.perf_counter()

func_fb(*a,**b) #这里函数调用就可以有参数了

stop01 = time.perf_counter()

print("函数调用的时间是",(stop01-start01))

return jisuanshijian

#斐波那契数列

@youhua

def func_fb(n):

if n ==0 or n==1:

return 1

else:

return func_fb(n-1)+func_fb(n-2)

#函数调用的时间是 1.3999999999986246e-06

func_fb(1)

判断语句if

单分支

语法

"""

if 条件:

代码块

1.冒号必须是英文状态下

2.必须要缩进

"""

执行流程

代码

"""

eval(字符串)

1.把字符串转换成int类型

a = eval("10")

print(a) #10

print(type(a)) #<class 'int'>

2.对字符串进行计算

a = "3*2"

print(a) #3*2

b = eval(a)

print(b) #6

"""

#input("请猜一个数字") ---Str

#eval() 把Str转换成int

guess = eval(input("请猜一个数字"))

if guess ==99:

print("恭喜你猜对了") #恭喜你猜对了

二分支

语法

"""

if 条件:

代码块

else:

代码块

"""

执行流程

代码

guess = eval(input("请猜一个数字"))

if guess == 99:

print("恭喜你猜对了")

else:

print("谢谢惠顾")

多分支

语法

"""

if 条件:

代码块

elif 条件:

代码块

elif 条件:

代码块

........

else:

代码块

"""

执行流程图

代码

score = eval(input("请输入一个成绩："))

if score >= 90:

print("a")

elif 90 > score>=80:

print("B")

elif 80 >score>=70:

print("C")

elif 70>score>=60:

print("D")

else:

print("不及格")

三目运算符

语法

满足条件的代码块 if 条件 else 不满足条件的代码块

执行流程

代码

guess = eval(input("请猜一个数字"))

"""

三目运算符

if的缩写

满足条件的代码块 if 条件 else 不满足条件的代码块

"""

print("恭喜你，猜对了")if guess == 99 else print("谢谢惠顾")

注意

必须是二分支语句

条件判断以及组合

操作符	数学符号	描述
<	<	小于
<=	≤	小于等于
>=	≥	大于等于
>	>	大于
==	=	等于
！=	≠	不等于

操作符及使用	描述
x and y	两个条件x和y的逻辑与
x or y	两个条件x和y的逻辑或
not x	条件x的逻辑非

练习

分类	国际BMI值 (kg/m^2)	国内BMI值 (kg/m^2)
偏瘦	<18.5	<18.5
正常	18.5 ~ 25	18.5 ~ 24
偏胖	25 ~ 30	24 ~ 28
肥胖	≥30	≥28

公式：BMI = 体重 (kg) / 身高2 (m2)

需求：按照国内指标，输入一组数据，判断是胖是瘦

循环语句for

语法

"""

for 变量 in 遍历结构:

代码块

"""

执行流程

用法

字符串遍历

Str = "hello python"

for i in Str:

print(i)

"""

列表遍历

list01 = ["赵丽颖","舒畅","戚薇","朱梓骁"]

for i in list01:

print(i)

"""

赵丽颖

舒畅

戚薇

朱梓骁

"""

字典遍历

dict01 = {"天龙八部":"段誉","倚天屠龙记":"张无忌","九阴真经":"周芷若","射雕英雄传":"郭靖"}

"""

1.用普通遍历,只能打印key

天龙八部

倚天屠龙记

九阴真经

射雕英雄传

"""

for i in dict01:

print(i)

"""

2.字典.items() 返回一个元组("天龙八部","段誉")

('天龙八部', '段誉')

('倚天屠龙记', '张无忌')

('九阴真经', '周芷若')

('射雕英雄传', '郭靖')

"""

for t in dict01.items():

print(t)

print(type(t))

"""

3.获取单独的key和value，就是想办法把元组拆分,返回基本数据类型

把元组赋值给两个变量

天龙八部

段誉

"""

for k,v in dict01.items():

print(k)

print(type(k)) #Str

print(v)

print(type(v)) #Str

Set集合遍历

set01 = {1,2,3,4}

for i in set01:

print(i)

无限循环(while)

语法

"""

while 条件:

变量改变公式

代码块

"""

代码

a = 10

while a>0:

#变量不断改变，为了满足条件，避免进入死循环

a -= 1

print(a)

break continue

break跳出并结束当前整个循环，不执行循环后的语句

continue结束当次循环，继续执行后续次数循环

执行流程

代码

for i in [1,2,3,4,5]:

if i==2:

break

print(i) #1

for i in [1,2,3,4,5]:

if i==2:

continue

print(i) #1

"""

循环加else

语法

"""

for 变量 in 遍历结构:

代码块

else:

代码块

"""

执行流程

"""

1.先执行完for循环

2.执行完以后执行else

"""

代码

for i in [1,2,3,4,5]:

print(i)

else:

print("循环结束")

同理，while能不能加else，可以，和上面一样

while语法

while <条件> :

<语句块1>

else :

<语句块2>

#循环结束后，会执行else的代码

1. 定义一个函数，接收n多个数字，求这些参数数字的和

function 方法

*代表可以接受多个数据

"""

def func_sum(x,*y):

#定义一个sum01变量接收求和

sum01 = x

#由于y是多个数据，所以利用for循环获取数据

for i in y:

# sum01 = sum01 +i

sum01 += i

#要和，要等相加完成之后在输出，所以要for循环束

return sum01

# x = 1 y=2,3,4,5,6

a = func_sum(1,2,3,4,5,6)

print(a) #21

定义一个函数，传入一个列表[1,2,3,4,5,6,7]，把列表中的奇数返回，返回一个新的列

"""

2. 定义一个函数，传入一个列表[1,2,3,4,5,6,7]，把列表中的奇数返回，返回一个新的列表

"""

#定义一个函数，传入一个列表

def func_ji(list01):

list02 = []

#把列表中的奇数返回

for i in list01:

if i%2 == 1:

list02.append(i)

#返回一个新的列表

return list02

list01 = [1,2,3,4,5,6,7]

l = func_ji(list01)

print(l) #[1, 3, 5, 7]

定义一个函数，传入用户id，判断用户id长度是否大于5

"""

3. 定义一个函数，传入用户id返回Ture False

"""

# 定义一个函数，传入用户id

def func_if(id):

#获取id的长度

length01 = len(id)

#length01 > 5 比较运算符，本身就会返回Ture False

return length01 > 5

id = "YJ123409"

print(func_if(id)) #True

定义一个函数，统计字符串中有几个字母，几个数字，几个空格，几个其他字符，并返回结果

"""

4.定义一个函数，统计字符串中有几个字母，几个数字，几个空格，几个其他字符，并返回结果

"""

#定义一个函数，统计字符串

def func_count(Str):

num = 0

zimu = 0

kongge = 0

other = 0

for i in Str:

#判断是否是数字

if i.isdigit():

num += 1

#判断是否是字母

elif i.isalpha():

zimu += 1

#判断是否是空格

elif i.isspace():

kongge += 1

else:

other += 1

return num,zimu,kongge,other

Str = "I love,you 1314"

"""

等号右边有四个值，等号左边要有四个变量

a,b,c = 10,"张三",[1,2,3,4]

a =10

b = "张三"

c = [1,2,3,4]

"""

a,b,c,d = func_count(Str)

print(a)

print(b)

print(c)

print(d)

"""

异常

定义

语法

Try – except-else

"""

try -except-else

try:

代码块

except <错误的名字(可写可不写)>:

代码块

...........

else:

代码块

可以把else去掉

try:

代码块

except <错误的名字(可写可不写)>:

代码块

注意：1.try不能单独使用

2.错误的名字(可写可不写)

运行结果：

报错(除数是0)，运行的是except

不报错(除数不是0)，运行的是else

"""

try:

s = eval(input("请输入一个数字："))

a = 10/s

except ZeroDivisionError:

print("除数不能是零")

else:

print("除数是正常的，运行成功")

Try-finally

"""

Try-finally

try：

代码块

finally:

代码块

执行结果：

无论报不报错最终都会执行

"""

#control+c

try:

s= input("请输入内容")

finally:

print("异常退出")

Raise关键字

"""

raise：无论代码是否异常，他自己会触发异常

语法：

raise 异常名称

"""

try:

s = eval(input("请输入一个除数："))

a = 10/s

#无论你的除数等不等于0，他都会报错

raise ZeroDivisionError

except ZeroDivisionError:

#except是异常的时候给出的警告

print("警告：除数不能为0")

"""

请输入一个除数：3

警告：除数不能为0

"""

常见的异常列表(要求再认)

BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
ValueError	传入无效的参数
ZeroDivisionError	除(或取模)零 (所有数据类型)
KeyError	映射中没有这个键
AttributeError	对象没有这个属性