Zadaci za wannabe pythoniste

lines = open(filename).readlines()

for filename in sorted(glob.glob('*txt')):

Code:
for filename in sorted(glob.glob('*txt')):   # OK, sortiranje fajlova pre otvaranja, da bi išlo po godinama, mada kod men u WIn to je već sortirano.
    godina = int(filename[0:4])         # beleži prva 4 karaktera iz imena fajla, što je godina 
    lines = open(filename).readlines()       # učitava u memoriju ceo tekst fajla
    lista= set()                           # tip liste je skup, što znači nema ponavljanja
    for line in lines:      
        name = line.strip().split()[0]         # promenljiva name je indeks[0] u listi, npr. ['James', 32340]
        lista.add(name)                     # dodaje to ime u listu
                                                    OVDE IMAM PROBLEM: kad dovde izvršim program za jednu godinu sa: 
                                                    for filename in sorted(glob.glob('1990*txt')):)
                                                    u listi imam samo ženska imena:

{'Stephanie', 'Maria', 'Lindsay', 'Anna', 'Shannon', 'Julie', 'Hannah', 'Katie', 'Kelly', 'Lindsey', 'Kathleen', 'Ashley', 'Veronica', 
'Mary', 'Angela', 'Elizabeth', 'Cassandra', 'Shelby', 'Tiffany', 'Jenna', 'Brooke', 'Andrea', 'Tara', 'Jessica', 'Katelyn', 'Kelsey', 
'Amy', 'Erin', 'Alicia', 'Alexandra', 'Laura', 'Holly', 'Diana', 'Brianna', 'Gabrielle', 'Kathryn', 'Whitney', 'Sarah', 'Jennifer', 'Catherine',
 'Kristin', 'Emily', 'Amanda', 'Megan', 'Christine', 'Victoria', 'Alyssa', 'Courtney', 'Alexis', 'Erika', 'Melissa', 'Michelle', 'Danielle', 
'Sara', 'Kimberly', 'Katherine', 'Olivia', 'Ariel', 'Cynthia', 'Meghan', 'Rebecca', 'Samantha', 'Monica', 'Patricia', 'Leah', 'Christina', 
'Taylor', 'Julia', 'Morgan', 'Nicole', 'Heather', 'Marissa', 'Brittany', 'Rachel', 'April', 'Kaitlyn', 'Erica', 'Natalie', 'Brittney', 'Vanessa', 
'Caitlin', 'Abigail', 'Lisa', 'Jacqueline', 'Kristen', 'Chelsea', 'Kristina', 'Bianca', 'Molly', 'Alexandria', 'Paige', 'Jamie', 'Jordan', 'Kayla',
'Amber', 'Jasmine', 'Melanie', 'Lauren', 'Allison', 'Crystal'}

Šta se dešava sa muškim imenima? Koji je smisao ove liste?
I onda mi ni ovo što sledi nije jasno:

    if (godina not in imena):                      # U prvom fajlu iz godine X hashtable imena je prazna
        imena[godina] = lista
    else:                                                  # U drugom fajlu iz godine X trazimo uniq(m,f)
        imena[godina] = imena[godina].intersection(lista)

Code:
l = [1, 2, 3, 4, 5, 6]

l[1:]              # od indeksa 1 do kraja, u Pythonu indeksiranje pocinje od 0
[2, 3, 4, 5, 6]

ili sa slice

l[slice(1, None)]
[2, 3, 4, 5, 6]

l[::2]             # svaki drugi
[1, 3, 5]

ili

l[slice(None, None, 2)]
[1, 3, 5]

list(zip(l, l[1:]))
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]

Posto mi treba svaki drugi par, na primer za godine (1900, 1901), (1902, 1903), itd...

list(zip(l, l[1:]))[::2]
[(1, 2), (3, 4), (5, 6)]

Code:
import glob
import xlsxwriter

workbook = xlsxwriter.Workbook('Imena.xlsx')
worksheet = workbook.add_worksheet()

row = 0
col = 0
worksheet.write(row, col, 'Name')
worksheet.write(col, 1, 'Gender')

