Python入门【formatted字符串字面值、字符串新方法、变量类型标注、二进制表示中频率为1的数量统计、字典的三个方法新增mapping属性、字典合并】(三十一)

艾派徳

已于 2023-08-19 21:36:14 修改

阅读量323

点赞数

分类专栏： python入门到实战文章标签： python formatted 字符串新方法

于 2023-08-19 19:21:35 首次发布

本文链接：https://blog.csdn.net/abc19991119/article/details/132365757

版权

python入门到实战专栏收录该内容

35 篇文章 19 订阅

订阅专栏

本文介绍了Python3.10中的新特性，如formatted字符串的便捷使用、变量类型注解的简化、字典方法的mapping属性和match语法的应用，展示了Python在编程效率和代码可读性上的提升。

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

👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人

🔥🔥🔥 python入门到实战专栏：从入门到实战

🔥🔥🔥 Python爬虫开发专栏：从入门到实战

🔥🔥🔥 Python办公自动化专栏：从入门到实战

🔥🔥🔥 Python数据分析专栏：从入门到实战

🔥🔥🔥 Python前后端开发专栏：从入门到实战

formatted字符串字面值

formatted字符串是带有’f’字符前缀的字符串，可以很方便的格式化字符串

#旧版本
name = '小tong程序员'
print('公司是：%s'%name)
print('公司是：{}'.format(name))

#新版本
print(f'欢迎加入：{name}')
languages = ['Python','SQL']
print(f'课程包含:{languages[0]},{languages[1]}等多种开发技术')
#格式化字符串字面值（formatted string literal），可以在字符串常量内使用嵌入的Python表达式。
a = 5
b = 10
print(f'表达式运算的结果：{2*(a+b)}')

formatted字符串支持 =

user = 'txc'
info = f'{user=}'
print(info) # user=txc
#指定格式输出
name = 'xiaotong'

#旧版本
print('{:*^20}'.format(name))

#新版本
print(f'{name:*^20}')
#数值类型的格式化输出
num = 10
print(f'{num=:.2f}') # num=10.00   :.2f代表控
制输出2个小数
pct = 0.834

#旧版本
print('{:.2f}%'.format(pct*100))

#新版本
print(f'{pct*100:.2f}%')

字符串新方法

方法名	功能描述
str.removeprefix()	如果str以它开头的话，将会返回一个修改过前缀的新字符串，否则它将返回原始字符串。
str.removesuffix()	如果str以其结尾，则返回带有修改过后缀的新字符串，否则它将返回原始字符串。

info = 'APSXT'
print(info.removeprefix('APS'))
print(info.removesuffix('XT'))

变量类型标注

变量类型注解是用来对变量和函数的参数返回值类型做注解（暗示），帮助开发者写出更加严谨的代码，让调用方减少类型方面的错误，也可以提高代码的可读性和易用性。

但是，变量类型注解语法传入的类型表述能力有限，不能说明复杂的类型组成情况，因此引入了 typing 模块，来实现复杂的类型表达。

常用的数据类型

Type	Description
int	整型 integer
float	浮点数字
bool	布尔（int 的子类）
str	字符 (unicode)
bytes	8 位字符
object	任意对象（公共基类）
List[str]	字符组成的列表
Tuple[int, int]	两个int对象的元组
Tuple[int, ...]	任意数量的 int 对象的元组
Dict[str, int]	键是 str 值是 int 的字典
Iterable[int]	包含 int 的可迭代对象
Sequence[bool]	布尔值序列（只读）
Mapping[str, int]	从 str 键到 int 值的映射（只读）
Any	具有任意类型的动态类型值
Union	联合类型
Optional	参数可以为空或已经声明的类型
Mapping	映射，是 collections.abc.Mapping 的泛型
MutableMapping	Mapping 对象的子类，可变
Generator	生成器类型, Generator[YieldType、SendType、ReturnType]
NoReturn	函数没有返回结果
Set	集合 set 的泛型, 推荐用于注解返回类型
AbstractSet	collections.abc.Set 的泛型，推荐用于注解参数
Sequence	collections.abc.Sequence 的泛型，list、tuple 等的泛化类型
TypeVar	自定义兼容特定类型的变量
Generic	自定义泛型类型
NewType	声明一些具有特殊含义的类型
Callable	可调用类型, Callable[[参数类型], 返回类型]
NoReturn	没法返回值

注意：

1、mypy是Python的可选静态类型检查器。

2、安装mypy模块

3、使用mypy进行静态类型检查 mypy 执行python文件

基本使用

from typing import List, Set, Dict, Tuple

