s = ' jsadlk '.strip()
def choice():
if res:=isinstance(s, int): #如果res为真的话赋值给res
return res
else:return res
res = choice()
也可用于循环
while a:=True:
print('helloworld')
a = '你好'
b = '世界'
print(f'a={a} b={b}')
# a=你好 b=世界
# f-string在3.8中变得更加简洁
a = '你好'
b = '世界'
print(f'{a=} {b=}')
# a=你好 b=世界
还添加了赋值符号!s和!f,制定输入结果格式
import datetime
time = datetime.datetime.now()
print(f'{time=!s}')
# time=2019-07-30 16:58:00.123412
import math
print(f'{math.pi=!f:.2f}') # 精确到小数点后面两位
新增了一个函数形参语法 / 用来指明某些函数形参必须使用仅限位置而非关键字参数的形式。 这种标记语法与通过 help() 所显示的使用 Larry Hastings 的 Argument Clinic 工具标记的 C 函数相同。在下面的例子中，形参 a 和 b 为仅限位置形参，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
#以下均为合法的调用:
f(10, 20, 30, d=40, e=50, f=60)
# 但是，以下均为不合法的调用:
f(10, b=20, c=30, d=40, e=50, f=60) # b cannot be a keyword argument
f(10, 20, 30, 40, 50, f=60) # e must be a keyword argument
以下均为合法定义
def name(p1, p2, /, p_or_kw, *, kw):
def name(p1, p2=None, /, p_or_kw=None, *, kw):
def name(p1, p2=None, /, *, kw):
def name(p1, p2=None, /):
def name(p1, p2, /, p_or_kw):
def name(p1, p2, /):
def name(p1, p2): #当然不加的话没有任何影响,和以前的没有区别
下面是有效的定义函数
def name(p_or_kw, *, kw):
def name(*, kw):
下面是无效的函数定义
def name(p1, p2=None, /, p_or_kw, *, kw): # p_or_kw也需要默认值
def name(p1=None, p2, /, p_or_kw=None, *, kw):
def name(p1=None, p2, /):
这种标记形式的一个用例是它允许纯 Python 函数完整模拟现有的用 C 代码编写的函数的行为。 例如，内置的 pow() 函数不接受关键字参数:
def pow(x, y, z=None, /):
"Emulate the built in pow() function"
r = x ** y
return r if z is None else r%z
另一个用例是在不需要形参名称时排除关键字参数。 例如，内置的 len() 函数的签名为 len(obj, /)。 这可以排除如下这种笨拙的调用形式:
len(obj='hello') # The "obj" keyword argument impairs readability
第三个用例是将形参标记为仅限位置形参将允许在未来修改形参名而不会破坏客户的代码。 例如，在 statistics 模块中，形参名 dist 在未来可能被修改。 这使得以下函数描述成为可能:
def quantiles(dist, /, *, n=4, method='exclusive')
...
由于在 / 左侧的形参不会被公开为可用关键字，其他形参名仍可在 **kwargs 中使用:
>>> def f(a, b, /, **kwargs):
... print(a, b, kwargs)
...
>>> f(10, 20, a=1, b=2, c=3) # a and b are used in two ways
10 20 {'a': 1, 'b': 2, 'c': 3}
这极大地简化了需要接受任意关键字参数的函数和方法的实现。例如，下面是collections模块中的代码摘录：
class Counter(dict):
def __init__(self, iterable=None, /, **kwds):
# Note "iterable" is a possible keyword argument
multiprocessing模块提供了SharedMemory类，可以在不同的Python进城之间创建共享的内存区域
__pycache__目录是由 Python3 解释器创建的，用于保存.pyc 文件。这些文件保存着解释器编译.py 文件之后的字节码（byte code）。之前的 Python 版本仅仅只是为每个.py 文件创建一个.pyc 文件，但是新版本会有所变化。
为了支持多版本的 Python，包括一些不是 CPython 的版本（如 PyPy），现在库文件会为每个 Python 版本创建对应的.pyc 文件，格式形如「name.interp-version.pyc」。例如，某个 foo.py 文件在第一次使用的时候会创建一个对应的 pyc 文件，其路径为「pycache/foo.cpython-37.pyc」，这个 pyc 文件会定义使用的 Python 版本。
asyncio.run()
已经从暂定状态晋级为稳定 API。 此函数可被用于执行一个 coroutine 并返回结果，同时自动管理事件循环。 例如:
import asyncioasync
def main():
await asyncio.sleep(0)
return 42
asyncio.run(main())
这大致等价于:
import asyncio
asyn def main():
await asyncio.sleep(0)
return 42
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(main())
finally:
asyncio.set_event_loop(None)
loop.close()
实际的实现要更复杂许多。 因此 asyncio.run() 应该作为运行 asyncio 程序的首选方式。
现在 dict 和 dictview 可以使用 reversed() 按插入顺序反向迭代。
Python 3.9引入了新的字典合并运算符(|)，它可以合并两个字典。下面是一个示例：
a = {'x': 1, 'y': 2}
b = {'y': 3, 'z': 4}
c = a | b
print(c) # {'x': 1, 'y': 3, 'z': 4}
在上面的代码中，我们首先定义了两个字典a和b，然后使用|运算符将它们合并成一个新的字典c。注意，如果两个字典中有相同的键，则使用后面的字典中的值。
Python 3.9引入了一种新的字符串对齐方法，它可以在字符串的左侧、右侧或中心添加填充字符。下面是一个示例：
s = 'hello'
print(s.ljust(10, '-')) # hello-----
print(s.rjust(10, '-')) # -----hello
print(s.center(10, '-')) # --hello---
在上面的代码中，我们使用ljust()方法将字符串s左对齐，并在右侧添加了-字符，使其总长度为10。类似地，rjust()方法将字符串右对齐，而center()方法将字符串居中对齐。
Python 3.9引入了一种新的语法，可以将类型提示标记为可选的。下面是一个示例：
def greet(name: str, *, greeting: str = 'Hello') -> str:
return f'{greeting}, {name}!'
在上面的代码中，我们定义了一个名为greet()的函数，并使用类型提示指定了参数和返回值的类型。注意，我们使用=符号将greeting参数标记为可选的，并使用*符号将其与name参数分开。
Python 3.9引入了一些新的浮点数方法和常量，包括math.isqrt()方法和math.tau常量。下面是一个示例：
import math
x = 16
print(math.isqrt(x)) # 4
print(math.tau) # 6.283185307179586
在上面的代码中，我们使用math.isqrt()方法计算x的平方根，并使用math.tau常量表示圆周率的两倍。
Python 3.9引入了一些新的异常处理机制，包括新的try语法、新的raise语法和新的异常类型。下面是一个示例：
try:
# some code that may raise an exception
except SomeException as e:
# handle the exception
else:
# execute if no exception is raised
finally:
# always execute
在上面的代码中，我们使用新的try语法来捕获可能会引发SomeException异常的代码块，并使用except语法处理异常。如果没有异常被引发，则执行else语句块。无论异常是否被引发，finally语句块都会被执行。
Python 3.9引入了一种新的装饰器语法，它可以在装饰器和函数之间省略括号。下面是一个示例：
@my_decorator
def my_function():
print('Hello, world!')
在上面的代码中，我们使用新的装饰器语法将my_decorator装饰器应用于my_function函数，而不需要使用括号。
Python 3.9引入了一些新的可迭代协议，包括__len__()方法和__getitem__()方法。下面是一个示例：
class MyList:
def __init__(self, items):
self.items = items
def __len__(self):
return len(self.items)
def __getitem__(self, index):
return self.items[index]
my_list = MyList([1, 2, 3])
for item in my_list:
print(item)
在上面的代码中，我们定义了一个名为MyList的类，并实现了__len__()方法和__getitem__()方法。这使得我们可以像使用标准列表一样使用my_list对象进行迭代。
Python 3.9引入了一些新的异步编程支持，包括新的async with语法和新的异步上下文管理器。下面是一个示例：
class AsyncContextManager:
async def __aenter__(self):
print('entering context')
async def __aexit__(self, exc_type, exc, tb):
print('exiting context')
async def my_coroutine():
async with AsyncContextManager():
print('inside context')
asyncio.run(my_coroutine())
在上面的代码中，我们定义了一个名为AsyncContextManager的异步上下文管理器，并使用新的async with语法将其应用于my_coroutine异步函数。这允许我们在异步代码中使用上下文管理器。
更好的模块解析
# my_package/__init__.py
from .my_module import my_function
# my_package/my_module.py
def my_function():
print('Hello, world!')
# main.py
from my_package import my_function
my_function()
在上面的代码中，我们定义了一个名为my_package的包，并从my_module模块中导入了my_function函数。我们可以在main.py模块中使用my_function函数，而不需要知道它来自哪个模块。
Python 3.9引入了一些新的注解支持，包括新的typing.Annotated类和新的typing.get_origin()函数。下面是一个示例：
from typing import Annotated
x: Annotated[int, 'positive']
y: Annotated[int, 'negative']
print(x.__metadata__) # ('positive',)
print(y.__metadata__) # ('negative',)
import typing
if typing.get_origin(Annotated[int, 'positive']) == int:
print('Annotated[int, "positive"] is a subclass of int')
在上面的代码中，我们使用Annotated类为变量x和y添加了元数据，并使用typing.get_origin()函数检查Annotated[int, ‘positive’]是否是int的子类。这使得我们可以更好地描述和处理类型信息。
在类型标注中现在你可以使用内置多项集类型例如 list 和 dict 作为通用类型而不必从 typing 导入对应的大写形式类型名 (例如 List 和 Dict)。 标准库中的其他一些类型现在同样也是通用的，例如 queue.Queue。示例:
def greet_all(names: list[str]) -> None:
for name in names:
print("Hello", name)
import() 现在会引发 ImportError 而不是 ValueError。
至于原因，在Python的官方文档中有相应的解释：后者曾经会在相对导入超出其最高层级包时发生。
在新增模块方面，zoneinfo模块为标准库引入了IANA 时区数据库。
这是一个基于系统时区数据的实体 datetime.tzinfo 实现
除了新增的模块外，Python3.9还对原有的一些模块进行了改进。
Prasoon举出了他认为比较重要的一项——Random。
名为random.Random.randbytes的方法，可以用于生成随机字节串
此外，还有cancel_futures。
Python3.9将新的 cancel_futures 形参，添加到 concurrent.futures.Executor.shutdown()，可以取消尚未开始运行的所有挂起的 Future，而不必等待它们完成运行再关闭执行器。
新版本简化了 Union Type 的使用 ，改为更为简洁的|
# 旧版
from typing import Uniona: Union[int, str] = 1
# 新版
a: str | int = 1
# 二者完全等价：
Union[int, str] == int | str # True
# 该特性也可用于 isinstance和issubclass
# True
isinstance("FunnySaltyFish", int|str)
# True
issubclass(str, str|int)
zip新增可选参数strict， 当该选项为True时，传入zip的两个可迭代项长度必须相等，否则将抛出 ValueError旧版（及不加此参数），当二者长度不等时，以长度较小的为准
# 旧版（及不加此参数），当二者长度不等时，以长度较小的为准
names = ["a","b","c","d"]
numbers = [1,2,3]
z = zip(names,numbers)
for each in z:
print(each) # ('a', 1)# ('b', 2)# ('c', 3)
设置strict为True
# ...
z = zip(names,numbers,strict=True)
# ...
d:\projects\python\learn\Py310探索.py in <module>
3 numbers = [1,2,3]
4 z = zip(names,numbers,strict=True)
----> 5 for each in z:
6 print(each)
ValueError: zip() argument 2 is shorter than argument 1
with可以加括号了
with (CtxManager() as example):
...
with (
CtxManager1(),
CtxManager2()
):
...
with (CtxManager1() as example,
CtxManager2()):
...
with (CtxManager1(),
CtxManager2() as example):
...
with (
CtxManager1() as example1,
CtxManager2() as example2
):
...
如
import pathlib
p = pathlib.Path()
p1 = p/"text1.txt" # 内容：文本1的内容
p2 = p/"text2.txt" # 内容：文本2的内容
with(
p1.open(encoding="utf-8") as f1,
p2.open(encoding="utf-8") as f2
):
print(f1.read(), f2.read(), sep="\n")
# 文本1的内容
# 文本2的内容
使用 TypeAlias 显式标注类型别名，提高可读性
旧的方式：
x = int
def plus_int(a:x,b:x) -> x:
return a+b
可以看到，x很容易被搞混新的方式：使用 TypeAlias表明这是个别名
from typing import TypeAlias
x : TypeAlias = int
def plus_int(a:x,b:x) -> x:
return a+b
Python 3.10 引入了结构化模式匹配，允许您匹配列表、元组和字典等数据结构中的模式。这可以使代码更简洁易读。例如：
# 匹配模式
def process_data(data):
match data:
case []:
print('没有数据')
case [x]:
print(f'一个项目：{x}')
case [x, y]:
print(f'两个项目：{x}，{y}')
case _:
print('超过两个项目')
subject：这在处理命令行参数的时候特别有用
"""
@copyright : [FunnySaltyFish](https://funnysaltyfish.github.io)
@date : 2021/10/05 21:08:42
"""
command = "save 1.txt"
# 试着把command改成 list / copy 1.txt 2.txt 看看效果
match command.split(" "):
case ["list"]:
print("列出文件~")
case ["save", file_name]:
print(f"保存文件到 {file_name}")
case ["copy",source,target]:
print(f"拷贝 {source} -> {target}")
也可以匹配对象：
class Person():
pass
class Student(Person):
def __init__(self, id: int) -> None:
self.id = id
class Teacher(Person):
def __init__(self, name: str) -> None:
self.name = name
a = Student(1)
# a = Student(2)
# a = Teacher("FunnySaltyFish")
match a:
case Student(id = 2):
print(f"这是位学生，且id正好是2")
case Student():
print(f"这是学生，id为{a.id}")
case Teacher():
print(f"这是老师, 姓名为{a.name}")
当然也可以匹配字典：
d = {
"name" : "李四", # 张三
"age" : 18,
"hobby" : "阅读"
}
match d:
case {"name":"张三", **args}:
# **收集其他参数
print("这是张三", args) # 这是张三 {'age': 18, 'hobby': '阅读'}
case {"name" : name , "age" : age, "hobby": hobby}:
print(f"我叫{name}, 今年{age}岁, 喜欢{hobby}") #我叫李四,今年18岁，喜欢阅读
约束项
match point:
case Point(x, y) if x == y:
print(f"The point is located on the diagonal Y=X at {x}.")
case Point(x, y):
print(f"Point is not on the diagonal.")
其他关键特性
case (Point(x1, y1), Point(x2, y2) as p2): ...
from enum import Enumclass Color(Enum):
RED = 0
GREEN = 1
BLUE = 2
match color:
case Color.RED:
print("I see red!")
case Color.GREEN:
print("Grass is green")
case Color.BLUE:
print("I'm feeling the blues :(")
现在，当你的括号、引号未闭合时，python会抛出更加清晰明了的错误
str = "未闭合的str
File "d:\projects\python\learn\Py310探索.py", line 90
str = "未闭合的str
^
SyntaxError: unterminated string literal (detected at line 90)
arr = [1, 2, 2, 3
File "d:\projects\python\learn\Py310探索.py", line 91
arr = [1, 2, 2, 3
^
SyntaxError: '[' was never closed
distutils 被弃用