Python零基础速成班-第19讲-Python 3.6到3.10新特性简介

Python零基础速成班-第19讲-Python 3.6到3.10新特性简介

学习目标

1. Python 3.6到3.10新特性简介

友情提示：将下文中代码拷贝到JupyterNotebook中直接执行即可，部分代码需要连续执行。

1、Python 3.6到3.10新特性简介

我总结了Python 3.6到3.11 的新特性，浓缩为以下内容：

1.1 Python3.6新特性

字符串 %s {} 的用法:
%s为字符串，%d为整数，%f为浮点数(%8.2f 表示保留8位整数，保留2位小数的浮点数)。
{}表示将固定值传入字符串中, .format(* value)表示传入的是元组tuple， .format(** value)表示传入的是字典dict。

print("%s %d %8.2f" %("one",50,3.1415))
print("{} {}".format("one",2))
print("X轴={},Y轴={},Z轴={}".format(*(8,7,6)))
print("name={name},age={age}".format(**{"name":"lulu","age":38}))

one 50     3.14
one 2
X轴=8,Y轴=7,Z轴=6
name=lulu,age=38

r" “的作用是去除转义字符，如正则表达式。
b” “的作用是表明后面字符串是bytes 类型。
f” “的作用是表示在字符串内支持大括号内的python 表达式，如f”{ a + b }"表示字符串中a、b 为变量值而不是字符a、b。

str1= 'input\n'
str2= r'input\n'
str3= b'\xe6\x88\x91\xe7\x9a\x84\xe5\xae\xb6\xe4\xb9\xa1'
print(str1) # print去掉\n 
print(str2) #转义符原样输出
print(str3.decode("utf-8"))

input

input\n
我的家乡

name = "linda"
age = "ten"
print(f"my name is {name} and {age} years old")

my name is linda and ten years old

a = 5
b = 10
print(f'five plus ten is {a + b} not {a * b}')

five plus ten is 15 not 50

连等的运用

x = y = z = 0
x = (y == z + 1)
print(x)

False

1.2 Python3.7新特性

在开发Python程序时，在使用breakpoint()函数的地方进入程序调试器，以便跟踪观察程序的运行情况。

def guess(target):
    user_guess = input("请输入你猜的数 >>> ")
    breakpoint()   #加入这一行进入调试模式
    if int(user_guess) == target:
        return "你猜对了!"
    else:
        return "猜错了"


if __name__ == '__main__':
    a = 100
    print(guess(a))

请输入你猜的数 >>> 1
猜错了

加入函数注解：能快速展示函数传入参数的类型和函数返回值类型，描述如何使用这个函数，同时help(函数名) 还可获取函数的帮助信息。

不带类型注解
def foo(bar, baz):

带类型注解
def foo(bar: ‘参数bar的描述’, baz: int) -> ‘函数返回值描述’：

"""猜数字游戏"""
def guess(target:'猜中数字')->'返回是否猜中的字符串':
    user_guess = input("请输入你猜的数 >>> ")
    if int(user_guess) == target:
        return "你猜对了!"
    else:
        return "猜错了"

if __name__ == '__main__':
    a = 100
    print(guess(a))

请输入你猜的数 >>> 100
你猜对了!

help(guess)

Help on function guess in module __main__:

guess(target: '猜中数字') -> '返回是否猜中的字符串'

新的时间函数使用后缀_ns。比如说，time.process_time()的纳秒版本是time.process_time_ns()纳秒，即一秒的十亿分之一，等于10的负9次方秒。

import time
print(time.process_time())
print(time.process_time_ns())

10.65625
10656250000

我们通常用time()来做时间的格式输出，也会用在测试代码时间上面。需要调用两次做差值，注意它会把sleep()的时间也算进去。
通常time.process_time()也用在测试代码时间上，需要调用两次做差值，注意process_time()不包括sleep()休眠时间。

import time
t0 = time.time()
p0 = time.process_time()
r = 0
for i in range(1000000):
    r += i
