Expérience pratique et compétences en matière de développement de programmation Python publiées

Table des matières de l'article

• 1. Conserver les décimales désignées pour les décimales
• • 1. Méthode %f
  • Fonction 2.format
  • Fonction 3.round()
  • Troncation directe
• 2. Jugement Type de données de la variable
• • 1.type() :
  • 2.isinstance()
  • 3.__class__.__name__ attribut
• 3. Méthode de classe (@classmethod) en Python
• 4. str.format et caractère de tabulation pour définir l'alignement chinois
• 5. L'utilisation de
• 6. Obtenez les informations spécifiques de l'exception levée
• 7. Utilisez la bibliothèque BeautifulSoup pour supprimer les balises HTML dans la chaîne

(apprentissage gratuit recommandé : Tutoriel vidéo Python)

1 Les décimales doivent être conservées aux emplacements décimaux désignés.

Méthode 1.%f

f = 1.23456f1 = '%.4f' % f
f2 = '%.2f' % fprint(f1,type(f1))print(f2,type(f2))

Imprimer

1.2346 <class &#39;str&#39;>1.23 <class &#39;str&#39;>

Facile à connaître, cette méthode arrondira, mais convertira le type à virgule flottante dans une valeur de chaîne. Ce n'est plus la valeur d'origine.

Fonction 2.format

f = 1.23456f1 = format(f,'.4f')f2 = format(f,'.2f')print(f1,type(f1))print(f2,type(f2))

Print

1.2346 <class &#39;str&#39;>1.23 <class &#39;str&#39;>

De même, cette méthode arrondira également, mais convertira le type à virgule flottante en valeurs String ne sont plus des valeurs numériques primitives.

Fonction 3.round()

a = 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))

Print

1.235 <class &#39;float&#39;>2.35 <class &#39;float&#39;>4 <class &#39;int&#39;>2 <class &#39;int&#39;>

On voit que la fonction round() obtient finalement une valeur numérique (flottant type point ou type entier), mais les règles "d'arrondi" et "d'arrondi" ne sont pas forcément les mêmes :
(1) Dans la fonction round(x,n), le report ou l'arrondi dépend de n chiffres et n+1 chiffres décimaux La valeur de
(2) Il est facile de se tromper uniquement lorsque le chiffre n+1 est 5. Si n est un nombre pair, alors le chiffre n+1 est 5, alors reportez-vous, pour exemple, le tour (1,23456, 3) devient finalement 1,235
(3) Si n est un nombre impair, alors le chiffre n+1 est le nombre 5, et il n'y a pas de report, comme le tour (2,355, 2), la valeur finale est 2,35
(4) Si n est 0, il n'est pas renseigné Quand n, le résultat final est opposé à celui ci-dessus, c'est-à-dire que lorsque la partie entière est un nombre pair, la décimale 5 est non porté, par exemple (le tour (2,5) devient 2).
(5) Lorsque la partie entière est un nombre impair, la décimale est arrondie à 5. (le tour (3.5) devient 4)

4. Tronquer directement

a = int(1.23456 * 1000) / 1000print(a)

Imprimer 1.234
Cette méthode est simple et grossière, supprimez simplement ce qui suit, Qu'il soit supérieur ou non à 5.

2. Déterminez le type de données de la variable

1.type():

a = 1.23print(type(a))

Print<class &#39;float&#39;> .

2.isinstance()

le prototype est isinstance(x, A_tuple),

a = 1.23tp = isinstance(a,float)print(tp)

imprime True. L'attribut

3.class.__name__

utilise l'attribut __class__.__name__ de la variable, qui est aussi l'essence de la méthode type() :

num = 1.23print(num.__class__.__name__)

print :

float

3. Méthode de classe (@classmethod) en Python

Lorsque vous faites de la programmation orientée objet en python, vous devez souvent utiliser le 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)

3. 🎜> méthode de classe, qui n'est pas une méthode dans la classe. Les méthodes de classe sont également une technique pratique. Voici une description simple : "Les méthodes de classe rendent les modèles de classe mémorables."

Les modèles de classe sont des classes que nous définissons. Dans des circonstances normales, si vous n'utilisez pas de méthodes de classe pour instancier une classe, la classe elle-même n'a pas de mémoire. Juste au moment où un modèle statique est appliqué plusieurs fois. Si nous voulons que la classe enregistre de la mémoire après chaque instanciation, cela sera utile pour de nombreuses opérations.

12

Imprimer@classmethod

#name是包含中文的字符串，22是整个字符串一行的总长度，一般要顾及测试才能得到，\t后的x是一标记字符，可换为别的所需的字符串print('[{string:<{len}}\tx&#39;.format(string=string+&#39;]&#39;,len=22-len(string.encode(&#39;GBK&#39;))+len(string)))

Insérez la classe Man deux fois, et l'identifiant de chaque instance est différent. Ceci est réalisé en s'appuyant sur des méthodes de classe : utilisez d'abord

pour décrire la méthode de classe, puis utilisez "cls" pour représenter cette classe. Le traitement des attributs de classe par les méthodes de classe est mémorisé.

Il est à noter que les variables traitées par la méthode de classe doivent être des variables de classe. Étant donné que vous ne pouvez pas utiliser self pour traiter les variables d'instance dans les méthodes de classe, vous devez placer les variables de classe au début de la description, comme indiqué dans "id=0" ci-dessus. Les variables de classe sont accessibles par soi-même, donc une fois les variables de classe définies, il n'est pas nécessaire de décrire à nouveau les variables de classe dans la fonction _init_. Par conséquent, self.id n’est pas nécessairement nécessaire dans le code ci-dessus.

4. str.format et le caractère de tabulation définissent l'alignement chinois

{:<x}{:>x}str.format formate la chaîne, et la syntaxe de <code>{:^x} signifie l'alignement à gauche est aligné à droite, est centré), et inférieur à Si l'alignement échoue, vous devez prendre en compte la longueur de la chaîne et encoder la chaîne chinoise avant de calculer.

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0)

Pour plus de détails, veuillez vous référer à https://blog.csdn.net/excaliburrr/article/details/76794451

Utilisation de la classe timedelta dans le module datetime

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个单位：

• 1毫秒转换为1000微秒
• 1分钟转换为60秒
• 1小时转换为3600秒
• 1周转换为7天

然后对这3个值进行标准化，使得它们的表示是唯一的：

• microseconds : [0, 999999]
• seconds : [0, 86399]
• days : [-999999999, 999999999]

类属性：

类属性名称	描述
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教程（视频）

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!