Python-将CSV转换为对象-代码设计

我有一个小脚本，我们用来读取包含员工的CSV文件，并对这些数据执行一些基本操作

我们读入数据（import_gdu_dump），并创建一个

Employees

对象，其中包含

Employees

对象的列表（也许我应该考虑一个更好的命名约定…lol）。然后，我们在

员工

上调用

clean\u-all\u-phone\u-numbers（）

，在每个

员工

上调用

clean\u-phone\u-numbers（）

，在

员工

上调用

clean\u-phone\u-numbers（）

import csv
import re
import sys

#class CSVLoader:
#    """Virtual class to assist with loading in CSV files."""
#    def import_gd_dump(self, input_file='Gp Directory 20100331 original.csv'):
#        gd_extract = csv.DictReader(open(input_file), dialect='excel')
#        employees = []
#        for row in gd_extract:
#            curr_employee = Employee(row)
#            employees.append(curr_employee)
#        return employees
#    #self.employees = {row['dbdirid']:row for row in gd_extract}

# Previously, this was inside a (virtual) class called "CSVLoader".
# However, according to here (http://tomayko.com/writings/the-static-method-thing) - the idiomatic way of doing this in Python is not with a class-function but with a module-level function
def import_gd_dump(input_file='Gp Directory 20100331 original.csv'):
    """Return a list ('employee') of dict objects, taken from a Group Directory CSV file."""
    gd_extract = csv.DictReader(open(input_file), dialect='excel')
    employees = []
    for row in gd_extract:
        employees.append(row)
    return employees

def write_gd_formatted(employees_dict, output_file="gd_formatted.csv"):
    """Read in an Employees() object, and write out each Employee() inside this to a CSV file"""
    gd_output_fieldnames = ('hrid', 'mail', 'givenName', 'sn', 'dbcostcenter', 'dbdirid', 'hrreportsto', 'PHFull', 'PHFull_message', 'SupervisorEmail', 'SupervisorFirstName', 'SupervisorSurname')
    try:
        gd_formatted = csv.DictWriter(open(output_file, 'w', newline=''), fieldnames=gd_output_fieldnames, extrasaction='ignore', dialect='excel')
    except IOError:
        print('Unable to open file, IO error (Is it locked?)')
        sys.exit(1)

    headers = {n:n for n in gd_output_fieldnames}
    gd_formatted.writerow(headers)
    for employee in employees_dict.employee_list:
        # We're using the employee object's inbuilt __dict__ attribute - hmm, is this good practice?
        gd_formatted.writerow(employee.__dict__)

class Employee:
    """An Employee in the system, with employee attributes (name, email, cost-centre etc.)"""
    def __init__(self, employee_attributes):
        """We use the Employee constructor to convert a dictionary into instance attributes."""
        for k, v in employee_attributes.items():
            setattr(self, k, v)

    def clean_phone_number(self):
        """Perform some rudimentary checks and corrections, to make sure numbers are in the right format.
        Numbers should be in the form 0XYYYYYYYY, where X is the area code, and Y is the local number."""
        if self.telephoneNumber is None or self.telephoneNumber == '':
            return '', 'Missing phone number.'
        else:
            standard_format = re.compile(r'^\+(?P<intl_prefix>\d{2})\((?P<area_code>\d)\)(?P<local_first_half>\d{4})-(?P<local_second_half>\d{4})')
            extra_zero = re.compile(r'^\+(?P<intl_prefix>\d{2})\(0(?P<area_code>\d)\)(?P<local_first_half>\d{4})-(?P<local_second_half>\d{4})')
            missing_hyphen = re.compile(r'^\+(?P<intl_prefix>\d{2})\(0(?P<area_code>\d)\)(?P<local_first_half>\d{4})(?P<local_second_half>\d{4})')
            if standard_format.search(self.telephoneNumber):
                result = standard_format.search(self.telephoneNumber)
                return '0' + result.group('area_code') + result.group('local_first_half') + result.group('local_second_half'), ''
            elif extra_zero.search(self.telephoneNumber):
                result = extra_zero.search(self.telephoneNumber)
                return '0' + result.group('area_code') + result.group('local_first_half') + result.group('local_second_half'), 'Extra zero in area code - ask user to remediate. '
            elif missing_hyphen.search(self.telephoneNumber):
                result = missing_hyphen.search(self.telephoneNumber)
                return '0' + result.group('area_code') + result.group('local_first_half') + result.group('local_second_half'), 'Missing hyphen in local component - ask user to remediate. '
            else:
                return '', "Number didn't match recognised format. Original text is: " + self.telephoneNumber

class Employees:
    def __init__(self, import_list):
        self.employee_list = []    
        for employee in import_list:
            self.employee_list.append(Employee(employee))

    def clean_all_phone_numbers(self):
        for employee in self.employee_list:
            #Should we just set this directly in Employee.clean_phone_number() instead?
            employee.PHFull, employee.PHFull_message = employee.clean_phone_number()

    # Hmm, the search is O(n^2) - there's probably a better way of doing this search?
    def lookup_all_supervisors(self):
        for employee in self.employee_list:
            if employee.hrreportsto is not None and employee.hrreportsto != '':
                for supervisor in self.employee_list:
                    if supervisor.hrid == employee.hrreportsto:
                        (employee.SupervisorEmail, employee.SupervisorFirstName, employee.SupervisorSurname) = supervisor.mail, supervisor.givenName, supervisor.sn
                        break
                else:
                    (employee.SupervisorEmail, employee.SupervisorFirstName, employee.SupervisorSurname) = ('Supervisor not found.', 'Supervisor not found.', 'Supervisor not found.')
            else:
                (employee.SupervisorEmail, employee.SupervisorFirstName, employee.SupervisorSurname) = ('Supervisor not set.', 'Supervisor not set.', 'Supervisor not set.')

    #Is thre a more pythonic way of doing this?
    def print_employees(self):
        for employee in self.employee_list:
            print(employee.__dict__)

