字符串格式化输出
字符串格式化输出
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 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: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 = 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('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:str
number:int
postion:str
age:int
p1 = 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__被设为None3. 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: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建立类变量
在类中建立变量，默认是成员变量，若需要设置类变量，需要设置类型为：
ClassVarfrom dataclasses import dataclass from typing import ClassVar @dataclass class Player: name:str number:int postion:str age:int country: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。如果前面两个都不匹配，则输出最后的默认结果。
601
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
