--- a/src/ast_convert.rs
+++ b/src/ast_convert.rs
@@ -307,6 +307,7 @@ fn parse_expr(py: Python, ast: PyObject)
     let set_type = ast_module.get(py, "Set").unwrap();
     let setcomp_type = ast_module.get(py, "SetComp").unwrap();
     let generatorexp_type = ast_module.get(py, "GeneratorExp").unwrap();
+    let lambda_type = ast_module.get(py, "Lambda").unwrap();
 
     assert!(is_instance(&ast, &ast_type));
 
@@ -444,6 +445,14 @@ fn parse_expr(py: Python, ast: PyObject)
         let generators = parse_list(py, generators, parse_comprehension);
 
         expr::GeneratorExp(Box::new(elt), generators)
+    } else if is_instance(&ast, &lambda_type) {
+        let args = ast.getattr(py, "args").unwrap();
+        let body = ast.getattr(py, "body").unwrap();
+
+        let args = parse_arguments(py, args);
+        let body = parse_expr(py, body);
+
+        expr::Lambda(Box::new(args), Box::new(body))
     } else {
         println!("expr {}", ast);
         unreachable!()

--- a/src/ast_dump.rs
+++ b/src/ast_dump.rs
@@ -197,6 +197,7 @@ impl to_string_able for expr {
             expr::Set(elts) => format!("{{{}}}", vec_to_strings_vec(elts).join(", ")),
             expr::SetComp(elt, generators) => format!("{{{} {}}}", elt.to_string(), vec_to_strings_vec(generators).join(" ")),
             expr::GeneratorExp(elt, generators) => format!("({} {})", elt.to_string(), vec_to_strings_vec(generators).join(" ")),
+            expr::Lambda(args, body) => format!("lambda {}: {}", args.to_string(), body.to_string()),
         }
     }
 }

--- a/src/python_ast.rs
+++ b/src/python_ast.rs
@@ -81,7 +81,7 @@ pub enum expr {
     BoolOp(boolop, Vec<expr>),
     BinOp(Box<expr>, operator, Box<expr>),
     UnaryOp(unaryop, Box<expr>),
-    //Lambda(arguments, Box<expr>)
+    Lambda(Box<arguments>, Box<expr>),
     //IfExp(Box<expr>, Box<expr>, Box<expr>)
     //Dict(Vec<expr>, Vec<expr>)
     Set(Vec<expr>),

new file mode 100644
--- /dev/null
+++ b/tests/test_parse_files/test_lambda.py
@@ -0,0 +1,1 @@
+a = lambda x, y: (x, y)