if __name__ == '__main__':
    db_employees = Employees(import_gd_dump())
    db_employees.clean_all_phone_numbers()
    db_employees.lookup_all_supervisors()
    #db_employees.print_employees()
    write_gd_formatted(db_employees)

导入csv
进口稀土
导入系统
#CSV类装载机：
#“”“帮助加载CSV文件的虚拟类。”“”
#def导入_gd_转储（自身，输入文件='Gp目录20100331 original.csv'）：
#gd_extract=csv.DictReader（打开（输入文件），方言='excel'）
#雇员=[]
#对于gd_摘录中的行：
#当前员工=员工（行）
#employees.append（当前员工）
#返回员工
##self.employees={row['dbdirid']：gd_extract中的行对行}
#以前，它位于一个名为“CSVLoader”的（虚拟）类中。
#但是根据这里的说法,(http://tomayko.com/writings/the-static-method-thing)-Python中的惯用方法不是使用类函数，而是使用模块级函数
def导入_gd_转储（输入_file='Gp Directory 20100331 original.csv'）：
“”“返回从组目录CSV文件中获取的dict对象列表（'employee'）。”
gd_extract=csv.DictReader（打开（输入文件），方言='excel'）
雇员=[]
对于gd_摘录中的行：
employees.append（行）
返回员工
def write_gd_formatted（员工dict，output_file=“gd_formatted.csv”）：
“”“读入Employees（）对象，并将其中的每个Employees（）写入CSV文件”“”
gd_输出_字段名=（'hrid'，'mail'，'givenName'，'sn'，'dbcostcenter'，'dbdirid'，'hrreportsto'，'PHFull'，'PHFull_消息'，'SupervisorMail'，'SupervisorFirstName'，'SupervisorUrName'）
尝试：
gd_formatted=csv.DictWriter（打开（输出文件'w'，换行符=''），字段名=gd_输出字段名，extraction='ignore'，方言='excel'）
除IOError外：
打印（'无法打开文件，IO错误（是否已锁定？））
系统出口（1）
headers={n:n表示gd_output_fieldnames中的n}
gd_格式化的.writerow（标题）
对于员工目录中的员工：
#我们正在使用employee对象的内置dict属性-嗯，这是一种好的做法吗？
gd_格式化的.writerow（雇员.uuu命令）
班级员工：
“”“系统中的员工，具有员工属性（姓名、电子邮件、成本中心等）。”“”
定义初始化（自我、员工属性）：
“”“我们使用Employee构造函数将字典转换为实例属性。”“”
对于employee_attributes.items（）中的k、v：
setattr（自、k、v）
def清洁电话号码（自身）：
“”“执行一些基本检查和更正，以确保数字的格式正确。”。
数字的格式应为0xyyyyyy，其中X是区号，Y是本地号码。”“”
如果self.telephoneNumber为None或self.telephoneNumber=''：
返回“”，“缺少电话号码。”
其他：
标准格式=重新编译（r'^\+（？P\d{2}）\（？P\d）\（？P\d{4}）-（？P\d{4}））
额外零=重新编译（r'^\+（？P\d{2}）\（0（？P\d）\（？P\d{4}）-（？P\d{4}））
缺少重新编译（r'^\+（？P\d{2}）\（0（？P\d）\）（？P\d{4}）（？P\d{4}））
如果是标准格式搜索（self.telephoneNumber）：
结果=标准格式搜索（self.telephoneNumber）
返回“0”+result.group（'area_code'）+result.group（'local_first_half'）+result.group（'local_second_half'），“”
elif extra_zero.搜索（自身电话号码）：
结果=额外零搜索（自身电话号码）
返回“0”+result.group（'area_code'）+result.group（'local_first_half'）+result.group（'local_second_half'），“区号中的额外零-请用户进行修正。”
elif缺少连字符搜索（self.telephoneNumber）：
结果=缺少连字符搜索（self.telephoneNumber）
返回“0”+result.group（'area_code'）+result.group（'local_first_half'）+result.group（'local_second_half'），“本地组件中缺少连字符-请用户进行修正。”
其他：
返回“”，“号码与识别的格式不匹配。原始文本为：“+self.telephoneNumber”
类别雇员：
定义初始化（自我，导入列表）：
self.employee_list=[]
对于导入列表中的员工：
self.employee_list.append（employee（employee））
def clean_所有电话号码（自身）：
对于self.employee_列表中的员工：
#我们应该直接在Employee.clean\u phone\u number（）中设置吗？
employee.PHFull，employee.PHFull\u message=employee.clean\u电话号码（）
#嗯，搜索是O（n^2）-可能有更好的搜索方法？
def查找\u所有\u主管（自我）：
对于self.employee_列表中的员工：
如果employee.hrreportsto不是None，employee.hrreportsto！=''：
对于self.employee_列表中的主管：
如果supervisor.hrid==employee.hrreportsto：
（employee.SupervisorEmail，employee.SupervisorFirstName，employee.supervisorUrName）=supervisor.mail，supervisor.givenName，supervisor.sn
打破
其他：
（employee.SupervisorEmail、employee.SupervisorFirstName、employee.SupervisorUrName）=（“未找到主管”、“未找到主管”、“未找到主管”）
其他：
（employee.SupervisorEmail、employee.SupervisorFirstName、employee.SupervisorUrName）=（‘未设置主管’、‘未设置主管’、‘未设置主管’）
#是t吗