Python从文件中创建字典

Question

我有这个Python代码，它不是正在读取我想要它准确读取的内容。 对于最坏的汽车，福特应该是最坏的汽车数量最多的汽车，但我仍然得到雪佛兰ssr的任何帮助？

这是文件的我正在使用的格式：

1899 Horsey Horseless 
1909 Ford Model T 
1911 Overland OctoAuto 
1913 Scripps-Booth Bi-Autogo 
1920 Briggs and Stratton Flyer 
1933 Fuller Dymaxion 
1934 Chrysler/Desoto Airflow 
1949 Crosley Hotshot 
1956 Renault Dauphine 
1957 King Midget Model III 

这是我的代码：

import string 

def car_dictionary(file_obj): 
    car_dict = {} 
    for line in file_obj: 
     line =line.strip() 
     line =line.split() 
     manufacturer = line[1] 
    if len(line) ==3: 
     car_tuple = (line[0],''.join(line[2:])) 
    else: 
     car_tuple = (line[0]) 
    if manufacturer in car_dict: 
     car_dict[manufacturer].append(car_tuple) 
    else: 
     car_dict[manufacturer] = [car_tuple] 

return car_dict 

def max_worst_cars(car_dict): 
    worst_manufacturer =("") 
    worst_count = 0 
    for a,b in car_dict.items(): 
     if len(b) > worst_count: 
      worst_manufacturer = a 
      worst_count = len(b) 
      print("Worse Manufacturer is: ", worst_manufacturer) 
      print("Cars: ") 
    for y, m in car_dict[worst_manufacturer]: 
     print(y,m) 

file_obj=open("cars.txt", "r") 
car_dict = car_dictionary(file_obj) 
file_obj.close() 
max_worst_cars(car_dict) 

Answer 1

从你的代码不正确indendation

除了（这可能是一个当您将其粘贴到问题中时出错），只有一个实际问题：

car_tuple = (line[0]) 

这不会构成元组，但只会将line[0]分配给car_tuple。为了使一个元组，你需要包括一个逗号：

car_tuple = (line[0],) 

然而，这不会改变后，你将有当您试图解开元组的问题，所以你应该只使用一个空字符串作为第二元组项目：

car_tuple = (line[0], '') 

那么，你的代码产生正确的结果：

Worse Manufacturer is: Ford 
Cars: 
1909 
1958 Edsel 
1971 Pinto 
1995 Explorer 
2000 Excursion 

---

这为S.通过使用更多的Python技巧，你可以做到这一点更简单。这是我的8线解决方案，加上注释，所以你明白这是怎么回事：

# We’re going to use `defaultdict` to handle the whole “when there is 
# already an element in the dictionay, append to the list, otherwise 
# create a new entry with a single list item” thing. `defaultdict` just 
# allows us to append without having to manually initialize new keys. 
from collections import defaultdict 

# Files should always be opened with the `with` statement, to ensure 
# that they are closed correctly afterwards. Since we’re reading, we 
# don’t need to specify the open mode ('r' is the default). 
with open('cars.txt') as f: 
    # We initialize our dictionary as a defaultdict, where each item 
    # is automatically initialized with an empty list. 
    cars = defaultdict(list) 

    for line in f: 
     # We put strip and split in a single line. Since we always 
     # get at least two values from your file format, we can just 
     # unpack the values directly. We collect additional unpacked 
     # values (so index 2 or above) in a list called `rest` (the 
     # star symbol does that). That list may be empty, or not. 
     year, manufacturer, *rest = line.strip().split() 

     # We just append (because it’s a defaultdict, we don’t need 
     # to initialize it) to the list of the manufacturer a tuple 
     # with the unpacked year, and the joined values of the rest. 
     cars[manufacturer].append((year, ' '.join(rest))) 

# Now that we collected our cars dictionary, we want to find the 
# manufacturer that has the highest number of cars. Since `cars` maps 
# the key manufacturer to the a list of cars (car tuples actually), we 
# essentially want to get the dictionary item with the maximum length 
# in the item value. We use the built-in `max` function with a custom 
# key function for this. 
# `cars.items()` returns a sequence of key/value tuples of the 
# dictionary. We want to get the maximum value of those key/value 
# tuples, and as a metric for “maximum value” we use a function that 
# takes this tuple `(manufacturer, listOfCarTuples)` and returns the 
# length of that `listOfCarTuples`. So in the key function, `x` is that 
# tuple, so `x[1]` is the list of car tuples. So the length of that list 
# is the metric of the current dictionary item which we want to get the 
# maximum from. 
worst = max(cars.items(), key=lambda x: len(x[1])) 

# `worst` is now `(manufacturer, listOfCarTuples)` where 
# `len(listOfCarTuples)` has the maximum value. 
print(worst)