Artikelverzeichnis
Python-Video-Tutorial)
1. Behalten Sie die festgelegten Dezimalstellen für Dezimalstellen bei1.%f-Methode
f = 1.23456f1 = '%.4f' % f
f2 = '%.2f' % fprint(f1,type(f1))print(f2,type(f2))
1.2346 <class 'str'>1.23 <class 'str'>
Einfach zu Wissen Sie, diese Methode rundet den Gleitkommatyp, konvertiert ihn jedoch in einen Zeichenfolgenwert, der nicht mehr der ursprüngliche numerische Wert ist.
2.Format-Funktionf = 1.23456f1 = format(f,'.4f')f2 = format(f,'.2f')print(f1,type(f1))print(f2,type(f2))
1.2346 <class 'str'>1.23 <class 'str'>
In ähnlicher Weise rundet diese Methode auch, aber der Gleitkommatyp wird in einen Zeichenfolgenwert konvertiert, der nicht mehr der ursprüngliche numerische Wert ist.
3.round()-Funktiona = 1.23456b = 2.355c = 3.5d = 2.5a1 = round(a, 3)b1 = round(b, 2)c1 = round(c)d1 = round(d)print(a1,type(a1))print(b1,type(b1))print(c1,type(c1))print(d1,type(d1))
1.235 <class 'float'>2.35 <class 'float'>4 <class 'int'>2 <class 'int'>
Es ist ersichtlich, dass die Funktion „round()“ schließlich einen numerischen Wert (Gleitkomma oder Ganzzahl) erhält, jedoch in den Regeln „Rundung“ und „Rundung“. " Das oben Gesagte ist nicht unbedingt der Fall:
(1) In der Round(x,n)-Funktion hängt die Frage, ob übertragen oder gerundet werden soll, vom Wert von n Ziffern und n+1 Dezimalstellen ab (2) Nur wenn n+ 1 Ziffer ist 5, leicht zu verwechseln, wenn n eine gerade Zahl ist, dann ist die Ziffer n+1 5, dann wird der Übertrag zum Beispiel aus rund (1,23456, 3) schließlich 1,235
(3) Wenn n eine ungerade Zahl ist , dann ist die n+1-Ziffer die Zahl 5, dann gibt es keinen Übertrag, zum Beispiel rund (2,355, 2), der Endwert ist 2,35
(4) Wenn n 0 ist, das heißt, wenn n nicht ausgefüllt ist Das Endergebnis ist das Gegenteil von oben, das heißt, wenn der ganzzahlige Teil eine gerade Zahl ist, wird die Dezimalstelle 5 nicht übertragen. Beispiel: (Runde (2,5) wird zu 2).
(5) Wenn der ganzzahlige Teil eine ungerade Zahl ist, wird die Dezimalstelle auf 5 aufgerundet. (Runde (3,5) wird zu 4)
a = int(1.23456 * 1000) / 1000print(a)
1.234
1.234
这种方法简单粗暴，直接去掉后边的，不管是否大于5。
二、判断变量的数据类型
1.type():
a = 1.23print(type(a))
打印<class 'float'>。
2.isinstance()
原型为isinstance(x, A_tuple)，
a = 1.23tp = isinstance(a,float)print(tp)
打印True。
3.class.__name__属性
使用变量的__class__.__name__属性 ，这也是type()方法的实质：
num = 1.23print(num.__class__.__name__)
打印：
float
三、Python中的类方法(@classmethod)
python做面向对象编程的时候，经常需要使用classmethod类方法，这并不是类中的方法。
类方法也算一种实用的技巧，简单描述之：“类方法让类模板具有记忆力”。
类模板就是我们所定义的类。在普通情况下，不使用类方法对类进行实例化，类本身是不具有记忆性的。只是当一个静态模板被套用多次而已。如果我们想让类在每一次实例化之后，都能记载一些记忆，会对很多操作很有用。
class Man:
id = 0 # 类变量
def __init__(self, name):
self.name = name
self.id = self.id_number()
@classmethod
def id_number(cls):
cls.id += 1
return cls.id
a = Man('A')print(a.id)b = Man('B')print(b.id)打印
12
对Man这个类进行实例化2次，每个实例的id都不一样。这就依靠类方法来实现了：首先，用@classmethod描述类方法，然后用"cls"代表本类。类方法对类属性进行的处理是有记忆性的。
需要注意的是，类方法处理的变量一定要是类变量。因为在类方法里你用不了self来寻址实例变量，所以需要把类变量放到最前面描述，如上面的"id=0"所示。类变量是可以被self访问的，所以，在类变量定义好了以后，不需要在_init_函数里对类变量再一次描述。所以，上面代码里self.id不一定需要。
四、str.format与制表符t设置中文对齐
str.format对字符串进行格式化，{:<x}的语法表示左对齐，{:>x}为右对齐，{:^x}
1.type():
#name是包含中文的字符串，22是整个字符串一行的总长度，一般要顾及测试才能得到，\t后的x是一标记字符，可换为别的所需的字符串print('[{string:<{len}}\tx'.format(string=string+']',len=22-len(string.encode('GBK'))+len(string)))<class 'float'>. 🎜🎜🎜2.isinstance()🎜🎜🎜Der Prototyp ist <code>isinstance(x, A_tuple), 🎜class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0)
True aus. 🎜🎜🎜3.class.__name__-Attribut🎜🎜🎜Verwenden Sie das __class__.__name__-Attribut der Variablen, das auch die Essenz der type()-Methode ist: 🎜>>> import datetime>>>>>> datetime.timedelta(365).total_seconds() # 一年包含的总秒数31536000.0>>> dt = datetime.datetime.now()>>> dt + datetime.timedelta(3) # 3天后datetime.datetime(2020, 1, 22, 11, 17, 0, 214877)>>> dt + datetime.timedelta(-3) # 3天前datetime.datetime(2020, 1, 16, 11, 17, 0, 214877)>>> dt + datetime.timedelta(hours=3) # 3小时后datetime.datetime(2020, 1, 19, 14, 17, 0, 214877)>>> dt + datetime.timedelta(hours=-3) # 3小时前datetime.datetime(2020, 1, 19, 8, 17, 0, 214877)>>> dt + datetime.timedelta(hours=3, seconds=30) # 3小时30秒后 datetime.datetime(2020, 1, 19, 14, 17, 30, 214877)
def get_exception_info():
try:
s = 2 / 0
except Exception as e:
print('异常内容：', e.args[0])
print('异常行数：', e.__traceback__.tb_lineno)
print('异常文件：', e.__traceback__.tb_frame.f_globals["__file__"])get_exception_info()classmethod verwenden, die keine ist Methode in der Klasse. 🎜 Klassenmethoden sind ebenfalls eine praktische Technik, die einfach beschrieben wird: „Klassenmethoden machen Klassenvorlagen einprägsam.“ 🎜 Klassenvorlage ist die Klasse, die wir definieren. Wenn Sie unter normalen Umständen keine Klassenmethoden zum Instanziieren einer Klasse verwenden, verfügt die Klasse selbst über keinen Speicher. Gerade dann, wenn eine statische Vorlage mehrfach angewendet wird. Wenn wir möchten, dass die Klasse nach jeder Instanziierung etwas Speicher aufzeichnet, ist dies für viele Operationen nützlich. 🎜异常内容： pision by zero 异常行数： 8异常文件： XXX/test.py
text = """<p> <h1>Title</h1> <p>A long text........ </p> <a href=""> a link </a> </p>"""
@classmethod, um die Klassenmethode zu beschreiben, und verwenden Sie dann „cls“, um diese Klasse darzustellen. Die Verarbeitung von Klassenattributen durch Klassenmethoden wird gespeichert. 🎜🎜Es ist zu beachten, dass die von Klassenmethoden verarbeiteten Variablen Klassenvariablen sein müssen. Da Sie self nicht zum Ansprechen von Instanzvariablen in Klassenmethoden verwenden können, müssen Sie die Klassenvariablen an den Anfang der Beschreibung setzen, wie oben in „id=0“ gezeigt. Auf Klassenvariablen kann selbst zugegriffen werden, sodass nach der Definition der Klassenvariablen keine erneute Beschreibung der Klassenvariablen in der Funktion _init_ erforderlich ist. Daher ist self.id im obigen Code nicht unbedingt erforderlich. 🎜🎜🎜4. str.format und Tabulatorzeichen t legen die chinesische Ausrichtung fest 🎜🎜🎜str.format formatiert die Zeichenfolge, die Syntax von {:<x} bedeutet Linksausrichtung, {: >x} ist rechtsbündig, {:^x} ist zentriert) und weniger als x Ziffern werden automatisch vervollständigt (Standard ist Leerzeichenvervollständigung), bei chinesischen Zeichen ist dies jedoch der Fall Wird nicht gut unterstützt, daher kommt es zu einer Fehlausrichtung, wenn mehrere Zeilen chinesischer Zeichenfolgen vorhanden sind. Sie müssen die Länge der Zeichenfolge berücksichtigen und die chinesische Zeichenfolge vor der Berechnung codieren. 🎜from bs4 import BeautifulSoup text = """<p> <h1>Title</h1> <p>A long text........ </p> <a href=""> a link </a> </p>"""clean_text = BeautifulSoup(text, "lxml").textprint(clean_text)
timedelta对象表示两个不同时间之间的差值， 这个差值的单位可以是：天、秒、微秒、毫秒、分钟、小时、周。
如果使用time模块对时间进行算术运算，只能将字符串格式的时间和struct_time格式的时间对象先转换为时间戳格式，然后对该时间戳加上或减去n秒，最后再转换回struct_time格式或字符串格式，这显然很不方便。而datetime模块提供的timedelta类可以让我们很方面的对datetime.date, datetime.time和datetime.datetime对象做算术运算，且两个时间之间的差值单位也更加容易控制。
datetime.timedelta类的定义：
class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0)
所有参数都是默认参数，因此都是可选参数。参数的值可以是整数或浮点数，也可以是正数或负数。内部值存储days、seconds 和 microseconds，其他所有参数都将被转换成这3个单位：
然后对这3个值进行标准化，使得它们的表示是唯一的：
类属性：
| 类属性名称 | 描述 |
|---|---|
| timedelta.min | timedelta(-999999999) |
| timedelta.max | timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999) |
| timedelta.resolution | timedelta(microseconds=1) |
实例方法和属性：
| 实例方法/属性名称 | 描述 |
|---|---|
| td.days | 天 [-999999999, 999999999] |
| td.seconds | 秒 [0, 86399] |
| td.microseconds | 微秒 [0, 999999] |
| td.total_seconds() | 时间差中包含的总秒数，等价于: td / timedelta(seconds=1) |
| 方法/属性 | 描述 |
|---|---|
| datetime.datetime.now() | 返回当前本地时间（datetime.datetime对象实例） |
| datetime.datetime.fromtimestamp(timestamp) | 返回指定时间戳对应的时间（datetime.datetime对象实例） |
| datetime.timedelta() | 返回一个时间间隔对象，可以直接与datetime.datetime对象做加减操作 |
>>> import datetime>>>>>> datetime.timedelta(365).total_seconds() # 一年包含的总秒数31536000.0>>> dt = datetime.datetime.now()>>> dt + datetime.timedelta(3) # 3天后datetime.datetime(2020, 1, 22, 11, 17, 0, 214877)>>> dt + datetime.timedelta(-3) # 3天前datetime.datetime(2020, 1, 16, 11, 17, 0, 214877)>>> dt + datetime.timedelta(hours=3) # 3小时后datetime.datetime(2020, 1, 19, 14, 17, 0, 214877)>>> dt + datetime.timedelta(hours=-3) # 3小时前datetime.datetime(2020, 1, 19, 8, 17, 0, 214877)>>> dt + datetime.timedelta(hours=3, seconds=30) # 3小时30秒后 datetime.datetime(2020, 1, 19, 14, 17, 30, 214877)
更多关于Python对日期、时间的处理可参考https://www.jb51.net/article/105840.htm。
六、获取抛出的异常具体信息
很多时候，在Python运行抛出异常并接收到之后需要显示异常的具体信息，包括异常内容、异常所在的行数和异常所在的Python文件等等，分别使用args[0]、__traceback__.tb_lineno和__traceback__.tb_frame.f_globals["__file__"]属性即可，示意如下：
def get_exception_info():
try:
s = 2 / 0
except Exception as e:
print('异常内容：', e.args[0])
print('异常行数：', e.__traceback__.tb_lineno)
print('异常文件：', e.__traceback__.tb_frame.f_globals["__file__"])get_exception_info()打印：
异常内容： pision by zero 异常行数： 8异常文件： XXX/test.py
七、使用BeautifulSoup库去掉字符串中的HTML标签
有时候，字符串中含有HTML标签，如
text = """<p> <h1>Title</h1> <p>A long text........ </p> <a href=""> a link </a> </p>"""
需要得到'\nTitle\nA long text........ \n a link \n'，可以使用正则表达式匹配，但是稍嫌麻烦，此时可以直接使用BeautifulSoup库进行转化，更加简单，如下：
from bs4 import BeautifulSoup text = """<p> <h1>Title</h1> <p>A long text........ </p> <a href=""> a link </a> </p>"""clean_text = BeautifulSoup(text, "lxml").textprint(clean_text)
打印：
Title A long text........ a link
显然，此时已经去掉了字符串中的HTML标签。
相关免费学习推荐：python教程（视频）
Das obige ist der detaillierte Inhalt vonPraktische Erfahrungen und Fähigkeiten in der Python-Programmierentwicklung veröffentlicht. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