# 对于简单的 Python 内置类型，只需使用类型的名称
x: int = 1
x: float = 1.0
x: bool = True
x: str = "test"
x: bytes = b"test"
# 对于 collections ，类型名称用大写字母表示，并且
# collections 内类型的名称在方括号中
x: List[int] = [1]
x: Set[int] = {6, 7}
# 对于映射，需要键和值的类型
x: Dict[str, float] = {'field': 2.0}
# 对于固定大小的元组，指定所有元素的类型
x: Tuple[int, str, float] = (3, "yes", 7.5)
# 对于可变大小的元组，使用一种类型和省略号
x: Tuple[int, ...] = (1, 2, 3)

简化变量类型标注

languages : list[str] = ['a','b','c']
y :dict[str,int] = {'a':1,'b':2}    
x:set[int] = {1,2,3,4}
x:tuple[str,int,int] = ('a',1,2)
#定义可变大小的可以使用省略号
x:tuple[int,...] = (1,2,3)

函数参数返回值添加类型标注

# 注释函数定义的方式
def stringify(num: int) -> str:
    return str(num)
# 指定多个参数的方式
def plus(num1: int, num2: int) -> int:
    return num1 + num2
# 在类型注释后为参数添加默认值
def func1(num1: int, my_float: float = 3.5)
-> float:
    return num1 + my_float

from typing import Callable

def func1(num1:int,my_float:float=3.5) ->
str:
    return f'返回结果{num1+my_float}'
# Callable指向可调用（函数）值的方式, lambda 可以此方法
x: Callable[[int, float], str] = func1
print(x(20,30))

from typing import Iterator
# 产生整数的生成器函数安全地返回只是一个
# 整数迭代器的函数，因此这就是我们对其进行注释的方式
def g(n: int) -> Iterator[int]:
    i = 0
    while i < n:
        yield i
        i += 1
print(g(10))
for i in g(10):
    print(i)

混合类型检查改进

联合运算符使用“|”线来代替了就版本中Union[]方法，使得程序更加简洁。

#旧版本
from typing import Union
def oldFunc(para:Union[int,float])- >Union[int,float]:
    return para**2
#调用
oldFunc(10)

#新版本
def newFunc(para:int|float)-> int|float:
    return para+10
print(newFunc(10))
print(newFunc(10.10))

类型别名更改

之前是直接通过不同类型的赋值操作来赋予类型新的名字，在新版本中通过TypeAlias来规定了类型名字的替换。这样操作的优势在于能够让程序开发人员和Python编辑器更加清楚的知道newname是一个变量名还是一个类型的别名，提升程序开发的可靠性。

#旧版本
oldname = str
def oldFunc(param:oldname) -> oldname:
    return param + param
oldFunc('oldFunc:艾派徳')

#新版本
from typing import TypeAlias
newname: TypeAlias = str
def newFunc(param:newname) -> newname:
    return param + param
newFunc('newFunc:艾派徳')

二进制表示中频率为1的数量统计

通过调用bit_count函数来统计二进制中数字“1”的个数。

# bit_count()函数
#旧版本
value = 5
print(bin(value).count("1"))
#新版本
print(value.bit_count())

字典的三个方法新增mapping属性

mydict = {"一":1,"二":2,"三":3}

#旧版本
print(mydict.keys(),mydict.values(),mydict.items())

#新版本
keys = mydict.keys()
values = mydict.values()
items = mydict.items()
print(keys.mapping,values.mapping,items.mapping)

在Python3.10中，针对于字典的三个方法，items，keys，和 values都增加了一mapping属性，通过上诉的程序可以发现，对三个方法调用mapping属性后都会返回原字典数据。

函数zip()新增strict参数

keys = ['one','two','three','four']
values = [1,2,3,4,5]
#旧版本
print(dict(zip(keys,values)))
#新版本
print(dict(zip(keys,values,strict=True)))

对于zip函数加了strict参数，顾名思义strict参数就是要严格的通过参数长度的匹配原则，在以上代码中，keys和values列表的长度并不一致。旧版本的zip函数会根据长度最短的参数创建字典。新版本的zip函数中，当设定strict参数为True，则要求zip的输入数必须要长度一致，否则报错。

dataclass

为了支持数据修改, 默认值, 比较等功能。更加好一些的方法是：使用自定义类来实现数据类。

class Player:
    def
__init__(self,name:str,number:int,postion:str,age:int = 18) -> None:
        self.name = name
        self.number = number
        self.postion = postion
        self.age = age
    def __repr__(self) -> str:
        return f'Player: {self.name} {self.number}'
    def __eq__(self, __o: object) -> bool:
        return self.age == __o.age
    def __gt__(self,__o: object) ->bool:
        return self.age > __o.age
p1 = Player('apd',18,'PG',26)
print(p1)

缺点

1、__init__ 方法中重复代码 (示例中每个属性都需要写3遍)

2、需要自己实现 __repr__ 方法, 和比较方法 __eq__ , __gt__ 等

