Python 佛脚不好抱 - 流程控制与函数

最新推荐文章于 2024-04-13 01:08:40 发布

泰格瓦拉·孙

最新推荐文章于 2024-04-13 01:08:40 发布

阅读量137

点赞数

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/Indecreasy/article/details/126648425

版权

Python 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了Python的基础控制结构，包括if-elif-else条件控制、while循环、for循环以及它们的各种用法。强调了缩进的重要性，并讲解了函数的定义、参数传递、默认参数、不定长参数等。此外，还提到了匿名函数（lambda）、return语句、装饰器以及闭包的概念。内容涵盖了Python编程的核心要素，适合初学者学习。

摘要由CSDN通过智能技术生成

条件控制

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块
使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块
没有switch - case语句
只有一条语句，可以写在一行if test<10: print(test)
可以嵌套
- 控制好缩进
- 嵌套不要超过三层

while循环

没有do...while循环
无限循环
- while...True
- 可以使用CTRL+C可退出当前的无限循环
while...else语句：在条件判断的情况下执行一次****的语句块

for循环

for <variable> in <sequence>:
    <statements>
else:
    <statements>

range()函数的使用要熟练掌握

break 语句和continue语句

break语句跳出循环，不执行对应循环的else块
continue跳过当前循环剩余语句，继续进行下一轮循环

函数的定义与形式

def fuction_name ():
    '''
    第一行关于对象用途的简介，这一行应该以大写字母开头，以句号结尾，第二行空行.

    详细描述应有一或多段以描述对象的调用约定、边界效应等.
    <fuction_documents>
    '''
    pass

参数传递

不可变类型传值：int, str, tuple

如fun(a)，传递的只是a的值，没有影响a对象本身，在 fun(a)内部修改 a的值，只是修改另一个复制的对象，不会影响a本身

def fa(a):
    a = 100
    print(hex(id(a)))
    print(hex(id(100)))

a = 10
print(hex(id(a)))
print(hex(id(10)))
fa(a)
print(hex(id(a)))
print(hex(id(10)))

------------------
 
0x106351a80 #main_a
0x106351a80 #main_100
0x1063525c0 #func_a
0x1063525c0 #func_100
0x106351a80 #main_a
0x106351a80 #main_100

可变类型传引用：list, dict, set

fun(L)修改后fun外部的L也会受影响

def fc(a):
    a.append(100)
    print(hex(id(a)))
l=[1,2,3]
print(l)
print(hex(id(l)))
fc(l)
print(l)

-------------------
 
[1, 2, 3]
0x7fbf9a87fd40
0x7fbf9a87fd40
[1, 2, 3, 100]

必需参数（位置参数）

必须顺序正确
调用一致原则

关键字参数

关键字参数来确定传入的参数值
关键字的参数应跟随在位置参数后
允许函数调用时参数的顺序与声明时不一致
- 解释器能够用参数名匹配参数值

def fun(name,key):
    pass

fun(key='lambda x:x[1]',name='test')

默认参数

如果没有传递参数并调用函数，使用默认参数

def fun(name='zjc',key):
    python

fun(key = 'lambda x:x[1]')

默认值只被赋值一次，这使得当默认值是可变对象时会有所不同，比如列表、字典或者大多数类的实例

def f(a, L=[]):
    print(hex(id(L)))
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

--------------------
0x7f8b6a880dc0
[1]
0x7f8b6a880dc0
[1, 2]
0x7f8b6a880dc0
[1, 2, 3]

修改方法：

def f(a, L=None):
    if L is None:
        L = []
    print(hex(id(L)))
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

---------------------
0x7fbc4f080540
[1]
0x7fbc4f080540
[2]
0x7fbc4f080540
[3]

不定长参数

加*的参数会以Tuple：元组的形式导入，存放所有未命名的参数变量

def ptest(arg1, *vartuple):
    print(arg1, end=' , ')
    print(vartuple)


ptest(70, 'test', 50)

------------------------
70 , ('test', 50)

加**的参数会以Dictionary：字典 dict的形式导入

def ptest2(arg1, **vardict):
    print(arg1)
    print(vardict)


ptest2(10, a=2, b=4)

---------------- 
10
{'a': 2, 'b': 4}

通常这些可变参数是参数列表中的最后一个
任何出现在不定长参数的后面的参数只能是关键字参数，不能是位置有关参数
```
def concat(*args, sep="/"):
    pass
```

声明函数时，参数中星号 * 可以单独出现，* 后的参数必须用关键字传入

>>>def f(a,b,*,c):
...     return a+b+c
...
>>> f(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given

>>> f(1,2,c=3)
6

参数列表的分拆

要传递的参数已经是一个数据结构如列表等，但要调用的函数却只接受分成一个一个的参数值

可以使用* 操作符来自动把参数列表拆开:

args=[3,6]
x=list(range(*args)) 
print(x)

-------------------
[3, 4, 5]

可以使用 ** 操作符分拆关键字参数为字典:

d={'name':'zjc','age':35,'job':'prof.'}

def printInfo(name,age,job):
   print("Name:{0}\tAge:{1}\tJob:{2}".format\
   (name,age,job))
   pass
printInfo(**d) #字典分拆(**)

--------------------
Name:zjc  Age:35  Job:prof.

匿名参数

不再使用def语句标准的形式定义函数
使用lambda来创建匿名函数
- lambda只是一个表达式，函数体比def简单很多
- lambda的主体是一个表达式，而不是一个代码块
- 仅仅能在lambda表达式中封装有限的逻辑
- 普通函数定义中的一个语法技巧
- 格式是lambda [arg1 [,arg2,.....argn]]:expression
```
>>> sum = lambda arg1, arg2: arg1 + arg2
>>> sum(1, 2)
3
```

return语句

用于退出函数并有选择性地返回一个表达式
不带参数的return语句返回None
没有return语句返回None

嵌套函数

def func():
    [statements]
    def func_inner():
        [statements]

lambda 如何从外部作用域引用变量?

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f=make_incrementor(1)
>>> f(0)
1

函数的闭包

在一个外函数中定义了一个内函数，内函数里运用了外函数的变量，并且外函数的返回值是对内函数的引用
闭包变量实际上只有一份，每次开启内函数时都在使用同一份闭包变量
调用某些功能时，需要做一些准备工作
装饰器

def outer(x):
    b = [x]  # python 2.x

    def inner(y):
        nonlocal x  # python 3.x
        x += y
        b[0] += y
        return x

    return inner


f1 = outer(10)
print(f1(1))
print(f1(2))

------------------
11
13