diff --git a/README.md b/README.md index 4ee74a2..b405c14 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,20 @@ +# Setup +1. python -m venv venv +2. pip install -r requirements.txt + +# How to run +- arg1 Execute type + - M Migrate +- arg2 Datasource file +- arg3 Target db +- arg4 csv path + +# visualize +- visualize.ipynb + +Example +python run.py M ../data-devclub-1.xml ../database/dev_mountain.db ../output/test.csv + # hackathon-season2 ## Story สายการบิน DevMountain ถูก Take Over โดยสายการบิน DevClub ซึ่งจะต้องมีการย้ายพนักงานจาก DevMountain มา DevClub ซึ่งส่งผลกระทบกับทางแผนกไอทีต้องทำการย้ายข้อมูลมาลงในฐานข้อมูลใหม่ @@ -64,24 +81,3 @@ - ส่งเร็ว - Creative ตอนทำ Data visualization - ผลลัพธ์จาก SQLlite ต้องได้เป็น **JSON** format - - - -### ไม่รู้วิธี Fork หรือ สร้าง PR สามารถฝึกได้จากที่นี่ -https://github.com/firstcontributions/first-contributions - -## How to submit -- Create a PR to hackathon season 2 repository, add your name or team information and your repo link - - -## Q&A คำถามที่พบบ่อย -- ดูได้จาก issues -https://github.com/devmountaintechfest/hackathon-season2/issues - -## ทีม Dev mountain ที่ดูแลการแข่งครั้งนี้ -สมาชิก -- [annibuliful](https://github.com/annibuliful) -- [lordbenz](https://github.com/lordbenz) -- [Issawat](https://github.com/Issawat) - -Repo: [hackathon](https://github.com/devmountaintechfest/hackathon-season2) diff --git a/csv/devclub.csv b/csv/devclub.csv new file mode 100644 index 0000000..8b79530 --- /dev/null +++ b/csv/devclub.csv @@ -0,0 +1,13 @@ +EMP_ID,PASSPORT,FIRSTNAME,LASTNAME,GENDER,BIRTHDAY,NATIONALITY,HIRED,DEPT,POSITION,STATUS,REGION +2,CDC87ETW8EQ,Burton,Gallegos,0,22-09-1960,Germany,29-10-2021,Aircraft Maintenance,Pilot,1,APAC +3,JUI65YBK7AF,Jada,Bender,0,28-05-1963,Pakistan,11-02-2001,Pilot,Pilot,1,Canada +5,AZE20CSG4MU,Lillian,Reese,0,03-12-1982,Ukraine,19-05-2002,Flight Planning,Steward,1,Canada +23,NFH65BYM0VB,Armand,Horn,0,24-05-1987,Netherlands,19-06-2007,Aircraft Maintenance,Airhostess,1,Ocenia +29,CMK62UAD3VK,Rowan,Leonard,1,15-07-1974,Germany,27-03-2004,Aircraft Maintenance,Pilot,1,Ocenia +33,EWD45RJW5YK,Carter,Velasquez,0,23-11-1967,Indonesia,27-02-2005,Flight Planning,Pilot,1,APAC +34,BFS82MEY3CX,Selma,Bush,0,26-03-1972,Italy,10-10-2008,Flight Attendance,Airhostess,1,USA +50,MRC33GHJ2KW,Calvin,Roach,1,16-04-1999,Mexico,18-03-2011,Flight Attendance,Steward,1,Europe +66,WKV12UQC6QF,Zachery,Valentine,0,04-06-1971,Philippines,25-08-2011,Flight Attendance,Steward,1,Middle East +80,EUC74ENE9ZK,Ryan,Rush,0,13-06-1998,Italy,31-07-2019,Aircraft Maintenance,Pilot,1,Middle East +95,OUP31WOE2IE,Dara,Wilcox,1,29-06-1996,Singapore,18-05-2011,Flight Attendance,Airhostess,1,Canada +97,SUF73DKV4QE,Dante,Hart,0,21-12-1999,Peru,22-02-2016,Pilot,Pilot,1,Europe diff --git a/database/dev_mountain.db b/database/dev_mountain.db new file mode 100644 index 0000000..09aee33 Binary files /dev/null and b/database/dev_mountain.db differ diff --git a/output/test_Germany.csv b/output/test_Germany.csv new file mode 100644 index 0000000..465d0b9 --- /dev/null +++ b/output/test_Germany.csv @@ -0,0 +1,2 @@ +2,CDC87ETW8EQ,Burton,Gallegos,0,22-09-1960,Germany,29-10-2021,Aircraft Maintenance,Pilot,1,APAC +29,CMK62UAD3VK,Rowan,Leonard,1,15-07-1974,Germany,27-03-2004,Aircraft Maintenance,Pilot,1,Ocenia diff --git a/output/test_Indonesia.csv b/output/test_Indonesia.csv new file mode 100644 index 0000000..c3dd508 --- /dev/null +++ b/output/test_Indonesia.csv @@ -0,0 +1 @@ +33,EWD45RJW5YK,Carter,Velasquez,0,23-11-1967,Indonesia,27-02-2005,Flight Planning,Pilot,1,APAC diff --git a/output/test_Italy.csv b/output/test_Italy.csv new file mode 100644 index 0000000..8918796 --- /dev/null +++ b/output/test_Italy.csv @@ -0,0 +1,2 @@ +34,BFS82MEY3CX,Selma,Bush,0,26-03-1972,Italy,10-10-2008,Flight Attendance,Airhostess,1,USA +80,EUC74ENE9ZK,Ryan,Rush,0,13-06-1998,Italy,31-07-2019,Aircraft Maintenance,Pilot,1,Middle East diff --git a/output/test_Mexico.csv b/output/test_Mexico.csv new file mode 100644 index 0000000..4e355b6 --- /dev/null +++ b/output/test_Mexico.csv @@ -0,0 +1 @@ +50,MRC33GHJ2KW,Calvin,Roach,1,16-04-1999,Mexico,18-03-2011,Flight Attendance,Steward,1,Europe diff --git a/output/test_Netherlands.csv b/output/test_Netherlands.csv new file mode 100644 index 0000000..9c3298d --- /dev/null +++ b/output/test_Netherlands.csv @@ -0,0 +1 @@ +23,NFH65BYM0VB,Armand,Horn,0,24-05-1987,Netherlands,19-06-2007,Aircraft Maintenance,Airhostess,1,Ocenia diff --git a/output/test_Pakistan.csv b/output/test_Pakistan.csv new file mode 100644 index 0000000..baf8b54 --- /dev/null +++ b/output/test_Pakistan.csv @@ -0,0 +1 @@ +3,JUI65YBK7AF,Jada,Bender,0,28-05-1963,Pakistan,11-02-2001,Pilot,Pilot,1,Canada diff --git a/output/test_Peru.csv b/output/test_Peru.csv new file mode 100644 index 0000000..c9a820f --- /dev/null +++ b/output/test_Peru.csv @@ -0,0 +1 @@ +97,SUF73DKV4QE,Dante,Hart,0,21-12-1999,Peru,22-02-2016,Pilot,Pilot,1,Europe diff --git a/output/test_Philippines.csv b/output/test_Philippines.csv new file mode 100644 index 0000000..8dd7022 --- /dev/null +++ b/output/test_Philippines.csv @@ -0,0 +1 @@ +66,WKV12UQC6QF,Zachery,Valentine,0,04-06-1971,Philippines,25-08-2011,Flight Attendance,Steward,1,Middle East diff --git a/output/test_Singapore.csv b/output/test_Singapore.csv new file mode 100644 index 0000000..1812615 --- /dev/null +++ b/output/test_Singapore.csv @@ -0,0 +1 @@ +95,OUP31WOE2IE,Dara,Wilcox,1,29-06-1996,Singapore,18-05-2011,Flight Attendance,Airhostess,1,Canada diff --git a/output/test_Ukraine.csv b/output/test_Ukraine.csv new file mode 100644 index 0000000..30ab964 --- /dev/null +++ b/output/test_Ukraine.csv @@ -0,0 +1 @@ +5,AZE20CSG4MU,Lillian,Reese,0,03-12-1982,Ukraine,19-05-2002,Flight Planning,Steward,1,Canada diff --git a/src/data.py b/src/data.py new file mode 100644 index 0000000..4685b0e --- /dev/null +++ b/src/data.py @@ -0,0 +1,37 @@ +import json + +class DevMountainData(object): + def __init__(self, data): + self.emp_id=int(data[0].text) + self.passport=data[1].text + self.firstname=data[2].text + self.lastname=data[3].text + self.gender=int(data[4].text) + self.birthday=data[5].text + self.nationality=data[6].text + self.hired=data[7].text + self.dept=data[8].text + self.position=data[9].text + self.status=int(data[10].text) + self.region=data[11].text + +class ClubData(object): + def __init__(self, data): + self.emp_id=data.emp_id + self.passport=data.passport + self.firstname=data.firstname + self.lastname=data.lastname + self.gender=data.gender + self.birthday=data.birthday + self.nationality=data.nationality + self.hired=data.hired + self.dept=data.dept + self.position=data.position + self.status=data.status + self.region=data.region + + def toSet(self): + return (self.emp_id,self.passport,self.firstname,self.lastname,self.gender,self.birthday,self.nationality,self.hired,self.dept,self.position,self.status,self.region) + + def toJson(self): + return json.dumps(self.__dict__) \ No newline at end of file diff --git a/src/requirments.txt b/src/requirments.txt new file mode 100644 index 0000000..67ca1b1 --- /dev/null +++ b/src/requirments.txt @@ -0,0 +1,11 @@ +antiorm==1.2.1 +db==0.1.1 +db-sqlite3==0.0.1 +lxml==4.9.1 +numpy==1.23.3 +python-dateutil==2.8.2 +pytz==2022.4 +six==1.16.0 +matplotlib==3.6.1 +jupyterlab==3.4.8 +notebook==6.4.12 \ No newline at end of file diff --git a/src/run.py b/src/run.py new file mode 100644 index 0000000..e7306f3 --- /dev/null +++ b/src/run.py @@ -0,0 +1,145 @@ +from lxml import etree as ET +from data import DevMountainData, ClubData +from util import DataUtility, FileUtility, usedtime +import time,sys,os,csv +import sys +from datetime import datetime, date +from dateutil import relativedelta +import matplotlib.pyplot as plt + + +@usedtime +class Executor(object): + config = {} + total = int() + valid = int() + invalid = int() + results = [] + + @usedtime + def setup(self, config): + self.config = config + + @usedtime + def extract(self): + global clubData + print("Extract..") + today = date.today().strftime("%d-%m-%Y") + xmlData = self.config['datasource'] + parser = ET.XMLParser(remove_comments=False) + xml = ET.parse(xmlData, parser=parser) + alldata = xml.xpath("count(/records/record)") + self.total = int(alldata) + print("Raw Data Total:", self.total) + datasource = xml.xpath( + "/records/record[STATUS/text()='1' and (POSITION/text()='Steward' or POSITION/text()='Pilot' or " + "POSITION/text()='Airhostess') and EMPID/text()!=PASSPORT/text()]") + + for element in list(datasource): + data = DevMountainData(element) + birthday = data.birthday + d1 = datetime.strptime(today, "%d-%m-%Y") + d2 = datetime.strptime(birthday, "%d-%m-%Y") + datediff = relativedelta.relativedelta(d1, d2) + print(datediff.days) + if datediff.days > 3: + clubData = ClubData(data) + self.results.append(clubData.toSet()) + + print("Raw Data Valid:", len(self.results)) + print("Raw Data InValid:", str(self.total - len(self.results))) + + @usedtime + def load(self): + print("Load..") + dataUtility = DataUtility(self.config['dbName']) + dataUtility.dbSetup() + dataUtility.view() + dataUtility.save(self.results) + + @usedtime + def generateSummary(self): + print("Generate Summary..") + nation_group = [] + for nat in self.results: + if nat[6] not in nation_group: + nation_group.append(nat[6]) + for ds in nation_group: + data = [i for i in self.results if i[6] == ds] + FileUtility().write(self.config['clubDataReport'], [list(dat) for dat in data]) + + if not os.path.exists("../csv"): + os.makedirs("../csv") + + with open("../csv/devclub.csv", 'w', newline="") as f: + write = csv.writer(f) + write.writerow(["EMP_ID","PASSPORT","FIRSTNAME","LASTNAME","GENDER","BIRTHDAY","NATIONALITY","HIRED","DEPT","POSITION","STATUS","REGION"]) + write.writerows([list(dat) for dat in self.results]) + + @usedtime + def visualize(self): + print("Generate visualize..") + if not os.path.exists("../visualize"): + os.makedirs("../visualize") + # gender + male = 0 + female = 0 + for data in self.results: + gender = data[4] + if gender == 0: + male += 1 + elif gender == 1: + female += 1 + else: + pass + gender_data = [male, female] + gender_data_label = ["Male", "Female"] + print(gender_data) + plt.pie(gender_data, labels=gender_data_label) + plt.legend() + plt.title("summary gender") + plt.savefig('../visualize/gender.png') + # import numpy as np + # import pandas as pd + # import matplotlib.pyplot as plt + # df1 = pd.read_csv("../csv/devclub.csv") + # df2 = df1[['GENDER', 'EMP_ID']] + # df2 = df2.groupby(['GENDER'])['EMP_ID'] + # print(df2.plot.pie()) + +def main(): + try: + print("#####start#####") + print(f"{sys.argv}") + if len(sys.argv) > 1: + exeType = sys.argv[1] + print(f'{exeType}') + if exeType == 'M': + datasource = sys.argv[2] + dbName = sys.argv[3] + reportName = sys.argv[4] + config = { + "datasource": datasource, + "dbName": dbName, + "clubDataReport": reportName + } + startTime = time.perf_counter() + exe = Executor() + exe.setup(config) + exe.extract() + exe.load() + exe.generateSummary() + exe.visualize() + endTime = time.perf_counter() + totalTime = endTime - startTime + print(f'##Total used time {totalTime:.4f} seconds##') + else: + print("Please enter Execute Type (M) Parameter!") + else: + print("Please enter Parameter!") + except ValueError as ve: + return str(ve) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/util.py b/src/util.py new file mode 100644 index 0000000..b90a622 --- /dev/null +++ b/src/util.py @@ -0,0 +1,89 @@ +import sqlite3 +from functools import wraps +import time +import csv,json + + +def usedtime(func): + @wraps(func) + def usedtimeWrapper(*args, **kwargs): + startTime = time.perf_counter() + result = func(*args, **kwargs) + endTime = time.perf_counter() + totalTime = endTime - startTime + print(f'{func.__name__} used time {totalTime:.4f} seconds') + return result + + return usedtimeWrapper + + +class DataUtility(object): + def __init__(self, DB_NAME): + self.dbName = DB_NAME + + def getConnection(self): + con = sqlite3.connect(self.dbName) + return con + + def dbSetup(self): + con = self.getConnection() + cur = con.cursor() + try: + cur.execute("DROP TABLE employee;") + except: + pass + cur.execute( + "CREATE TABLE employee(EMP_ID INTEGER,PASSPORT VARCHAR(100),FIRSTNAME VARCHAR(100),LASTNAME VARCHAR(100)," + "GENDER INTEGER,BIRTHDAY VARCHAR(100),NATIONALITY VARCHAR(100),HIRED VARCHAR(100),DEPT VARCHAR(100)," + "POSITION VARCHAR(100),STATUS INTEGER,REGION VARCHAR(100));") + con.close() + print("setup completed.") + + def view(self): + con = self.getConnection() + cur = con.cursor() + try: + cur.execute("DROP VIEW employee_country_view;") + except: + pass + try: + cur.execute("DROP VIEW employee_department_view;") + except: + pass + try: + cur.execute("DROP VIEW employee_nation_view;") + except: + pass + cur.execute("""CREATE VIEW employee_country_view AS SELECT "EMP_ID","PASSPORT","FIRSTNAME","LASTNAME", + "REGION" FROM employee;""") + cur.execute("""CREATE VIEW employee_department_view AS SELECT "EMP_ID","PASSPORT","FIRSTNAME","LASTNAME", + "DEPT" FROM employee;""") + cur.execute("""CREATE VIEW employee_nation_view AS SELECT "EMP_ID","PASSPORT","FIRSTNAME","LASTNAME", + "NATIONALITY" FROM employee;""") + con.close() + print("setup completed.") + + def save(self, data): + print("Save..") + con = self.getConnection() + con.executemany( + "INSERT INTO employee (EMP_ID,PASSPORT,FIRSTNAME,LASTNAME,GENDER,BIRTHDAY,NATIONALITY,HIRED,DEPT," + "POSITION,STATUS,REGION) VALUES(?,?,?,?,?,?,?,?,?,?,?,?);", + data) + con.commit() + con.close() + + +class FileUtility(object): + def write(seft, fileName, data): + print("Write..") + nation = data[0][6] + print(nation) + with open("{}_{}.csv".format(fileName.replace(".csv", ""), nation), 'w', newline="") as f: + write = csv.writer(f) + write.writerows(data) + + def json(seft, fileName, data): + print("Write json..") + with open("{}.json".format(fileName.replace(".json", "")), "w") as final: + json.dump(data, final) diff --git a/src/visualize.ipynb b/src/visualize.ipynb new file mode 100644 index 0000000..2d3100e --- /dev/null +++ b/src/visualize.ipynb @@ -0,0 +1,1332 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 71, + "id": "f9abef71", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from datetime import datetime as dt" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "04714c6f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['EMP_ID', 'PASSPORT', 'FIRSTNAME', 'LASTNAME', 'GENDER', 'BIRTHDAY',\n", + " 'NATIONALITY', 'HIRED', 'DEPT', 'POSITION', 'STATUS', 'REGION'],\n", + " dtype='object')" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe=pd.read_csv(\"../csv/devclub.csv\")\n", + "dev_club_dataframe.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "89d0ce3f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EMP_IDPASSPORTFIRSTNAMELASTNAMEGENDERBIRTHDAYNATIONALITYHIREDDEPTPOSITIONSTATUSREGION
02CDC87ETW8EQBurtonGallegos022-09-1960Germany29-10-2021Aircraft MaintenancePilot1APAC
13JUI65YBK7AFJadaBender028-05-1963Pakistan11-02-2001PilotPilot1Canada
25AZE20CSG4MULillianReese003-12-1982Ukraine19-05-2002Flight PlanningSteward1Canada
323NFH65BYM0VBArmandHorn024-05-1987Netherlands19-06-2007Aircraft MaintenanceAirhostess1Ocenia
429CMK62UAD3VKRowanLeonard115-07-1974Germany27-03-2004Aircraft MaintenancePilot1Ocenia
533EWD45RJW5YKCarterVelasquez023-11-1967Indonesia27-02-2005Flight PlanningPilot1APAC
634BFS82MEY3CXSelmaBush026-03-1972Italy10-10-2008Flight AttendanceAirhostess1USA
750MRC33GHJ2KWCalvinRoach116-04-1999Mexico18-03-2011Flight AttendanceSteward1Europe
866WKV12UQC6QFZacheryValentine004-06-1971Philippines25-08-2011Flight AttendanceSteward1Middle East
980EUC74ENE9ZKRyanRush013-06-1998Italy31-07-2019Aircraft MaintenancePilot1Middle East
1095OUP31WOE2IEDaraWilcox129-06-1996Singapore18-05-2011Flight AttendanceAirhostess1Canada
1197SUF73DKV4QEDanteHart021-12-1999Peru22-02-2016PilotPilot1Europe
\n", + "
" + ], + "text/plain": [ + " EMP_ID PASSPORT FIRSTNAME LASTNAME GENDER BIRTHDAY NATIONALITY \\\n", + "0 2 CDC87ETW8EQ Burton Gallegos 0 22-09-1960 Germany \n", + "1 3 JUI65YBK7AF Jada Bender 0 28-05-1963 Pakistan \n", + "2 5 AZE20CSG4MU Lillian Reese 0 03-12-1982 Ukraine \n", + "3 23 NFH65BYM0VB Armand Horn 0 24-05-1987 Netherlands \n", + "4 29 CMK62UAD3VK Rowan Leonard 1 15-07-1974 Germany \n", + "5 33 EWD45RJW5YK Carter Velasquez 0 23-11-1967 Indonesia \n", + "6 34 BFS82MEY3CX Selma Bush 0 26-03-1972 Italy \n", + "7 50 MRC33GHJ2KW Calvin Roach 1 16-04-1999 Mexico \n", + "8 66 WKV12UQC6QF Zachery Valentine 0 04-06-1971 Philippines \n", + "9 80 EUC74ENE9ZK Ryan Rush 0 13-06-1998 Italy \n", + "10 95 OUP31WOE2IE Dara Wilcox 1 29-06-1996 Singapore \n", + "11 97 SUF73DKV4QE Dante Hart 0 21-12-1999 Peru \n", + "\n", + " HIRED DEPT POSITION STATUS REGION \n", + "0 29-10-2021 Aircraft Maintenance Pilot 1 APAC \n", + "1 11-02-2001 Pilot Pilot 1 Canada \n", + "2 19-05-2002 Flight Planning Steward 1 Canada \n", + "3 19-06-2007 Aircraft Maintenance Airhostess 1 Ocenia \n", + "4 27-03-2004 Aircraft Maintenance Pilot 1 Ocenia \n", + "5 27-02-2005 Flight Planning Pilot 1 APAC \n", + "6 10-10-2008 Flight Attendance Airhostess 1 USA \n", + "7 18-03-2011 Flight Attendance Steward 1 Europe \n", + "8 25-08-2011 Flight Attendance Steward 1 Middle East \n", + "9 31-07-2019 Aircraft Maintenance Pilot 1 Middle East \n", + "10 18-05-2011 Flight Attendance Airhostess 1 Canada \n", + "11 22-02-2016 Pilot Pilot 1 Europe " + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "a742e531", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EMP_IDPASSPORTFIRSTNAMELASTNAMEGENDERBIRTHDAYNATIONALITYHIREDDEPTPOSITIONSTATUSREGIONGEN_DESC
02CDC87ETW8EQBurtonGallegos022-09-1960Germany29-10-2021Aircraft MaintenancePilot1APACMale
13JUI65YBK7AFJadaBender028-05-1963Pakistan11-02-2001PilotPilot1CanadaMale
25AZE20CSG4MULillianReese003-12-1982Ukraine19-05-2002Flight PlanningSteward1CanadaMale
323NFH65BYM0VBArmandHorn024-05-1987Netherlands19-06-2007Aircraft MaintenanceAirhostess1OceniaMale
429CMK62UAD3VKRowanLeonard115-07-1974Germany27-03-2004Aircraft MaintenancePilot1OceniaFemale
533EWD45RJW5YKCarterVelasquez023-11-1967Indonesia27-02-2005Flight PlanningPilot1APACMale
634BFS82MEY3CXSelmaBush026-03-1972Italy10-10-2008Flight AttendanceAirhostess1USAMale
750MRC33GHJ2KWCalvinRoach116-04-1999Mexico18-03-2011Flight AttendanceSteward1EuropeFemale
866WKV12UQC6QFZacheryValentine004-06-1971Philippines25-08-2011Flight AttendanceSteward1Middle EastMale
980EUC74ENE9ZKRyanRush013-06-1998Italy31-07-2019Aircraft MaintenancePilot1Middle EastMale
1095OUP31WOE2IEDaraWilcox129-06-1996Singapore18-05-2011Flight AttendanceAirhostess1CanadaFemale
1197SUF73DKV4QEDanteHart021-12-1999Peru22-02-2016PilotPilot1EuropeMale
\n", + "
" + ], + "text/plain": [ + " EMP_ID PASSPORT FIRSTNAME LASTNAME GENDER BIRTHDAY NATIONALITY \\\n", + "0 2 CDC87ETW8EQ Burton Gallegos 0 22-09-1960 Germany \n", + "1 3 JUI65YBK7AF Jada Bender 0 28-05-1963 Pakistan \n", + "2 5 AZE20CSG4MU Lillian Reese 0 03-12-1982 Ukraine \n", + "3 23 NFH65BYM0VB Armand Horn 0 24-05-1987 Netherlands \n", + "4 29 CMK62UAD3VK Rowan Leonard 1 15-07-1974 Germany \n", + "5 33 EWD45RJW5YK Carter Velasquez 0 23-11-1967 Indonesia \n", + "6 34 BFS82MEY3CX Selma Bush 0 26-03-1972 Italy \n", + "7 50 MRC33GHJ2KW Calvin Roach 1 16-04-1999 Mexico \n", + "8 66 WKV12UQC6QF Zachery Valentine 0 04-06-1971 Philippines \n", + "9 80 EUC74ENE9ZK Ryan Rush 0 13-06-1998 Italy \n", + "10 95 OUP31WOE2IE Dara Wilcox 1 29-06-1996 Singapore \n", + "11 97 SUF73DKV4QE Dante Hart 0 21-12-1999 Peru \n", + "\n", + " HIRED DEPT POSITION STATUS REGION GEN_DESC \n", + "0 29-10-2021 Aircraft Maintenance Pilot 1 APAC Male \n", + "1 11-02-2001 Pilot Pilot 1 Canada Male \n", + "2 19-05-2002 Flight Planning Steward 1 Canada Male \n", + "3 19-06-2007 Aircraft Maintenance Airhostess 1 Ocenia Male \n", + "4 27-03-2004 Aircraft Maintenance Pilot 1 Ocenia Female \n", + "5 27-02-2005 Flight Planning Pilot 1 APAC Male \n", + "6 10-10-2008 Flight Attendance Airhostess 1 USA Male \n", + "7 18-03-2011 Flight Attendance Steward 1 Europe Female \n", + "8 25-08-2011 Flight Attendance Steward 1 Middle East Male \n", + "9 31-07-2019 Aircraft Maintenance Pilot 1 Middle East Male \n", + "10 18-05-2011 Flight Attendance Airhostess 1 Canada Female \n", + "11 22-02-2016 Pilot Pilot 1 Europe Male " + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe['GEN_DESC'] = np.where(dev_club_dataframe['GENDER'] == 0, \"Male\", \"Female\")\n", + "dev_club_dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "0413071e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GEN_DESC\n", + "Female 3\n", + "Male 9\n", + "Name: EMP_ID, dtype: int64" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"GEN_DESC\"])[\"EMP_ID\"].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "41ae319f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"GEN_DESC\"])[\"EMP_ID\"].count().plot.pie(ylabel='Gender',autopct='%1.0f%%',colors = ['#DBC970','#E0787C'])" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "c9aa8da8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NATIONALITY\n", + "Germany 2\n", + "Indonesia 1\n", + "Italy 2\n", + "Mexico 1\n", + "Netherlands 1\n", + "Pakistan 1\n", + "Peru 1\n", + "Philippines 1\n", + "Singapore 1\n", + "Ukraine 1\n", + "Name: EMP_ID, dtype: int64" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"NATIONALITY\"])[\"EMP_ID\"].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "093b4228", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"NATIONALITY\"])[\"EMP_ID\"].count().plot.bar(ylabel='People',color=['#95D5E3','#F6E9D9','#F5C7D3'])" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "4b51512c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "REGION\n", + "APAC 2\n", + "Canada 3\n", + "Europe 2\n", + "Middle East 2\n", + "Ocenia 2\n", + "USA 1\n", + "Name: EMP_ID, dtype: int64" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"REGION\"])[\"EMP_ID\"].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "790ec398", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"REGION\"])[\"EMP_ID\"].count().plot.bar(ylabel='Region',color = ['#FFD9D1','#F8EFDD','#CADBBB','#F3EEE3','#DED8C8','#91D4D3'])" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "bab6332b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DEPT\n", + "Aircraft Maintenance 4\n", + "Flight Attendance 4\n", + "Flight Planning 2\n", + "Pilot 2\n", + "Name: EMP_ID, dtype: int64" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"DEPT\"])[\"EMP_ID\"].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "5f455022", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"DEPT\"])[\"EMP_ID\"].count().plot.pie(ylabel='Department',autopct='%1.0f%%',colors = ['#E0BBE4','#957DAD','#D291BC','#FEC8D8','#FFDFD3'])" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "c193d897", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EMP_IDPASSPORTFIRSTNAMELASTNAMEGENDERBIRTHDAYNATIONALITYHIREDDEPTPOSITIONSTATUSREGIONGEN_DESCTODAYAGEEXP
02CDC87ETW8EQBurtonGallegos01960-09-22Germany2021-10-29Aircraft MaintenancePilot1APACMale2022-10-09 19:02:44.98758362.00.0
13JUI65YBK7AFJadaBender01963-05-28Pakistan2001-11-02PilotPilot1CanadaMale2022-10-09 19:02:44.98758359.020.0
25AZE20CSG4MULillianReese01982-03-12Ukraine2002-05-19Flight PlanningSteward1CanadaMale2022-10-09 19:02:44.98758340.020.0
323NFH65BYM0VBArmandHorn01987-05-24Netherlands2007-06-19Aircraft MaintenanceAirhostess1OceniaMale2022-10-09 19:02:44.98758335.015.0
429CMK62UAD3VKRowanLeonard11974-07-15Germany2004-03-27Aircraft MaintenancePilot1OceniaFemale2022-10-09 19:02:44.98758348.018.0
533EWD45RJW5YKCarterVelasquez01967-11-23Indonesia2005-02-27Flight PlanningPilot1APACMale2022-10-09 19:02:44.98758354.017.0
634BFS82MEY3CXSelmaBush01972-03-26Italy2008-10-10Flight AttendanceAirhostess1USAMale2022-10-09 19:02:44.98758350.013.0
750MRC33GHJ2KWCalvinRoach11999-04-16Mexico2011-03-18Flight AttendanceSteward1EuropeFemale2022-10-09 19:02:44.98758323.011.0
866WKV12UQC6QFZacheryValentine01971-04-06Philippines2011-08-25Flight AttendanceSteward1Middle EastMale2022-10-09 19:02:44.98758351.011.0
980EUC74ENE9ZKRyanRush01998-06-13Italy2019-07-31Aircraft MaintenancePilot1Middle EastMale2022-10-09 19:02:44.98758324.03.0
1095OUP31WOE2IEDaraWilcox11996-06-29Singapore2011-05-18Flight AttendanceAirhostess1CanadaFemale2022-10-09 19:02:44.98758326.011.0
1197SUF73DKV4QEDanteHart01999-12-21Peru2016-02-22PilotPilot1EuropeMale2022-10-09 19:02:44.98758322.06.0
\n", + "
" + ], + "text/plain": [ + " EMP_ID PASSPORT FIRSTNAME LASTNAME GENDER BIRTHDAY NATIONALITY \\\n", + "0 2 CDC87ETW8EQ Burton Gallegos 0 1960-09-22 Germany \n", + "1 3 JUI65YBK7AF Jada Bender 0 1963-05-28 Pakistan \n", + "2 5 AZE20CSG4MU Lillian Reese 0 1982-03-12 Ukraine \n", + "3 23 NFH65BYM0VB Armand Horn 0 1987-05-24 Netherlands \n", + "4 29 CMK62UAD3VK Rowan Leonard 1 1974-07-15 Germany \n", + "5 33 EWD45RJW5YK Carter Velasquez 0 1967-11-23 Indonesia \n", + "6 34 BFS82MEY3CX Selma Bush 0 1972-03-26 Italy \n", + "7 50 MRC33GHJ2KW Calvin Roach 1 1999-04-16 Mexico \n", + "8 66 WKV12UQC6QF Zachery Valentine 0 1971-04-06 Philippines \n", + "9 80 EUC74ENE9ZK Ryan Rush 0 1998-06-13 Italy \n", + "10 95 OUP31WOE2IE Dara Wilcox 1 1996-06-29 Singapore \n", + "11 97 SUF73DKV4QE Dante Hart 0 1999-12-21 Peru \n", + "\n", + " HIRED DEPT POSITION STATUS REGION GEN_DESC \\\n", + "0 2021-10-29 Aircraft Maintenance Pilot 1 APAC Male \n", + "1 2001-11-02 Pilot Pilot 1 Canada Male \n", + "2 2002-05-19 Flight Planning Steward 1 Canada Male \n", + "3 2007-06-19 Aircraft Maintenance Airhostess 1 Ocenia Male \n", + "4 2004-03-27 Aircraft Maintenance Pilot 1 Ocenia Female \n", + "5 2005-02-27 Flight Planning Pilot 1 APAC Male \n", + "6 2008-10-10 Flight Attendance Airhostess 1 USA Male \n", + "7 2011-03-18 Flight Attendance Steward 1 Europe Female \n", + "8 2011-08-25 Flight Attendance Steward 1 Middle East Male \n", + "9 2019-07-31 Aircraft Maintenance Pilot 1 Middle East Male \n", + "10 2011-05-18 Flight Attendance Airhostess 1 Canada Female \n", + "11 2016-02-22 Pilot Pilot 1 Europe Male \n", + "\n", + " TODAY AGE EXP \n", + "0 2022-10-09 19:02:44.987583 62.0 0.0 \n", + "1 2022-10-09 19:02:44.987583 59.0 20.0 \n", + "2 2022-10-09 19:02:44.987583 40.0 20.0 \n", + "3 2022-10-09 19:02:44.987583 35.0 15.0 \n", + "4 2022-10-09 19:02:44.987583 48.0 18.0 \n", + "5 2022-10-09 19:02:44.987583 54.0 17.0 \n", + "6 2022-10-09 19:02:44.987583 50.0 13.0 \n", + "7 2022-10-09 19:02:44.987583 23.0 11.0 \n", + "8 2022-10-09 19:02:44.987583 51.0 11.0 \n", + "9 2022-10-09 19:02:44.987583 24.0 3.0 \n", + "10 2022-10-09 19:02:44.987583 26.0 11.0 \n", + "11 2022-10-09 19:02:44.987583 22.0 6.0 " + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe[\"BIRTHDAY\"]= pd.to_datetime(dev_club_dataframe[\"BIRTHDAY\"])\n", + "dev_club_dataframe[\"HIRED\"]= pd.to_datetime(dev_club_dataframe[\"HIRED\"])\n", + "dev_club_dataframe[\"TODAY\"] = pd.to_datetime(\"today\")\n", + "dev_club_dataframe[\"AGE\"]=((dev_club_dataframe[\"TODAY\"]-dev_club_dataframe[\"BIRTHDAY\"])/ np.timedelta64(1, 'Y')).apply(np.floor)\n", + "dev_club_dataframe[\"EXP\"]=((dev_club_dataframe[\"TODAY\"]-dev_club_dataframe[\"HIRED\"])/ np.timedelta64(1, 'Y')).apply(np.floor)\n", + "dev_club_dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "ea867633", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AGE
meanminmax
REGION
APAC58.00000054.062.0
Canada41.66666726.059.0
Europe22.50000022.023.0
Middle East37.50000024.051.0
Ocenia41.50000035.048.0
USA50.00000050.050.0
\n", + "
" + ], + "text/plain": [ + " AGE \n", + " mean min max\n", + "REGION \n", + "APAC 58.000000 54.0 62.0\n", + "Canada 41.666667 26.0 59.0\n", + "Europe 22.500000 22.0 23.0\n", + "Middle East 37.500000 24.0 51.0\n", + "Ocenia 41.500000 35.0 48.0\n", + "USA 50.000000 50.0 50.0" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"REGION\"]).agg({'AGE':['mean','min','max']})" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "401fe0d8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dev_club_dataframe.groupby([\"REGION\"]).agg({'AGE':['mean','min','max']}).plot(kind='line', figsize=(8, 6), title='Age', xlabel='Region', ylabel='Age', rot=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18e561a5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b50c1372", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/visualize/gender.png b/visualize/gender.png new file mode 100644 index 0000000..0bea69d Binary files /dev/null and b/visualize/gender.png differ