python 部分代码2

class List:
    def __init__(self, lst=None):
        if lst is None:
                    self.lst = []
        else:
            self.lst = lst


def length(l):
    return len(l.lst)


def isempty(l):
    if len(l.lst)==0:
        return True
    else:
        return False

def get(l, i):
    if isempty(l):
        print("The get() is unsuccessful!")
        print("The list is empty!")
        return -1
    elif (i<1) or (i>length(l)):
        print("The get() is unsuccessful!")
        print("The index given is out of range!")
        return -1
    else:
        return(l.lst[i-1])

def locatebyvalue(l, x):
    position = 1
    for item in l.lst:
        if x == item:
            return position
        else:
            position = position+1
    return -1        

def locatebyid(l, idd):
    position = 1
    for item in l.lst:
        if item.id == idd:
            return position
        else:
            position = position+1
    return -1        

def insert(l, i, x):
    if (i<1) or (i>length(l)+1):
        print("The insert() is unsuccessful!")
        print("The index given is out of range!")
        
    else: 
        l.lst.insert(i-1, x)

def delete(l, i):
    if isempty(l):
        print("The delete() is unsuccessful!")
        print("The list is empty!")
        return
    elif (i<1) or (i>length(l)):
        print("The delete() is unsuccessful!")
        print("The index given is out of range!")
        return
    else: 
        del l.lst[i-1]


def display(l):
    print(l.lst)



    

 

 

 

from queuestackm import *

def main():
    qs = Stack()
    if(isemptys(qs)):
        print("The stack is empty now.")
    else:
        print("The stack is not empty now.")	
    push(qs, "a")
    push(qs, "b")
    push(qs, "c")
    print("The push operations has been performed three times.")	
    if(isemptys(qs)):
        print("The stack is empty now.")
    else:
        print("The stack is not empty now.")	
    top = gettop(qs)
    print(f"Now, the top element is '{top}'.")
    print("Now, the stack is containing ", end="")
    displays(qs)
    pop(qs)
    de = pop(qs)
    print("The pop operations has been performed two times.")	
    print(f"The last popped element is '{de}'.")	
    push(qs, "d")
    push(qs, "e")
    top = gettop(qs)
    print(f"Now, the top element is '{top}'.")
    print("Now, the stack is containing ", end="")
    displays(qs)


main()

 

from listm import *


class Queue(List):
    def __init__(self, que=None):
        List.__init__(self, que)
        self.rear = 0


def isemptyq(q):
    if isempty(q):
        return True
    else:
        return False

def enqueue(q, x):
    q.rear= q.rear + 1
    insert(q, q.rear, x)
    


def dequeue(q):
    if isemptyq(q):
        print("Dequeue error, queue underflow!!!\n")
        return -1
    else:
        tmp = get(q, 1)
        delete(q, 1)
        q.rear = q.rear - 1
        return tmp    



def getfront(q):
    if isemptyq(q):
        print("Getfront error, queue underflow!!!\n")
        return -1
    else:
        tmp = get(q, 1)
        return tmp


def displayq(q):
    display(q)

 

from listm import *

class Stack(List):
    def __init__(self, stk=None):
        List.__init__(self, stk)
        self.top = length(self)


def isemptys(s):
    if isempty(s):
        return True
    else:
        return False

def push(s, x):
    s.top = s.top + 1
    insert(s, s.top, x)
    


def pop(s):
    if isemptys(s):
        print("Pop error, stack underflow!!!\n")
        return -1
    else:
        tmp = get(s, s.top)
        delete(s, s.top)
        s.top = s.top - 1
        return tmp    



def gettop(s):
    if isemptys(s):
        print("Gettop error, stack underflow!!!\n")
        return -1
    else:
        tmp = get(s, s.top)
        return tmp


def displays(s):
    display(s)

from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split, GridSearchCV
# 10-fold cross-validation
cvKFold=StratifiedKFold(n_splits=10, shuffle=True, random_state=0)
# K-Nearest Neighbour
from sklearn.neighbors import KNeighborsClassifier
def kNNClassifier(X, y, K):
    knn = KNeighborsClassifier(n_neighbors=K)
    scores = cross_val_score(knn, np.asarray(X, dtype='float64'), y,
                             cv=cvKFold)
    print("{:.4f}".format(scores.mean()), end='')

# Logistic Regression
from sklearn.linear_model import LogisticRegression
def logregClassifier(X, y):
    logreg = LogisticRegression(random_state=0)
    scores = cross_val_score(logreg, np.asarray(X, dtype='float64'), y,
                             cv=cvKFold)
    print("{:.4f}".format(scores.mean()), end='')
# Naïve Bayes
from sklearn.naive_bayes import GaussianNB
def nbClassifier(X, y):
    nb = GaussianNB()
    scores = cross_val_score(nb, np.asarray(X, dtype='float64'), y,
                             cv=cvKFold)
    print("{:.4f}".format(scores.mean()), end='')
# Decision Tree
from sklearn.tree import DecisionTreeClassifier
def dtClassifier(X, y):
    tree = DecisionTreeClassifier(criterion='entropy', random_state=0)
    scores = cross_val_score(tree, np.asarray(X, dtype='float64'), y,
                             cv=cvKFold)
    print("{:.4f}".format(scores.mean()), end='')
# Bagging
from sklearn.ensemble import BaggingClassifier
def bagDTClassifier(X, y, n_estimators, max_samples, max_depth):
    bag_clf = BaggingClassifier(DecisionTreeClassifier(max_depth=max_depth,
                                         criterion='entropy', random_state=0), n_estimators=n_estimators,
                  max_samples=max_samples, random_state=0)
    scores = cross_val_score(bag_clf, np.asarray(X, dtype='float64'), y,
                         cv=cvKFold)
    print("{:.4f}".format(scores.mean()), end='')