time.sleep(2)  #休眠2秒
t1 = time.time()
p1 = time.process_time()
spend1 = t1 - t0
spend2 = p1 - p0
print("time方法用时:%s"%spend1)
print("time_process方法用时:{}秒".format(spend2))

time方法用时:2.117649555206299
time_process方法用时:0.109375秒

1.3 Python3.8新特性

新的语法 :=，将值赋给一个更大的表达式中的变量。它被亲切地称为 “海象运算符”(walrus operator)，因为它长得像海象的眼睛和象牙。在下面的示例中，赋值表达式可以避免调用 len () 两次：

a = list()
for i in range(9):
    a.append(i)
print(len(a))
if (n := len(a)) <= 10:
    print(f"List is too long ({n} elements, expected <= 10)")

9
List is too long (9 elements, expected <= 10)

新增一个函数形参语法 “/” 用来指明某些函数形参必须使用仅限位置而非关键字参数的形式。
在下面的例子中，形参 a 和 b 为仅限位置形参，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参。

def f(a, b, /, c, d, *, e, f):

    print(a, b, c, d, e, f)
if __name__ == '__main__':
    f(10, 20, 30, d=40, e=50, f=60)

10 20 30 40 50 60

错误用法
f(10, b=20, c=30, d=40, e=50, f=60) # b 不可以是一个关键字参数
f(10, 20, 30, 40, 50, f=60) # e 必须是一个关键字参数

1.4 Python3.9新特性

字典“并集”运算符

d1 ={"姓名":"杨幂","身高":165,"民族":"汉族"}
d2 ={"姓名":"周杰伦","身高":175 }
print(d1 | d2)
d1 |= d2 #等同于上面语法，将并集结果赋值给d1
print(d1)

{'姓名': '周杰伦', '身高': 175, '民族': '汉族'}
{'姓名': '周杰伦', '身高': 175, '民族': '汉族'}

装饰器语法更加灵活。

Python的修饰器（decorator）是一个非常强大的功能，一种优秀的设计模式，将重复的内容抽象出来，赋予一个函数其他的功能，但又不去改变函数自身。使得代码极其简洁，易于维护。一些常见的案例是程序日志记录和调试。

如下例，我们定义修饰器@不再是一个函数名，而是lambda函数，返回函数的名称。

@(lambda f: lambda *_, **__: print(f.__name__))
def testfunction(a,b):
    pass
testfunction()

testfunction

classmethod 支持包装其他描述器：Python3.9可以结合 classmethod 和 property 轻松创造出一个类的属性(在 3.8 及之前的版本中，开发者需要手工实现一个描述器以支持类似的功能)。

class MyStudy:
    @classmethod
    @property
    def hover(cls):
        return"i like python"
MyStudy.hover

'i like python'

1.5 Python3.10新特性

结构化模式匹配：match…case，关键字 match 后跟变量名。 如果匹配，则将执行 case 块内的语句, 没有匹配，则执行 case _ 块内的语句。

for i in [1,2,3,4,5,6,7]:
    match i:
        case 1:
            print('周一')
        case 2:
            print('周二')
        case 3:
            print('周三')
        case 4:
            print('周四')
        case 5:
            print('周五')
        case _:
            print('周末')

新型联合运算符，以 X|Y 的形式引入了新的类型联合运算符。

def square(number: int|float): 
    return number ** 2

print(square(4))
print(square(4.4))

zip 的严格模式，函数 zip() 增加 strict 参数，如果设置 strict = True，而传输的参数的长度不相等将会抛出异常。

x = [1,2,3,4,5]
y = [1,2,3]
z = zip(x,y, strict=True)
print(list(z))

字典增加了 mapping 属性，dict.items()、dict.keys()、dict.values() 分别增加了 mapping 属性。

x = {'name': '张三', 'age': 14}
keys = x.keys()
values = x.values()
items = x.items()
print(keys.mapping)
print(values.mapping)
print(items.mapping)