row = 0
col = 2
files = sorted(glob.glob('*txt'))
for file1, file2 in list(zip(files, files[1:]))[::2]:
    worksheet.write(row, col, file1[0:4])       #upisuje godine
    col += 1

col = 0
row = 1
it = iter(files)
for chunk in zip(it, it):
    for filename in list(chunk):
        if 'Boys' in filename:
            lines = open(filename).readlines()
            for item in lines:
                name = item.strip().split()[0]
                worksheet.write(row, col, name)        # upisuje imena
                worksheet.write(row, col + 1, 'M')      # upisuje pol
                row += 1
        else:
            lines = open(filename).readlines()
            for item in lines:
                name = item.strip().split()[0]
                worksheet.write(row, col, name)
                worksheet.write(row, col + 1, 'F')
                row += 1
col = 2
row = 1
it = iter(files)
for chunk in zip(it, it):
    for txt in list(chunk):
        lines = open(txt).readlines()
        for item in lines:
            broj = item.strip().split()[1]
            worksheet.write(row, col, broj)     # upisuje brojeve
            row += 1
    col += 1

col = 1
row = 1
for filename in files:
    if 'Boys' in filename:
        worksheet.write(row, col, 'M')
        row += 1
    else:
        worksheet.write(row, col, 'F')
        row += 1

workbook.close()

Code:

use std::ffi::{CString, CStr};
#[repr(C)]
struct lxw_workbook(*mut lxw_workbook);
#[repr(C)]
struct lxw_worksheet(*mut lxw_worksheet);
#[repr(C)]
#[derive(Clone)]
struct lxw_format(*mut lxw_format);
#[link(name="xlsxwriter",kind="dylib")]
extern "C" {
    fn workbook_new(wkbk: *const i8)->*mut lxw_workbook;
    fn workbook_add_worksheet(wkbk:*mut lxw_workbook, sheetname:*const i8)->*mut lxw_worksheet;
    fn workbook_add_format(wkbk:*mut lxw_workbook)->*mut lxw_format;
    fn workbook_close(wkbk:*mut lxw_workbook)->i32;
    fn lxw_strerror(errnum:i32)->*const i8;
    fn format_set_bg_color(fmt:*mut lxw_format, color: u32);
    fn worksheet_write_string(wksht:*mut lxw_worksheet, row:u32,col:u16,s:*const i8,fmt:*const lxw_format)->i32;
}
impl lxw_workbook {
    fn new(wkbk:&str)->lxw_workbook {
        unsafe {lxw_workbook(workbook_new(CString::new(wkbk).unwrap().as_ptr())) }
    }
    fn add_worksheet(&self,sheetname:&str)->lxw_worksheet {
        unsafe {lxw_worksheet(workbook_add_worksheet(self.0,CString::new(sheetname).unwrap().as_ptr())) }
    }
    fn add_format(&self)->lxw_format {
        unsafe {lxw_format(workbook_add_format(self.0)) }
    }
    fn close(&self)->i32{
        unsafe {workbook_close(self.0)}
    }
    fn strerror(errnum:i32)->&'static str {
        unsafe { CStr::from_ptr(lxw_strerror(errnum)).to_str().unwrap() }
    }
}
impl Drop for lxw_workbook {
    fn drop(&mut self) {
        let rc = self.close();
        if rc != 0 {
            panic!("{}",lxw_workbook::strerror(rc));
        }
    }
}
impl lxw_format {
    fn set_bg_color(&self, color: u32){
        unsafe { format_set_bg_color(self.0,color); }
    }
}
impl lxw_worksheet {
    fn write_string(&self, row:u32, col:u16, s:&str,fmt:lxw_format)->Result<(),String>{
        let s = CString::new(s);
        let rc;
        unsafe { rc = worksheet_write_string(self.0,row,col,s.unwrap().as_ptr(),fmt.0);}
        if rc == 0 {
            Ok(())
        }else {
            Err(lxw_workbook::strerror(rc).to_string())
        }
    }
}