# Ada Boost
from sklearn.ensemble import AdaBoostClassifier
def adaDTClassifier(X, y, n_estimators, learning_rate, max_depth):
    ada_clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=max_depth,
                                          criterion='entropy', random_state=0), n_estimators=n_estimators,
                   learning_rate=learning_rate, random_state=0)
    scores = cross_val_score(ada_clf, np.asarray(X, dtype='float64'), y,
                         cv=cvKFold)
    print("{:.4f}".format(scores.mean()), end='')
# Gradient Boosting
from sklearn.ensemble import GradientBoostingClassifier
def gbClassifier(X, y, n_estimators, learning_rate):
    gb_clf = GradientBoostingClassifier(n_estimators=n_estimators,
                                        learning_rate=learning_rate, random_state=0)
    scores = cross_val_score(gb_clf, np.asarray(X, dtype='float64'), y,
                             cv=cvKFold)
    print("{:.4f}".format(scores.mean()), end='')
# Linear SVM
from sklearn.svm import SVC
def bestLinClassifier(X,y):
    X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                        stratify=y, random_state=0)
    param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100],
                  'gamma': [0.001, 0.01, 0.1, 1, 10, 100]}
    grid_search = GridSearchCV(SVC(kernel="linear", random_state=0),
                               param_grid, cv=cvKFold, return_train_score=True)
    grid_search.fit(X_train, y_train)
    print(grid_search.best_params_['C'])
    print(grid_search.best_params_['gamma'])
    print("{:.4f}".format(grid_search.best_score_))
    print("{:.4f}".format(grid_search.score(X_test, y_test)), end='')
# Random Forest
from sklearn.ensemble import RandomForestClassifier
def bestRFClassifier(X,y):
    X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                        stratify=y, random_state=0)
    param_grid = {'n_estimators': [10, 20, 50, 100],
                  'max_features': ['auto', 'sqrt', 'log2'],
                  'max_leaf_nodes': [10, 20, 30]}
    grid_search = GridSearchCV(RandomForestClassifier(random_state=0,
                                                      criterion='entropy'), param_grid, cv=cvKFold, return_train_score=True)
    grid_search.fit(X_train, y_train)
    print(grid_search.best_params_['n_estimators'])
    print(grid_search.best_params_['max_features'])
    print(grid_search.best_params_['max_leaf_nodes'])
    print("{:.4f}".format(grid_search.best_score_))
    print("{:.4f}".format(grid_search.score(X_test, y_test)), end='')
import sys
import numpy as np
import pandas as pd
# Read the data file
df = pd.read_csv(sys.argv[1])
import numpy as np
# Preprocess data
# Replace missing data '?' with np.nan
df = df.replace('?', np.nan)
df_feature = df.iloc[:, 0:-1]
# Replace missing data with the mean value of the column
from sklearn.impute import SimpleImputer
imp = SimpleImputer(missing_values=np.nan, strategy='mean')
features = imp.fit_transform(df_feature)
# Normalise each attribute value and truncated to 4 decimal places
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# np.set_printoptions(formatter={'float_kind':"{:.4f}".format})
features1 = scaler.fit_transform(features)
# Save the 4 decimal truncated value as a list of string
data_list = []
for i in features1:
    temp = []
    for j in i:
        temp.append('%0.4f' % j)
    data_list.append(temp)
# Get a list of all the classes
classes = df.iloc[:, -1].tolist()
# Label encoding
from sklearn.preprocessing import LabelEncoder
labels = np.unique(classes)
lEnc = LabelEncoder()
lEnc.fit(labels)
label_encoder = lEnc.transform(classes)
numClass = len(labels)
label_encoder=label_encoder.astype(np.float64)
def p():
    # Print the preprocessed data
    for i in range(len(data_list)):
        for j in data_list[i]:
            print(j, end =',')
    if i < len(data_list) - 1:
        print(int(label_encoder[i]))
    else:
        print(int(label_encoder[i]), end='')
# Read the config file
def conf_file(file):
    conf = pd.read_csv(file)

    # Convert parameters to a list:
    parameters = conf.iloc[0].tolist()
    return parameters
if sys.argv[2] == 'NN':
    parameter_list = conf_file(sys.argv[3])
    K = int(parameter_list[0])
    kNNClassifier(features1, label_encoder, K)
if sys.argv[2] == 'LR':
    logregClassifier(features1, label_encoder)
if sys.argv[2] == 'NB':
    nbClassifier(features1, label_encoder)
if sys.argv[2] == 'DT':
    dtClassifier(features1, label_encoder)
if sys.argv[2] == 'BAG':
    parameter_list = conf_file(sys.argv[3])
    n_estimators = int(parameter_list[0])
    max_samples = int(parameter_list[1])
    max_depth = int(parameter_list[2])
    bagDTClassifier(features1, label_encoder, n_estimators, max_samples,
                    max_depth)
if sys.argv[2] == 'ADA':
    parameter_list = conf_file(sys.argv[3])
    n_estimators = int(parameter_list[0])
    learning_rate = parameter_list[1]
    max_depth = int(parameter_list[2])
    adaDTClassifier(features1, label_encoder, n_estimators,
                    learning_rate, max_depth)
if sys.argv[2] == 'GB':
    parameter_list = conf_file(sys.argv[3])
    n_estimators = int(parameter_list[0])
    learning_rate = parameter_list[1]
    gbClassifier(features1, label_encoder, n_estimators, learning_rate)
if sys.argv[2] == 'RF':
    bestRFClassifier(features1, label_encoder)
if sys.argv[2] == 'SVM':
    bestLinClassifier(features1, label_encoder)
if sys.argv[2] == 'P':
    p()