python 常用方法记录

Mark_Aussie

已于 2024-10-30 09:56:10 修改

阅读量262

点赞数

分类专栏： Python 文章标签： python

于 2021-04-15 11:29:24 首次发布

本文链接：https://blog.youkuaiyun.com/MarkAustralia/article/details/115719839

版权

Python 专栏收录该内容

61 篇文章

订阅专栏

Python 打 whl 包

生成whl包命令：

从终端进入相应的项目目录下，如 D:\Algorithm\lib；

执行命令 python setup.py sdist bdist_wheel；

执行完后会在目录中生成四个文件夹，whl文件在dist目录中

判断列表b是否存在于列表a：

列表的交集

列表的并集

列表差集

合并python列表中的小列表：

注：使用sum(list, [])方法，有时会不好使

统计列表中制定元素数量：内置函数count() 的使用

字典反转的方法：

26英文字母编号：

letter = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# 构建字符索引 {0：'A', 1:'B'......}
num_letter = dict(enumerate(list(letter)))
# 键值对反转 {'A':0, 'B':1......}
letter_num = dict(zip(num_letter.values(), num_letter.keys()))

列表元素按字母排序：

按字母顺序排序 sort()，按字母排序，无法恢复到原来的排列顺序

>>> names.sort()
>>> names
['aodi', 'bigben', 'bmw']
>>> names
['aodi', 'bigben', 'bmw']

相反顺序排序 sort(reverse=True)

sort(reverse=True) 倒序排列单词 reverse 意为相反

>>> name = ['congcong', 'yuxi', 'jinghua', 'lili']

>>> name.sort(reverse=True)

>>> print(name)

['yuxi', 'lili', 'jinghua', 'congcong']

临时顺序排列 sorted

sorted()临时顺序排列，可以恢复到原来的排列顺序, 倒序排列(reverse=True)同样适用

>>> names
['aodi', 'bmw', 'bigben']
>>> names=['bigben','bmw','aodi']
>>> sorted(names)
['aodi', 'bigben', 'bmw']
>>> names
['bigben', 'bmw', 'aodi']

使用完之后依旧可以再回复原来的顺序(临时顺序排列)

倒序打印 reserve()

>>> names=['bigben','bmw','aodi']
>>> names.reverse()
>>> names
['aodi', 'bmw', 'bigben']

删除列表中的空列表：

list2 = [x for x in list1 if x != []]
list2 = filter(None, list1)

删除所有空字符串，空元组，零：list2 = [x for x in list1 if x]

python中的defaultdict:

from collections import defaultdict

使用普通的字典时，添加元素 dict[element] = value，调用：dict[element] = xxx，前提是element在字典里，如果不在字典里就会报错，此时可以使用 defaultdict，defaultdict 可接受一个工厂函数作为参数，如：list、set、str、dict，作用是当 key 不存在时返回工厂函数的默认值，如 list 对应[ ]，str对应的是空字符串，set 对应set( )，int 对应0。

如果defaultdict 未给出工厂函数类型，则<class 'dict'> 处为 None。

将列表字符串转为列表：

可使用 eval() 函数

>>> strs = "[1, 2, 3]"
>>> eval(strs)
[1, 2, 3]

python 类的 super() 方法：

Python 中类初始化使用 __init__()，父类和子类的初始化方式都是__init__()，如果子类初始化时没有这个函数，则直接调用父类 __init__()；如果子类指定了__init__()，则覆盖父类的初始化函数__init__()，如果想在进行子类的初始化的同时也继承父类的__init__()，要在子类中显示使用super() 调用父类的__init__()函数。

class Animal: # 定义一个父类
def __init__(self): # 父类的初始化
self.name = 'animal'
self.role = 'parent'
print('I am father')

class Dog(Animal): # 继承 Animal 的子类
def __init__(self): # 子类的初始化函数，此时会覆盖父类Animal类的初始化函数
super(Dog, self).__init__() # 子类初始化同时继承父类，使用super()，self.name= 'animal'
print('I am son')
self.name = 'dog' # 定义子类的name属性,并且会把刚才的self.name= 'animal'更新为'dog'

super(Dog,self) 可以写成super()，super(Dog,self).__init__() == Animal.__init__(self)，

super(Dog,self) == Animal 返回当前类的继承顺序中针对多继承Dog后的一个类（即Animal）

self 和 super的区别：self 首先调用自己的方法或者属性，当自身没有目标属性或方法时，再去父类中寻找；super会直接去父类中寻找目标属性或方法。如上，self.name 返回’dog’，而super().name的返回值为’animal’；self时类，super是预编译指令。

Error：RuntimeWarning: invalid value encountered in greater

可能是在比较数字是遇到了 nan 值导致的报错。

RuntimeError: Set changed size during iteration

