【Python】：老鸟的入门笔记（4）

WEBJ2EE

发布于 2023-09-02 10:04:29

16500

代码可运行

文章被收录于专栏：WebJ2EEWebJ2EE

运行总次数：0

代码可运行

阅读本文大概需要 10 分钟。

提要

哈喽，大家好！继续分享我整理的一些Python3笔记

。

TL;DR

* 赋值

* 迭代

* 函数

* 作用域

* 参数

* 函数式编程工具

一、赋值

赋值语句创建对象引用
变量在首次赋值时会被创建
变量在引用前必须先赋值

# 序列赋值
nudge = 1
wink = 2
A, B = nudge, wink # 元组赋值
print(A, B)

[C, D] = [nudge, wink] # 列表赋值
print(C, D)

nudge, wink = wink, nudge # 数值交换
print(nudge, wink)

# 赋值语句右侧支持任意的可迭代对象
[a, b, c] = (1, 2, 3) 
print(a, b, c)
(a, b, c) = "KFC"
print(a, b, c)

((a, b), c) = ('SP', 'AM') # 支持嵌套
print(a, b, c)

a, b, c = 'TRUMP' # 右侧元素要与左侧变量保持数目相同

seq = [1, 2, 3, 4]
a, *b = seq
print(a, b)

*a, b = seq
print(a, b)

a, *b, c = seq
print(a, b, c)

a, b, c, *d = seq
print(d)

a, b, c, d, *e = seq
print(e)

*a, = seq
print(a)

# 多目标赋值是将最右侧的对象依次赋值给左侧所有的名称
# 要记住，在这里只有一个对象，但是由三个变量共享
a = b = c = []
print(a is b is c)

a.append(42)
print(a, b, c)

# += 对于列表而言是原位置修改
M = L = [1, 2]
M += [3, 4]
print(M, L)

# + 总是会产生新的对象
M = L = [1, 2]
M = M + [3, 4]
print(M, L)

二、迭代

可迭代对象：迭代的被调对象，其 __iter__ 方法被 iter 函数所调用
迭代器对象：可迭代对象的返回结果，在迭代过程中实际提供值的对象。它的 __next__ 方法被 next 运行，并在结束时触发 StopIteration 异常。

f = open('myfile.txt', 'r', encoding='utf-8')
print(f.readline())
print(f.readline())
print(f.readline())
print(f.readline())
f.close()

# 手动调用迭代协议
f = open('myfile.txt', 'r', encoding='utf-8')
i = iter(f)
print(next(i))
print(next(i))
print(next(i))
print(next(i))
f.close()

一些对象既是迭代上下文的工具（它们可以主动发起迭代），也是可迭代对象（它们的返回值可迭代）。
- 文件对象自身就是迭代器。
- 列表以及很多其他内置对象，由于自身不是迭代器，因此支持多次迭代。

f = open('myfile.txt', 'r', encoding='utf-8')
print(f is iter(f))

l = [1, 2, 3]
print(l is iter(l))

三、函数

def 是可执行的代码。当 Python 运行到 def 语句时，将生成一个新的函数对象并将其赋值给这个函数名。
lambda 创建一个对象并将其作为结果返回。

i = input('please input i:')

if i == '1':
    def m(i):
        return i ** 3
elif i == '2':
    def m(i):
        return i + 100
else:
    def m(i):
        return i ** 10

print(m(int(i)))

四、作用域

外围模块是全局作用域，全局作用域的作用范围仅限于单个文件。
赋值的变量名除非被生命为 global 或 nonlocal，否则均为局部变量。

# 默认情况下，
# 一个赋值（X = value）会创建或改变当前作用域中的变量名 X
X = 88

def func():
    X = 99
    print('inner', X)

func()
print('outer', X)

# global 声明会将变量映射至外层模块
X = 88

def func():
    global X
    X = 99
    print('inner', X)

func()
print('outer', X)

# X 在函数运行前的外围模块中并不存在，
# 函数内的第一条赋值语句将自动在模块中创建 X 这个变量
def func():
    global X
    X = 99
    print('inner', X)

func()
print('outer', X)

nonlocal 语句允许内嵌函数修改定义在语法上位于外层的函数的作用域中的一个或多个名称。
当执行到 nonloal 语句的时候，nonlocal 中列出的名称必须在一个外层的 def 中被提前定义过，否则将引发一个错误。

# 闭包
def count():
    cnt = 0
    def counter():
        nonlocal cnt
        cnt += 1
        return cnt
    return counter

counter = count()

print(counter())
print(counter())
print(counter())
print(counter())

# 循环变量可能需要默认值参数，而不是作用域（这里有点类似ES3的闭包问题）
def makeActions():
    acts = []
    for i in range(5):
        acts.append(lambda x: i ** x)
    return acts

acts = makeActions()
print('------')
print(acts[0](2))
print(acts[1](2))
print(acts[2](2))


def makeActions2():
    acts = []
    for i in range(5):
        acts.append(lambda x, i=i: i ** x)
    return acts
acts2 = makeActions2()
print('------')
print(acts2[0](2))
print(acts2[1](2))
print(acts2[2](2))

五、参数

参数的传递是通过自动将对象赋值给局部变量名来实现的。
在函数内部赋值参数名不会影响调用者。
改变函数的可变对象参数的值也许会对调用者有影响。
Python 提供了额外的工具，来改变调用中参数对象和头部的参数名的配对关系。
- 在函数调用时，参数必须按此顺序出现：所有基于位置的参数（value），之后是所有关键字参数（name=value）和 *iterable 形式的组合，之后是 **dict 形式。
- 在函数定时时，参数必须按此顺序出现：所有一般参数（name），之后是所有默认值参数（name=value），之后是 *name 形式，之后是所有 name 或 name=value 的 keyword-only 参数，之后是 **name 形式。

def f(a, b, c):
    print(a, b, c)

f(1, 2, 3)
f(c=3, b=2, a=1)
f(1, c=3, b=2)

关键字参数从本质上允许我们跳过带默认值的参数。

def f(a, b=2, c=3):
    print(a, b, c)


f(1)
f(a=1)
f(1, 4)
f(1, c=6) # 允许你跳过定义 b

def f(*pargs, **kargs):
    print(pargs, kargs)


f(1, 2, 3, a=1, b=2, c=3)
f(*[1, 2, 3], **{
    'a': 1,
    'b': 2,
    'c': 3
})

# keyword-only 参数——必须只按照关键字传入
# 并且永远不会被基于位置参数来填充的参数
def func(a, *b, c):
    print(a, b, c)

func(1, 2, 3, c=4)
func(1, c=4)
func(1)

六、函数式编程工具

from functools import reduce

L = [1, 2, 3, 4]
M = map(lambda x: x * 10, L)
print(list(M))

N = filter(lambda x: x > 2, L)
print(list(N))

O = reduce(lambda x, y: x+y, L)
print(O)