use std::io;
use std::fs::File;
use std::fs::read_dir;
use std::io::prelude::*;
use std::collections::BTreeMap;
type map_t = BTreeMap<i32,i32>;
fn main()->io::Result<()>{
    let mut common:BTreeMap<String,Vec<(char,map_t)>> = BTreeMap::new();
    let mut buf = String::new();
    if let Ok(dir) = read_dir("BabyNames") {
        for file in dir {
            let file = file?;
            let mut f = File::open(file.path())?;
            let path = file.path();
            let fname = path.to_str().unwrap().to_string();
            let it = fname.split('_').collect::<Vec<_>>();
            let it1 = it[0].split('/').collect::<Vec<_>>();
            let year = it1[1].parse::<i32>().unwrap();
            let c = if it[1] == "GirlsNames.txt" {
                'F'
            } else {
                'M'
            };
            buf.clear();
            let _ = f.read_to_string(&mut buf);
            for line in buf.lines() {
                let two:Vec<_> = line.split_whitespace().collect();
                let r = common.entry(two[0].to_string()).or_insert(vec!{(c,map_t::new())});
                (*r).last_mut().unwrap().1.insert(year,two[1].parse::<i32>().unwrap());
            }
        }
    } else {
        println!("Not in directory above BabyNames...");
    }
    let wkbk = lxw_workbook::new("example.xlsx");
    let wksht = wkbk.add_worksheet("Names");
    let hc = wkbk.add_format();
    hc.set_bg_color(0xe0e0e0);
    let gc = wkbk.add_format();
    gc.set_bg_color(0xf9c7ff);
    let bc = wkbk.add_format();
    bc.set_bg_color(0xb8bbff);

    let _ = wksht.write_string(0,0, "Name",hc.clone());
    let _ = wksht.write_string(0,1, "Gender",hc.clone());
    for (ord,(name,pair)) in common.iter().enumerate() {
        for (gender,map) in pair.iter() {
            for (ord1,(year,value)) in map.iter().rev().enumerate() {
                let _ = wksht.write_string(0,ord1 as u16+2,year.to_string().as_str(),hc.clone());
                let clr;
                if *gender == 'F' {
                    clr = gc.clone();
                    let _ = wksht.write_string(ord as u32+1,0,name,gc.clone());
                    let _ = wksht.write_string(ord as u32+1,1,"F",gc.clone());
                } else {
                    clr = bc.clone();
                    let _ = wksht.write_string(ord as u32+1,0,name,bc.clone());
                    let _ = wksht.write_string(ord as u32+1,1,"M",bc.clone());
                }
                    let _ = wksht.write_string(ord as u32+1,ord1 as u16+2, value.to_string().as_str(),clr);
                }
            }
        }
    Ok(())
}

Code:

use std::ffi::{CString, CStr};
#[repr(C)]
struct lxw_workbook(*mut lxw_workbook);
#[repr(C)]
struct lxw_worksheet(*mut lxw_worksheet);
#[repr(C)]
#[derive(Clone)]
struct lxw_format(*mut lxw_format);
#[link(name="xlsxwriter",kind="dylib")]
extern "C" {
    fn workbook_new(wkbk: *const i8)->*mut lxw_workbook;
    fn workbook_add_worksheet(wkbk:*mut lxw_workbook, sheetname:*const i8)->*mut lxw_worksheet;
    fn workbook_add_format(wkbk:*mut lxw_workbook)->*mut lxw_format;
    fn workbook_close(wkbk:*mut lxw_workbook)->i32;
    fn lxw_strerror(errnum:i32)->*const i8;
    fn format_set_bg_color(fmt:*mut lxw_format, color: u32);
    fn worksheet_write_string(wksht:*mut lxw_worksheet, row:u32,col:u16,s:*const i8,fmt:*const lxw_format)->i32;
}
impl lxw_workbook {
    fn new(wkbk:&str)->lxw_workbook {
        unsafe {lxw_workbook(workbook_new(CString::new(wkbk).unwrap().as_ptr())) }
    }
    fn add_worksheet(&self,sheetname:&str)->lxw_worksheet {
        unsafe {lxw_worksheet(workbook_add_worksheet(self.0,CString::new(sheetname).unwrap().as_ptr())) }
    }
    fn add_format(&self)->lxw_format {
        unsafe {lxw_format(workbook_add_format(self.0)) }
    }
    fn close(&self)->i32{
        unsafe {workbook_close(self.0)}
    }
    fn strerror(errnum:i32)->&'static str {
        unsafe { CStr::from_ptr(lxw_strerror(errnum)).to_str().unwrap() }
    }
}
impl Drop for lxw_workbook {
    fn drop(&mut self) {
        let rc = self.close();
        if rc != 0 {
            panic!("{}",lxw_workbook::strerror(rc));
        }
    }
}
impl lxw_format {
    fn set_bg_color(&self, color: u32){
        unsafe { format_set_bg_color(self.0,color); }
    }
}
impl lxw_worksheet {
    fn write_string(&self, row:u32, col:u16, s:&str,fmt:lxw_format)->Result<(),String>{
        let s = CString::new(s);
        let rc;
        unsafe { rc = worksheet_write_string(self.0,row,col,s.unwrap().as_ptr(),fmt.0);}
        if rc == 0 {
            Ok(())
        }else {
            Err(lxw_workbook::strerror(rc).to_string())
        }
    }
}

