字符串格式化输出
字符串格式化输出
formatted字符串是带有'f'字符前缀的字符串,可以很方便的格式化字符串
#旧版本
name = '泉信 '
print('公司是: %s'%name)
print('公司是: {}'.format(name))
#新版本
print(f'欢迎加入: {name}')
languages = ['Python','JAVA']
print(f'课程包含:{languages[0]},{languages[1]} 等多种开发技术 ')
#格式化字符串字面值(formatted string literal),可以在字符串常量内使用嵌入的Python表达 式。
a = 5
b = 10
print(f'表达式运算的结果: {2*(a+b)}')
formatted字符串支持 =
user = '泉信'
info = f'{user=}'
print(info) # user=SXT#指定格式输出
name = 'quanxin'
#旧版本
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 = '泉州'
print(info.removeprefix('泉'))
print(info.removesuffix('州'))
变量类型标注
变量类型注解是用来对变量和函数的参数返回值类型做注解(暗示),帮助开发者写出更加严谨的代码,让调用方减少类型方面的错误,也可以提高代码的可读性和易用性。
但是,变量类型注解语法传入的类型表述能力有限,不能说明复杂的类型组成情况,因此引入了 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 | 没法返回值 |
注意:
mypy是Python的可选静态类型检查器。
安装mypy模块
使用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 Callabledef 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 = 0while i < n:yield ii += 1print(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:QZ')
#新版本
from typing import TypeAlias
newname: TypeAlias = str
def newFunc(param:newname) -> newname:return param + param
newFunc('newFunc:QZ')
二进制表示中频率为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 = nameself.number = numberself.postion = postionself.age = agedef __repr__(self) -> str:return f'Player: {self.name} {self.number}'def __eq__(self, __o: object) -> bool:return self.age == __o.agedef __gt__(self,__o: object) ->bool:return self.age > __o.agep1 = Player('QZ',18,'PG',26)
print(p1)
缺点
__init__
方法中重复代码 (示例中每个属性都需要写3遍)需要自己实现
__repr__
方法, 和比较方法__eq__
,__gt__
等
使用dataclass
dataclass 可以认为是提供了一个简写__init__
方法的语法糖,类型注释是必填项 (不限制数据类型时, 添加typing.Any为类型注释), 默认值的传递方式和__init__
方法的参数格式一致。
from dataclasses import dataclass
from typing import ClassVar
@dataclass
class Player:name:strnumber:intpostion:strage:intp1 = Player('QZ',18,'PG',26)
print(p1)
优点
可以使用 dataclasses 模块中的其它方法,比如:
转为字典 asdict
转为元组 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__
方法中是否加入此属性,默认是Truefrom dataclasses import dataclass @dataclass class Player:name:strnumber:intpostion:strage: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:strnumber:intpostion:strage:intcountry:ClassVar[str]p1 = Player('QZ',18,'PG',26) print(p1)
字典合并
- 字典添加两个新的运算符:[|]和[|=]。[|]运算符用于合并字典。[|=]用于更新字典。
dict1 = {'name':'QZ'} dict2 = {'type':'二线'} #旧版本 dict1.update(dict2) print(dict1) #新版本 dict3 = dict1 | dict2 print(dict3) # {'name': 'sxt', '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。如果前面两个都不匹配,则输出最后的默认结果。