Ajoutez dynamiquement des attributs et générez des objets dans les classes Python

Cet article résoudra le problème un par un à travers les aspects suivants

1. Principales fonctions du programme

2. Mise en œuvre process

3. Définition de la classe

4. Utiliser le générateur pour mettre à jour dynamiquement chaque objet et renvoyer l'objet

5. Utiliser strip pour supprimer les caractères inutiles

6. rematcher la chaîne correspondante

7. Utilisez timestrptime pour extraire la chaîne et la convertir en un objet temporel

8. Code complet

Principales fonctions du programme

Il existe désormais un document sous forme de tableau qui stocke les informations utilisateur : la première ligne est Attributs, chaque attribut est séparé par des virgules (,). À partir de la deuxième ligne, chaque ligne est la valeur correspondant à chaque attribut, et chaque ligne représente un utilisateur. Comment lire ce document et générer un objet utilisateur par ligne ?
Il y a aussi 4 petites exigences :

Chaque document est très volumineux. Si autant d'objets générés par toutes les lignes sont stockés dans une liste et renvoyés en même temps, la mémoire s'effondrera. Un seul objet généré par ligne peut être stocké dans le programme à la fois.

Chaque chaîne séparée par des virgules peut être précédée ou suivie de guillemets doubles (") ou de guillemets simples ('). Par exemple, "Zhang San", les guillemets doivent être supprimés ; si c'est un nombre, il peut être quelque chose comme 000000001.24 , vous devez supprimer tous les chiffres et 0 précédents et extraire 1.24

Il y a une heure dans le document, qui peut être sous la forme du 29/10/2013, ou elle peut être sous la forme du 29/10/2013 2:23:56, Pour convertir une telle chaîne en un type d'heure

il existe de nombreux documents de ce type, chacun avec des attributs différents. Par exemple, il s'agit d'informations utilisateur, et il s'agit des enregistrements d'appels, donc les attributs spécifiques de la classe sont qui doivent être générés dynamiquement en fonction de la première ligne du document

Processus de mise en œuvre

1. Définition de la classe

Étant donné que les attributs sont ajoutés dynamiquement, les paires attribut-valeur sont également ajoutées dynamiquement. La classe doit contenir deux fonctions membres

et <.>. De plus, utilisez une liste updateAttributes（） pour stocker les attributs et les dictionnaires updatePairs（）Mappage de stockage. La fonction attributes est un constructeur avant attrilist indique une variable privée et ne peut pas être appelée directement à l'extérieur. Il suffit de init()__attributesa=UserInfo()

class UserInfo(object):
 'Class to restore UserInformation'
 def __init__ (self):
  self.attrilist={}
  self.__attributes=[]
 def updateAttributes(self,attributes):
  self.__attributes=attributes
 def updatePairs(self,values):
  for i in range(len(values)):
   self.attrilist[self.__attributes[i]]=values[i]

2. Mettre à jour dynamiquement chaque objet avec un générateur et renvoyer l'objet

. Le générateur est équivalent à une fonction qui ne doit être initialisée qu'une seule fois et peut être exécutée automatiquement plusieurs fois, renvoyant un résultat à chaque fois. Cependant, la fonction utilise
pour renvoyer le résultat, tandis que le générateur utilise

pour renvoyer le résultat à chaque fois. Toutes les exécutions reviennent à

, et l'exécution suivante commence après return . Par exemple, nous implémentons la séquence de Fibonacci en utilisant des fonctions et des générateurs : yield <🎜. >yieldyield

On calcule les 6 premiers nombres de la suite :

def fib(max):
 n, a, b = 0, 0, 1
 while n < max:
  print(b)
  a, b = b, a + b
  n = n + 1
 return &#39;done&#39;

Si vous utilisez un générateur, il suffit de changer

>>> fib(6)
1
1
2
3
5
8
'done'

par

C'est tout :

print yield

Comment utiliser :

def fib(max):
 n, a, b = 0, 0, 1
 while n < max:
  yield b
  a, b = b, a + b
  n = n + 1

Vous pouvez voir que le générateur fib lui-même est un objet. Chaque fois qu'il est exécuté pour produire, il s'interrompra et renverra un résultat la prochaine fois, il continuera à s'exécuter à partir de la suivante. ligne de code dans

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>
>>> for i in f:
...  print(i)
... 
1
1
2
3
5
8
>>>

. Le générateur peut également être exécuté avec

Dans mon programme, le code de la pièce du générateur est le suivant : yieldgenerator.next()

.

où,

def ObjectGenerator(maxlinenum):
 filename='/home/thinkit/Documents/usr_info/USER.csv'
 attributes=[]
 linenum=1
 a=UserInfo()
 file=open(filename)
 while linenum < maxlinenum:
  values=[]
  line=str.decode(file.readline(),&#39;gb2312&#39;)#linecache.getline(filename, linenum,&#39;gb2312&#39;)
  if line==&#39;&#39;:
   print&#39;reading fail! Please check filename!&#39;
   break
  str_list=line.split(&#39;,&#39;)
  for item in str_list:
   item=item.strip()
   item=item.strip(&#39;\"&#39;)
   item=item.strip(&#39;\&#39;&#39;)
   item=item.strip(&#39;+0*&#39;)
   item=catchTime(item)
   if linenum==1:
    attributes.append(item)
   else:
    values.append(item)
  if linenum==1:
   a.updateAttributes(attributes)
  else:
   a.updatePairs(values)
   yield a.attrilist #change to &#39; a &#39; to use
  linenum = linenum +1

est la classe

Instanciation Parce que le document est encodé en gb2312, la méthode de décodage correspondante est utilisée ci-dessus Puisque la première ligne est l'attribut, il existe une fonction pour. stockez la liste d'attributs dans

, c'est-à-dire que les lignes après

doivent stocker les attributs. -Les paires de valeurs sont lues dans un dictionnaire et stockées. Le dictionnaire dans a=UserInfo() est équivalent à une carte.<🎜. >UserInfoUserInfoupdateAttributes();3. Utilisez strip pour supprimer les caractères inutiles p.s.python

À partir du code ci-dessus, vous pouvez voir que l'utilisation de peut supprimer le caractères avant et après str.
peut être un symbole ou une expression régulière, comme ci-dessus :

str.strip(somechar)somecharsomechar

item=item.strip()#除去字符串前后的所有转义字符，如\t,\n等
item=item.strip('\"')#除去前后的"
item=item.strip('\'')
item=item.strip('+0*')#除去前后的+00...00，*表示0的个数可以任意多，也可以没有

4.re.match caractères correspondants Chaîne

Syntaxe de la fonction :

Description du paramètre de fonction :

re.match(pattern, string, flags=0)

Paramètres Description

pattern Expression régulière correspondante

string La chaîne à rechercher.

flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

若匹配成功re.match方法返回一个匹配的对象，否则返回None。`

>>> s='2015-09-18'
>>> matchObj=re.match(r'\d{4}-\d{2}-\d{2}',s, flags= 0)
>>> print matchObj
<_sre.SRE_Match object at 0x7f3525480f38>
1
2
3
4
5

5.使用time.strptime提取字符串转化为时间对象

在time模块中,time.strptime(str,format)可以把str按照format格式转化为时间对象，format中的常用格式有：

%y 两位数的年份表示（00-99）

%Y 四位数的年份表示（000-9999）

%m 月份（01-12）

%d 月内中的一天（0-31）

%H 24小时制小时数（0-23）

%I 12小时制小时数（01-12）

%M 分钟数（00=59）

%S 秒（00-59）

此外，还需要使用re模块，用正则表达式，对字符串进行匹配，看是否是一般时间的格式，如YYYY/MM/DD H:M:S, YYYY-MM-DD等

在上面的代码中，函数catchTime就是判断item是否为时间对象，是的话转化为时间对象。

代码如下：

import time
import re

def catchTime(item):
 # check if it's time
 matchObj=re.match(r'\d{4}-\d{2}-\d{2}',item, flags= 0)
 if matchObj!= None :
  item =time.strptime(item,'%Y-%m-%d')
  #print "returned time: %s " %item
  return item
 else:
  matchObj=re.match(r'\d{4}/\d{2}/\d{2}\s\d+:\d+:\d+',item,flags=0 )
  if matchObj!= None :
   item =time.strptime(item,'%Y/%m/%d %H:%M:%S')
   #print "returned time: %s " %item
  return item

完整代码：

import collections
import time
import re

class UserInfo(object):
 'Class to restore UserInformation'
 def __init__ (self):
  self.attrilist=collections.OrderedDict()# ordered
  self.__attributes=[]
 def updateAttributes(self,attributes):
  self.__attributes=attributes
 def updatePairs(self,values):
  for i in range(len(values)):
   self.attrilist[self.__attributes[i]]=values[i]

def catchTime(item):
 # check if it's time
 matchObj=re.match(r'\d{4}-\d{2}-\d{2}',item, flags= 0)
 if matchObj!= None :
  item =time.strptime(item,'%Y-%m-%d')
  #print "returned time: %s " %item
  return item
 else:
  matchObj=re.match(r'\d{4}/\d{2}/\d{2}\s\d+:\d+:\d+',item,flags=0 )
  if matchObj!= None :
   item =time.strptime(item,'%Y/%m/%d %H:%M:%S')
   #print "returned time: %s " %item
  return item


def ObjectGenerator(maxlinenum):
 filename='/home/thinkit/Documents/usr_info/USER.csv'
 attributes=[]
 linenum=1
 a=UserInfo()
 file=open(filename)
 while linenum < maxlinenum:
  values=[]
  line=str.decode(file.readline(),&#39;gb2312&#39;)#linecache.getline(filename, linenum,&#39;gb2312&#39;)
  if line==&#39;&#39;:
   print&#39;reading fail! Please check filename!&#39;
   break
  str_list=line.split(&#39;,&#39;)
  for item in str_list:
   item=item.strip()
   item=item.strip(&#39;\"&#39;)
   item=item.strip(&#39;\&#39;&#39;)
   item=item.strip(&#39;+0*&#39;)
   item=catchTime(item)
   if linenum==1:
    attributes.append(item)
   else:
    values.append(item)
  if linenum==1:
   a.updateAttributes(attributes)
  else:
   a.updatePairs(values)
   yield a.attrilist #change to &#39; a &#39; to use
  linenum = linenum +1

if __name__ == '__main__':
 for n in ObjectGenerator(10):
  print n  #输出字典，看是否正确

总结

以上就是这篇文章的全部内容，希望能对大家的学习或者工作带来一定帮助，如果有疑问大家可以留言交流，谢谢大家对PHP中文网的支持。

更多在python的类中动态添加属性与生成对象相关文章请关注PHP中文网！