use std::io;
use std::fs::File;
use std::fs::read_dir;
use std::io::prelude::*;
use std::collections::BTreeMap;
type map_t = BTreeMap<i32,i32>;
fn main()->io::Result<()>{
    let mut common:BTreeMap<String,Vec<(char,map_t)>> = BTreeMap::new();
    let mut buf = String::new();
    if let Ok(dir) = read_dir("BabyNames") {
        for file in dir {
            let file = file?;
            let mut f = File::open(file.path())?;
            let path = file.path();
            let fname = path.to_str().unwrap().to_string();
            let it = fname.split('_').collect::<Vec<_>>();
            let it1 = it[0].split('/').collect::<Vec<_>>();
            let year = it1[1].parse::<i32>().unwrap();
            let c = if it[1] == "GirlsNames.txt" {
                'F'
            } else {
                'M'
            };
            buf.clear();
            let _ = f.read_to_string(&mut buf);
            for line in buf.lines() {
                let two:Vec<_> = line.split_whitespace().collect();
                let r = common.entry(two[0].to_string()).or_insert(vec!{(c,map_t::new())});
                (*r).last_mut().unwrap().1.insert(year,two[1].parse::<i32>().unwrap());
            }
        }
    } else {
        println!("Not in directory above BabyNames...");
    }
    let wkbk = lxw_workbook::new("example.xlsx");
    let wksht = wkbk.add_worksheet("Names");
    let hc = wkbk.add_format();
    hc.set_bg_color(0xe0e0e0);
    let gc = wkbk.add_format();
    gc.set_bg_color(0xf9c7ff);
    let bc = wkbk.add_format();
    bc.set_bg_color(0xb8bbff);
    let mut years = BTreeMap::new();
    for (i,j) in (1900..=2012).rev().enumerate() {
        years.insert(j,i);
        let _ = wksht.write_string(0,i as u16+2,j.to_string().as_str(),hc.clone());
    }
    let _ = wksht.write_string(0,0, "Name",hc.clone());
    let _ = wksht.write_string(0,1, "Gender",hc.clone());
    for (ord,(name,pair)) in common.iter().enumerate() {
        for (gender,map) in pair.iter() {
            for (year,value) in map.iter().rev() {
                let clr;
                if *gender == 'F' {
                    clr = gc.clone();
                    let _ = wksht.write_string(ord as u32+1,0,name,gc.clone());
                    let _ = wksht.write_string(ord as u32+1,1,"F",gc.clone());
                } else {
                    clr = bc.clone();
                    let _ = wksht.write_string(ord as u32+1,0,name,bc.clone());
                    let _ = wksht.write_string(ord as u32+1,1,"M",bc.clone());
                }
                let _ = wksht.write_string(ord as u32+1,years[&*year]as u16+2,value.to_string().as_str(),clr);
            }
        }
    }
    Ok(())
}