CS130考试指南

string format

def calculate_average(list1):
    for i in range(len(list1)):
        list1[i]=float(list1[i])
    average=round((sum(list1)/len(list1)),2)
    return str("{0:.2f}".format(average))

read file

def read_words(filename):
    input_file=open(filename,"r")
    content=input_file.read()
    word_list=content.split()
    input_file.close()
    return word_list

求质因数

def prime_factors(num):
    list1=[]
    factor=2
    while num>=factor:
            if num%factor==0:
                num/=factor
                list1.append(factor)
            else:
                factor+=1
    return list1

doctest

def convert_to_roman(i):
    """Returns the Roman numeral

    Arguments:
        i: an integer to be converted

    Returns:
        A string containing the roman
        numerals representing i

    >>> convert_to_roman(1)
    'I'
    >>> convert_to_roman(9)
    'IX'
    >>> convert_to_roman(14)
    'XIV'
    >>> convert_to_roman(98)
    'XCVIII'
    >>> convert_to_roman(634)
    'DCXXXIV'
    >>> convert_to_roman(979)
    'CMLXXIX'
    >>> convert_to_roman(2445)
    'MMCDXLV'
    
    """
    ones = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX']
    tens = ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC']
    hundreds = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM']
    thousands = ['', 'M', 'MM', 'MMM']
    
    return (thousands[i//1000%4] +
            hundreds[i//100%10] +
            tens[i//10%10] +
            ones[i%10])

import doctest
doctest.testmod()

def get_contents(filename):
    input_file=open(filename,"r")
    contents=input_file.read()
    contents=contents.lower()
    return contents
def generate_frequency_table(filename):
    contents=get_contents(filename)
    word_dict={}
    for letter in contents:
        if letter.isalpha():
            if letter not in word_dict:
                word_dict[letter]=1
            else:
                word_dict[letter]+=1
    return word_dict
def get_largest_value(data):
    max_num=-1
    for num in data.keys():
        if data[num]>max_num:
            max_num=data[num]
    return max_num
def ordered_keys(dict1,ordering='key',ascending=True):
    list1=[]
    dict2={}
    if ordering=='key' and ascending==True:
        for key in sorted(dict1.keys()):
            list1.append(key)
    elif ordering=='key' and ascending==False:
        for key in sorted(dict1.keys(),reverse=True):
            list1.append(key)
    elif ordering=='value' and ascending==True:
        for key in dict1:
            dict2[dict1[key]]=key
        for key in sorted(dict2.keys()):
            list1.append(dict2[key])
    else:
        for key in dict1:
            dict2[dict1[key]]=key
        for key in sorted(dict2.keys(),reverse=True):
            list1.append(dict2[key])
    return list1
def generate_histogram_04(data, max_bar_length, ordering, ascending):
    list_of_letter=ordered_keys(data,ordering,ascending)
    ordered_dict={}
    for letter in list_of_letter:
        ordered_dict[letter]=data[letter]
    max_num=get_largest_value(data)
    scalar=max_num/max_bar_length
    for key in ordered_dict.keys():
        ordered_dict[key]=round(ordered_dict[key]/scalar)
    return ordered_dict
def check_orientation(orientation,ordered_dict,max_length):
    col=len(ordered_dict.keys())
    if orientation=='horizontal':
        for key in ordered_dict:
            print(key," ","X"*ordered_dict[key],"|"*(max_length-ordered_dict[key]),sep="")
    else:
        ve_list=[]
        n=col
        m=max_length
        ve_list=[['-']*m for i in range(n)]
        i=0
        key_string=""
        for key in ordered_dict:
            for j in range(m-1,m-ordered_dict[key]-1,-1):
                ve_list[i][j]="X"
            i+=1
            key_string+=key
        for i in range(m): 
            row="" 
            for j in range(n):
                row+=ve_list[j][i]
            print(row)
        print()
        print(key_string)
        
def display_frequency_final(filename, max_length = 10, ordering='key', ascending=True,orientation='vertical'):
    data=generate_frequency_table(filename)
    ordered_dict=generate_histogram_04(data, max_length, ordering, ascending)
    print_final=check_orientation(orientation,ordered_dict,max_length)
        

class strange_list:
    def __init__(self):
        self._data = []
        self._count = 0
    def add(self, item):
        if item not in self._data:
            self._count += 1
        self._data += [item]
    def remove(self, item):
        if item in self._data:
            self._count -= 1
            self._data.remove(item)
    def uniques(self):
        return self._count    
    def is_empty(self):
        return len(self._data) == 0  
    def size(self):
        return len(self._data)
    def __str__(self):
        return str(self._data)