第四章python进阶

于 2021-11-26 17:08:00 发布
阅读量335 收藏
点赞数
分类专栏： 第四章 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52672503/article/details/121563980
版权
本文详细讲解了Python中的判断与循环语句，包括if单分支和多分支，for循环，while循环，以及循环中的break和continue。此外，还介绍了迭代器、生成器的概念，以及装饰器、推导式、高阶函数等高级特性，帮助读者深入理解Python编程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

判断与循环

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二分之和多分支

if 条件:

     代码块

 else:

     代码块

 if 条件:

     代码块

 elif 条件:

     代码块

 elif 条件:

     代码块

  ........

  else:

      代码块

guess  = eval(input("请猜一个数字"))
if guess == 99:
    print("恭喜你猜对了")
else:
    print("谢谢惠顾")

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("不及格")

循环语句for

语法

 for 变量 in 遍历结构:

     代码块

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

 2.字典.items()  返回一个元组

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

     把元组赋值给两个变量

Str = "hello python"
for  i in Str:
    print(i)

list01 = ["赵丽颖","舒畅","戚薇","朱梓骁"]
for i in list01:
    print(i)

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

for t in dict01.items():
    print(t)
    print(type(t))

for k,v in dict01.items():
    print(k)
    print(type(k)) #Str
    print(v)
    print(type(v)) #Str

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

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

while语法

while <条件> : 

    <语句块1>

else : 

    <语句块2>

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

for i in [1,2,3,4,5]:
    print(i)
else:
    print("循环结束")

迭代器与生成器

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

  1. 迭代器返回一个对象

  2. 那些东西可以进行迭代

  容器类型的---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__()
for i in list01:
   print(i)

 迭代对象的遍历

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

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

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

迭代对象

  1. 那些东西可以进行迭代

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

为什么是两个下划线

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

Next()

.next()

.__Next__()

__init__()

__iter__()

Func_sum()

生成器

定义

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

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

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

优点是节省内存

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

生成器一边循环一边计算

  1. 生成器都是迭代器，迭代器不一定是生成器

  2. 字符串，列表，元组，字典，集合都可以被for循环，说明他们都是可迭代对象

  3. 迭代器的两个方法：1.有__iter__() 2. 有__next__()

  4. isinstance() 类型判断。isinstance(a,Iterable) 判断a 是否是可迭代对象。

装饰器

 1.装饰器是一个函数

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

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

语法

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

   @def func_a

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

相当于func_a(func_b)

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

 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()

推导式

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

语法

[逻辑/结果 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()}

高阶函数

定义

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

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

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

函数为变量（补充）

  函数为变量并不是高阶函数， 函数为变量

#定义一个函数，传入一个参数，求这个参数的平方
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) #

函数为参数

#普通函数
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对象

  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对象

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
#累加   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}]

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__ 是个属性，可以拿到函数的名字，在调用的时候函数不要加()

"""
1. @wraps(gaoyuanyuan) 保留高圆圆这个函数的所有属性和方法
2. from functools import wraps
"""
print(gaoyuanyuan.__name__) #gaoyuanyuan

函数为返回值

语法

  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.闭包。函数里面的子函数，叫做闭包

#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

lambda表达式

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

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

lambda表达式：一行函数

def func01(x,y):
    return x**y

lambda x,y:x**y

关键字global与return

那首先我们来看看第一段也就是包含 return关键字的代码，那个函数把值赋给了调用它的效置（也就是例子中的 resbt变量）。大多数境况下，你并不需要使用gba关键字。另外一段也就是包含gbotea 关键字的代码。那个函数生成了一个gbtal（全局）变量(resuli)。 gtba 交量宽味着我们可以在逐数以外的区域都能访问这个变量，

#首先，是没有使用 global 变量

def add(valuel, value2):

result = value1 + value2

add(2, 4)

print(result)

#输出报错信息：NameError：name ‘result' is not defined

函数的递归

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

 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

作用域

是按照变量的查找顺序 L>E>G>B

L(local) 局部作用域

E(Enclosing) 闭包函数中的作用域

  nonlocal  :把闭包外的变量引用过来

G(Global) 全局作用域

B(Built-in) 内建作用域

def func():
      #a是函数中的变量，是局部变量,只能在函数中使用
      a=10
      print(a)
#a是不存在的
print(a)

E(Enclosing) 闭包函数中的作用域
  nonlocal  :把闭包外的变量引用过来
#刚出生的年龄，是全局变量，意味这谁都是从这个年龄开始的
age = 1
def qunian():
      #闭包外的变量，局部变量  4-11能用
      age = 19
      def jinian():
            """
            #把全局变量引用过来，那么就是把age=1引用过来
            global age
            我们想要引用的是闭包外面的变量
            nonlocal  :把闭包外的变量引用过来
            """
            nonlocal age
            #闭包里面的变量 ，局部变量 7-9行能用
            age=age +1
            print("今年的年龄",age)
      print("去年的年龄",age)
      return jinian

#qunian()返回的是return jinian
jinian = qunian()
#所以还要调用一下今年这个函数jinian()
jinian()
#今年的年龄 20

G(Global) 全局作用域
global  把全局的age引用过来


"""
G(Global) 全局作用域
"""
#全局
age = 20
def func():
      #把全局的age引用过来
      global age
      #局部
      #前面的a相当于是重新赋值的a，是局部的
      #后面的a是要进行相加的数据，所以要有这个数据，所以是全局的
      age=1 + age
      return age
      
print(func()) #30

B(Built-in) 内建作用域
系统固定模块里面的变量，比如 int, bytearray 等。
比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
总结
是按照变量的查找顺序 L>E>G>B
逐渐扩大范围去寻找

异常处理

语法

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:

      代码块

执行结果：

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

#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")

常见的异常列表

BaseException

所有异常的基类

SystemExit

解释器请求退出

KeyboardInterrupt

用户中断执行(通常是输入^C)

Exception

常规错误的基类

StopIteration

迭代器没有更多的值

GeneratorExit

生成器(generator)发生异常来通知退出

StandardError

所有的内建标准异常的基类

ArithmeticError

所有数值计算错误的基类

FloatingPointError

浮点计算错误

ValueError

传入无效的参数

ZeroDivisionError

除(或取模)零 (所有数据类型)

KeyError

映射中没有这个键

AttributeError

对象没有这个属性

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值