使用dataclass

dataclass 可以认为是提供了一个简写 __init__ 方法的语法糖，类型注释是必填项 (不限制数据类型时, 添加typing.Any为类型注释), 默认值的传递方式和 __init__ 方法的参数格式一致。

from dataclasses import dataclass
from typing import ClassVar
@dataclass
class Player:
    name:str
    number:int
    postion:str
    age:int
p1 = Player('apd',18,'PG',26)
print(p1)

优点

可以使用 dataclasses 模块中的其它方法，比如：

1、转为字典 asdict

2、转为元组 astuple

dataclass装饰器上的参数

dataclass 装饰器将根据类属性生成数据类和数据类需要的方法。

dataclasses.dataclass(*, init=True,
repr=True, eq=True, order=False,
unsafe_hash=False, frozen=False)

key	含义
init	指定是否自动生成 __init__ ，如果已经有定义同名方法则忽略这个值，也就是指定为True也不会自动生成
repr	同init，指定是否自动生成 __repr__ ；自动生成的打印格式为 class_name(arrt1:value1, attr2:value2, ...)
eq	同init，指定是否生成 __eq__ ；自动生成的方法将按属性在类内定义时的顺序逐个比较，全部的值相同才会返回True
order	自动生成 __lt__ ， __le__ ， __gt__ ， __ge__ ，比较方式与eq相同；如果order指定为True而eq指定为False，将引发 ValueError ；如果已经定义同名函数，将引发 TypeError
unsafehash	如果是False，将根据eq和frozen参数来生成 __hash__ : 1. eq和frozen都为True， __hash__ 将会生成 2. eq为True而frozen为False， __hash__ 被设为 None 3. eq为False，frozen为True， __hash__ 将使用超类（object）的同名属性（通常就是基于对象id的hash）当设置为True时将会根据类属性自动生成 __hash__ ，然而这是不安全的，因为这些属性是默认可变的，这会导致hash的不一致，所以除非能保证对象属性不可随意改变，否则应该谨慎地设置该参数为 True
frozen	设为True时对field赋值将会引发错误，对象将是不可变的，如果已经定义了 __setattr__ 和 __delattr__ 将会引发 TypeError

dataclass成员变量额外设置

可以通过 dataclass.filed 方法设置变量的额外功能

defualt:设置默认值

值为具体的值

default_factory:设置默认值

值为类型名，程序会根据类型名创建一个空的对象，若使用defualt设置需要手动创建空对象

repr设置生成的 __repr__ 方法中是否加入此属性,默认是True

from dataclasses import dataclass
@dataclass
class Player:
    name:str
    number:int
    postion:str
    age:int=field(default=19,repr=False)
    # 引用类型可以通过default_factory初始化参数
    country:str= field(default_factory=str) # country:str= field(default='')

dataclass建立类变量

在类中建立变量，默认是成员变量，若需要设置类变量，需要设置类型为： ClassVar

from dataclasses import dataclass
from typing import ClassVar
@dataclass
class Player:
    name:str
    number:int
    postion:str
    age:int
 country:ClassVar[str]
p1 = Player('aps',18,'PG',26)
print(p1)

字典合并

字典添加两个新的运算符：[|]和[|=]。[|]运算符用于合并字典。 [|=]用于更新字典。

dict1 = {'name':'aps'}
dict2 = {'type':'IT'}
#旧版本
dict1.update(dict2)
print(dict1)
#新版本
dict3 = dict1 | dict2
print(dict3)  # {'name': 'aps', 'type':'IT'}
#[|=]
dict1 |= dict2  # 等价于dict1 = dict1 | dict2
print(dict1)

match语法

match...case结构化模式匹配，可以匹配字典、类以及其他更复杂的结构。match...case的匹配模式匹配于Java或C++中的switch的使用很相似。

# 语句结构
'''
match subject:
   case <pattern_1>:
       <action_1>
   case <pattern_2>:
       <action_2>
   case <pattern_3>:
       <action_3>
   case _:
       <action_wildcard>
'''

status = 200
match status:
    case 200:
        print('访问成功')
    case 404:
        print('页面丢了')
    case _:
        print('不能识别')

#模式匹配
person1 = ('James',23,'male')
person2 = ('Lili',33,'female')
person3 = ('Mary',34,'female')
def func(person):
    match person:
        case (name,_,'female'):
            print(f'{name} is woman')
        case (name,_,'male'):
            print(f'{name} is man')
        case (name,age,gender):
            print(f'{name} is {age} old')
#调用函数
func(person1)
func(person2)
func(person3)

上述代码中，case函数通过匹配元组，如果元组第三个参数是 “female”，匹配到第一个case。如果元组第三个参数是“male”，匹配到第二个case。如果前面两个都不匹配，则输出最后的默认结果。