循环操作set()元素时可能会遇到上面的报错，可使用添加copy()方法解决

max获取字符串列表中最长的字符串：

max(str, key=len)

内置函数 map

map()：根据提供的函数对指定的序列做映射。

第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。

函数依次作用在list中的每一个元素上，得到一个新的list并返回；map不改变原list，返回新list。

map(lambda x, y: x+y, [1,3,5,7,9], [2,4,6,8,10]) # 多个序列情况

不传入function时，map() 等同于zip()，将多个列表相同位置的元素归并到一个元组：

map(None, [2,4,6], [3,2,1])

类型转换：map(int,(1,2,3)) # 将元组转换为list

map(int,'1234') # 将字符串转换为list

提取字典中的key，并将结果放在一个list中，map(int,{1:2,2:3,3:4})

忽略告警输出的方法：

import warnings

方法一： warnings.warn("deprecated", DeprecationWarning)

不添加DeprecationWarning是增加告警，

添加DeprecationWarning是丢弃告警

方法二： warnings.filterwarnings("ignore") # 忽略告警

方法三： warnings.simplefilter("ignore") # 忽略告警

使用pickle保存和加载时报错‘TypeError: write() argument must be str, not bytes’：

Python中的str和repr

_str__：面向用户，用于显示；

__repr_：面向程序员，用于显示；

当输出一个类的实例时，如果__str__和__repr__都没有重写，则输出类地址；如果重写了，则输出方法返回值；如果两个方法都重写了，优先且只调用__str__方法；只重写一个方法，则会调用重写的方法；两个方法都要求返回值为字符串。

class Human:
def __init__(self, n):
self.name = n

def __str__(self):
return str(self.name) #这里的返回值必须为字符串

def __repr__(self):
return "2" #返回值也必须为字符串

单星号*和双星号**

*：用于解序列或可迭代对象，将元素分配给函数的参数或在列表、元组等数据中拼接。

**：用于解包字典，将其键值对传递给函数的参数或在字典中进行拼接。

都可用于传递可变数量的参数或关键字参数，以及在数据结构中进行拼接操作。

# 迭代器示例
numbers = [1, 2, 3, 4, 5]
iterator = iter(numbers)
first, *rest = iterator
print(first) # 输出：1
print(rest) # 输出：[2, 3, 4, 5]
# 生成器示例
def generate_numbers():
yield from range(1, 6)
first, *rest = generate_numbers()
print(first) # 输出：1
print(rest) # 输出：[2, 3, 4, 5]

@property装饰器的作用

添加@property装饰器的函数，可作为类的属性调用，即不需要添加()；

需要修改或删除属性时，需要使用setter和deleter方法。

加载JSON

json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

参数说明：
obj: 要编码的Python对象（如字典、列表等）。
skipkeys: 默认为False。如果字典的键不是基本类型（str, int, float, bool, None），且skipkeys为True，则这些键会被跳过；如果为False，则引发TypeError。
ensure_ascii: 默认为True。如果确保输出为ASCII，则非ASCII字符将被转义。如果为False，则非ASCII字符会以\uXXXX的形式输出。
check_circular: 默认为True。检测容器类型中的循环引用，并引发ValueError以避免无限递归。
allow_nan: 默认为True。如果为True，则允许将NaN、Infinity、-Infinity编码为它们的JSON等价物。如果为False，则引发ValueError。
indent: 用于美化输出的缩进量（整数）。如果为None（默认值），则输出是紧凑的；如果为正值，则每个级别将缩进这么多空格。
separators: 默认为(', ', ': ')，用于指定元素之间和键值对之间的分隔符。
default: 一个函数，用于将不可序列化为JSON的对象转换为一个可序列化的对象。
sort_keys: 默认为False。如果为True，则字典的输出将按键排序。

import json

# 示例字典
data = {
'name': 'John Doe',
'age': 30,
'is_student': False,
'courses': ['Math', 'Science'],
'null_value': None
}

# 转换为JSON字符串，不使用缩进
json_str = json.dumps(data)
print(json_str)

# 转换为JSON字符串，使用缩进和确保非ASCII字符不转义
json_pretty = json.dumps(data, indent=4, ensure_ascii=False)
print(json_pretty)

# 自定义分隔符
json_custom_sep = json.dumps(data, separators=(',', ':'))
print(json_custom_sep)

# 转换包含特殊值（如NaN）的字典（需要allow_nan=True）
data_with_nan = {'value': float('nan')}
try:
json_with_nan = json.dumps(data_with_nan, allow_nan=True)
print(json_with_nan)
except ValueError as e:
print(e)

参考：

Python中的*（星号）和**(双星号）完全详解_python **符号-优快云博客

【python】 @property属性详解-优快云博客