sequence
stringlengths 546
16.2k
| code
stringlengths 108
19.3k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:to_json; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 16; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:sets; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:sets; 15, argument_list; 16, return_statement; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:sorted; 19, generator_expression; 19, 20; 19, 24; 20, call; 20, 21; 20, 22; 21, identifier:sorted; 22, argument_list; 22, 23; 23, identifier:x; 24, for_in_clause; 24, 25; 24, 26; 25, identifier:x; 26, identifier:sets | def to_json(self):
"""Returns the equivalence classes a sorted list of sorted lists."""
sets = self.sets()
return sorted(sorted(x) for x in sets) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:reload; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 14; 5, 15; 5, 16; 5, 17; 5, 23; 5, 24; 6, expression_statement; 6, 7; 7, string:'Generate histrow for each row and then reverse-sort by length.'; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:rows; 13, list:[]; 14, comment; 15, comment; 16, comment; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:discreteBinning; 22, argument_list; 23, comment; 24, for_statement; 24, 25; 24, 26; 24, 29; 25, identifier:c; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:nonKeyVisibleCols; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:c; 34, identifier:_cachedValues; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:collections; 38, identifier:OrderedDict; 39, argument_list | def reload(self):
'Generate histrow for each row and then reverse-sort by length.'
self.rows = []
# if len(self.origCols) == 1 and self.origCols[0].type in (int, float, currency):
# self.numericBinning()
# else:
self.discreteBinning()
# automatically add cache to all columns now that everything is binned
for c in self.nonKeyVisibleCols:
c._cachedValues = collections.OrderedDict() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:resolve_colors; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:colorstack; 6, block; 6, 7; 6, 9; 6, 15; 6, 37; 7, expression_statement; 7, 8; 8, string:'Returns the curses attribute for the colorstack, a list of color option names sorted highest-precedence color first.'; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:attr; 12, call; 12, 13; 12, 14; 13, identifier:CursesAttr; 14, argument_list; 15, for_statement; 15, 16; 15, 17; 15, 18; 16, identifier:coloropt; 17, identifier:colorstack; 18, block; 18, 19; 18, 28; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:c; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:get_color; 26, argument_list; 26, 27; 27, identifier:coloropt; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:attr; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:attr; 34, identifier:update_attr; 35, argument_list; 35, 36; 36, identifier:c; 37, return_statement; 37, 38; 38, identifier:attr | def resolve_colors(self, colorstack):
'Returns the curses attribute for the colorstack, a list of color option names sorted highest-precedence color first.'
attr = CursesAttr()
for coloropt in colorstack:
c = self.get_color(coloropt)
attr = attr.update_attr(c)
return attr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get_mentions; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:docs; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, False; 11, block; 11, 12; 11, 14; 11, 18; 11, 172; 12, expression_statement; 12, 13; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:result; 17, list:[]; 18, if_statement; 18, 19; 18, 20; 18, 112; 19, identifier:docs; 20, block; 20, 21; 20, 35; 20, 36; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:docs; 24, conditional_expression:if; 24, 25; 24, 26; 24, 33; 25, identifier:docs; 26, call; 26, 27; 26, 28; 27, identifier:isinstance; 28, argument_list; 28, 29; 28, 30; 29, identifier:docs; 30, tuple; 30, 31; 30, 32; 31, identifier:list; 32, identifier:tuple; 33, list:[docs]; 33, 34; 34, identifier:docs; 35, comment; 36, for_statement; 36, 37; 36, 38; 36, 41; 37, identifier:mention_class; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:mention_classes; 41, block; 41, 42; 41, 83; 41, 105; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:mentions; 45, parenthesized_expression; 45, 46; 46, call; 46, 47; 46, 82; 47, attribute; 47, 48; 47, 81; 48, call; 48, 49; 48, 77; 49, attribute; 49, 50; 49, 76; 50, call; 50, 51; 50, 61; 51, attribute; 51, 52; 51, 60; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:session; 57, identifier:query; 58, argument_list; 58, 59; 59, identifier:mention_class; 60, identifier:filter; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:mention_class; 66, identifier:document_id; 67, identifier:in_; 68, argument_list; 68, 69; 69, list_comprehension; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:doc; 72, identifier:id; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:doc; 75, identifier:docs; 76, identifier:order_by; 77, argument_list; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:mention_class; 80, identifier:id; 81, identifier:all; 82, argument_list; 83, if_statement; 83, 84; 83, 85; 84, identifier:sort; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:mentions; 89, call; 89, 90; 89, 91; 90, identifier:sorted; 91, argument_list; 91, 92; 91, 93; 92, identifier:mentions; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:key; 95, lambda; 95, 96; 95, 98; 96, lambda_parameters; 96, 97; 97, identifier:x; 98, call; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:x; 102, integer:0; 103, identifier:get_stable_id; 104, argument_list; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:result; 109, identifier:append; 110, argument_list; 110, 111; 111, identifier:mentions; 112, else_clause; 112, 113; 113, block; 113, 114; 114, for_statement; 114, 115; 114, 116; 114, 119; 115, identifier:mention_class; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:mention_classes; 119, block; 119, 120; 119, 143; 119, 165; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:mentions; 123, parenthesized_expression; 123, 124; 124, call; 124, 125; 124, 142; 125, attribute; 125, 126; 125, 141; 126, call; 126, 127; 126, 137; 127, attribute; 127, 128; 127, 136; 128, call; 128, 129; 128, 134; 129, attribute; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:session; 133, identifier:query; 134, argument_list; 134, 135; 135, identifier:mention_class; 136, identifier:order_by; 137, argument_list; 137, 138; 138, attribute; 138, 139; 138, 140; 139, identifier:mention_class; 140, identifier:id; 141, identifier:all; 142, argument_list; 143, if_statement; 143, 144; 143, 145; 144, identifier:sort; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:mentions; 149, call; 149, 150; 149, 151; 150, identifier:sorted; 151, argument_list; 151, 152; 151, 153; 152, identifier:mentions; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:key; 155, lambda; 155, 156; 155, 158; 156, lambda_parameters; 156, 157; 157, identifier:x; 158, call; 158, 159; 158, 164; 159, attribute; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:x; 162, integer:0; 163, identifier:get_stable_id; 164, argument_list; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:result; 169, identifier:append; 170, argument_list; 170, 171; 171, identifier:mentions; 172, return_statement; 172, 173; 173, identifier:result | def get_mentions(self, docs=None, sort=False):
"""Return a list of lists of the mentions associated with this extractor.
Each list of the return will contain the Mentions for one of the
mention classes associated with the MentionExtractor.
:param docs: If provided, return Mentions from these documents. Else,
return all Mentions.
:param sort: If sort is True, then return all Mentions sorted by stable_id.
:type sort: bool
:return: Mentions for each mention_class.
:rtype: List of lists.
"""
result = []
if docs:
docs = docs if isinstance(docs, (list, tuple)) else [docs]
# Get cands from all splits
for mention_class in self.mention_classes:
mentions = (
self.session.query(mention_class)
.filter(mention_class.document_id.in_([doc.id for doc in docs]))
.order_by(mention_class.id)
.all()
)
if sort:
mentions = sorted(mentions, key=lambda x: x[0].get_stable_id())
result.append(mentions)
else:
for mention_class in self.mention_classes:
mentions = (
self.session.query(mention_class).order_by(mention_class.id).all()
)
if sort:
mentions = sorted(mentions, key=lambda x: x[0].get_stable_id())
result.append(mentions)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_candidates; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:docs; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:split; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort; 13, False; 14, block; 14, 15; 14, 17; 14, 21; 14, 249; 15, expression_statement; 15, 16; 16, comment; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:result; 20, list:[]; 21, if_statement; 21, 22; 21, 23; 21, 132; 22, identifier:docs; 23, block; 23, 24; 23, 38; 23, 39; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:docs; 27, conditional_expression:if; 27, 28; 27, 29; 27, 36; 28, identifier:docs; 29, call; 29, 30; 29, 31; 30, identifier:isinstance; 31, argument_list; 31, 32; 31, 33; 32, identifier:docs; 33, tuple; 33, 34; 33, 35; 34, identifier:list; 35, identifier:tuple; 36, list:[docs]; 36, 37; 37, identifier:docs; 38, comment; 39, for_statement; 39, 40; 39, 41; 39, 44; 40, identifier:candidate_class; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:candidate_classes; 44, block; 44, 45; 44, 86; 44, 125; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:cands; 48, parenthesized_expression; 48, 49; 49, call; 49, 50; 49, 85; 50, attribute; 50, 51; 50, 84; 51, call; 51, 52; 51, 80; 52, attribute; 52, 53; 52, 79; 53, call; 53, 54; 53, 64; 54, attribute; 54, 55; 54, 63; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:session; 60, identifier:query; 61, argument_list; 61, 62; 62, identifier:candidate_class; 63, identifier:filter; 64, argument_list; 64, 65; 65, call; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:candidate_class; 69, identifier:document_id; 70, identifier:in_; 71, argument_list; 71, 72; 72, list_comprehension; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:doc; 75, identifier:id; 76, for_in_clause; 76, 77; 76, 78; 77, identifier:doc; 78, identifier:docs; 79, identifier:order_by; 80, argument_list; 80, 81; 81, attribute; 81, 82; 81, 83; 82, identifier:candidate_class; 83, identifier:id; 84, identifier:all; 85, argument_list; 86, if_statement; 86, 87; 86, 88; 87, identifier:sort; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:cands; 92, call; 92, 93; 92, 94; 93, identifier:sorted; 94, argument_list; 94, 95; 94, 96; 95, identifier:cands; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:key; 98, lambda; 98, 99; 98, 101; 99, lambda_parameters; 99, 100; 100, identifier:x; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, string:" "; 104, identifier:join; 105, argument_list; 105, 106; 106, list_comprehension; 106, 107; 106, 116; 107, call; 107, 108; 107, 115; 108, attribute; 108, 109; 108, 114; 109, subscript; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:x; 112, identifier:i; 113, integer:0; 114, identifier:get_stable_id; 115, argument_list; 116, for_in_clause; 116, 117; 116, 118; 117, identifier:i; 118, call; 118, 119; 118, 120; 119, identifier:range; 120, argument_list; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:len; 123, argument_list; 123, 124; 124, identifier:x; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:result; 129, identifier:append; 130, argument_list; 130, 131; 131, identifier:cands; 132, else_clause; 132, 133; 133, block; 133, 134; 134, for_statement; 134, 135; 134, 136; 134, 139; 134, 140; 135, identifier:candidate_class; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:candidate_classes; 139, comment; 140, block; 140, 141; 140, 168; 140, 203; 140, 242; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:sub_query; 144, parenthesized_expression; 144, 145; 145, call; 145, 146; 145, 167; 146, attribute; 146, 147; 146, 166; 147, call; 147, 148; 147, 160; 148, attribute; 148, 149; 148, 159; 149, call; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:session; 154, identifier:query; 155, argument_list; 155, 156; 156, attribute; 156, 157; 156, 158; 157, identifier:Candidate; 158, identifier:id; 159, identifier:filter; 160, argument_list; 160, 161; 161, comparison_operator:==; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:Candidate; 164, identifier:split; 165, identifier:split; 166, identifier:subquery; 167, argument_list; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:cands; 171, parenthesized_expression; 171, 172; 172, call; 172, 173; 172, 202; 173, attribute; 173, 174; 173, 201; 174, call; 174, 175; 174, 197; 175, attribute; 175, 176; 175, 196; 176, call; 176, 177; 176, 187; 177, attribute; 177, 178; 177, 186; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:session; 183, identifier:query; 184, argument_list; 184, 185; 185, identifier:candidate_class; 186, identifier:filter; 187, argument_list; 187, 188; 188, call; 188, 189; 188, 194; 189, attribute; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:candidate_class; 192, identifier:id; 193, identifier:in_; 194, argument_list; 194, 195; 195, identifier:sub_query; 196, identifier:order_by; 197, argument_list; 197, 198; 198, attribute; 198, 199; 198, 200; 199, identifier:candidate_class; 200, identifier:id; 201, identifier:all; 202, argument_list; 203, if_statement; 203, 204; 203, 205; 204, identifier:sort; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:cands; 209, call; 209, 210; 209, 211; 210, identifier:sorted; 211, argument_list; 211, 212; 211, 213; 212, identifier:cands; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:key; 215, lambda; 215, 216; 215, 218; 216, lambda_parameters; 216, 217; 217, identifier:x; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, string:" "; 221, identifier:join; 222, argument_list; 222, 223; 223, list_comprehension; 223, 224; 223, 233; 224, call; 224, 225; 224, 232; 225, attribute; 225, 226; 225, 231; 226, subscript; 226, 227; 226, 230; 227, subscript; 227, 228; 227, 229; 228, identifier:x; 229, identifier:i; 230, integer:0; 231, identifier:get_stable_id; 232, argument_list; 233, for_in_clause; 233, 234; 233, 235; 234, identifier:i; 235, call; 235, 236; 235, 237; 236, identifier:range; 237, argument_list; 237, 238; 238, call; 238, 239; 238, 240; 239, identifier:len; 240, argument_list; 240, 241; 241, identifier:x; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:result; 246, identifier:append; 247, argument_list; 247, 248; 248, identifier:cands; 249, return_statement; 249, 250; 250, identifier:result | def get_candidates(self, docs=None, split=0, sort=False):
"""Return a list of lists of the candidates associated with this extractor.
Each list of the return will contain the candidates for one of the
candidate classes associated with the CandidateExtractor.
:param docs: If provided, return candidates from these documents from
all splits.
:type docs: list, tuple of ``Documents``.
:param split: If docs is None, then return all the candidates from this
split.
:type split: int
:param sort: If sort is True, then return all candidates sorted by stable_id.
:type sort: bool
:return: Candidates for each candidate_class.
:rtype: List of lists of ``Candidates``.
"""
result = []
if docs:
docs = docs if isinstance(docs, (list, tuple)) else [docs]
# Get cands from all splits
for candidate_class in self.candidate_classes:
cands = (
self.session.query(candidate_class)
.filter(candidate_class.document_id.in_([doc.id for doc in docs]))
.order_by(candidate_class.id)
.all()
)
if sort:
cands = sorted(
cands,
key=lambda x: " ".join(
[x[i][0].get_stable_id() for i in range(len(x))]
),
)
result.append(cands)
else:
for candidate_class in self.candidate_classes:
# Filter by candidate_ids in a particular split
sub_query = (
self.session.query(Candidate.id)
.filter(Candidate.split == split)
.subquery()
)
cands = (
self.session.query(candidate_class)
.filter(candidate_class.id.in_(sub_query))
.order_by(candidate_class.id)
.all()
)
if sort:
cands = sorted(
cands,
key=lambda x: " ".join(
[x[i][0].get_stable_id() for i in range(len(x))]
),
)
result.append(cands)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:text; 6, default_parameter; 6, 7; 6, 8; 7, identifier:checked; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, block; 12, 13; 12, 15; 12, 31; 12, 37; 12, 43; 12, 54; 12, 62; 12, 69; 13, expression_statement; 13, 14; 14, comment; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:node; 18, call; 18, 19; 18, 20; 19, identifier:ListItem; 20, argument_list; 20, 21; 20, 26; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:parent_id; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:id; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:parent_server_id; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:server_id; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:node; 35, identifier:checked; 36, identifier:checked; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:node; 41, identifier:text; 42, identifier:text; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:sort; 46, None; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:node; 52, identifier:sort; 53, identifier:sort; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:append; 59, argument_list; 59, 60; 59, 61; 60, identifier:node; 61, True; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:touch; 67, argument_list; 67, 68; 68, True; 69, return_statement; 69, 70; 70, identifier:node | def add(self, text, checked=False, sort=None):
"""Add a new item to the list.
Args:
text (str): The text.
checked (bool): Whether this item is checked.
sort (int): Item id for sorting.
"""
node = ListItem(parent_id=self.id, parent_server_id=self.server_id)
node.checked = checked
node.text = text
if sort is not None:
node.sort = sort
self.append(node, True)
self.touch(True)
return node |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:items_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, identifier:items; 6, block; 6, 7; 6, 9; 6, 152; 6, 192; 7, expression_statement; 7, 8; 8, comment; 9, class_definition; 9, 10; 9, 11; 9, 13; 10, identifier:t; 11, argument_list; 11, 12; 12, identifier:tuple; 13, block; 13, 14; 13, 16; 13, 62; 13, 77; 13, 92; 13, 107; 13, 122; 13, 137; 14, expression_statement; 14, 15; 15, comment; 16, function_definition; 16, 17; 16, 18; 16, 21; 17, function_name:__cmp__; 18, parameters; 18, 19; 18, 20; 19, identifier:self; 20, identifier:other; 21, block; 21, 22; 21, 60; 22, for_statement; 22, 23; 22, 26; 22, 35; 23, pattern_list; 23, 24; 23, 25; 24, identifier:a; 25, identifier:b; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:six; 30, identifier:moves; 31, identifier:zip_longest; 32, argument_list; 32, 33; 32, 34; 33, identifier:self; 34, identifier:other; 35, block; 35, 36; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:!=; 37, 38; 37, 39; 38, identifier:a; 39, identifier:b; 40, block; 40, 41; 40, 48; 40, 56; 41, if_statement; 41, 42; 41, 45; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:a; 44, None; 45, block; 45, 46; 46, return_statement; 46, 47; 47, integer:1; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:b; 51, None; 52, block; 52, 53; 53, return_statement; 53, 54; 54, unary_operator:-; 54, 55; 55, integer:1; 56, return_statement; 56, 57; 57, binary_operator:-; 57, 58; 57, 59; 58, identifier:a; 59, identifier:b; 60, return_statement; 60, 61; 61, integer:0; 62, function_definition; 62, 63; 62, 64; 62, 67; 63, function_name:__lt__; 64, parameters; 64, 65; 64, 66; 65, identifier:self; 66, identifier:other; 67, block; 67, 68; 68, return_statement; 68, 69; 69, comparison_operator:<; 69, 70; 69, 76; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:__cmp__; 74, argument_list; 74, 75; 75, identifier:other; 76, integer:0; 77, function_definition; 77, 78; 77, 79; 77, 82; 78, function_name:__gt_; 79, parameters; 79, 80; 79, 81; 80, identifier:self; 81, identifier:other; 82, block; 82, 83; 83, return_statement; 83, 84; 84, comparison_operator:>; 84, 85; 84, 91; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:__cmp__; 89, argument_list; 89, 90; 90, identifier:other; 91, integer:0; 92, function_definition; 92, 93; 92, 94; 92, 97; 93, function_name:__le__; 94, parameters; 94, 95; 94, 96; 95, identifier:self; 96, identifier:other; 97, block; 97, 98; 98, return_statement; 98, 99; 99, comparison_operator:<=; 99, 100; 99, 106; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:__cmp__; 104, argument_list; 104, 105; 105, identifier:other; 106, integer:0; 107, function_definition; 107, 108; 107, 109; 107, 112; 108, function_name:__ge_; 109, parameters; 109, 110; 109, 111; 110, identifier:self; 111, identifier:other; 112, block; 112, 113; 113, return_statement; 113, 114; 114, comparison_operator:>=; 114, 115; 114, 121; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:__cmp__; 119, argument_list; 119, 120; 120, identifier:other; 121, integer:0; 122, function_definition; 122, 123; 122, 124; 122, 127; 123, function_name:__eq__; 124, parameters; 124, 125; 124, 126; 125, identifier:self; 126, identifier:other; 127, block; 127, 128; 128, return_statement; 128, 129; 129, comparison_operator:==; 129, 130; 129, 136; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:__cmp__; 134, argument_list; 134, 135; 135, identifier:other; 136, integer:0; 137, function_definition; 137, 138; 137, 139; 137, 142; 138, function_name:__ne__; 139, parameters; 139, 140; 139, 141; 140, identifier:self; 141, identifier:other; 142, block; 142, 143; 143, return_statement; 143, 144; 144, comparison_operator:!=; 144, 145; 144, 151; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:__cmp__; 149, argument_list; 149, 150; 150, identifier:other; 151, integer:0; 152, function_definition; 152, 153; 152, 154; 152, 156; 153, function_name:key_func; 154, parameters; 154, 155; 155, identifier:x; 156, block; 156, 157; 156, 181; 157, if_statement; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:x; 160, identifier:indented; 161, block; 161, 162; 162, return_statement; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:t; 165, argument_list; 165, 166; 166, tuple; 166, 167; 166, 175; 167, call; 167, 168; 167, 169; 168, identifier:int; 169, argument_list; 169, 170; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:x; 173, identifier:parent_item; 174, identifier:sort; 175, call; 175, 176; 175, 177; 176, identifier:int; 177, argument_list; 177, 178; 178, attribute; 178, 179; 178, 180; 179, identifier:x; 180, identifier:sort; 181, return_statement; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:t; 184, argument_list; 184, 185; 185, tuple; 185, 186; 186, call; 186, 187; 186, 188; 187, identifier:int; 188, argument_list; 188, 189; 189, attribute; 189, 190; 189, 191; 190, identifier:x; 191, identifier:sort; 192, return_statement; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:sorted; 195, argument_list; 195, 196; 195, 197; 195, 200; 196, identifier:items; 197, keyword_argument; 197, 198; 197, 199; 198, identifier:key; 199, identifier:key_func; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:reverse; 202, True | def items_sort(cls, items):
"""Sort list items, taking into account parent items.
Args:
items (list[gkeepapi.node.ListItem]): Items to sort.
Returns:
list[gkeepapi.node.ListItem]: Sorted items.
"""
class t(tuple):
"""Tuple with element-based sorting"""
def __cmp__(self, other):
for a, b in six.moves.zip_longest(self, other):
if a != b:
if a is None:
return 1
if b is None:
return -1
return a - b
return 0
def __lt__(self, other):
return self.__cmp__(other) < 0
def __gt_(self, other):
return self.__cmp__(other) > 0
def __le__(self, other):
return self.__cmp__(other) <= 0
def __ge_(self, other):
return self.__cmp__(other) >= 0
def __eq__(self, other):
return self.__cmp__(other) == 0
def __ne__(self, other):
return self.__cmp__(other) != 0
def key_func(x):
if x.indented:
return t((int(x.parent_item.sort), int(x.sort)))
return t((int(x.sort), ))
return sorted(items, key=key_func, reverse=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:text; 6, default_parameter; 6, 7; 6, 8; 7, identifier:checked; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, block; 12, 13; 12, 15; 12, 29; 12, 42; 12, 49; 13, expression_statement; 13, 14; 14, comment; 15, if_statement; 15, 16; 15, 21; 16, comparison_operator:is; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:parent; 20, None; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:exception; 26, identifier:InvalidException; 27, argument_list; 27, 28; 28, string:'Item has no parent'; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:node; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:parent; 37, identifier:add; 38, argument_list; 38, 39; 38, 40; 38, 41; 39, identifier:text; 40, identifier:checked; 41, identifier:sort; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:indent; 47, argument_list; 47, 48; 48, identifier:node; 49, return_statement; 49, 50; 50, identifier:node | def add(self, text, checked=False, sort=None):
"""Add a new sub item to the list. This item must already be attached to a list.
Args:
text (str): The text.
checked (bool): Whether this item is checked.
sort (int): Item id for sorting.
"""
if self.parent is None:
raise exception.InvalidException('Item has no parent')
node = self.parent.add(text, checked, sort)
self.indent(node)
return node |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_subsections; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:srcdir; 5, identifier:examples_dir; 6, identifier:sortkey; 7, block; 7, 8; 7, 10; 7, 41; 7, 53; 7, 69; 7, 79; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:subfolders; 13, list_comprehension; 13, 14; 13, 15; 13, 23; 14, identifier:subfolder; 15, for_in_clause; 15, 16; 15, 17; 16, identifier:subfolder; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:os; 20, identifier:listdir; 21, argument_list; 21, 22; 22, identifier:examples_dir; 23, if_clause; 23, 24; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:os; 28, identifier:path; 29, identifier:exists; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:os; 35, identifier:path; 36, identifier:join; 37, argument_list; 37, 38; 37, 39; 37, 40; 38, identifier:examples_dir; 39, identifier:subfolder; 40, string:'README.txt'; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:base_examples_dir_path; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:os; 48, identifier:path; 49, identifier:relpath; 50, argument_list; 50, 51; 50, 52; 51, identifier:examples_dir; 52, identifier:srcdir; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:subfolders_with_path; 56, list_comprehension; 56, 57; 56, 66; 57, call; 57, 58; 57, 63; 58, attribute; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:os; 61, identifier:path; 62, identifier:join; 63, argument_list; 63, 64; 63, 65; 64, identifier:base_examples_dir_path; 65, identifier:item; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:item; 68, identifier:subfolders; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:sorted_subfolders; 72, call; 72, 73; 72, 74; 73, identifier:sorted; 74, argument_list; 74, 75; 74, 76; 75, identifier:subfolders_with_path; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:key; 78, identifier:sortkey; 79, return_statement; 79, 80; 80, list_comprehension; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:subfolders; 83, identifier:i; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:i; 86, list_comprehension; 86, 87; 86, 93; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:subfolders_with_path; 90, identifier:index; 91, argument_list; 91, 92; 92, identifier:item; 93, for_in_clause; 93, 94; 93, 95; 94, identifier:item; 95, identifier:sorted_subfolders | def get_subsections(srcdir, examples_dir, sortkey):
"""Return the list of subsections of a gallery
Parameters
----------
srcdir : str
absolute path to directory containing conf.py
examples_dir : str
path to the examples directory relative to conf.py
sortkey : callable
The sort key to use.
Returns
-------
out : list
sorted list of gallery subsection folder names
"""
subfolders = [subfolder for subfolder in os.listdir(examples_dir)
if os.path.exists(os.path.join(
examples_dir, subfolder, 'README.txt'))]
base_examples_dir_path = os.path.relpath(examples_dir, srcdir)
subfolders_with_path = [os.path.join(base_examples_dir_path, item)
for item in subfolders]
sorted_subfolders = sorted(subfolders_with_path, key=sortkey)
return [subfolders[i] for i in [subfolders_with_path.index(item)
for item in sorted_subfolders]] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 1, 18; 2, function_name:alphabetical_sort; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:list_to_sort; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:Iterable; 9, type_parameter; 9, 10; 10, type; 10, 11; 11, identifier:str; 12, type; 12, 13; 13, generic_type; 13, 14; 13, 15; 14, identifier:List; 15, type_parameter; 15, 16; 16, type; 16, 17; 17, identifier:str; 18, block; 18, 19; 18, 21; 19, expression_statement; 19, 20; 20, comment; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:sorted; 24, argument_list; 24, 25; 24, 26; 25, identifier:list_to_sort; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:key; 28, identifier:norm_fold | def alphabetical_sort(list_to_sort: Iterable[str]) -> List[str]:
"""Sorts a list of strings alphabetically.
For example: ['a1', 'A11', 'A2', 'a22', 'a3']
To sort a list in place, don't call this method, which makes a copy. Instead, do this:
my_list.sort(key=norm_fold)
:param list_to_sort: the list being sorted
:return: the sorted list
"""
return sorted(list_to_sort, key=norm_fold) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 1, 18; 2, function_name:natural_sort; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:list_to_sort; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:Iterable; 9, type_parameter; 9, 10; 10, type; 10, 11; 11, identifier:str; 12, type; 12, 13; 13, generic_type; 13, 14; 13, 15; 14, identifier:List; 15, type_parameter; 15, 16; 16, type; 16, 17; 17, identifier:str; 18, block; 18, 19; 18, 21; 19, expression_statement; 19, 20; 20, comment; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:sorted; 24, argument_list; 24, 25; 24, 26; 25, identifier:list_to_sort; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:key; 28, identifier:natural_keys | def natural_sort(list_to_sort: Iterable[str]) -> List[str]:
"""
Sorts a list of strings case insensitively as well as numerically.
For example: ['a1', 'A2', 'a3', 'A11', 'a22']
To sort a list in place, don't call this method, which makes a copy. Instead, do this:
my_list.sort(key=natural_keys)
:param list_to_sort: the list being sorted
:return: the list sorted naturally
"""
return sorted(list_to_sort, key=natural_keys) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:find; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:_clauses; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 12; 9, 23; 9, 33; 9, 43; 9, 53; 9, 63; 9, 73; 9, 86; 9, 95; 9, 107; 9, 126; 9, 142; 9, 150; 9, 176; 10, expression_statement; 10, 11; 11, comment; 12, if_statement; 12, 13; 12, 17; 13, not_operator; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:exists; 17, block; 17, 18; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:iter; 21, argument_list; 21, 22; 22, list:[]; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:_limit; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:kwargs; 29, identifier:pop; 30, argument_list; 30, 31; 30, 32; 31, string:'_limit'; 32, None; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:_offset; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:kwargs; 39, identifier:pop; 40, argument_list; 40, 41; 40, 42; 41, string:'_offset'; 42, integer:0; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:order_by; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:kwargs; 49, identifier:pop; 50, argument_list; 50, 51; 50, 52; 51, string:'order_by'; 52, None; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:_streamed; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:kwargs; 59, identifier:pop; 60, argument_list; 60, 61; 60, 62; 61, string:'_streamed'; 62, False; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:_step; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:kwargs; 69, identifier:pop; 70, argument_list; 70, 71; 70, 72; 71, string:'_step'; 72, identifier:QUERY_STEP; 73, if_statement; 73, 74; 73, 81; 74, boolean_operator:or; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:_step; 77, False; 78, comparison_operator:==; 78, 79; 78, 80; 79, identifier:_step; 80, integer:0; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:_step; 85, None; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:order_by; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:_args_to_order_by; 93, argument_list; 93, 94; 94, identifier:order_by; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:args; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_args_to_clause; 102, argument_list; 102, 103; 102, 104; 103, identifier:kwargs; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:clauses; 106, identifier:_clauses; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:query; 110, call; 110, 111; 110, 116; 111, attribute; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:table; 115, identifier:select; 116, argument_list; 116, 117; 116, 120; 116, 123; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:whereclause; 119, identifier:args; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:limit; 122, identifier:_limit; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:offset; 125, identifier:_offset; 126, if_statement; 126, 127; 126, 131; 127, call; 127, 128; 127, 129; 128, identifier:len; 129, argument_list; 129, 130; 130, identifier:order_by; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:query; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:query; 138, identifier:order_by; 139, argument_list; 139, 140; 140, list_splat; 140, 141; 141, identifier:order_by; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:conn; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:db; 149, identifier:executable; 150, if_statement; 150, 151; 150, 152; 151, identifier:_streamed; 152, block; 152, 153; 152, 165; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:conn; 156, call; 156, 157; 156, 164; 157, attribute; 157, 158; 157, 163; 158, attribute; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:db; 162, identifier:engine; 163, identifier:connect; 164, argument_list; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:conn; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:conn; 171, identifier:execution_options; 172, argument_list; 172, 173; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:stream_results; 175, True; 176, return_statement; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:ResultIter; 179, argument_list; 179, 180; 179, 186; 179, 193; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:conn; 183, identifier:execute; 184, argument_list; 184, 185; 185, identifier:query; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:row_type; 188, attribute; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:db; 192, identifier:row_type; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:step; 195, identifier:_step | def find(self, *_clauses, **kwargs):
"""Perform a simple search on the table.
Simply pass keyword arguments as ``filter``.
::
results = table.find(country='France')
results = table.find(country='France', year=1980)
Using ``_limit``::
# just return the first 10 rows
results = table.find(country='France', _limit=10)
You can sort the results by single or multiple columns. Append a minus
sign to the column name for descending order::
# sort results by a column 'year'
results = table.find(country='France', order_by='year')
# return all rows sorted by multiple columns (descending by year)
results = table.find(order_by=['country', '-year'])
To perform complex queries with advanced filters or to perform
aggregation, use :py:meth:`db.query() <dataset.Database.query>`
instead.
"""
if not self.exists:
return iter([])
_limit = kwargs.pop('_limit', None)
_offset = kwargs.pop('_offset', 0)
order_by = kwargs.pop('order_by', None)
_streamed = kwargs.pop('_streamed', False)
_step = kwargs.pop('_step', QUERY_STEP)
if _step is False or _step == 0:
_step = None
order_by = self._args_to_order_by(order_by)
args = self._args_to_clause(kwargs, clauses=_clauses)
query = self.table.select(whereclause=args,
limit=_limit,
offset=_offset)
if len(order_by):
query = query.order_by(*order_by)
conn = self.db.executable
if _streamed:
conn = self.db.engine.connect()
conn = conn.execution_options(stream_results=True)
return ResultIter(conn.execute(query),
row_type=self.db.row_type,
step=_step) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 1, 6; 2, function_name:find_write_contribs; 3, parameters; 4, type; 4, 5; 5, None; 6, block; 6, 7; 6, 9; 6, 13; 6, 14; 6, 45; 6, 52; 6, 53; 6, 76; 6, 77; 6, 84; 6, 95; 6, 96; 6, 103; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:map_file_auth; 12, dictionary; 13, comment; 14, for_statement; 14, 15; 14, 16; 14, 20; 15, identifier:filename; 16, call; 16, 17; 16, 18; 17, identifier:scantree; 18, argument_list; 18, 19; 19, string:'cltk'; 20, block; 20, 21; 20, 27; 20, 28; 20, 35; 20, 36; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:filepath; 24, attribute; 24, 25; 24, 26; 25, identifier:filename; 26, identifier:path; 27, comment; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:authors_list; 31, call; 31, 32; 31, 33; 32, identifier:get_authors; 33, argument_list; 33, 34; 34, identifier:filepath; 35, comment; 36, if_statement; 36, 37; 36, 38; 37, identifier:authors_list; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:map_file_auth; 43, identifier:filepath; 44, identifier:authors_list; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:map_auth_file; 48, call; 48, 49; 48, 50; 49, identifier:defaultdict; 50, argument_list; 50, 51; 51, identifier:list; 52, comment; 53, for_statement; 53, 54; 53, 57; 53, 62; 54, pattern_list; 54, 55; 54, 56; 55, identifier:file; 56, identifier:authors_file; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:map_file_auth; 60, identifier:items; 61, argument_list; 62, block; 62, 63; 63, for_statement; 63, 64; 63, 65; 63, 66; 64, identifier:author; 65, identifier:authors_file; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:map_auth_file; 72, identifier:author; 73, identifier:append; 74, argument_list; 74, 75; 75, identifier:file; 76, comment; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:map_auth_file; 80, call; 80, 81; 80, 82; 81, identifier:sort_def_dict; 82, argument_list; 82, 83; 83, identifier:map_auth_file; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:map_auth_file_sorted; 87, call; 87, 88; 87, 89; 88, identifier:sorted; 89, argument_list; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:map_auth_file; 93, identifier:items; 94, argument_list; 95, comment; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:map_auth_file; 99, call; 99, 100; 99, 101; 100, identifier:OrderedDict; 101, argument_list; 101, 102; 102, identifier:map_auth_file_sorted; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:write_contribs; 106, argument_list; 106, 107; 107, identifier:map_auth_file | def find_write_contribs() -> None:
"""Look for files, find authors, sort, write file."""
map_file_auth = {} # type: Dict[str, List[str]]
for filename in scantree('cltk'):
filepath = filename.path # type: str
authors_list = get_authors(filepath) # type: List[str]
if authors_list:
map_file_auth[filepath] = authors_list
map_auth_file = defaultdict(list) # type: Dict[str, List[str]]
for file, authors_file in map_file_auth.items():
for author in authors_file:
map_auth_file[author].append(file)
# now sort the str contents of the list value
map_auth_file = sort_def_dict(map_auth_file)
map_auth_file_sorted = sorted(map_auth_file.items()) # type: List[Tuple[str, List[str]]]
map_auth_file = OrderedDict(map_auth_file_sorted)
write_contribs(map_auth_file) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:find_files; 3, parameters; 3, 4; 4, identifier:folder; 5, block; 5, 6; 5, 8; 5, 28; 5, 34; 5, 73; 5, 89; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:files; 11, list_comprehension; 11, 12; 11, 13; 11, 21; 12, identifier:i; 13, for_in_clause; 13, 14; 13, 15; 14, identifier:i; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:os; 18, identifier:listdir; 19, argument_list; 19, 20; 20, identifier:folder; 21, if_clause; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:i; 25, identifier:startswith; 26, argument_list; 26, 27; 27, string:"left"; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:files; 32, identifier:sort; 33, argument_list; 34, for_statement; 34, 35; 34, 36; 34, 43; 35, identifier:i; 36, call; 36, 37; 36, 38; 37, identifier:range; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:len; 41, argument_list; 41, 42; 42, identifier:files; 43, block; 43, 44; 43, 61; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:insert_string; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, string:"right{}"; 50, identifier:format; 51, argument_list; 51, 52; 52, subscript; 52, 53; 52, 58; 53, subscript; 53, 54; 53, 55; 54, identifier:files; 55, binary_operator:*; 55, 56; 55, 57; 56, identifier:i; 57, integer:2; 58, slice; 58, 59; 58, 60; 59, integer:4; 60, colon; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:files; 65, identifier:insert; 66, argument_list; 66, 67; 66, 72; 67, binary_operator:+; 67, 68; 67, 71; 68, binary_operator:*; 68, 69; 68, 70; 69, identifier:i; 70, integer:2; 71, integer:1; 72, identifier:insert_string; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:files; 76, list_comprehension; 76, 77; 76, 86; 77, call; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:os; 81, identifier:path; 82, identifier:join; 83, argument_list; 83, 84; 83, 85; 84, identifier:folder; 85, identifier:filename; 86, for_in_clause; 86, 87; 86, 88; 87, identifier:filename; 88, identifier:files; 89, return_statement; 89, 90; 90, identifier:files | def find_files(folder):
"""Discover stereo photos and return them as a pairwise sorted list."""
files = [i for i in os.listdir(folder) if i.startswith("left")]
files.sort()
for i in range(len(files)):
insert_string = "right{}".format(files[i * 2][4:])
files.insert(i * 2 + 1, insert_string)
files = [os.path.join(folder, filename) for filename in files]
return files |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:cdx_load; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:sources; 5, identifier:query; 6, default_parameter; 6, 7; 6, 8; 7, identifier:process; 8, True; 9, block; 9, 10; 9, 12; 9, 20; 9, 21; 9, 28; 9, 36; 9, 52; 9, 58; 9, 70; 9, 104; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:cdx_iter; 15, call; 15, 16; 15, 17; 16, identifier:create_merged_cdx_gen; 17, argument_list; 17, 18; 17, 19; 18, identifier:sources; 19, identifier:query; 20, comment; 21, if_statement; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:query; 24, identifier:page_count; 25, block; 25, 26; 26, return_statement; 26, 27; 27, identifier:cdx_iter; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:cdx_iter; 31, call; 31, 32; 31, 33; 32, identifier:make_obj_iter; 33, argument_list; 33, 34; 33, 35; 34, identifier:cdx_iter; 35, identifier:query; 36, if_statement; 36, 37; 36, 43; 37, boolean_operator:and; 37, 38; 37, 39; 38, identifier:process; 39, not_operator; 39, 40; 40, attribute; 40, 41; 40, 42; 41, identifier:query; 42, identifier:secondary_index_only; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:cdx_iter; 47, call; 47, 48; 47, 49; 48, identifier:process_cdx; 49, argument_list; 49, 50; 49, 51; 50, identifier:cdx_iter; 51, identifier:query; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:custom_ops; 55, attribute; 55, 56; 55, 57; 56, identifier:query; 57, identifier:custom_ops; 58, for_statement; 58, 59; 58, 60; 58, 61; 59, identifier:op; 60, identifier:custom_ops; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:cdx_iter; 65, call; 65, 66; 65, 67; 66, identifier:op; 67, argument_list; 67, 68; 67, 69; 68, identifier:cdx_iter; 69, identifier:query; 70, if_statement; 70, 71; 70, 76; 70, 87; 71, comparison_operator:==; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:query; 74, identifier:output; 75, string:'text'; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:cdx_iter; 80, call; 80, 81; 80, 82; 81, identifier:cdx_to_text; 82, argument_list; 82, 83; 82, 84; 83, identifier:cdx_iter; 84, attribute; 84, 85; 84, 86; 85, identifier:query; 86, identifier:fields; 87, elif_clause; 87, 88; 87, 93; 88, comparison_operator:==; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:query; 91, identifier:output; 92, string:'json'; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:cdx_iter; 97, call; 97, 98; 97, 99; 98, identifier:cdx_to_json; 99, argument_list; 99, 100; 99, 101; 100, identifier:cdx_iter; 101, attribute; 101, 102; 101, 103; 102, identifier:query; 103, identifier:fields; 104, return_statement; 104, 105; 105, identifier:cdx_iter | def cdx_load(sources, query, process=True):
"""
merge text CDX lines from sources, return an iterator for
filtered and access-checked sequence of CDX objects.
:param sources: iterable for text CDX sources.
:param process: bool, perform processing sorting/filtering/grouping ops
"""
cdx_iter = create_merged_cdx_gen(sources, query)
# page count is a special case, no further processing
if query.page_count:
return cdx_iter
cdx_iter = make_obj_iter(cdx_iter, query)
if process and not query.secondary_index_only:
cdx_iter = process_cdx(cdx_iter, query)
custom_ops = query.custom_ops
for op in custom_ops:
cdx_iter = op(cdx_iter, query)
if query.output == 'text':
cdx_iter = cdx_to_text(cdx_iter, query.fields)
elif query.output == 'json':
cdx_iter = cdx_to_json(cdx_iter, query.fields)
return cdx_iter |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:cdx_sort_closest; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:closest; 5, identifier:cdx_iter; 6, default_parameter; 6, 7; 6, 8; 7, identifier:limit; 8, integer:10; 9, block; 9, 10; 9, 12; 9, 16; 9, 20; 9, 27; 9, 109; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:closest_cdx; 15, list:[]; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:closest_keys; 19, list:[]; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:closest_sec; 23, call; 23, 24; 23, 25; 24, identifier:timestamp_to_sec; 25, argument_list; 25, 26; 26, identifier:closest; 27, for_statement; 27, 28; 27, 29; 27, 30; 28, identifier:cdx; 29, identifier:cdx_iter; 30, block; 30, 31; 30, 40; 30, 49; 30, 50; 30, 51; 30, 61; 30, 69; 30, 77; 30, 95; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:sec; 34, call; 34, 35; 34, 36; 35, identifier:timestamp_to_sec; 36, argument_list; 36, 37; 37, subscript; 37, 38; 37, 39; 38, identifier:cdx; 39, identifier:TIMESTAMP; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:key; 43, call; 43, 44; 43, 45; 44, identifier:abs; 45, argument_list; 45, 46; 46, binary_operator:-; 46, 47; 46, 48; 47, identifier:closest_sec; 48, identifier:sec; 49, comment; 50, comment; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:i; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:bisect; 57, identifier:bisect_right; 58, argument_list; 58, 59; 58, 60; 59, identifier:closest_keys; 60, identifier:key; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:closest_keys; 65, identifier:insert; 66, argument_list; 66, 67; 66, 68; 67, identifier:i; 68, identifier:key; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:closest_cdx; 73, identifier:insert; 74, argument_list; 74, 75; 74, 76; 75, identifier:i; 76, identifier:cdx; 77, if_statement; 77, 78; 77, 84; 77, 85; 78, comparison_operator:==; 78, 79; 78, 83; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, identifier:closest_cdx; 83, identifier:limit; 84, comment; 85, block; 85, 86; 86, if_statement; 86, 87; 86, 93; 87, comparison_operator:>; 87, 88; 87, 89; 88, identifier:key; 89, subscript; 89, 90; 89, 91; 90, identifier:closest_keys; 91, unary_operator:-; 91, 92; 92, integer:1; 93, block; 93, 94; 94, break_statement; 95, if_statement; 95, 96; 95, 102; 96, comparison_operator:>; 96, 97; 96, 101; 97, call; 97, 98; 97, 99; 98, identifier:len; 99, argument_list; 99, 100; 100, identifier:closest_cdx; 101, identifier:limit; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:closest_cdx; 107, identifier:pop; 108, argument_list; 109, for_statement; 109, 110; 109, 111; 109, 112; 110, identifier:cdx; 111, identifier:closest_cdx; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, yield; 114, 115; 115, identifier:cdx | def cdx_sort_closest(closest, cdx_iter, limit=10):
"""
sort CDXCaptureResult by closest to timestamp.
"""
closest_cdx = []
closest_keys = []
closest_sec = timestamp_to_sec(closest)
for cdx in cdx_iter:
sec = timestamp_to_sec(cdx[TIMESTAMP])
key = abs(closest_sec - sec)
# create tuple to sort by key
#bisect.insort(closest_cdx, (key, cdx))
i = bisect.bisect_right(closest_keys, key)
closest_keys.insert(i, key)
closest_cdx.insert(i, cdx)
if len(closest_cdx) == limit:
# assuming cdx in ascending order and keys have started increasing
if key > closest_keys[-1]:
break
if len(closest_cdx) > limit:
closest_cdx.pop()
for cdx in closest_cdx:
yield cdx |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:iter_prefix; 3, parameters; 3, 4; 3, 5; 4, identifier:reader; 5, identifier:key; 6, block; 6, 7; 6, 9; 7, expression_statement; 7, 8; 8, comment; 9, return_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:itertools; 13, identifier:takewhile; 14, argument_list; 14, 15; 14, 24; 15, lambda; 15, 16; 15, 18; 16, lambda_parameters; 16, 17; 17, identifier:line; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:line; 21, identifier:startswith; 22, argument_list; 22, 23; 23, identifier:key; 24, call; 24, 25; 24, 26; 25, identifier:search; 26, argument_list; 26, 27; 26, 28; 27, identifier:reader; 28, identifier:key | def iter_prefix(reader, key):
"""
Creates an iterator which iterates over lines that start with prefix
'key' in a sorted text file.
"""
return itertools.takewhile(
lambda line: line.startswith(key),
search(reader, key)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_basis_dict; 3, parameters; 3, 4; 4, identifier:bs; 5, block; 5, 6; 5, 8; 5, 9; 5, 61; 5, 62; 5, 63; 5, 80; 5, 104; 5, 123; 5, 180; 6, expression_statement; 6, 7; 7, comment; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:_keyorder; 12, list:[
# Schema stuff
'molssi_bse_schema', 'schema_type', 'schema_version',
# Auxiliary block
'jkfit', 'jfit', 'rifit', 'admmfit', 'dftxfit', 'dftjfit',
# Basis set metadata
'name', 'names', 'aliases', 'flags', 'family', 'description', 'role', 'auxiliaries',
'notes', 'function_types',
# Reference stuff
'reference_description', 'reference_keys',
# Version metadata
'version', 'revision_description',
# Sources of components
'data_source',
# Elements and data
'elements', 'references', 'ecp_electrons',
'electron_shells', 'ecp_potentials', 'components',
# Shell information
'function_type', 'region', 'angular_momentum', 'exponents',
'coefficients',
'ecp_type', 'angular_momentum', 'r_exponents', 'gaussian_exponents',
'coefficients'
]; 12, 13; 12, 14; 12, 15; 12, 16; 12, 17; 12, 18; 12, 19; 12, 20; 12, 21; 12, 22; 12, 23; 12, 24; 12, 25; 12, 26; 12, 27; 12, 28; 12, 29; 12, 30; 12, 31; 12, 32; 12, 33; 12, 34; 12, 35; 12, 36; 12, 37; 12, 38; 12, 39; 12, 40; 12, 41; 12, 42; 12, 43; 12, 44; 12, 45; 12, 46; 12, 47; 12, 48; 12, 49; 12, 50; 12, 51; 12, 52; 12, 53; 12, 54; 12, 55; 12, 56; 12, 57; 12, 58; 12, 59; 12, 60; 13, comment; 14, string:'molssi_bse_schema'; 15, string:'schema_type'; 16, string:'schema_version'; 17, comment; 18, string:'jkfit'; 19, string:'jfit'; 20, string:'rifit'; 21, string:'admmfit'; 22, string:'dftxfit'; 23, string:'dftjfit'; 24, comment; 25, string:'name'; 26, string:'names'; 27, string:'aliases'; 28, string:'flags'; 29, string:'family'; 30, string:'description'; 31, string:'role'; 32, string:'auxiliaries'; 33, string:'notes'; 34, string:'function_types'; 35, comment; 36, string:'reference_description'; 37, string:'reference_keys'; 38, comment; 39, string:'version'; 40, string:'revision_description'; 41, comment; 42, string:'data_source'; 43, comment; 44, string:'elements'; 45, string:'references'; 46, string:'ecp_electrons'; 47, string:'electron_shells'; 48, string:'ecp_potentials'; 49, string:'components'; 50, comment; 51, string:'function_type'; 52, string:'region'; 53, string:'angular_momentum'; 54, string:'exponents'; 55, string:'coefficients'; 56, string:'ecp_type'; 57, string:'angular_momentum'; 58, string:'r_exponents'; 59, string:'gaussian_exponents'; 60, string:'coefficients'; 61, comment; 62, comment; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:_keyorder; 67, identifier:extend; 68, argument_list; 68, 69; 69, list_comprehension; 69, 70; 69, 74; 70, call; 70, 71; 70, 72; 71, identifier:str; 72, argument_list; 72, 73; 73, identifier:x; 74, for_in_clause; 74, 75; 74, 76; 75, identifier:x; 76, call; 76, 77; 76, 78; 77, identifier:range; 78, argument_list; 78, 79; 79, integer:150; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:bs_sorted; 83, call; 83, 84; 83, 85; 84, identifier:sorted; 85, argument_list; 85, 86; 85, 91; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:bs; 89, identifier:items; 90, argument_list; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:key; 93, lambda; 93, 94; 93, 96; 94, lambda_parameters; 94, 95; 95, identifier:x; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:_keyorder; 99, identifier:index; 100, argument_list; 100, 101; 101, subscript; 101, 102; 101, 103; 102, identifier:x; 103, integer:0; 104, if_statement; 104, 105; 104, 106; 104, 114; 105, identifier:_use_odict; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:bs_sorted; 110, call; 110, 111; 110, 112; 111, identifier:OrderedDict; 112, argument_list; 112, 113; 113, identifier:bs_sorted; 114, else_clause; 114, 115; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:bs_sorted; 119, call; 119, 120; 119, 121; 120, identifier:dict; 121, argument_list; 121, 122; 122, identifier:bs_sorted; 123, for_statement; 123, 124; 123, 127; 123, 132; 123, 133; 123, 134; 124, pattern_list; 124, 125; 124, 126; 125, identifier:k; 126, identifier:v; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:bs_sorted; 130, identifier:items; 131, argument_list; 132, comment; 133, comment; 134, block; 134, 135; 135, if_statement; 135, 136; 135, 141; 135, 151; 136, call; 136, 137; 136, 138; 137, identifier:isinstance; 138, argument_list; 138, 139; 138, 140; 139, identifier:v; 140, identifier:dict; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:bs_sorted; 146, identifier:k; 147, call; 147, 148; 147, 149; 148, identifier:sort_basis_dict; 149, argument_list; 149, 150; 150, identifier:v; 151, elif_clause; 151, 152; 151, 157; 151, 158; 151, 159; 152, call; 152, 153; 152, 154; 153, identifier:isinstance; 154, argument_list; 154, 155; 154, 156; 155, identifier:v; 156, identifier:list; 157, comment; 158, comment; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:bs_sorted; 164, identifier:k; 165, list_comprehension; 165, 166; 165, 177; 166, conditional_expression:if; 166, 167; 166, 171; 166, 176; 167, call; 167, 168; 167, 169; 168, identifier:sort_basis_dict; 169, argument_list; 169, 170; 170, identifier:x; 171, call; 171, 172; 171, 173; 172, identifier:isinstance; 173, argument_list; 173, 174; 173, 175; 174, identifier:x; 175, identifier:dict; 176, identifier:x; 177, for_in_clause; 177, 178; 177, 179; 178, identifier:x; 179, identifier:v; 180, return_statement; 180, 181; 181, identifier:bs_sorted | def sort_basis_dict(bs):
"""Sorts a basis set dictionary into a standard order
This, for example, allows the written file to be more easily read by humans by,
for example, putting the name and description before more detailed fields.
This is generally for cosmetic reasons. However, users will generally like things
in a consistent order
"""
# yapf: disable
_keyorder = [
# Schema stuff
'molssi_bse_schema', 'schema_type', 'schema_version',
# Auxiliary block
'jkfit', 'jfit', 'rifit', 'admmfit', 'dftxfit', 'dftjfit',
# Basis set metadata
'name', 'names', 'aliases', 'flags', 'family', 'description', 'role', 'auxiliaries',
'notes', 'function_types',
# Reference stuff
'reference_description', 'reference_keys',
# Version metadata
'version', 'revision_description',
# Sources of components
'data_source',
# Elements and data
'elements', 'references', 'ecp_electrons',
'electron_shells', 'ecp_potentials', 'components',
# Shell information
'function_type', 'region', 'angular_momentum', 'exponents',
'coefficients',
'ecp_type', 'angular_momentum', 'r_exponents', 'gaussian_exponents',
'coefficients'
]
# yapf: enable
# Add integers for the elements (being optimistic that element 150 will be found someday)
_keyorder.extend([str(x) for x in range(150)])
bs_sorted = sorted(bs.items(), key=lambda x: _keyorder.index(x[0]))
if _use_odict:
bs_sorted = OrderedDict(bs_sorted)
else:
bs_sorted = dict(bs_sorted)
for k, v in bs_sorted.items():
# If this is a dictionary, sort recursively
# If this is a list, sort each element but DO NOT sort the list itself.
if isinstance(v, dict):
bs_sorted[k] = sort_basis_dict(v)
elif isinstance(v, list):
# Note - the only nested list is with coeffs, which shouldn't be sorted
# (so we don't have to recurse into lists of lists)
bs_sorted[k] = [sort_basis_dict(x) if isinstance(x, dict) else x for x in v]
return bs_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_shell; 3, parameters; 3, 4; 3, 5; 4, identifier:shell; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 11; 8, 23; 8, 24; 8, 41; 8, 42; 8, 70; 8, 71; 8, 82; 8, 83; 8, 102; 8, 103; 8, 121; 8, 122; 8, 132; 8, 144; 8, 145; 8, 160; 8, 188; 8, 196; 8, 214; 8, 224; 8, 230; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 13; 12, identifier:use_copy; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:shell; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:copy; 20, identifier:deepcopy; 21, argument_list; 21, 22; 22, identifier:shell; 23, comment; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:tmp_c; 27, call; 27, 28; 27, 29; 28, identifier:list; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:map; 32, argument_list; 32, 33; 32, 34; 33, identifier:list; 34, call; 34, 35; 34, 36; 35, identifier:zip; 36, argument_list; 36, 37; 37, list_splat; 37, 38; 38, subscript; 38, 39; 38, 40; 39, identifier:shell; 40, string:'coefficients'; 41, comment; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:nonzero_idx; 45, list_comprehension; 45, 46; 45, 67; 46, call; 46, 47; 46, 48; 47, identifier:next; 48, argument_list; 48, 49; 48, 66; 49, generator_expression; 49, 50; 49, 51; 49, 59; 50, identifier:i; 51, for_in_clause; 51, 52; 51, 55; 52, pattern_list; 52, 53; 52, 54; 53, identifier:i; 54, identifier:x; 55, call; 55, 56; 55, 57; 56, identifier:enumerate; 57, argument_list; 57, 58; 58, identifier:c; 59, if_clause; 59, 60; 60, comparison_operator:!=; 60, 61; 60, 65; 61, call; 61, 62; 61, 63; 62, identifier:float; 63, argument_list; 63, 64; 64, identifier:x; 65, float:0.0; 66, None; 67, for_in_clause; 67, 68; 67, 69; 68, identifier:c; 69, identifier:tmp_c; 70, comment; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:tmp; 74, call; 74, 75; 74, 76; 75, identifier:zip; 76, argument_list; 76, 77; 76, 80; 76, 81; 77, subscript; 77, 78; 77, 79; 78, identifier:shell; 79, string:'exponents'; 80, identifier:tmp_c; 81, identifier:nonzero_idx; 82, comment; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:tmp; 86, call; 86, 87; 86, 88; 87, identifier:sorted; 88, argument_list; 88, 89; 88, 90; 89, identifier:tmp; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:key; 92, lambda; 92, 93; 92, 95; 93, lambda_parameters; 93, 94; 94, identifier:x; 95, unary_operator:-; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:float; 98, argument_list; 98, 99; 99, subscript; 99, 100; 99, 101; 100, identifier:x; 101, integer:0; 102, comment; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:tmp; 106, call; 106, 107; 106, 108; 107, identifier:sorted; 108, argument_list; 108, 109; 108, 110; 109, identifier:tmp; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:key; 112, lambda; 112, 113; 112, 115; 113, lambda_parameters; 113, 114; 114, identifier:x; 115, call; 115, 116; 115, 117; 116, identifier:int; 117, argument_list; 117, 118; 118, subscript; 118, 119; 118, 120; 119, identifier:x; 120, integer:2; 121, comment; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:tmp_c; 125, list_comprehension; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:x; 128, integer:1; 129, for_in_clause; 129, 130; 129, 131; 130, identifier:x; 131, identifier:tmp; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:shell; 136, string:'exponents'; 137, list_comprehension; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:x; 140, integer:0; 141, for_in_clause; 141, 142; 141, 143; 142, identifier:x; 143, identifier:tmp; 144, comment; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:tmp_c; 148, call; 148, 149; 148, 150; 149, identifier:list; 150, argument_list; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:map; 153, argument_list; 153, 154; 153, 155; 154, identifier:list; 155, call; 155, 156; 155, 157; 156, identifier:zip; 157, argument_list; 157, 158; 158, list_splat; 158, 159; 159, identifier:tmp_c; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:nonzero_idx; 163, list_comprehension; 163, 164; 163, 185; 164, call; 164, 165; 164, 166; 165, identifier:next; 166, argument_list; 166, 167; 166, 184; 167, generator_expression; 167, 168; 167, 169; 167, 177; 168, identifier:i; 169, for_in_clause; 169, 170; 169, 173; 170, pattern_list; 170, 171; 170, 172; 171, identifier:i; 172, identifier:x; 173, call; 173, 174; 173, 175; 174, identifier:enumerate; 175, argument_list; 175, 176; 176, identifier:c; 177, if_clause; 177, 178; 178, comparison_operator:!=; 178, 179; 178, 183; 179, call; 179, 180; 179, 181; 180, identifier:float; 181, argument_list; 181, 182; 182, identifier:x; 183, float:0.0; 184, None; 185, for_in_clause; 185, 186; 185, 187; 186, identifier:c; 187, identifier:tmp_c; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:tmp; 191, call; 191, 192; 191, 193; 192, identifier:zip; 193, argument_list; 193, 194; 193, 195; 194, identifier:tmp_c; 195, identifier:nonzero_idx; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:tmp; 199, call; 199, 200; 199, 201; 200, identifier:sorted; 201, argument_list; 201, 202; 201, 203; 202, identifier:tmp; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:key; 205, lambda; 205, 206; 205, 208; 206, lambda_parameters; 206, 207; 207, identifier:x; 208, call; 208, 209; 208, 210; 209, identifier:int; 210, argument_list; 210, 211; 211, subscript; 211, 212; 211, 213; 212, identifier:x; 213, integer:1; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:tmp_c; 217, list_comprehension; 217, 218; 217, 221; 218, subscript; 218, 219; 218, 220; 219, identifier:x; 220, integer:0; 221, for_in_clause; 221, 222; 221, 223; 222, identifier:x; 223, identifier:tmp; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:shell; 228, string:'coefficients'; 229, identifier:tmp_c; 230, return_statement; 230, 231; 231, identifier:shell | def sort_shell(shell, use_copy=True):
"""
Sort a basis set shell into a standard order
If use_copy is True, the input shells are not modified.
"""
if use_copy:
shell = copy.deepcopy(shell)
# Transpose of coefficients
tmp_c = list(map(list, zip(*shell['coefficients'])))
# For each primitive, find the index of the first nonzero coefficient
nonzero_idx = [next((i for i, x in enumerate(c) if float(x) != 0.0), None) for c in tmp_c]
# Zip together exponents and coeffs for sorting
tmp = zip(shell['exponents'], tmp_c, nonzero_idx)
# Sort by decreasing value of exponent
tmp = sorted(tmp, key=lambda x: -float(x[0]))
# Now (stable) sort by first non-zero coefficient
tmp = sorted(tmp, key=lambda x: int(x[2]))
# Unpack, and re-transpose the coefficients
tmp_c = [x[1] for x in tmp]
shell['exponents'] = [x[0] for x in tmp]
# Now sort the columns of the coefficient by index of first nonzero coefficient
tmp_c = list(map(list, zip(*tmp_c)))
nonzero_idx = [next((i for i, x in enumerate(c) if float(x) != 0.0), None) for c in tmp_c]
tmp = zip(tmp_c, nonzero_idx)
tmp = sorted(tmp, key=lambda x: int(x[1]))
tmp_c = [x[0] for x in tmp]
shell['coefficients'] = tmp_c
return shell |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_shells; 3, parameters; 3, 4; 3, 5; 4, identifier:shells; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 11; 8, 23; 8, 24; 8, 25; 8, 37; 8, 38; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 13; 12, identifier:use_copy; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:shells; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:copy; 20, identifier:deepcopy; 21, argument_list; 21, 22; 22, identifier:shells; 23, comment; 24, comment; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:shells; 28, list_comprehension; 28, 29; 28, 34; 29, call; 29, 30; 29, 31; 30, identifier:sort_shell; 31, argument_list; 31, 32; 31, 33; 32, identifier:sh; 33, False; 34, for_in_clause; 34, 35; 34, 36; 35, identifier:sh; 36, identifier:shells; 37, comment; 38, return_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:list; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:sorted; 44, argument_list; 44, 45; 44, 46; 45, identifier:shells; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:key; 48, lambda; 48, 49; 48, 51; 49, lambda_parameters; 49, 50; 50, identifier:x; 51, tuple; 51, 52; 51, 58; 51, 65; 51, 72; 52, call; 52, 53; 52, 54; 53, identifier:max; 54, argument_list; 54, 55; 55, subscript; 55, 56; 55, 57; 56, identifier:x; 57, string:'angular_momentum'; 58, unary_operator:-; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:len; 61, argument_list; 61, 62; 62, subscript; 62, 63; 62, 64; 63, identifier:x; 64, string:'exponents'; 65, unary_operator:-; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, subscript; 69, 70; 69, 71; 70, identifier:x; 71, string:'coefficients'; 72, unary_operator:-; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:float; 75, argument_list; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:max; 78, argument_list; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:x; 81, string:'exponents' | def sort_shells(shells, use_copy=True):
"""
Sort a list of basis set shells into a standard order
The order within a shell is by decreasing value of the exponent.
The order of the shell list is in increasing angular momentum, and then
by decreasing number of primitives, then decreasing value of the largest exponent.
If use_copy is True, the input shells are not modified.
"""
if use_copy:
shells = copy.deepcopy(shells)
# Sort primitives within a shell
# (copying already handled above)
shells = [sort_shell(sh, False) for sh in shells]
# Sort the list by increasing AM, then general contraction level, then decreasing highest exponent
return list(
sorted(
shells,
key=lambda x: (max(x['angular_momentum']), -len(x['exponents']), -len(x['coefficients']), -float(
max(x['exponents']))))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_potentials; 3, parameters; 3, 4; 3, 5; 4, identifier:potentials; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 11; 8, 23; 8, 24; 8, 42; 8, 54; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 13; 12, identifier:use_copy; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:potentials; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:copy; 20, identifier:deepcopy; 21, argument_list; 21, 22; 22, identifier:potentials; 23, comment; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:potentials; 27, call; 27, 28; 27, 29; 28, identifier:list; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:sorted; 32, argument_list; 32, 33; 32, 34; 33, identifier:potentials; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:key; 36, lambda; 36, 37; 36, 39; 37, lambda_parameters; 37, 38; 38, identifier:x; 39, subscript; 39, 40; 39, 41; 40, identifier:x; 41, string:'angular_momentum'; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:potentials; 46, identifier:insert; 47, argument_list; 47, 48; 47, 49; 48, integer:0; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:potentials; 52, identifier:pop; 53, argument_list; 54, return_statement; 54, 55; 55, identifier:potentials | def sort_potentials(potentials, use_copy=True):
"""
Sort a list of ECP potentials into a standard order
The order within a potential is not modified.
The order of the shell list is in increasing angular momentum, with the largest
angular momentum being moved to the front.
If use_copy is True, the input potentials are not modified.
"""
if use_copy:
potentials = copy.deepcopy(potentials)
# Sort by increasing AM, then move the last element to the front
potentials = list(sorted(potentials, key=lambda x: x['angular_momentum']))
potentials.insert(0, potentials.pop())
return potentials |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_basis; 3, parameters; 3, 4; 3, 5; 4, identifier:basis; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 11; 8, 23; 8, 69; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 13; 12, identifier:use_copy; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:basis; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:copy; 20, identifier:deepcopy; 21, argument_list; 21, 22; 22, identifier:basis; 23, for_statement; 23, 24; 23, 27; 23, 34; 24, pattern_list; 24, 25; 24, 26; 25, identifier:k; 26, identifier:el; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:basis; 31, string:'elements'; 32, identifier:items; 33, argument_list; 34, block; 34, 35; 34, 52; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:in; 36, 37; 36, 38; 37, string:'electron_shells'; 38, identifier:el; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:el; 44, string:'electron_shells'; 45, call; 45, 46; 45, 47; 46, identifier:sort_shells; 47, argument_list; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:el; 50, string:'electron_shells'; 51, False; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:in; 53, 54; 53, 55; 54, string:'ecp_potentials'; 55, identifier:el; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, subscript; 59, 60; 59, 61; 60, identifier:el; 61, string:'ecp_potentials'; 62, call; 62, 63; 62, 64; 63, identifier:sort_potentials; 64, argument_list; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:el; 67, string:'ecp_potentials'; 68, False; 69, return_statement; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:sort_basis_dict; 72, argument_list; 72, 73; 73, identifier:basis | def sort_basis(basis, use_copy=True):
"""
Sorts all the information in a basis set into a standard order
If use_copy is True, the input basis set is not modified.
"""
if use_copy:
basis = copy.deepcopy(basis)
for k, el in basis['elements'].items():
if 'electron_shells' in el:
el['electron_shells'] = sort_shells(el['electron_shells'], False)
if 'ecp_potentials' in el:
el['ecp_potentials'] = sort_potentials(el['ecp_potentials'], False)
return sort_basis_dict(basis) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_single_reference; 3, parameters; 3, 4; 4, identifier:ref_entry; 5, block; 5, 6; 5, 8; 5, 9; 5, 36; 5, 37; 5, 61; 6, expression_statement; 6, 7; 7, comment; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:_keyorder; 12, list:[
# Schema stuff
# This function gets called on the schema 'entry', too
'schema_type', 'schema_version',
# Type of the entry
'type',
# Actual publication info
'authors', 'title', 'booktitle', 'series', 'editors', 'journal',
'institution', 'volume', 'number', 'page', 'year', 'note', 'publisher',
'address', 'isbn', 'doi'
]; 12, 13; 12, 14; 12, 15; 12, 16; 12, 17; 12, 18; 12, 19; 12, 20; 12, 21; 12, 22; 12, 23; 12, 24; 12, 25; 12, 26; 12, 27; 12, 28; 12, 29; 12, 30; 12, 31; 12, 32; 12, 33; 12, 34; 12, 35; 13, comment; 14, comment; 15, string:'schema_type'; 16, string:'schema_version'; 17, comment; 18, string:'type'; 19, comment; 20, string:'authors'; 21, string:'title'; 22, string:'booktitle'; 23, string:'series'; 24, string:'editors'; 25, string:'journal'; 26, string:'institution'; 27, string:'volume'; 28, string:'number'; 29, string:'page'; 30, string:'year'; 31, string:'note'; 32, string:'publisher'; 33, string:'address'; 34, string:'isbn'; 35, string:'doi'; 36, comment; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:sorted_entry; 40, call; 40, 41; 40, 42; 41, identifier:sorted; 42, argument_list; 42, 43; 42, 48; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:ref_entry; 46, identifier:items; 47, argument_list; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:key; 50, lambda; 50, 51; 50, 53; 51, lambda_parameters; 51, 52; 52, identifier:x; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:_keyorder; 56, identifier:index; 57, argument_list; 57, 58; 58, subscript; 58, 59; 58, 60; 59, identifier:x; 60, integer:0; 61, if_statement; 61, 62; 61, 63; 61, 69; 62, identifier:_use_odict; 63, block; 63, 64; 64, return_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:OrderedDict; 67, argument_list; 67, 68; 68, identifier:sorted_entry; 69, else_clause; 69, 70; 70, block; 70, 71; 71, return_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:dict; 74, argument_list; 74, 75; 75, identifier:sorted_entry | def sort_single_reference(ref_entry):
"""Sorts a dictionary containing data for a single reference into a standard order
"""
# yapf: disable
_keyorder = [
# Schema stuff
# This function gets called on the schema 'entry', too
'schema_type', 'schema_version',
# Type of the entry
'type',
# Actual publication info
'authors', 'title', 'booktitle', 'series', 'editors', 'journal',
'institution', 'volume', 'number', 'page', 'year', 'note', 'publisher',
'address', 'isbn', 'doi'
]
# yapf: enable
sorted_entry = sorted(ref_entry.items(), key=lambda x: _keyorder.index(x[0]))
if _use_odict:
return OrderedDict(sorted_entry)
else:
return dict(sorted_entry) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_references_dict; 3, parameters; 3, 4; 4, identifier:refs; 5, block; 5, 6; 5, 8; 5, 25; 5, 26; 5, 27; 5, 35; 5, 36; 5, 58; 6, expression_statement; 6, 7; 7, comment; 8, if_statement; 8, 9; 8, 10; 8, 17; 9, identifier:_use_odict; 10, block; 10, 11; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:refs_sorted; 14, call; 14, 15; 14, 16; 15, identifier:OrderedDict; 16, argument_list; 17, else_clause; 17, 18; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:refs_sorted; 22, call; 22, 23; 22, 24; 23, identifier:dict; 24, argument_list; 25, comment; 26, comment; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:refs_sorted; 31, string:'molssi_bse_schema'; 32, subscript; 32, 33; 32, 34; 33, identifier:refs; 34, string:'molssi_bse_schema'; 35, comment; 36, for_statement; 36, 37; 36, 40; 36, 48; 37, pattern_list; 37, 38; 37, 39; 38, identifier:k; 39, identifier:v; 40, call; 40, 41; 40, 42; 41, identifier:sorted; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:refs; 46, identifier:items; 47, argument_list; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:refs_sorted; 53, identifier:k; 54, call; 54, 55; 54, 56; 55, identifier:sort_single_reference; 56, argument_list; 56, 57; 57, identifier:v; 58, return_statement; 58, 59; 59, identifier:refs_sorted | def sort_references_dict(refs):
"""Sorts a reference dictionary into a standard order
The keys of the references are also sorted, and the keys for the data for each
reference are put in a more canonical order.
"""
if _use_odict:
refs_sorted = OrderedDict()
else:
refs_sorted = dict()
# We insert this first, That is ok - it will be overwritten
# with the sorted version later
refs_sorted['molssi_bse_schema'] = refs['molssi_bse_schema']
# This sorts the entries by reference key (author1985a, etc)
for k, v in sorted(refs.items()):
refs_sorted[k] = sort_single_reference(v)
return refs_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:make_general; 3, parameters; 3, 4; 3, 5; 4, identifier:basis; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 11; 8, 15; 8, 24; 8, 284; 9, expression_statement; 9, 10; 10, comment; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:zero; 14, string:'0.00000000'; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:basis; 18, call; 18, 19; 18, 20; 19, identifier:uncontract_spdf; 20, argument_list; 20, 21; 20, 22; 20, 23; 21, identifier:basis; 22, integer:0; 23, identifier:use_copy; 24, for_statement; 24, 25; 24, 28; 24, 35; 25, pattern_list; 25, 26; 25, 27; 26, identifier:k; 27, identifier:el; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:basis; 32, string:'elements'; 33, identifier:items; 34, argument_list; 35, block; 35, 36; 35, 43; 35, 44; 35, 48; 35, 71; 35, 78; 35, 82; 35, 278; 36, if_statement; 36, 37; 36, 41; 37, not_operator; 37, 38; 38, comparison_operator:in; 38, 39; 38, 40; 39, string:'electron_shells'; 40, identifier:el; 41, block; 41, 42; 42, continue_statement; 43, comment; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:all_am; 47, list:[]; 48, for_statement; 48, 49; 48, 50; 48, 53; 49, identifier:sh; 50, subscript; 50, 51; 50, 52; 51, identifier:el; 52, string:'electron_shells'; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 61; 55, not_operator; 55, 56; 56, comparison_operator:in; 56, 57; 56, 60; 57, subscript; 57, 58; 57, 59; 58, identifier:sh; 59, string:'angular_momentum'; 60, identifier:all_am; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:all_am; 66, identifier:append; 67, argument_list; 67, 68; 68, subscript; 68, 69; 68, 70; 69, identifier:sh; 70, string:'angular_momentum'; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:all_am; 74, call; 74, 75; 74, 76; 75, identifier:sorted; 76, argument_list; 76, 77; 77, identifier:all_am; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:newshells; 81, list:[]; 82, for_statement; 82, 83; 82, 84; 82, 85; 83, identifier:am; 84, identifier:all_am; 85, block; 85, 86; 85, 105; 85, 106; 85, 131; 85, 132; 85, 141; 85, 145; 85, 271; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:newsh; 89, dictionary; 89, 90; 89, 93; 89, 96; 89, 99; 89, 102; 90, pair; 90, 91; 90, 92; 91, string:'angular_momentum'; 92, identifier:am; 93, pair; 93, 94; 93, 95; 94, string:'exponents'; 95, list:[]; 96, pair; 96, 97; 96, 98; 97, string:'coefficients'; 98, list:[]; 99, pair; 99, 100; 99, 101; 100, string:'region'; 101, string:''; 102, pair; 102, 103; 102, 104; 103, string:'function_type'; 104, None; 105, comment; 106, for_statement; 106, 107; 106, 108; 106, 111; 107, identifier:sh; 108, subscript; 108, 109; 108, 110; 109, identifier:el; 110, string:'electron_shells'; 111, block; 111, 112; 111, 120; 112, if_statement; 112, 113; 112, 118; 113, comparison_operator:!=; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:sh; 116, string:'angular_momentum'; 117, identifier:am; 118, block; 118, 119; 119, continue_statement; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 127; 122, attribute; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:newsh; 125, string:'exponents'; 126, identifier:extend; 127, argument_list; 127, 128; 128, subscript; 128, 129; 128, 130; 129, identifier:sh; 130, string:'exponents'; 131, comment; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:nprim; 135, call; 135, 136; 135, 137; 136, identifier:len; 137, argument_list; 137, 138; 138, subscript; 138, 139; 138, 140; 139, identifier:newsh; 140, string:'exponents'; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:cur_prim; 144, integer:0; 145, for_statement; 145, 146; 145, 147; 145, 150; 146, identifier:sh; 147, subscript; 147, 148; 147, 149; 148, identifier:el; 149, string:'electron_shells'; 150, block; 150, 151; 150, 159; 150, 174; 150, 175; 150, 181; 150, 187; 150, 188; 150, 189; 150, 203; 150, 212; 150, 262; 151, if_statement; 151, 152; 151, 157; 152, comparison_operator:!=; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:sh; 155, string:'angular_momentum'; 156, identifier:am; 157, block; 157, 158; 158, continue_statement; 159, if_statement; 159, 160; 159, 165; 160, comparison_operator:is; 160, 161; 160, 164; 161, subscript; 161, 162; 161, 163; 162, identifier:newsh; 163, string:'function_type'; 164, None; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:newsh; 170, string:'function_type'; 171, subscript; 171, 172; 171, 173; 172, identifier:sh; 173, string:'function_type'; 174, comment; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:ft1; 178, subscript; 178, 179; 178, 180; 179, identifier:newsh; 180, string:'function_type'; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:ft2; 184, subscript; 184, 185; 184, 186; 185, identifier:sh; 186, string:'function_type'; 187, comment; 188, comment; 189, if_statement; 189, 190; 189, 197; 190, boolean_operator:and; 190, 191; 190, 194; 191, comparison_operator:not; 191, 192; 191, 193; 192, identifier:ft1; 193, identifier:ft2; 194, comparison_operator:not; 194, 195; 194, 196; 195, identifier:ft2; 196, identifier:ft1; 197, block; 197, 198; 198, raise_statement; 198, 199; 199, call; 199, 200; 199, 201; 200, identifier:RuntimeError; 201, argument_list; 201, 202; 202, string:"Cannot make general contraction of different function types"; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:ngen; 206, call; 206, 207; 206, 208; 207, identifier:len; 208, argument_list; 208, 209; 209, subscript; 209, 210; 209, 211; 210, identifier:sh; 211, string:'coefficients'; 212, for_statement; 212, 213; 212, 214; 212, 218; 213, identifier:g; 214, call; 214, 215; 214, 216; 215, identifier:range; 216, argument_list; 216, 217; 217, identifier:ngen; 218, block; 218, 219; 218, 226; 218, 237; 218, 253; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:coef; 222, binary_operator:*; 222, 223; 222, 225; 223, list:[zero]; 223, 224; 224, identifier:zero; 225, identifier:cur_prim; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:coef; 230, identifier:extend; 231, argument_list; 231, 232; 232, subscript; 232, 233; 232, 236; 233, subscript; 233, 234; 233, 235; 234, identifier:sh; 235, string:'coefficients'; 236, identifier:g; 237, expression_statement; 237, 238; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:coef; 241, identifier:extend; 242, argument_list; 242, 243; 243, binary_operator:*; 243, 244; 243, 246; 244, list:[zero]; 244, 245; 245, identifier:zero; 246, parenthesized_expression; 246, 247; 247, binary_operator:-; 247, 248; 247, 249; 248, identifier:nprim; 249, call; 249, 250; 249, 251; 250, identifier:len; 251, argument_list; 251, 252; 252, identifier:coef; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 260; 255, attribute; 255, 256; 255, 259; 256, subscript; 256, 257; 256, 258; 257, identifier:newsh; 258, string:'coefficients'; 259, identifier:append; 260, argument_list; 260, 261; 261, identifier:coef; 262, expression_statement; 262, 263; 263, augmented_assignment:+=; 263, 264; 263, 265; 264, identifier:cur_prim; 265, call; 265, 266; 265, 267; 266, identifier:len; 267, argument_list; 267, 268; 268, subscript; 268, 269; 268, 270; 269, identifier:sh; 270, string:'exponents'; 271, expression_statement; 271, 272; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:newshells; 275, identifier:append; 276, argument_list; 276, 277; 277, identifier:newsh; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 283; 280, subscript; 280, 281; 280, 282; 281, identifier:el; 282, string:'electron_shells'; 283, identifier:newshells; 284, return_statement; 284, 285; 285, identifier:basis | def make_general(basis, use_copy=True):
"""
Makes one large general contraction for each angular momentum
If use_copy is True, the input basis set is not modified.
The output of this function is not pretty. If you want to make it nicer,
use sort_basis afterwards.
"""
zero = '0.00000000'
basis = uncontract_spdf(basis, 0, use_copy)
for k, el in basis['elements'].items():
if not 'electron_shells' in el:
continue
# See what we have
all_am = []
for sh in el['electron_shells']:
if not sh['angular_momentum'] in all_am:
all_am.append(sh['angular_momentum'])
all_am = sorted(all_am)
newshells = []
for am in all_am:
newsh = {
'angular_momentum': am,
'exponents': [],
'coefficients': [],
'region': '',
'function_type': None,
}
# Do exponents first
for sh in el['electron_shells']:
if sh['angular_momentum'] != am:
continue
newsh['exponents'].extend(sh['exponents'])
# Number of primitives in the new shell
nprim = len(newsh['exponents'])
cur_prim = 0
for sh in el['electron_shells']:
if sh['angular_momentum'] != am:
continue
if newsh['function_type'] is None:
newsh['function_type'] = sh['function_type']
# Make sure the shells we are merging have the same function types
ft1 = newsh['function_type']
ft2 = sh['function_type']
# Check if one function type is the subset of another
# (should handle gto/gto_spherical, etc)
if ft1 not in ft2 and ft2 not in ft1:
raise RuntimeError("Cannot make general contraction of different function types")
ngen = len(sh['coefficients'])
for g in range(ngen):
coef = [zero] * cur_prim
coef.extend(sh['coefficients'][g])
coef.extend([zero] * (nprim - len(coef)))
newsh['coefficients'].append(coef)
cur_prim += len(sh['exponents'])
newshells.append(newsh)
el['electron_shells'] = newshells
return basis |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:ComputeApplicationUniquifier; 3, parameters; 3, 4; 4, identifier:hash_obj; 5, block; 5, 6; 5, 8; 5, 152; 5, 203; 5, 271; 6, expression_statement; 6, 7; 7, comment; 8, function_definition; 8, 9; 8, 10; 8, 16; 9, function_name:ProcessDirectory; 10, parameters; 10, 11; 10, 12; 10, 13; 11, identifier:path; 12, identifier:relative_path; 13, default_parameter; 13, 14; 13, 15; 14, identifier:depth; 15, integer:1; 16, block; 16, 17; 16, 19; 16, 25; 16, 40; 16, 41; 16, 42; 16, 48; 17, expression_statement; 17, 18; 18, comment; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:>; 20, 21; 20, 22; 21, identifier:depth; 22, identifier:_MAX_DEPTH; 23, block; 23, 24; 24, return_statement; 25, try_statement; 25, 26; 25, 36; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:names; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:os; 33, identifier:listdir; 34, argument_list; 34, 35; 35, identifier:path; 36, except_clause; 36, 37; 36, 38; 37, identifier:BaseException; 38, block; 38, 39; 39, return_statement; 40, comment; 41, comment; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:modules; 45, call; 45, 46; 45, 47; 46, identifier:set; 47, argument_list; 48, for_statement; 48, 49; 48, 50; 48, 54; 49, identifier:name; 50, call; 50, 51; 50, 52; 51, identifier:sorted; 52, argument_list; 52, 53; 53, identifier:names; 54, block; 54, 55; 54, 67; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:current_path; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:os; 62, identifier:path; 63, identifier:join; 64, argument_list; 64, 65; 64, 66; 65, identifier:path; 66, identifier:name; 67, if_statement; 67, 68; 67, 77; 67, 129; 68, not_operator; 68, 69; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:os; 73, identifier:path; 74, identifier:isdir; 75, argument_list; 75, 76; 76, identifier:current_path; 77, block; 77, 78; 77, 91; 77, 101; 77, 108; 77, 115; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, pattern_list; 80, 81; 80, 82; 81, identifier:file_name; 82, identifier:ext; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:os; 87, identifier:path; 88, identifier:splitext; 89, argument_list; 89, 90; 90, identifier:name; 91, if_statement; 91, 92; 91, 98; 92, comparison_operator:not; 92, 93; 92, 94; 93, identifier:ext; 94, tuple; 94, 95; 94, 96; 94, 97; 95, string:'.py'; 96, string:'.pyc'; 97, string:'.pyo'; 98, block; 98, 99; 98, 100; 99, continue_statement; 100, comment; 101, if_statement; 101, 102; 101, 105; 102, comparison_operator:in; 102, 103; 102, 104; 103, identifier:file_name; 104, identifier:modules; 105, block; 105, 106; 105, 107; 106, continue_statement; 107, comment; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:modules; 112, identifier:add; 113, argument_list; 113, 114; 114, identifier:file_name; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:ProcessApplicationFile; 118, argument_list; 118, 119; 118, 120; 119, identifier:current_path; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:os; 124, identifier:path; 125, identifier:join; 126, argument_list; 126, 127; 126, 128; 127, identifier:relative_path; 128, identifier:name; 129, elif_clause; 129, 130; 129, 134; 130, call; 130, 131; 130, 132; 131, identifier:IsPackage; 132, argument_list; 132, 133; 133, identifier:current_path; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:ProcessDirectory; 138, argument_list; 138, 139; 138, 140; 138, 149; 139, identifier:current_path; 140, call; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:os; 144, identifier:path; 145, identifier:join; 146, argument_list; 146, 147; 146, 148; 147, identifier:relative_path; 148, identifier:name; 149, binary_operator:+; 149, 150; 149, 151; 150, identifier:depth; 151, integer:1; 152, function_definition; 152, 153; 152, 154; 152, 156; 153, function_name:IsPackage; 154, parameters; 154, 155; 155, identifier:path; 156, block; 156, 157; 156, 159; 156, 171; 157, expression_statement; 157, 158; 158, comment; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:init_base_path; 162, call; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:os; 166, identifier:path; 167, identifier:join; 168, argument_list; 168, 169; 168, 170; 169, identifier:path; 170, string:'__init__.py'; 171, return_statement; 171, 172; 172, parenthesized_expression; 172, 173; 173, boolean_operator:or; 173, 174; 173, 193; 174, boolean_operator:or; 174, 175; 174, 183; 175, call; 175, 176; 175, 181; 176, attribute; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:os; 179, identifier:path; 180, identifier:isfile; 181, argument_list; 181, 182; 182, identifier:init_base_path; 183, call; 183, 184; 183, 189; 184, attribute; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:os; 187, identifier:path; 188, identifier:isfile; 189, argument_list; 189, 190; 190, binary_operator:+; 190, 191; 190, 192; 191, identifier:init_base_path; 192, string:'c'; 193, call; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:os; 197, identifier:path; 198, identifier:isfile; 199, argument_list; 199, 200; 200, binary_operator:+; 200, 201; 200, 202; 201, identifier:init_base_path; 202, string:'o'; 203, function_definition; 203, 204; 203, 205; 203, 208; 204, function_name:ProcessApplicationFile; 205, parameters; 205, 206; 205, 207; 206, identifier:path; 207, identifier:relative_path; 208, block; 208, 209; 208, 211; 208, 222; 208, 233; 208, 260; 209, expression_statement; 209, 210; 210, comment; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:hash_obj; 215, identifier:update; 216, argument_list; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:relative_path; 220, identifier:encode; 221, argument_list; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:hash_obj; 226, identifier:update; 227, argument_list; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, string:':'; 231, identifier:encode; 232, argument_list; 233, try_statement; 233, 234; 233, 256; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:hash_obj; 239, identifier:update; 240, argument_list; 240, 241; 241, call; 241, 242; 241, 255; 242, attribute; 242, 243; 242, 254; 243, call; 243, 244; 243, 245; 244, identifier:str; 245, argument_list; 245, 246; 246, attribute; 246, 247; 246, 253; 247, call; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:os; 250, identifier:stat; 251, argument_list; 251, 252; 252, identifier:path; 253, identifier:st_size; 254, identifier:encode; 255, argument_list; 256, except_clause; 256, 257; 256, 258; 257, identifier:BaseException; 258, block; 258, 259; 259, pass_statement; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:hash_obj; 264, identifier:update; 265, argument_list; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, string:'\n'; 269, identifier:encode; 270, argument_list; 271, expression_statement; 271, 272; 272, call; 272, 273; 272, 274; 273, identifier:ProcessDirectory; 274, argument_list; 274, 275; 274, 280; 275, subscript; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:sys; 278, identifier:path; 279, integer:0; 280, string:'' | def ComputeApplicationUniquifier(hash_obj):
"""Computes hash of application files.
Application files can be anywhere on the disk. The application is free to
import a Python module from an arbitrary path ok the disk. It is also
impossible to distinguish application files from third party libraries.
Third party libraries are typically installed with "pip" and there is not a
good way to guarantee that all instances of the application are going to have
exactly the same version of each package. There is also a huge amount of files
in all sys.path directories and it will take too much time to traverse them
all. We therefore make an assumption that application files are only located
in sys.path[0].
When traversing files in sys.path, we can expect both .py and .pyc files. For
source deployment, we will find both .py and .pyc files. In this case we will
only index .py files and ignored .pyc file. In case of binary deployment, only
.pyc file will be there.
The naive way to hash files would be to read the file content and compute some
sort of a hash (e.g. SHA1). This can be expensive as well, so instead we just
hash file name and file size. It is a good enough heuristics to identify
modified files across different deployments.
Args:
hash_obj: hash aggregator to update with application uniquifier.
"""
def ProcessDirectory(path, relative_path, depth=1):
"""Recursively computes application uniquifier for a particular directory.
Args:
path: absolute path of the directory to start.
relative_path: path relative to sys.path[0]
depth: current recursion depth.
"""
if depth > _MAX_DEPTH:
return
try:
names = os.listdir(path)
except BaseException:
return
# Sort file names to ensure consistent hash regardless of order returned
# by os.listdir. This will also put .py files before .pyc and .pyo files.
modules = set()
for name in sorted(names):
current_path = os.path.join(path, name)
if not os.path.isdir(current_path):
file_name, ext = os.path.splitext(name)
if ext not in ('.py', '.pyc', '.pyo'):
continue # This is not an application file.
if file_name in modules:
continue # This is a .pyc file and we already indexed .py file.
modules.add(file_name)
ProcessApplicationFile(current_path, os.path.join(relative_path, name))
elif IsPackage(current_path):
ProcessDirectory(current_path,
os.path.join(relative_path, name),
depth + 1)
def IsPackage(path):
"""Checks if the specified directory is a valid Python package."""
init_base_path = os.path.join(path, '__init__.py')
return (os.path.isfile(init_base_path) or
os.path.isfile(init_base_path + 'c') or
os.path.isfile(init_base_path + 'o'))
def ProcessApplicationFile(path, relative_path):
"""Updates the hash with the specified application file."""
hash_obj.update(relative_path.encode())
hash_obj.update(':'.encode())
try:
hash_obj.update(str(os.stat(path).st_size).encode())
except BaseException:
pass
hash_obj.update('\n'.encode())
ProcessDirectory(sys.path[0], '') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_set_player; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 12; 5, 118; 5, 145; 5, 156; 5, 162; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:players; 11, list:[]; 12, for_statement; 12, 13; 12, 16; 12, 23; 12, 24; 12, 25; 13, pattern_list; 13, 14; 13, 15; 14, identifier:name; 15, identifier:p; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_mpris_players; 21, identifier:items; 22, argument_list; 23, comment; 24, comment; 25, block; 25, 26; 25, 91; 26, if_statement; 26, 27; 26, 30; 27, comparison_operator:not; 27, 28; 27, 29; 28, string:"_priority"; 29, identifier:p; 30, block; 30, 31; 30, 80; 31, if_statement; 31, 32; 31, 35; 31, 74; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:player_priority; 35, block; 35, 36; 36, try_statement; 36, 37; 36, 51; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:priority; 41, call; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:player_priority; 46, identifier:index; 47, argument_list; 47, 48; 48, subscript; 48, 49; 48, 50; 49, identifier:p; 50, string:"name"; 51, except_clause; 51, 52; 51, 53; 52, identifier:ValueError; 53, block; 53, 54; 54, try_statement; 54, 55; 54, 67; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:priority; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:player_priority; 64, identifier:index; 65, argument_list; 65, 66; 66, string:"*"; 67, except_clause; 67, 68; 67, 69; 68, identifier:ValueError; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:priority; 73, None; 74, else_clause; 74, 75; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:priority; 79, integer:0; 80, if_statement; 80, 81; 80, 84; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:priority; 83, None; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:p; 89, string:"_priority"; 90, identifier:priority; 91, if_statement; 91, 92; 91, 100; 92, comparison_operator:is; 92, 93; 92, 99; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:p; 96, identifier:get; 97, argument_list; 97, 98; 98, string:"_priority"; 99, None; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:players; 105, identifier:append; 106, argument_list; 106, 107; 107, tuple; 107, 108; 107, 111; 107, 114; 107, 117; 108, subscript; 108, 109; 108, 110; 109, identifier:p; 110, string:"_state_priority"; 111, subscript; 111, 112; 111, 113; 112, identifier:p; 113, string:"_priority"; 114, subscript; 114, 115; 114, 116; 115, identifier:p; 116, string:"index"; 117, identifier:name; 118, if_statement; 118, 119; 118, 120; 118, 139; 119, identifier:players; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:top_player; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:_mpris_players; 129, identifier:get; 130, argument_list; 130, 131; 131, subscript; 131, 132; 131, 138; 132, subscript; 132, 133; 132, 137; 133, call; 133, 134; 133, 135; 134, identifier:sorted; 135, argument_list; 135, 136; 136, identifier:players; 137, integer:0; 138, integer:3; 139, else_clause; 139, 140; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:top_player; 144, dictionary; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:_player; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:top_player; 153, identifier:get; 154, argument_list; 154, 155; 155, string:"_dbus_player"; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:_player_details; 161, identifier:top_player; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:py3; 168, identifier:update; 169, argument_list | def _set_player(self):
"""
Sort the current players into priority order and set self._player
Players are ordered by working state then prefernce supplied by user
and finally by instance if a player has more than one running.
"""
players = []
for name, p in self._mpris_players.items():
# we set the priority here as we need to establish the player name
# which might not be immediately available.
if "_priority" not in p:
if self.player_priority:
try:
priority = self.player_priority.index(p["name"])
except ValueError:
try:
priority = self.player_priority.index("*")
except ValueError:
priority = None
else:
priority = 0
if priority is not None:
p["_priority"] = priority
if p.get("_priority") is not None:
players.append((p["_state_priority"], p["_priority"], p["index"], name))
if players:
top_player = self._mpris_players.get(sorted(players)[0][3])
else:
top_player = {}
self._player = top_player.get("_dbus_player")
self._player_details = top_player
self.py3.update() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:file_sort; 3, parameters; 3, 4; 4, identifier:my_list; 5, block; 5, 6; 5, 8; 5, 37; 5, 46; 6, expression_statement; 6, 7; 7, comment; 8, function_definition; 8, 9; 8, 10; 8, 12; 9, function_name:alphanum_key; 10, parameters; 10, 11; 11, identifier:key; 12, block; 12, 13; 12, 15; 13, expression_statement; 13, 14; 14, comment; 15, return_statement; 15, 16; 16, list_comprehension; 16, 17; 16, 28; 17, conditional_expression:if; 17, 18; 17, 22; 17, 27; 18, call; 18, 19; 18, 20; 19, identifier:int; 20, argument_list; 20, 21; 21, identifier:s; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:s; 25, identifier:isdigit; 26, argument_list; 27, identifier:s; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:s; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:re; 33, identifier:split; 34, argument_list; 34, 35; 34, 36; 35, string:"([0-9]+)"; 36, identifier:key; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:my_list; 41, identifier:sort; 42, argument_list; 42, 43; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:key; 45, identifier:alphanum_key; 46, return_statement; 46, 47; 47, identifier:my_list | def file_sort(my_list):
"""
Sort a list of files in a nice way.
eg item-10 will be after item-9
"""
def alphanum_key(key):
"""
Split the key into str/int parts
"""
return [int(s) if s.isdigit() else s for s in re.split("([0-9]+)", key)]
my_list.sort(key=alphanum_key)
return my_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:squad; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:R_in; 5, identifier:t_in; 6, identifier:t_out; 7, block; 7, 8; 7, 10; 7, 35; 7, 36; 7, 37; 7, 38; 7, 39; 7, 40; 7, 54; 7, 55; 7, 56; 7, 57; 7, 58; 7, 59; 7, 60; 7, 61; 7, 62; 7, 63; 7, 64; 7, 136; 7, 231; 7, 232; 7, 233; 7, 234; 7, 235; 7, 236; 7, 237; 7, 238; 7, 239; 7, 240; 7, 241; 7, 242; 7, 243; 7, 251; 7, 252; 7, 253; 7, 254; 7, 255; 7, 256; 7, 257; 7, 258; 7, 259; 7, 269; 7, 270; 7, 271; 7, 272; 7, 273; 7, 274; 7, 275; 7, 276; 7, 277; 7, 278; 7, 288; 7, 289; 7, 290; 7, 291; 7, 292; 7, 293; 7, 294; 7, 295; 7, 296; 7, 297; 7, 298; 7, 320; 7, 321; 7, 322; 7, 323; 7, 324; 7, 335; 7, 357; 7, 368; 7, 379; 7, 400; 7, 417; 7, 418; 7, 437; 8, expression_statement; 8, 9; 9, comment; 10, if_statement; 10, 11; 10, 22; 11, boolean_operator:or; 11, 12; 11, 17; 12, comparison_operator:==; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:R_in; 15, identifier:size; 16, integer:0; 17, comparison_operator:==; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:t_out; 20, identifier:size; 21, integer:0; 22, block; 22, 23; 23, return_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:np; 27, identifier:array; 28, argument_list; 28, 29; 28, 30; 29, tuple; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:dtype; 32, attribute; 32, 33; 32, 34; 33, identifier:np; 34, identifier:quaternion; 35, comment; 36, comment; 37, comment; 38, comment; 39, comment; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:i_in_for_out; 43, binary_operator:-; 43, 44; 43, 53; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:t_in; 47, identifier:searchsorted; 48, argument_list; 48, 49; 48, 50; 49, identifier:t_out; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:side; 52, string:'right'; 53, integer:1; 54, comment; 55, comment; 56, comment; 57, comment; 58, comment; 59, comment; 60, comment; 61, comment; 62, comment; 63, comment; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:A; 67, binary_operator:*; 67, 68; 67, 69; 68, identifier:R_in; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:np; 72, identifier:exp; 73, argument_list; 73, 74; 74, binary_operator:*; 74, 75; 74, 135; 75, parenthesized_expression; 75, 76; 76, binary_operator:+; 76, 77; 76, 95; 77, unary_operator:-; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:np; 81, identifier:log; 82, argument_list; 82, 83; 83, binary_operator:*; 83, 84; 83, 87; 84, parenthesized_expression; 84, 85; 85, unary_operator:~; 85, 86; 86, identifier:R_in; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:np; 90, identifier:roll; 91, argument_list; 91, 92; 91, 93; 92, identifier:R_in; 93, unary_operator:-; 93, 94; 94, integer:1; 95, binary_operator:*; 95, 96; 95, 112; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:np; 99, identifier:log; 100, argument_list; 100, 101; 101, binary_operator:*; 101, 102; 101, 111; 102, parenthesized_expression; 102, 103; 103, unary_operator:~; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:np; 107, identifier:roll; 108, argument_list; 108, 109; 108, 110; 109, identifier:R_in; 110, integer:1; 111, identifier:R_in; 112, parenthesized_expression; 112, 113; 113, binary_operator:/; 113, 114; 113, 125; 114, parenthesized_expression; 114, 115; 115, binary_operator:-; 115, 116; 115, 124; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:np; 119, identifier:roll; 120, argument_list; 120, 121; 120, 122; 121, identifier:t_in; 122, unary_operator:-; 122, 123; 123, integer:1; 124, identifier:t_in; 125, parenthesized_expression; 125, 126; 126, binary_operator:-; 126, 127; 126, 128; 127, identifier:t_in; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:np; 131, identifier:roll; 132, argument_list; 132, 133; 132, 134; 133, identifier:t_in; 134, integer:1; 135, float:0.25; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:B; 139, binary_operator:*; 139, 140; 139, 148; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:np; 143, identifier:roll; 144, argument_list; 144, 145; 144, 146; 145, identifier:R_in; 146, unary_operator:-; 146, 147; 147, integer:1; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:np; 151, identifier:exp; 152, argument_list; 152, 153; 153, binary_operator:*; 153, 154; 153, 229; 154, parenthesized_expression; 154, 155; 155, binary_operator:-; 155, 156; 155, 212; 156, binary_operator:*; 156, 157; 156, 181; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:np; 160, identifier:log; 161, argument_list; 161, 162; 162, binary_operator:*; 162, 163; 162, 173; 163, parenthesized_expression; 163, 164; 164, unary_operator:~; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:np; 168, identifier:roll; 169, argument_list; 169, 170; 169, 171; 170, identifier:R_in; 171, unary_operator:-; 171, 172; 172, integer:1; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:np; 176, identifier:roll; 177, argument_list; 177, 178; 177, 179; 178, identifier:R_in; 179, unary_operator:-; 179, 180; 180, integer:2; 181, parenthesized_expression; 181, 182; 182, binary_operator:/; 182, 183; 182, 194; 183, parenthesized_expression; 183, 184; 184, binary_operator:-; 184, 185; 184, 193; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:np; 188, identifier:roll; 189, argument_list; 189, 190; 189, 191; 190, identifier:t_in; 191, unary_operator:-; 191, 192; 192, integer:1; 193, identifier:t_in; 194, parenthesized_expression; 194, 195; 195, binary_operator:-; 195, 196; 195, 204; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:np; 199, identifier:roll; 200, argument_list; 200, 201; 200, 202; 201, identifier:t_in; 202, unary_operator:-; 202, 203; 203, integer:2; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:np; 207, identifier:roll; 208, argument_list; 208, 209; 208, 210; 209, identifier:t_in; 210, unary_operator:-; 210, 211; 211, integer:1; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:np; 215, identifier:log; 216, argument_list; 216, 217; 217, binary_operator:*; 217, 218; 217, 221; 218, parenthesized_expression; 218, 219; 219, unary_operator:~; 219, 220; 220, identifier:R_in; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:np; 224, identifier:roll; 225, argument_list; 225, 226; 225, 227; 226, identifier:R_in; 227, unary_operator:-; 227, 228; 228, integer:1; 229, unary_operator:-; 229, 230; 230, float:0.25; 231, comment; 232, comment; 233, comment; 234, comment; 235, comment; 236, comment; 237, comment; 238, comment; 239, comment; 240, comment; 241, comment; 242, comment; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:A; 247, integer:0; 248, subscript; 248, 249; 248, 250; 249, identifier:R_in; 250, integer:0; 251, comment; 252, comment; 253, comment; 254, comment; 255, comment; 256, comment; 257, comment; 258, comment; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 265; 261, subscript; 261, 262; 261, 263; 262, identifier:A; 263, unary_operator:-; 263, 264; 264, integer:1; 265, subscript; 265, 266; 265, 267; 266, identifier:R_in; 267, unary_operator:-; 267, 268; 268, integer:1; 269, comment; 270, comment; 271, comment; 272, comment; 273, comment; 274, comment; 275, comment; 276, comment; 277, comment; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 284; 280, subscript; 280, 281; 280, 282; 281, identifier:B; 282, unary_operator:-; 282, 283; 283, integer:2; 284, subscript; 284, 285; 284, 286; 285, identifier:R_in; 286, unary_operator:-; 286, 287; 287, integer:1; 288, comment; 289, comment; 290, comment; 291, comment; 292, comment; 293, comment; 294, comment; 295, comment; 296, comment; 297, comment; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 304; 300, subscript; 300, 301; 300, 302; 301, identifier:B; 302, unary_operator:-; 302, 303; 303, integer:1; 304, binary_operator:*; 304, 305; 304, 316; 305, binary_operator:*; 305, 306; 305, 310; 306, subscript; 306, 307; 306, 308; 307, identifier:R_in; 308, unary_operator:-; 308, 309; 309, integer:1; 310, parenthesized_expression; 310, 311; 311, unary_operator:~; 311, 312; 312, subscript; 312, 313; 312, 314; 313, identifier:R_in; 314, unary_operator:-; 314, 315; 315, integer:2; 316, subscript; 316, 317; 316, 318; 317, identifier:R_in; 318, unary_operator:-; 318, 319; 319, integer:1; 320, comment; 321, comment; 322, comment; 323, comment; 324, expression_statement; 324, 325; 325, assignment; 325, 326; 325, 327; 326, identifier:R_ip1; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:np; 330, identifier:roll; 331, argument_list; 331, 332; 331, 333; 332, identifier:R_in; 333, unary_operator:-; 333, 334; 334, integer:1; 335, expression_statement; 335, 336; 336, assignment; 336, 337; 336, 341; 337, subscript; 337, 338; 337, 339; 338, identifier:R_ip1; 339, unary_operator:-; 339, 340; 340, integer:1; 341, binary_operator:*; 341, 342; 341, 353; 342, binary_operator:*; 342, 343; 342, 347; 343, subscript; 343, 344; 343, 345; 344, identifier:R_in; 345, unary_operator:-; 345, 346; 346, integer:1; 347, parenthesized_expression; 347, 348; 348, unary_operator:~; 348, 349; 349, subscript; 349, 350; 349, 351; 350, identifier:R_in; 351, unary_operator:-; 351, 352; 352, integer:2; 353, subscript; 353, 354; 353, 355; 354, identifier:R_in; 355, unary_operator:-; 355, 356; 356, integer:1; 357, expression_statement; 357, 358; 358, assignment; 358, 359; 358, 360; 359, identifier:R_ip1; 360, call; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:np; 363, identifier:array; 364, argument_list; 364, 365; 365, subscript; 365, 366; 365, 367; 366, identifier:R_ip1; 367, identifier:i_in_for_out; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 371; 370, identifier:t_inp1; 371, call; 371, 372; 371, 375; 372, attribute; 372, 373; 372, 374; 373, identifier:np; 374, identifier:roll; 375, argument_list; 375, 376; 375, 377; 376, identifier:t_in; 377, unary_operator:-; 377, 378; 378, integer:1; 379, expression_statement; 379, 380; 380, assignment; 380, 381; 380, 385; 381, subscript; 381, 382; 381, 383; 382, identifier:t_inp1; 383, unary_operator:-; 383, 384; 384, integer:1; 385, binary_operator:+; 385, 386; 385, 390; 386, subscript; 386, 387; 386, 388; 387, identifier:t_in; 388, unary_operator:-; 388, 389; 389, integer:1; 390, parenthesized_expression; 390, 391; 391, binary_operator:-; 391, 392; 391, 396; 392, subscript; 392, 393; 392, 394; 393, identifier:t_in; 394, unary_operator:-; 394, 395; 395, integer:1; 396, subscript; 396, 397; 396, 398; 397, identifier:t_in; 398, unary_operator:-; 398, 399; 399, integer:2; 400, expression_statement; 400, 401; 401, assignment; 401, 402; 401, 403; 402, identifier:tau; 403, binary_operator:/; 403, 404; 403, 410; 404, parenthesized_expression; 404, 405; 405, binary_operator:-; 405, 406; 405, 407; 406, identifier:t_out; 407, subscript; 407, 408; 407, 409; 408, identifier:t_in; 409, identifier:i_in_for_out; 410, parenthesized_expression; 410, 411; 411, subscript; 411, 412; 411, 416; 412, parenthesized_expression; 412, 413; 413, binary_operator:-; 413, 414; 413, 415; 414, identifier:t_inp1; 415, identifier:t_in; 416, identifier:i_in_for_out; 417, comment; 418, expression_statement; 418, 419; 419, assignment; 419, 420; 419, 421; 420, identifier:R_out; 421, call; 421, 422; 421, 425; 422, attribute; 422, 423; 422, 424; 423, identifier:np; 424, identifier:squad_vectorized; 425, argument_list; 425, 426; 425, 427; 425, 430; 425, 433; 425, 436; 426, identifier:tau; 427, subscript; 427, 428; 427, 429; 428, identifier:R_in; 429, identifier:i_in_for_out; 430, subscript; 430, 431; 430, 432; 431, identifier:A; 432, identifier:i_in_for_out; 433, subscript; 433, 434; 433, 435; 434, identifier:B; 435, identifier:i_in_for_out; 436, identifier:R_ip1; 437, return_statement; 437, 438; 438, identifier:R_out | def squad(R_in, t_in, t_out):
"""Spherical "quadrangular" interpolation of rotors with a cubic spline
This is the best way to interpolate rotations. It uses the analog
of a cubic spline, except that the interpolant is confined to the
rotor manifold in a natural way. Alternative methods involving
interpolation of other coordinates on the rotation group or
normalization of interpolated values give bad results. The
results from this method are as natural as any, and are continuous
in first and second derivatives.
The input `R_in` rotors are assumed to be reasonably continuous
(no sign flips), and the input `t` arrays are assumed to be
sorted. No checking is done for either case, and you may get
silently bad results if these conditions are violated.
This function simplifies the calling, compared to `squad_evaluate`
(which takes a set of four quaternions forming the edges of the
"quadrangle", and the normalized time `tau`) and `squad_vectorized`
(which takes the same arguments, but in array form, and efficiently
loops over them).
Parameters
----------
R_in: array of quaternions
A time-series of rotors (unit quaternions) to be interpolated
t_in: array of float
The times corresponding to R_in
t_out: array of float
The times to which R_in should be interpolated
"""
if R_in.size == 0 or t_out.size == 0:
return np.array((), dtype=np.quaternion)
# This list contains an index for each `t_out` such that
# t_in[i-1] <= t_out < t_in[i]
# Note that `side='right'` is much faster in my tests
# i_in_for_out = t_in.searchsorted(t_out, side='left')
# np.clip(i_in_for_out, 0, len(t_in) - 1, out=i_in_for_out)
i_in_for_out = t_in.searchsorted(t_out, side='right')-1
# Now, for each index `i` in `i_in`, we need to compute the
# interpolation "coefficients" (`A_i`, `B_ip1`).
#
# I previously tested an explicit version of the loops below,
# comparing `stride_tricks.as_strided` with explicit
# implementation via `roll` (as seen here). I found that the
# `roll` was significantly more efficient for simple calculations,
# though the difference is probably totally washed out here. In
# any case, it might be useful to test again.
#
A = R_in * np.exp((- np.log((~R_in) * np.roll(R_in, -1))
+ np.log((~np.roll(R_in, 1)) * R_in) * ((np.roll(t_in, -1) - t_in) / (t_in - np.roll(t_in, 1)))
) * 0.25)
B = np.roll(R_in, -1) * np.exp((np.log((~np.roll(R_in, -1)) * np.roll(R_in, -2))
* ((np.roll(t_in, -1) - t_in) / (np.roll(t_in, -2) - np.roll(t_in, -1)))
- np.log((~R_in) * np.roll(R_in, -1))) * -0.25)
# Correct the first and last A time steps, and last two B time steps. We extend R_in with the following wrap-around
# values:
# R_in[0-1] = R_in[0]*(~R_in[1])*R_in[0]
# R_in[n+0] = R_in[-1] * (~R_in[-2]) * R_in[-1]
# R_in[n+1] = R_in[0] * (~R_in[-1]) * R_in[0]
# = R_in[-1] * (~R_in[-2]) * R_in[-1] * (~R_in[-1]) * R_in[-1] * (~R_in[-2]) * R_in[-1]
# = R_in[-1] * (~R_in[-2]) * R_in[-1] * (~R_in[-2]) * R_in[-1]
# A[i] = R_in[i] * np.exp((- np.log((~R_in[i]) * R_in[i+1])
# + np.log((~R_in[i-1]) * R_in[i]) * ((t_in[i+1] - t_in[i]) / (t_in[i] - t_in[i-1]))
# ) * 0.25)
# A[0] = R_in[0] * np.exp((- np.log((~R_in[0]) * R_in[1]) + np.log((~R_in[0])*R_in[1]*(~R_in[0])) * R_in[0]) * 0.25)
# = R_in[0]
A[0] = R_in[0]
# A[-1] = R_in[-1] * np.exp((- np.log((~R_in[-1]) * R_in[n+0])
# + np.log((~R_in[-2]) * R_in[-1]) * ((t_in[n+0] - t_in[-1]) / (t_in[-1] - t_in[-2]))
# ) * 0.25)
# = R_in[-1] * np.exp((- np.log((~R_in[-1]) * R_in[n+0]) + np.log((~R_in[-2]) * R_in[-1])) * 0.25)
# = R_in[-1] * np.exp((- np.log((~R_in[-1]) * R_in[-1] * (~R_in[-2]) * R_in[-1])
# + np.log((~R_in[-2]) * R_in[-1])) * 0.25)
# = R_in[-1] * np.exp((- np.log((~R_in[-2]) * R_in[-1]) + np.log((~R_in[-2]) * R_in[-1])) * 0.25)
# = R_in[-1]
A[-1] = R_in[-1]
# B[i] = R_in[i+1] * np.exp((np.log((~R_in[i+1]) * R_in[i+2]) * ((t_in[i+1] - t_in[i]) / (t_in[i+2] - t_in[i+1]))
# - np.log((~R_in[i]) * R_in[i+1])) * -0.25)
# B[-2] = R_in[-1] * np.exp((np.log((~R_in[-1]) * R_in[0]) * ((t_in[-1] - t_in[-2]) / (t_in[0] - t_in[-1]))
# - np.log((~R_in[-2]) * R_in[-1])) * -0.25)
# = R_in[-1] * np.exp((np.log((~R_in[-1]) * R_in[0]) - np.log((~R_in[-2]) * R_in[-1])) * -0.25)
# = R_in[-1] * np.exp((np.log((~R_in[-1]) * R_in[-1] * (~R_in[-2]) * R_in[-1])
# - np.log((~R_in[-2]) * R_in[-1])) * -0.25)
# = R_in[-1] * np.exp((np.log((~R_in[-2]) * R_in[-1]) - np.log((~R_in[-2]) * R_in[-1])) * -0.25)
# = R_in[-1]
B[-2] = R_in[-1]
# B[-1] = R_in[0]
# B[-1] = R_in[0] * np.exp((np.log((~R_in[0]) * R_in[1]) - np.log((~R_in[-1]) * R_in[0])) * -0.25)
# = R_in[-1] * (~R_in[-2]) * R_in[-1]
# * np.exp((np.log((~(R_in[-1] * (~R_in[-2]) * R_in[-1])) * R_in[-1] * (~R_in[-2]) * R_in[-1] * (~R_in[-2]) * R_in[-1])
# - np.log((~R_in[-1]) * R_in[-1] * (~R_in[-2]) * R_in[-1])) * -0.25)
# = R_in[-1] * (~R_in[-2]) * R_in[-1]
# * np.exp((np.log(((~R_in[-1]) * R_in[-2] * (~R_in[-1])) * R_in[-1] * (~R_in[-2]) * R_in[-1] * (~R_in[-2]) * R_in[-1])
# - np.log((~R_in[-1]) * R_in[-1] * (~R_in[-2]) * R_in[-1])) * -0.25)
# * np.exp((np.log((~R_in[-2]) * R_in[-1])
# - np.log((~R_in[-2]) * R_in[-1])) * -0.25)
B[-1] = R_in[-1] * (~R_in[-2]) * R_in[-1]
# Use the coefficients at the corresponding t_out indices to
# compute the squad interpolant
# R_ip1 = np.array(np.roll(R_in, -1)[i_in_for_out])
# R_ip1[-1] = R_in[-1]*(~R_in[-2])*R_in[-1]
R_ip1 = np.roll(R_in, -1)
R_ip1[-1] = R_in[-1]*(~R_in[-2])*R_in[-1]
R_ip1 = np.array(R_ip1[i_in_for_out])
t_inp1 = np.roll(t_in, -1)
t_inp1[-1] = t_in[-1] + (t_in[-1] - t_in[-2])
tau = (t_out - t_in[i_in_for_out]) / ((t_inp1 - t_in)[i_in_for_out])
# tau = (t_out - t_in[i_in_for_out]) / ((np.roll(t_in, -1) - t_in)[i_in_for_out])
R_out = np.squad_vectorized(tau, R_in[i_in_for_out], A[i_in_for_out], B[i_in_for_out], R_ip1)
return R_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_resource_id; 3, parameters; 3, 4; 3, 5; 4, identifier:prefix; 5, list_splat_pattern; 5, 6; 6, identifier:data; 7, block; 7, 8; 7, 10; 7, 17; 7, 45; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:parts; 13, call; 13, 14; 13, 15; 14, identifier:flatten; 15, argument_list; 15, 16; 16, identifier:data; 17, for_statement; 17, 18; 17, 19; 17, 20; 18, identifier:part; 19, identifier:parts; 20, block; 20, 21; 21, if_statement; 21, 22; 21, 31; 22, comparison_operator:not; 22, 23; 22, 27; 23, call; 23, 24; 23, 25; 24, identifier:type; 25, argument_list; 25, 26; 26, identifier:part; 27, tuple; 27, 28; 27, 29; 27, 30; 28, identifier:str; 29, identifier:int; 30, identifier:float; 31, block; 31, 32; 32, raise_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:ValueError; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, string:'Supported data types: int, float, list, tuple, str. Got: {}'; 39, identifier:format; 40, argument_list; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:type; 43, argument_list; 43, 44; 44, identifier:part; 45, return_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, string:'{}-{}'; 49, identifier:format; 50, argument_list; 50, 51; 50, 52; 51, identifier:prefix; 52, subscript; 52, 53; 52, 69; 53, call; 53, 54; 53, 55; 54, identifier:get_hash; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, string:'-'; 59, identifier:join; 60, argument_list; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:sorted; 63, argument_list; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:map; 66, argument_list; 66, 67; 66, 68; 67, identifier:str; 68, identifier:parts; 69, slice; 69, 70; 69, 72; 70, unary_operator:-; 70, 71; 71, integer:16; 72, colon | def get_resource_id(prefix, *data):
"""Returns a unique ID based on the SHA256 hash of the provided data. The input data is flattened and sorted to
ensure identical hashes are generated regardless of the order of the input. Values must be of types `str`, `int` or
`float`, any other input type will raise a `ValueError`
>>> get_resource_id('ec2', 'lots', 'of', 'data')
'ec2-1d21940125214123'
>>> get_resource_id('ecs', 'foo', ['more', 'data', 'here', 2, 3])
'ecs-e536b036ea6fd463'
>>> get_resource_id('ecs', ['more'], 'data', 'here', [[2], 3], 'foo')
'ecs-e536b036ea6fd463'
Args:
prefix (`str`): Key prefix
*data (`str`, `int`, `float`, `list`, `tuple`): Data used to generate a unique ID
Returns:
`str`
"""
parts = flatten(data)
for part in parts:
if type(part) not in (str, int, float):
raise ValueError('Supported data types: int, float, list, tuple, str. Got: {}'.format(type(part)))
return '{}-{}'.format(
prefix,
get_hash('-'.join(sorted(map(str, parts))))[-16:]
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:sorted; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:iterator; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:reverse; 11, False; 12, block; 12, 13; 12, 15; 12, 18; 12, 30; 12, 38; 12, 45; 12, 231; 12, 243; 12, 249; 12, 262; 13, expression_statement; 13, 14; 14, comment; 15, global_statement; 15, 16; 15, 17; 16, identifier:MemoryBytesSpilled; 17, identifier:DiskBytesSpilled; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, pattern_list; 20, 21; 20, 22; 21, identifier:batch; 22, identifier:limit; 23, expression_list; 23, 24; 23, 25; 24, integer:100; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_next_limit; 29, argument_list; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, pattern_list; 32, 33; 32, 34; 33, identifier:chunks; 34, identifier:current_chunk; 35, expression_list; 35, 36; 35, 37; 36, list:[]; 37, list:[]; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:iterator; 41, call; 41, 42; 41, 43; 42, identifier:iter; 43, argument_list; 43, 44; 44, identifier:iterator; 45, while_statement; 45, 46; 45, 47; 45, 48; 46, True; 47, comment; 48, block; 48, 49; 48, 62; 48, 69; 48, 78; 48, 84; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:chunk; 52, call; 52, 53; 52, 54; 53, identifier:list; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:itertools; 58, identifier:islice; 59, argument_list; 59, 60; 59, 61; 60, identifier:iterator; 61, identifier:batch; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:current_chunk; 66, identifier:extend; 67, argument_list; 67, 68; 68, identifier:chunk; 69, if_statement; 69, 70; 69, 76; 70, comparison_operator:<; 70, 71; 70, 75; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:chunk; 75, identifier:batch; 76, block; 76, 77; 77, break_statement; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:used_memory; 81, call; 81, 82; 81, 83; 82, identifier:get_used_memory; 83, argument_list; 84, if_statement; 84, 85; 84, 88; 84, 89; 84, 214; 85, comparison_operator:>; 85, 86; 85, 87; 86, identifier:used_memory; 87, identifier:limit; 88, comment; 89, block; 89, 90; 89, 102; 89, 114; 89, 136; 89, 163; 89, 177; 89, 181; 89, 195; 89, 206; 89, 213; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:current_chunk; 94, identifier:sort; 95, argument_list; 95, 96; 95, 99; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:key; 98, identifier:key; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:reverse; 101, identifier:reverse; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:path; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:_get_path; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:len; 112, argument_list; 112, 113; 113, identifier:chunks; 114, with_statement; 114, 115; 114, 125; 115, with_clause; 115, 116; 116, with_item; 116, 117; 117, as_pattern; 117, 118; 117, 123; 118, call; 118, 119; 118, 120; 119, identifier:open; 120, argument_list; 120, 121; 120, 122; 121, identifier:path; 122, string:'wb'; 123, as_pattern_target; 123, 124; 124, identifier:f; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:serializer; 132, identifier:dump_stream; 133, argument_list; 133, 134; 133, 135; 134, identifier:current_chunk; 135, identifier:f; 136, function_definition; 136, 137; 136, 138; 136, 140; 137, function_name:load; 138, parameters; 138, 139; 139, identifier:f; 140, block; 140, 141; 140, 155; 140, 156; 140, 157; 141, for_statement; 141, 142; 141, 143; 141, 151; 142, identifier:v; 143, call; 143, 144; 143, 149; 144, attribute; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:serializer; 148, identifier:load_stream; 149, argument_list; 149, 150; 150, identifier:f; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, yield; 153, 154; 154, identifier:v; 155, comment; 156, comment; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:f; 161, identifier:close; 162, argument_list; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:chunks; 167, identifier:append; 168, argument_list; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:load; 171, argument_list; 171, 172; 172, call; 172, 173; 172, 174; 173, identifier:open; 174, argument_list; 174, 175; 174, 176; 175, identifier:path; 176, string:'rb'; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:current_chunk; 180, list:[]; 181, expression_statement; 181, 182; 182, augmented_assignment:+=; 182, 183; 182, 184; 183, identifier:MemoryBytesSpilled; 184, binary_operator:<<; 184, 185; 184, 194; 185, call; 185, 186; 185, 187; 186, identifier:max; 187, argument_list; 187, 188; 187, 193; 188, binary_operator:-; 188, 189; 188, 190; 189, identifier:used_memory; 190, call; 190, 191; 190, 192; 191, identifier:get_used_memory; 192, argument_list; 193, integer:0; 194, integer:20; 195, expression_statement; 195, 196; 196, augmented_assignment:+=; 196, 197; 196, 198; 197, identifier:DiskBytesSpilled; 198, call; 198, 199; 198, 204; 199, attribute; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:os; 202, identifier:path; 203, identifier:getsize; 204, argument_list; 204, 205; 205, identifier:path; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:os; 210, identifier:unlink; 211, argument_list; 211, 212; 212, identifier:path; 213, comment; 214, elif_clause; 214, 215; 214, 217; 215, not_operator; 215, 216; 216, identifier:chunks; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:batch; 221, call; 221, 222; 221, 223; 222, identifier:min; 223, argument_list; 223, 224; 223, 230; 224, call; 224, 225; 224, 226; 225, identifier:int; 226, argument_list; 226, 227; 227, binary_operator:*; 227, 228; 227, 229; 228, identifier:batch; 229, float:1.5; 230, integer:10000; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:current_chunk; 235, identifier:sort; 236, argument_list; 236, 237; 236, 240; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:key; 239, identifier:key; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:reverse; 242, identifier:reverse; 243, if_statement; 243, 244; 243, 246; 244, not_operator; 244, 245; 245, identifier:chunks; 246, block; 246, 247; 247, return_statement; 247, 248; 248, identifier:current_chunk; 249, if_statement; 249, 250; 249, 251; 250, identifier:current_chunk; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:chunks; 256, identifier:append; 257, argument_list; 257, 258; 258, call; 258, 259; 258, 260; 259, identifier:iter; 260, argument_list; 260, 261; 261, identifier:current_chunk; 262, return_statement; 262, 263; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:heapq; 266, identifier:merge; 267, argument_list; 267, 268; 267, 269; 267, 272; 268, identifier:chunks; 269, keyword_argument; 269, 270; 269, 271; 270, identifier:key; 271, identifier:key; 272, keyword_argument; 272, 273; 272, 274; 273, identifier:reverse; 274, identifier:reverse | def sorted(self, iterator, key=None, reverse=False):
"""
Sort the elements in iterator, do external sort when the memory
goes above the limit.
"""
global MemoryBytesSpilled, DiskBytesSpilled
batch, limit = 100, self._next_limit()
chunks, current_chunk = [], []
iterator = iter(iterator)
while True:
# pick elements in batch
chunk = list(itertools.islice(iterator, batch))
current_chunk.extend(chunk)
if len(chunk) < batch:
break
used_memory = get_used_memory()
if used_memory > limit:
# sort them inplace will save memory
current_chunk.sort(key=key, reverse=reverse)
path = self._get_path(len(chunks))
with open(path, 'wb') as f:
self.serializer.dump_stream(current_chunk, f)
def load(f):
for v in self.serializer.load_stream(f):
yield v
# close the file explicit once we consume all the items
# to avoid ResourceWarning in Python3
f.close()
chunks.append(load(open(path, 'rb')))
current_chunk = []
MemoryBytesSpilled += max(used_memory - get_used_memory(), 0) << 20
DiskBytesSpilled += os.path.getsize(path)
os.unlink(path) # data will be deleted after close
elif not chunks:
batch = min(int(batch * 1.5), 10000)
current_chunk.sort(key=key, reverse=reverse)
if not chunks:
return current_chunk
if current_chunk:
chunks.append(iter(current_chunk))
return heapq.merge(chunks, key=key, reverse=reverse) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_merge_sorted_items; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:index; 6, block; 6, 7; 6, 9; 6, 65; 6, 81; 6, 149; 7, expression_statement; 7, 8; 8, comment; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:load_partition; 11, parameters; 11, 12; 12, identifier:j; 13, block; 13, 14; 13, 23; 13, 38; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:path; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_get_spill_dir; 21, argument_list; 21, 22; 22, identifier:j; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:p; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:os; 30, identifier:path; 31, identifier:join; 32, argument_list; 32, 33; 32, 34; 33, identifier:path; 34, call; 34, 35; 34, 36; 35, identifier:str; 36, argument_list; 36, 37; 37, identifier:index; 38, with_statement; 38, 39; 38, 50; 39, with_clause; 39, 40; 40, with_item; 40, 41; 41, as_pattern; 41, 42; 41, 48; 42, call; 42, 43; 42, 44; 43, identifier:open; 44, argument_list; 44, 45; 44, 46; 44, 47; 45, identifier:p; 46, string:'rb'; 47, integer:65536; 48, as_pattern_target; 48, 49; 49, identifier:f; 50, block; 50, 51; 51, for_statement; 51, 52; 51, 53; 51, 61; 52, identifier:v; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:serializer; 58, identifier:load_stream; 59, argument_list; 59, 60; 60, identifier:f; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, yield; 63, 64; 64, identifier:v; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:disk_items; 68, list_comprehension; 68, 69; 68, 73; 69, call; 69, 70; 69, 71; 70, identifier:load_partition; 71, argument_list; 71, 72; 72, identifier:j; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:j; 75, call; 75, 76; 75, 77; 76, identifier:range; 77, argument_list; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:spills; 81, if_statement; 81, 82; 81, 85; 81, 86; 81, 104; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_sorted; 85, comment; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:sorted_items; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:heapq; 93, identifier:merge; 94, argument_list; 94, 95; 94, 96; 95, identifier:disk_items; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:key; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:operator; 101, identifier:itemgetter; 102, argument_list; 102, 103; 103, integer:0; 104, else_clause; 104, 105; 104, 106; 104, 107; 105, comment; 106, comment; 107, block; 107, 108; 107, 116; 107, 126; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:ser; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:flattened_serializer; 115, argument_list; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:sorter; 119, call; 119, 120; 119, 121; 120, identifier:ExternalSorter; 121, argument_list; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:memory_limit; 125, identifier:ser; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:sorted_items; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:sorter; 132, identifier:sorted; 133, argument_list; 133, 134; 133, 141; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:itertools; 137, identifier:chain; 138, argument_list; 138, 139; 139, list_splat; 139, 140; 140, identifier:disk_items; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:key; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:operator; 146, identifier:itemgetter; 147, argument_list; 147, 148; 148, integer:0; 149, return_statement; 149, 150; 150, generator_expression; 150, 151; 150, 154; 151, tuple; 151, 152; 151, 153; 152, identifier:k; 153, identifier:vs; 154, for_in_clause; 154, 155; 154, 158; 155, pattern_list; 155, 156; 155, 157; 156, identifier:k; 157, identifier:vs; 158, call; 158, 159; 158, 160; 159, identifier:GroupByKey; 160, argument_list; 160, 161; 161, identifier:sorted_items | def _merge_sorted_items(self, index):
""" load a partition from disk, then sort and group by key """
def load_partition(j):
path = self._get_spill_dir(j)
p = os.path.join(path, str(index))
with open(p, 'rb', 65536) as f:
for v in self.serializer.load_stream(f):
yield v
disk_items = [load_partition(j) for j in range(self.spills)]
if self._sorted:
# all the partitions are already sorted
sorted_items = heapq.merge(disk_items, key=operator.itemgetter(0))
else:
# Flatten the combined values, so it will not consume huge
# memory during merging sort.
ser = self.flattened_serializer()
sorter = ExternalSorter(self.memory_limit, ser)
sorted_items = sorter.sorted(itertools.chain(*disk_items),
key=operator.itemgetter(0))
return ((k, vs) for k, vs in GroupByKey(sorted_items)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:map; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:f; 6, default_parameter; 6, 7; 6, 8; 7, identifier:preservesPartitioning; 8, False; 9, block; 9, 10; 9, 12; 9, 27; 10, expression_statement; 10, 11; 11, comment; 12, function_definition; 12, 13; 12, 14; 12, 17; 13, function_name:func; 14, parameters; 14, 15; 14, 16; 15, identifier:_; 16, identifier:iterator; 17, block; 17, 18; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:map; 21, argument_list; 21, 22; 21, 26; 22, call; 22, 23; 22, 24; 23, identifier:fail_on_stopiteration; 24, argument_list; 24, 25; 25, identifier:f; 26, identifier:iterator; 27, return_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:mapPartitionsWithIndex; 32, argument_list; 32, 33; 32, 34; 33, identifier:func; 34, identifier:preservesPartitioning | def map(self, f, preservesPartitioning=False):
"""
Return a new RDD by applying a function to each element of this RDD.
>>> rdd = sc.parallelize(["b", "a", "c"])
>>> sorted(rdd.map(lambda x: (x, 1)).collect())
[('a', 1), ('b', 1), ('c', 1)]
"""
def func(_, iterator):
return map(fail_on_stopiteration(f), iterator)
return self.mapPartitionsWithIndex(func, preservesPartitioning) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:flatMap; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:f; 6, default_parameter; 6, 7; 6, 8; 7, identifier:preservesPartitioning; 8, False; 9, block; 9, 10; 9, 12; 9, 32; 10, expression_statement; 10, 11; 11, comment; 12, function_definition; 12, 13; 12, 14; 12, 17; 13, function_name:func; 14, parameters; 14, 15; 14, 16; 15, identifier:s; 16, identifier:iterator; 17, block; 17, 18; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:chain; 22, identifier:from_iterable; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:map; 26, argument_list; 26, 27; 26, 31; 27, call; 27, 28; 27, 29; 28, identifier:fail_on_stopiteration; 29, argument_list; 29, 30; 30, identifier:f; 31, identifier:iterator; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:mapPartitionsWithIndex; 37, argument_list; 37, 38; 37, 39; 38, identifier:func; 39, identifier:preservesPartitioning | def flatMap(self, f, preservesPartitioning=False):
"""
Return a new RDD by first applying a function to all elements of this
RDD, and then flattening the results.
>>> rdd = sc.parallelize([2, 3, 4])
>>> sorted(rdd.flatMap(lambda x: range(1, x)).collect())
[1, 1, 1, 2, 2, 3]
>>> sorted(rdd.flatMap(lambda x: [(x, x), (x, x)]).collect())
[(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)]
"""
def func(s, iterator):
return chain.from_iterable(map(fail_on_stopiteration(f), iterator))
return self.mapPartitionsWithIndex(func, preservesPartitioning) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:distinct; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:numPartitions; 7, None; 8, block; 8, 9; 8, 11; 9, expression_statement; 9, 10; 10, comment; 11, return_statement; 11, 12; 12, call; 12, 13; 12, 38; 13, attribute; 13, 14; 13, 36; 13, 37; 14, call; 14, 15; 14, 29; 15, attribute; 15, 16; 15, 27; 15, 28; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:map; 20, argument_list; 20, 21; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:x; 24, tuple; 24, 25; 24, 26; 25, identifier:x; 26, None; 27, line_continuation:\; 28, identifier:reduceByKey; 29, argument_list; 29, 30; 29, 35; 30, lambda; 30, 31; 30, 34; 31, lambda_parameters; 31, 32; 31, 33; 32, identifier:x; 33, identifier:_; 34, identifier:x; 35, identifier:numPartitions; 36, line_continuation:\; 37, identifier:map; 38, argument_list; 38, 39; 39, lambda; 39, 40; 39, 42; 40, lambda_parameters; 40, 41; 41, identifier:x; 42, subscript; 42, 43; 42, 44; 43, identifier:x; 44, integer:0 | def distinct(self, numPartitions=None):
"""
Return a new RDD containing the distinct elements in this RDD.
>>> sorted(sc.parallelize([1, 1, 2, 3]).distinct().collect())
[1, 2, 3]
"""
return self.map(lambda x: (x, None)) \
.reduceByKey(lambda x, _: x, numPartitions) \
.map(lambda x: x[0]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:repartitionAndSortWithinPartitions; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:numPartitions; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:partitionFunc; 10, identifier:portable_hash; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ascending; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:keyfunc; 16, lambda; 16, 17; 16, 19; 17, lambda_parameters; 17, 18; 18, identifier:x; 19, identifier:x; 20, block; 20, 21; 20, 23; 20, 36; 20, 53; 20, 59; 20, 100; 21, expression_statement; 21, 22; 22, comment; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:numPartitions; 26, None; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:numPartitions; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_defaultReducePartitions; 35, argument_list; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:memory; 39, call; 39, 40; 39, 41; 40, identifier:_parse_memory; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 50; 43, attribute; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:ctx; 48, identifier:_conf; 49, identifier:get; 50, argument_list; 50, 51; 50, 52; 51, string:"spark.python.worker.memory"; 52, string:"512m"; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:serializer; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_jrdd_deserializer; 59, function_definition; 59, 60; 59, 61; 59, 63; 60, function_name:sortPartition; 61, parameters; 61, 62; 62, identifier:iterator; 63, block; 63, 64; 63, 76; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:sort; 67, attribute; 67, 68; 67, 75; 68, call; 68, 69; 68, 70; 69, identifier:ExternalSorter; 70, argument_list; 70, 71; 70, 74; 71, binary_operator:*; 71, 72; 71, 73; 72, identifier:memory; 73, float:0.9; 74, identifier:serializer; 75, identifier:sorted; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:iter; 79, argument_list; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:sort; 82, argument_list; 82, 83; 82, 84; 82, 95; 83, identifier:iterator; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:key; 86, lambda; 86, 87; 86, 89; 87, lambda_parameters; 87, 88; 88, identifier:k_v; 89, call; 89, 90; 89, 91; 90, identifier:keyfunc; 91, argument_list; 91, 92; 92, subscript; 92, 93; 92, 94; 93, identifier:k_v; 94, integer:0; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:reverse; 97, parenthesized_expression; 97, 98; 98, not_operator; 98, 99; 99, identifier:ascending; 100, return_statement; 100, 101; 101, call; 101, 102; 101, 111; 102, attribute; 102, 103; 102, 110; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:partitionBy; 107, argument_list; 107, 108; 107, 109; 108, identifier:numPartitions; 109, identifier:partitionFunc; 110, identifier:mapPartitions; 111, argument_list; 111, 112; 111, 113; 112, identifier:sortPartition; 113, True | def repartitionAndSortWithinPartitions(self, numPartitions=None, partitionFunc=portable_hash,
ascending=True, keyfunc=lambda x: x):
"""
Repartition the RDD according to the given partitioner and, within each resulting partition,
sort records by their keys.
>>> rdd = sc.parallelize([(0, 5), (3, 8), (2, 6), (0, 8), (3, 8), (1, 3)])
>>> rdd2 = rdd.repartitionAndSortWithinPartitions(2, lambda x: x % 2, True)
>>> rdd2.glom().collect()
[[(0, 5), (0, 8), (2, 6)], [(1, 3), (3, 8), (3, 8)]]
"""
if numPartitions is None:
numPartitions = self._defaultReducePartitions()
memory = _parse_memory(self.ctx._conf.get("spark.python.worker.memory", "512m"))
serializer = self._jrdd_deserializer
def sortPartition(iterator):
sort = ExternalSorter(memory * 0.9, serializer).sorted
return iter(sort(iterator, key=lambda k_v: keyfunc(k_v[0]), reverse=(not ascending)))
return self.partitionBy(numPartitions, partitionFunc).mapPartitions(sortPartition, True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:sortBy; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:keyfunc; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ascending; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:numPartitions; 11, None; 12, block; 12, 13; 12, 15; 13, expression_statement; 13, 14; 14, comment; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 31; 17, attribute; 17, 18; 17, 30; 18, call; 18, 19; 18, 27; 19, attribute; 19, 20; 19, 26; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:keyBy; 24, argument_list; 24, 25; 25, identifier:keyfunc; 26, identifier:sortByKey; 27, argument_list; 27, 28; 27, 29; 28, identifier:ascending; 29, identifier:numPartitions; 30, identifier:values; 31, argument_list | def sortBy(self, keyfunc, ascending=True, numPartitions=None):
"""
Sorts this RDD by the given keyfunc
>>> tmp = [('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]
>>> sc.parallelize(tmp).sortBy(lambda x: x[0]).collect()
[('1', 3), ('2', 5), ('a', 1), ('b', 2), ('d', 4)]
>>> sc.parallelize(tmp).sortBy(lambda x: x[1]).collect()
[('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]
"""
return self.keyBy(keyfunc).sortByKey(ascending, numPartitions).values() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:groupBy; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:f; 6, default_parameter; 6, 7; 6, 8; 7, identifier:numPartitions; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:partitionFunc; 11, identifier:portable_hash; 12, block; 12, 13; 12, 15; 13, expression_statement; 13, 14; 14, comment; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 33; 17, attribute; 17, 18; 17, 32; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:map; 22, argument_list; 22, 23; 23, lambda; 23, 24; 23, 26; 24, lambda_parameters; 24, 25; 25, identifier:x; 26, tuple; 26, 27; 26, 31; 27, call; 27, 28; 27, 29; 28, identifier:f; 29, argument_list; 29, 30; 30, identifier:x; 31, identifier:x; 32, identifier:groupByKey; 33, argument_list; 33, 34; 33, 35; 34, identifier:numPartitions; 35, identifier:partitionFunc | def groupBy(self, f, numPartitions=None, partitionFunc=portable_hash):
"""
Return an RDD of grouped items.
>>> rdd = sc.parallelize([1, 1, 2, 3, 5, 8])
>>> result = rdd.groupBy(lambda x: x % 2).collect()
>>> sorted([(x, sorted(y)) for (x, y) in result])
[(0, [2, 8]), (1, [1, 1, 3, 5])]
"""
return self.map(lambda x: (f(x), x)).groupByKey(numPartitions, partitionFunc) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:top; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:num; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, block; 9, 10; 9, 12; 9, 29; 9, 48; 10, expression_statement; 10, 11; 11, comment; 12, function_definition; 12, 13; 12, 14; 12, 16; 13, function_name:topIterator; 14, parameters; 14, 15; 15, identifier:iterator; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, yield; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:heapq; 22, identifier:nlargest; 23, argument_list; 23, 24; 23, 25; 23, 26; 24, identifier:num; 25, identifier:iterator; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:key; 28, identifier:key; 29, function_definition; 29, 30; 29, 31; 29, 34; 30, function_name:merge; 31, parameters; 31, 32; 31, 33; 32, identifier:a; 33, identifier:b; 34, block; 34, 35; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:heapq; 39, identifier:nlargest; 40, argument_list; 40, 41; 40, 42; 40, 45; 41, identifier:num; 42, binary_operator:+; 42, 43; 42, 44; 43, identifier:a; 44, identifier:b; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:key; 47, identifier:key; 48, return_statement; 48, 49; 49, call; 49, 50; 49, 58; 50, attribute; 50, 51; 50, 57; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:mapPartitions; 55, argument_list; 55, 56; 56, identifier:topIterator; 57, identifier:reduce; 58, argument_list; 58, 59; 59, identifier:merge | def top(self, num, key=None):
"""
Get the top N elements from an RDD.
.. note:: This method should only be used if the resulting array is expected
to be small, as all the data is loaded into the driver's memory.
.. note:: It returns the list sorted in descending order.
>>> sc.parallelize([10, 4, 2, 12, 3]).top(1)
[12]
>>> sc.parallelize([2, 3, 4, 5, 6], 2).top(2)
[6, 5]
>>> sc.parallelize([10, 4, 2, 12, 3]).top(3, key=str)
[4, 3, 2]
"""
def topIterator(iterator):
yield heapq.nlargest(num, iterator, key=key)
def merge(a, b):
return heapq.nlargest(num, a + b, key=key)
return self.mapPartitions(topIterator).reduce(merge) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:saveAsTextFile; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:path; 6, default_parameter; 6, 7; 6, 8; 7, identifier:compressionCodecClass; 8, None; 9, block; 9, 10; 9, 12; 9, 58; 9, 67; 9, 73; 10, expression_statement; 10, 11; 11, comment; 12, function_definition; 12, 13; 12, 14; 12, 17; 13, function_name:func; 14, parameters; 14, 15; 14, 16; 15, identifier:split; 16, identifier:iterator; 17, block; 17, 18; 18, for_statement; 18, 19; 18, 20; 18, 21; 19, identifier:x; 20, identifier:iterator; 21, block; 21, 22; 21, 39; 21, 55; 22, if_statement; 22, 23; 22, 31; 23, not_operator; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:x; 28, tuple; 28, 29; 28, 30; 29, identifier:unicode; 30, identifier:bytes; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:x; 35, call; 35, 36; 35, 37; 36, identifier:unicode; 37, argument_list; 37, 38; 38, identifier:x; 39, if_statement; 39, 40; 39, 45; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:x; 44, identifier:unicode; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:x; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:x; 52, identifier:encode; 53, argument_list; 53, 54; 54, string:"utf-8"; 55, expression_statement; 55, 56; 56, yield; 56, 57; 57, identifier:x; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:keyed; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:mapPartitionsWithIndex; 65, argument_list; 65, 66; 66, identifier:func; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:keyed; 71, identifier:_bypass_serializer; 72, True; 73, if_statement; 73, 74; 73, 75; 73, 118; 74, identifier:compressionCodecClass; 75, block; 75, 76; 75, 95; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:compressionCodec; 79, call; 79, 80; 79, 93; 80, attribute; 80, 81; 80, 92; 81, attribute; 81, 82; 81, 91; 82, attribute; 82, 83; 82, 90; 83, attribute; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:ctx; 88, identifier:_jvm; 89, identifier:java; 90, identifier:lang; 91, identifier:Class; 92, identifier:forName; 93, argument_list; 93, 94; 94, identifier:compressionCodecClass; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 115; 97, attribute; 97, 98; 97, 114; 98, call; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:keyed; 102, identifier:_jrdd; 103, identifier:map; 104, argument_list; 104, 105; 105, call; 105, 106; 105, 113; 106, attribute; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:ctx; 111, identifier:_jvm; 112, identifier:BytesToString; 113, argument_list; 114, identifier:saveAsTextFile; 115, argument_list; 115, 116; 115, 117; 116, identifier:path; 117, identifier:compressionCodec; 118, else_clause; 118, 119; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 140; 122, attribute; 122, 123; 122, 139; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:keyed; 127, identifier:_jrdd; 128, identifier:map; 129, argument_list; 129, 130; 130, call; 130, 131; 130, 138; 131, attribute; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:ctx; 136, identifier:_jvm; 137, identifier:BytesToString; 138, argument_list; 139, identifier:saveAsTextFile; 140, argument_list; 140, 141; 141, identifier:path | def saveAsTextFile(self, path, compressionCodecClass=None):
"""
Save this RDD as a text file, using string representations of elements.
@param path: path to text file
@param compressionCodecClass: (None by default) string i.e.
"org.apache.hadoop.io.compress.GzipCodec"
>>> tempFile = NamedTemporaryFile(delete=True)
>>> tempFile.close()
>>> sc.parallelize(range(10)).saveAsTextFile(tempFile.name)
>>> from fileinput import input
>>> from glob import glob
>>> ''.join(sorted(input(glob(tempFile.name + "/part-0000*"))))
'0\\n1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n'
Empty lines are tolerated when saving to text files.
>>> tempFile2 = NamedTemporaryFile(delete=True)
>>> tempFile2.close()
>>> sc.parallelize(['', 'foo', '', 'bar', '']).saveAsTextFile(tempFile2.name)
>>> ''.join(sorted(input(glob(tempFile2.name + "/part-0000*"))))
'\\n\\n\\nbar\\nfoo\\n'
Using compressionCodecClass
>>> tempFile3 = NamedTemporaryFile(delete=True)
>>> tempFile3.close()
>>> codec = "org.apache.hadoop.io.compress.GzipCodec"
>>> sc.parallelize(['foo', 'bar']).saveAsTextFile(tempFile3.name, codec)
>>> from fileinput import input, hook_compressed
>>> result = sorted(input(glob(tempFile3.name + "/part*.gz"), openhook=hook_compressed))
>>> b''.join(result).decode('utf-8')
u'bar\\nfoo\\n'
"""
def func(split, iterator):
for x in iterator:
if not isinstance(x, (unicode, bytes)):
x = unicode(x)
if isinstance(x, unicode):
x = x.encode("utf-8")
yield x
keyed = self.mapPartitionsWithIndex(func)
keyed._bypass_serializer = True
if compressionCodecClass:
compressionCodec = self.ctx._jvm.java.lang.Class.forName(compressionCodecClass)
keyed._jrdd.map(self.ctx._jvm.BytesToString()).saveAsTextFile(path, compressionCodec)
else:
keyed._jrdd.map(self.ctx._jvm.BytesToString()).saveAsTextFile(path) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:reduceByKey; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:func; 6, default_parameter; 6, 7; 6, 8; 7, identifier:numPartitions; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:partitionFunc; 11, identifier:portable_hash; 12, block; 12, 13; 12, 15; 13, expression_statement; 13, 14; 14, comment; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:combineByKey; 20, argument_list; 20, 21; 20, 25; 20, 26; 20, 27; 20, 28; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:x; 24, identifier:x; 25, identifier:func; 26, identifier:func; 27, identifier:numPartitions; 28, identifier:partitionFunc | def reduceByKey(self, func, numPartitions=None, partitionFunc=portable_hash):
"""
Merge the values for each key using an associative and commutative reduce function.
This will also perform the merging locally on each mapper before
sending results to a reducer, similarly to a "combiner" in MapReduce.
Output will be partitioned with C{numPartitions} partitions, or
the default parallelism level if C{numPartitions} is not specified.
Default partitioner is hash-partition.
>>> from operator import add
>>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> sorted(rdd.reduceByKey(add).collect())
[('a', 2), ('b', 1)]
"""
return self.combineByKey(lambda x: x, func, func, numPartitions, partitionFunc) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:reduceByKeyLocally; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:func; 6, block; 6, 7; 6, 9; 6, 16; 6, 51; 6, 86; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:func; 12, call; 12, 13; 12, 14; 13, identifier:fail_on_stopiteration; 14, argument_list; 14, 15; 15, identifier:func; 16, function_definition; 16, 17; 16, 18; 16, 20; 17, function_name:reducePartition; 18, parameters; 18, 19; 19, identifier:iterator; 20, block; 20, 21; 20, 25; 20, 48; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:m; 24, dictionary; 25, for_statement; 25, 26; 25, 29; 25, 30; 26, pattern_list; 26, 27; 26, 28; 27, identifier:k; 28, identifier:v; 29, identifier:iterator; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:m; 35, identifier:k; 36, conditional_expression:if; 36, 37; 36, 44; 36, 47; 37, call; 37, 38; 37, 39; 38, identifier:func; 39, argument_list; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:m; 42, identifier:k; 43, identifier:v; 44, comparison_operator:in; 44, 45; 44, 46; 45, identifier:k; 46, identifier:m; 47, identifier:v; 48, expression_statement; 48, 49; 49, yield; 49, 50; 50, identifier:m; 51, function_definition; 51, 52; 51, 53; 51, 56; 52, function_name:mergeMaps; 53, parameters; 53, 54; 53, 55; 54, identifier:m1; 55, identifier:m2; 56, block; 56, 57; 56, 84; 57, for_statement; 57, 58; 57, 61; 57, 66; 58, pattern_list; 58, 59; 58, 60; 59, identifier:k; 60, identifier:v; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:m2; 64, identifier:items; 65, argument_list; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:m1; 71, identifier:k; 72, conditional_expression:if; 72, 73; 72, 80; 72, 83; 73, call; 73, 74; 73, 75; 74, identifier:func; 75, argument_list; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:m1; 78, identifier:k; 79, identifier:v; 80, comparison_operator:in; 80, 81; 80, 82; 81, identifier:k; 82, identifier:m1; 83, identifier:v; 84, return_statement; 84, 85; 85, identifier:m1; 86, return_statement; 86, 87; 87, call; 87, 88; 87, 96; 88, attribute; 88, 89; 88, 95; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:mapPartitions; 93, argument_list; 93, 94; 94, identifier:reducePartition; 95, identifier:reduce; 96, argument_list; 96, 97; 97, identifier:mergeMaps | def reduceByKeyLocally(self, func):
"""
Merge the values for each key using an associative and commutative reduce function, but
return the results immediately to the master as a dictionary.
This will also perform the merging locally on each mapper before
sending results to a reducer, similarly to a "combiner" in MapReduce.
>>> from operator import add
>>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> sorted(rdd.reduceByKeyLocally(add).items())
[('a', 2), ('b', 1)]
"""
func = fail_on_stopiteration(func)
def reducePartition(iterator):
m = {}
for k, v in iterator:
m[k] = func(m[k], v) if k in m else v
yield m
def mergeMaps(m1, m2):
for k, v in m2.items():
m1[k] = func(m1[k], v) if k in m1 else v
return m1
return self.mapPartitions(reducePartition).reduce(mergeMaps) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:combineByKey; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 4, identifier:self; 5, identifier:createCombiner; 6, identifier:mergeValue; 7, identifier:mergeCombiners; 8, default_parameter; 8, 9; 8, 10; 9, identifier:numPartitions; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:partitionFunc; 13, identifier:portable_hash; 14, block; 14, 15; 14, 17; 14, 30; 14, 38; 14, 46; 14, 55; 14, 84; 14, 96; 14, 106; 14, 133; 15, expression_statement; 15, 16; 16, comment; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:numPartitions; 20, None; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:numPartitions; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_defaultReducePartitions; 29, argument_list; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:serializer; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:ctx; 37, identifier:serializer; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:memory; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:_memory_limit; 45, argument_list; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:agg; 49, call; 49, 50; 49, 51; 50, identifier:Aggregator; 51, argument_list; 51, 52; 51, 53; 51, 54; 52, identifier:createCombiner; 53, identifier:mergeValue; 54, identifier:mergeCombiners; 55, function_definition; 55, 56; 55, 57; 55, 59; 56, function_name:combineLocally; 57, parameters; 57, 58; 58, identifier:iterator; 59, block; 59, 60; 59, 71; 59, 78; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:merger; 63, call; 63, 64; 63, 65; 64, identifier:ExternalMerger; 65, argument_list; 65, 66; 65, 67; 65, 70; 66, identifier:agg; 67, binary_operator:*; 67, 68; 67, 69; 68, identifier:memory; 69, float:0.9; 70, identifier:serializer; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:merger; 75, identifier:mergeValues; 76, argument_list; 76, 77; 77, identifier:iterator; 78, return_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:merger; 82, identifier:items; 83, argument_list; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:locally_combined; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:mapPartitions; 91, argument_list; 91, 92; 91, 93; 92, identifier:combineLocally; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:preservesPartitioning; 95, True; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:shuffled; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:locally_combined; 102, identifier:partitionBy; 103, argument_list; 103, 104; 103, 105; 104, identifier:numPartitions; 105, identifier:partitionFunc; 106, function_definition; 106, 107; 106, 108; 106, 110; 107, function_name:_mergeCombiners; 108, parameters; 108, 109; 109, identifier:iterator; 110, block; 110, 111; 110, 120; 110, 127; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:merger; 114, call; 114, 115; 114, 116; 115, identifier:ExternalMerger; 116, argument_list; 116, 117; 116, 118; 116, 119; 117, identifier:agg; 118, identifier:memory; 119, identifier:serializer; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:merger; 124, identifier:mergeCombiners; 125, argument_list; 125, 126; 126, identifier:iterator; 127, return_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:merger; 131, identifier:items; 132, argument_list; 133, return_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:shuffled; 137, identifier:mapPartitions; 138, argument_list; 138, 139; 138, 140; 139, identifier:_mergeCombiners; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:preservesPartitioning; 142, True | def combineByKey(self, createCombiner, mergeValue, mergeCombiners,
numPartitions=None, partitionFunc=portable_hash):
"""
Generic function to combine the elements for each key using a custom
set of aggregation functions.
Turns an RDD[(K, V)] into a result of type RDD[(K, C)], for a "combined
type" C.
Users provide three functions:
- C{createCombiner}, which turns a V into a C (e.g., creates
a one-element list)
- C{mergeValue}, to merge a V into a C (e.g., adds it to the end of
a list)
- C{mergeCombiners}, to combine two C's into a single one (e.g., merges
the lists)
To avoid memory allocation, both mergeValue and mergeCombiners are allowed to
modify and return their first argument instead of creating a new C.
In addition, users can control the partitioning of the output RDD.
.. note:: V and C can be different -- for example, one might group an RDD of type
(Int, Int) into an RDD of type (Int, List[Int]).
>>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 2)])
>>> def to_list(a):
... return [a]
...
>>> def append(a, b):
... a.append(b)
... return a
...
>>> def extend(a, b):
... a.extend(b)
... return a
...
>>> sorted(x.combineByKey(to_list, append, extend).collect())
[('a', [1, 2]), ('b', [1])]
"""
if numPartitions is None:
numPartitions = self._defaultReducePartitions()
serializer = self.ctx.serializer
memory = self._memory_limit()
agg = Aggregator(createCombiner, mergeValue, mergeCombiners)
def combineLocally(iterator):
merger = ExternalMerger(agg, memory * 0.9, serializer)
merger.mergeValues(iterator)
return merger.items()
locally_combined = self.mapPartitions(combineLocally, preservesPartitioning=True)
shuffled = locally_combined.partitionBy(numPartitions, partitionFunc)
def _mergeCombiners(iterator):
merger = ExternalMerger(agg, memory, serializer)
merger.mergeCombiners(iterator)
return merger.items()
return shuffled.mapPartitions(_mergeCombiners, preservesPartitioning=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:groupByKey; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:numPartitions; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:partitionFunc; 10, identifier:portable_hash; 11, block; 11, 12; 11, 14; 11, 22; 11, 37; 11, 52; 11, 60; 11, 66; 11, 75; 11, 104; 11, 116; 11, 126; 11, 153; 12, expression_statement; 12, 13; 13, comment; 14, function_definition; 14, 15; 14, 16; 14, 18; 15, function_name:createCombiner; 16, parameters; 16, 17; 17, identifier:x; 18, block; 18, 19; 19, return_statement; 19, 20; 20, list:[x]; 20, 21; 21, identifier:x; 22, function_definition; 22, 23; 22, 24; 22, 27; 23, function_name:mergeValue; 24, parameters; 24, 25; 24, 26; 25, identifier:xs; 26, identifier:x; 27, block; 27, 28; 27, 35; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:xs; 32, identifier:append; 33, argument_list; 33, 34; 34, identifier:x; 35, return_statement; 35, 36; 36, identifier:xs; 37, function_definition; 37, 38; 37, 39; 37, 42; 38, function_name:mergeCombiners; 39, parameters; 39, 40; 39, 41; 40, identifier:a; 41, identifier:b; 42, block; 42, 43; 42, 50; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:a; 47, identifier:extend; 48, argument_list; 48, 49; 49, identifier:b; 50, return_statement; 50, 51; 51, identifier:a; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:memory; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_memory_limit; 59, argument_list; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:serializer; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:_jrdd_deserializer; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:agg; 69, call; 69, 70; 69, 71; 70, identifier:Aggregator; 71, argument_list; 71, 72; 71, 73; 71, 74; 72, identifier:createCombiner; 73, identifier:mergeValue; 74, identifier:mergeCombiners; 75, function_definition; 75, 76; 75, 77; 75, 79; 76, function_name:combine; 77, parameters; 77, 78; 78, identifier:iterator; 79, block; 79, 80; 79, 91; 79, 98; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:merger; 83, call; 83, 84; 83, 85; 84, identifier:ExternalMerger; 85, argument_list; 85, 86; 85, 87; 85, 90; 86, identifier:agg; 87, binary_operator:*; 87, 88; 87, 89; 88, identifier:memory; 89, float:0.9; 90, identifier:serializer; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:merger; 95, identifier:mergeValues; 96, argument_list; 96, 97; 97, identifier:iterator; 98, return_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:merger; 102, identifier:items; 103, argument_list; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:locally_combined; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:mapPartitions; 111, argument_list; 111, 112; 111, 113; 112, identifier:combine; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:preservesPartitioning; 115, True; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:shuffled; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:locally_combined; 122, identifier:partitionBy; 123, argument_list; 123, 124; 123, 125; 124, identifier:numPartitions; 125, identifier:partitionFunc; 126, function_definition; 126, 127; 126, 128; 126, 130; 127, function_name:groupByKey; 128, parameters; 128, 129; 129, identifier:it; 130, block; 130, 131; 130, 140; 130, 147; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:merger; 134, call; 134, 135; 134, 136; 135, identifier:ExternalGroupBy; 136, argument_list; 136, 137; 136, 138; 136, 139; 137, identifier:agg; 138, identifier:memory; 139, identifier:serializer; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:merger; 144, identifier:mergeCombiners; 145, argument_list; 145, 146; 146, identifier:it; 147, return_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:merger; 151, identifier:items; 152, argument_list; 153, return_statement; 153, 154; 154, call; 154, 155; 154, 164; 155, attribute; 155, 156; 155, 163; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:shuffled; 159, identifier:mapPartitions; 160, argument_list; 160, 161; 160, 162; 161, identifier:groupByKey; 162, True; 163, identifier:mapValues; 164, argument_list; 164, 165; 165, identifier:ResultIterable | def groupByKey(self, numPartitions=None, partitionFunc=portable_hash):
"""
Group the values for each key in the RDD into a single sequence.
Hash-partitions the resulting RDD with numPartitions partitions.
.. note:: If you are grouping in order to perform an aggregation (such as a
sum or average) over each key, using reduceByKey or aggregateByKey will
provide much better performance.
>>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> sorted(rdd.groupByKey().mapValues(len).collect())
[('a', 2), ('b', 1)]
>>> sorted(rdd.groupByKey().mapValues(list).collect())
[('a', [1, 1]), ('b', [1])]
"""
def createCombiner(x):
return [x]
def mergeValue(xs, x):
xs.append(x)
return xs
def mergeCombiners(a, b):
a.extend(b)
return a
memory = self._memory_limit()
serializer = self._jrdd_deserializer
agg = Aggregator(createCombiner, mergeValue, mergeCombiners)
def combine(iterator):
merger = ExternalMerger(agg, memory * 0.9, serializer)
merger.mergeValues(iterator)
return merger.items()
locally_combined = self.mapPartitions(combine, preservesPartitioning=True)
shuffled = locally_combined.partitionBy(numPartitions, partitionFunc)
def groupByKey(it):
merger = ExternalGroupBy(agg, memory, serializer)
merger.mergeCombiners(it)
return merger.items()
return shuffled.mapPartitions(groupByKey, True).mapValues(ResultIterable) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:lookup; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:key; 6, block; 6, 7; 6, 9; 6, 29; 6, 56; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:values; 12, call; 12, 13; 12, 28; 13, attribute; 13, 14; 13, 27; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:filter; 18, argument_list; 18, 19; 19, lambda; 19, 20; 19, 22; 20, lambda_parameters; 20, 21; 21, identifier:kv; 22, comparison_operator:==; 22, 23; 22, 26; 23, subscript; 23, 24; 23, 25; 24, identifier:kv; 25, integer:0; 26, identifier:key; 27, identifier:values; 28, argument_list; 29, if_statement; 29, 30; 29, 35; 30, comparison_operator:is; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:partitioner; 34, None; 35, block; 35, 36; 36, return_statement; 36, 37; 37, call; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:ctx; 42, identifier:runJob; 43, argument_list; 43, 44; 43, 45; 43, 49; 44, identifier:values; 45, lambda; 45, 46; 45, 48; 46, lambda_parameters; 46, 47; 47, identifier:x; 48, identifier:x; 49, list:[self.partitioner(key)]; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:partitioner; 54, argument_list; 54, 55; 55, identifier:key; 56, return_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:values; 60, identifier:collect; 61, argument_list | def lookup(self, key):
"""
Return the list of values in the RDD for key `key`. This operation
is done efficiently if the RDD has a known partitioner by only
searching the partition that the key maps to.
>>> l = range(1000)
>>> rdd = sc.parallelize(zip(l, l), 10)
>>> rdd.lookup(42) # slow
[42]
>>> sorted = rdd.sortByKey()
>>> sorted.lookup(42) # fast
[42]
>>> sorted.lookup(1024)
[]
>>> rdd2 = sc.parallelize([(('a', 'b'), 'c')]).groupByKey()
>>> list(rdd2.lookup(('a', 'b'))[0])
['c']
"""
values = self.filter(lambda kv: kv[0] == key).values()
if self.partitioner is not None:
return self.ctx.runJob(values, lambda x: x, [self.partitioner(key)])
return values.collect() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:describeTopics; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:maxTermsPerTopic; 7, None; 8, block; 8, 9; 8, 11; 8, 37; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 15; 11, 25; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:maxTermsPerTopic; 14, None; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:topics; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:call; 23, argument_list; 23, 24; 24, string:"describeTopics"; 25, else_clause; 25, 26; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:topics; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:call; 34, argument_list; 34, 35; 34, 36; 35, string:"describeTopics"; 36, identifier:maxTermsPerTopic; 37, return_statement; 37, 38; 38, identifier:topics | def describeTopics(self, maxTermsPerTopic=None):
"""Return the topics described by weighted terms.
WARNING: If vocabSize and k are large, this can return a large object!
:param maxTermsPerTopic:
Maximum number of terms to collect for each topic.
(default: vocabulary size)
:return:
Array over topics. Each topic is represented as a pair of
matching arrays: (term indices, term weights in topic).
Each topic's terms are sorted in order of decreasing weight.
"""
if maxTermsPerTopic is None:
topics = self.call("describeTopics")
else:
topics = self.call("describeTopics", maxTermsPerTopic)
return topics |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_sort_cols; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:cols; 6, identifier:kwargs; 7, block; 7, 8; 7, 10; 7, 19; 7, 41; 7, 52; 7, 62; 7, 127; 8, expression_statement; 8, 9; 9, comment; 10, if_statement; 10, 11; 10, 13; 11, not_operator; 11, 12; 12, identifier:cols; 13, block; 13, 14; 14, raise_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:ValueError; 17, argument_list; 17, 18; 18, string:"should sort by at least one column"; 19, if_statement; 19, 20; 19, 34; 20, boolean_operator:and; 20, 21; 20, 27; 21, comparison_operator:==; 21, 22; 21, 26; 22, call; 22, 23; 22, 24; 23, identifier:len; 24, argument_list; 24, 25; 25, identifier:cols; 26, integer:1; 27, call; 27, 28; 27, 29; 28, identifier:isinstance; 29, argument_list; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:cols; 32, integer:0; 33, identifier:list; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:cols; 38, subscript; 38, 39; 38, 40; 39, identifier:cols; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:jcols; 44, list_comprehension; 44, 45; 44, 49; 45, call; 45, 46; 45, 47; 46, identifier:_to_java_column; 47, argument_list; 47, 48; 48, identifier:c; 49, for_in_clause; 49, 50; 49, 51; 50, identifier:c; 51, identifier:cols; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:ascending; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:kwargs; 58, identifier:get; 59, argument_list; 59, 60; 59, 61; 60, string:'ascending'; 61, True; 62, if_statement; 62, 63; 62, 70; 62, 87; 62, 115; 63, call; 63, 64; 63, 65; 64, identifier:isinstance; 65, argument_list; 65, 66; 65, 67; 66, identifier:ascending; 67, tuple; 67, 68; 67, 69; 68, identifier:bool; 69, identifier:int; 70, block; 70, 71; 71, if_statement; 71, 72; 71, 74; 72, not_operator; 72, 73; 73, identifier:ascending; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:jcols; 78, list_comprehension; 78, 79; 78, 84; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:jc; 82, identifier:desc; 83, argument_list; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:jc; 86, identifier:jcols; 87, elif_clause; 87, 88; 87, 93; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:ascending; 92, identifier:list; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:jcols; 97, list_comprehension; 97, 98; 97, 106; 98, conditional_expression:if; 98, 99; 98, 100; 98, 101; 99, identifier:jc; 100, identifier:asc; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:jc; 104, identifier:desc; 105, argument_list; 106, for_in_clause; 106, 107; 106, 110; 107, pattern_list; 107, 108; 107, 109; 108, identifier:asc; 109, identifier:jc; 110, call; 110, 111; 110, 112; 111, identifier:zip; 112, argument_list; 112, 113; 112, 114; 113, identifier:ascending; 114, identifier:jcols; 115, else_clause; 115, 116; 116, block; 116, 117; 117, raise_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:TypeError; 120, argument_list; 120, 121; 121, binary_operator:%; 121, 122; 121, 123; 122, string:"ascending can only be boolean or list, but got %s"; 123, call; 123, 124; 123, 125; 124, identifier:type; 125, argument_list; 125, 126; 126, identifier:ascending; 127, return_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_jseq; 132, argument_list; 132, 133; 133, identifier:jcols | def _sort_cols(self, cols, kwargs):
""" Return a JVM Seq of Columns that describes the sort order
"""
if not cols:
raise ValueError("should sort by at least one column")
if len(cols) == 1 and isinstance(cols[0], list):
cols = cols[0]
jcols = [_to_java_column(c) for c in cols]
ascending = kwargs.get('ascending', True)
if isinstance(ascending, (bool, int)):
if not ascending:
jcols = [jc.desc() for jc in jcols]
elif isinstance(ascending, list):
jcols = [jc if asc else jc.desc()
for asc, jc in zip(ascending, jcols)]
else:
raise TypeError("ascending can only be boolean or list, but got %s" % type(ascending))
return self._jseq(jcols) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_list_function_infos; 3, parameters; 3, 4; 4, identifier:jvm; 5, block; 5, 6; 5, 8; 5, 30; 5, 34; 5, 138; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:jinfos; 11, call; 11, 12; 11, 29; 12, attribute; 12, 13; 12, 28; 13, attribute; 13, 14; 13, 27; 14, attribute; 14, 15; 14, 26; 15, attribute; 15, 16; 15, 25; 16, attribute; 16, 17; 16, 24; 17, attribute; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:jvm; 21, identifier:org; 22, identifier:apache; 23, identifier:spark; 24, identifier:sql; 25, identifier:api; 26, identifier:python; 27, identifier:PythonSQLUtils; 28, identifier:listBuiltinFunctionInfos; 29, argument_list; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:infos; 33, list:[]; 34, for_statement; 34, 35; 34, 36; 34, 37; 35, identifier:jinfo; 36, identifier:jinfos; 37, block; 37, 38; 37, 46; 37, 54; 37, 69; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:name; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:jinfo; 44, identifier:getName; 45, argument_list; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:usage; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:jinfo; 52, identifier:getUsage; 53, argument_list; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:usage; 57, conditional_expression:if; 57, 58; 57, 65; 57, 68; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:usage; 61, identifier:replace; 62, argument_list; 62, 63; 62, 64; 63, string:"_FUNC_"; 64, identifier:name; 65, comparison_operator:is; 65, 66; 65, 67; 66, identifier:usage; 67, None; 68, identifier:usage; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:infos; 73, identifier:append; 74, argument_list; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:ExpressionInfo; 77, argument_list; 77, 78; 77, 85; 77, 88; 77, 91; 77, 104; 77, 117; 77, 124; 77, 131; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:className; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:jinfo; 83, identifier:getClassName; 84, argument_list; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:name; 87, identifier:name; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:usage; 90, identifier:usage; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:arguments; 93, call; 93, 94; 93, 101; 94, attribute; 94, 95; 94, 100; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:jinfo; 98, identifier:getArguments; 99, argument_list; 100, identifier:replace; 101, argument_list; 101, 102; 101, 103; 102, string:"_FUNC_"; 103, identifier:name; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:examples; 106, call; 106, 107; 106, 114; 107, attribute; 107, 108; 107, 113; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:jinfo; 111, identifier:getExamples; 112, argument_list; 113, identifier:replace; 114, argument_list; 114, 115; 114, 116; 115, string:"_FUNC_"; 116, identifier:name; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:note; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:jinfo; 122, identifier:getNote; 123, argument_list; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:since; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:jinfo; 129, identifier:getSince; 130, argument_list; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:deprecated; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:jinfo; 136, identifier:getDeprecated; 137, argument_list; 138, return_statement; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:sorted; 141, argument_list; 141, 142; 141, 143; 142, identifier:infos; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:key; 145, lambda; 145, 146; 145, 148; 146, lambda_parameters; 146, 147; 147, identifier:i; 148, attribute; 148, 149; 148, 150; 149, identifier:i; 150, identifier:name | def _list_function_infos(jvm):
"""
Returns a list of function information via JVM. Sorts wrapped expression infos by name
and returns them.
"""
jinfos = jvm.org.apache.spark.sql.api.python.PythonSQLUtils.listBuiltinFunctionInfos()
infos = []
for jinfo in jinfos:
name = jinfo.getName()
usage = jinfo.getUsage()
usage = usage.replace("_FUNC_", name) if usage is not None else usage
infos.append(ExpressionInfo(
className=jinfo.getClassName(),
name=name,
usage=usage,
arguments=jinfo.getArguments().replace("_FUNC_", name),
examples=jinfo.getExamples().replace("_FUNC_", name),
note=jinfo.getNote(),
since=jinfo.getSince(),
deprecated=jinfo.getDeprecated()))
return sorted(infos, key=lambda i: i.name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:merge; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:iterables; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, block; 11, 12; 11, 14; 11, 18; 11, 24; 11, 62; 11, 181; 11, 221; 11, 226; 11, 290; 12, expression_statement; 12, 13; 13, string:'''Merge multiple sorted inputs into a single sorted output.
Similar to sorted(itertools.chain(*iterables)) but returns a generator,
does not pull the data into memory all at once, and assumes that each of
the input streams is already sorted (smallest to largest).
>>> list(merge([1,3,5,7], [0,2,4,8], [5,10,15,20], [], [25]))
[0, 1, 2, 3, 4, 5, 5, 7, 8, 10, 15, 20, 25]
If *key* is not None, applies a key function to each element to determine
its sort order.
>>> list(merge(['dog', 'horse'], ['cat', 'fish', 'kangaroo'], key=len))
['dog', 'cat', 'fish', 'horse', 'kangaroo']
'''; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:h; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:h_append; 21, attribute; 21, 22; 21, 23; 22, identifier:h; 23, identifier:append; 24, if_statement; 24, 25; 24, 26; 24, 44; 25, identifier:reverse; 26, block; 26, 27; 26, 31; 26, 35; 26, 39; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:_heapify; 30, identifier:_heapify_max; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:_heappop; 34, identifier:_heappop_max; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:_heapreplace; 38, identifier:_heapreplace_max; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:direction; 42, unary_operator:-; 42, 43; 43, integer:1; 44, else_clause; 44, 45; 45, block; 45, 46; 45, 50; 45, 54; 45, 58; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:_heapify; 49, identifier:heapify; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:_heappop; 53, identifier:heappop; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:_heapreplace; 57, identifier:heapreplace; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:direction; 61, integer:1; 62, if_statement; 62, 63; 62, 66; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:key; 65, None; 66, block; 66, 67; 66, 99; 66, 104; 66, 157; 66, 180; 67, for_statement; 67, 68; 67, 71; 67, 79; 68, pattern_list; 68, 69; 68, 70; 69, identifier:order; 70, identifier:it; 71, call; 71, 72; 71, 73; 72, identifier:enumerate; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:map; 76, argument_list; 76, 77; 76, 78; 77, identifier:iter; 78, identifier:iterables; 79, block; 79, 80; 80, try_statement; 80, 81; 80, 95; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:h_append; 85, argument_list; 85, 86; 86, list:[next(it), order * direction, it]; 86, 87; 86, 91; 86, 94; 87, call; 87, 88; 87, 89; 88, identifier:next; 89, argument_list; 89, 90; 90, identifier:it; 91, binary_operator:*; 91, 92; 91, 93; 92, identifier:order; 93, identifier:direction; 94, identifier:it; 95, except_clause; 95, 96; 95, 97; 96, identifier:StopIteration; 97, block; 97, 98; 98, pass_statement; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:_heapify; 102, argument_list; 102, 103; 103, identifier:h; 104, while_statement; 104, 105; 104, 111; 105, comparison_operator:>; 105, 106; 105, 110; 106, call; 106, 107; 106, 108; 107, identifier:len; 108, argument_list; 108, 109; 109, identifier:h; 110, integer:1; 111, block; 111, 112; 112, try_statement; 112, 113; 112, 148; 113, block; 113, 114; 114, while_statement; 114, 115; 114, 116; 115, True; 116, block; 116, 117; 116, 128; 116, 131; 116, 140; 116, 141; 116, 147; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 123; 119, pattern_list; 119, 120; 119, 121; 119, 122; 120, identifier:value; 121, identifier:order; 122, identifier:it; 123, assignment; 123, 124; 123, 125; 124, identifier:s; 125, subscript; 125, 126; 125, 127; 126, identifier:h; 127, integer:0; 128, expression_statement; 128, 129; 129, yield; 129, 130; 130, identifier:value; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:s; 135, integer:0; 136, call; 136, 137; 136, 138; 137, identifier:next; 138, argument_list; 138, 139; 139, identifier:it; 140, comment; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:_heapreplace; 144, argument_list; 144, 145; 144, 146; 145, identifier:h; 146, identifier:s; 147, comment; 148, except_clause; 148, 149; 148, 150; 149, identifier:StopIteration; 150, block; 150, 151; 150, 156; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:_heappop; 154, argument_list; 154, 155; 155, identifier:h; 156, comment; 157, if_statement; 157, 158; 157, 159; 157, 160; 158, identifier:h; 159, comment; 160, block; 160, 161; 160, 170; 160, 173; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 167; 163, pattern_list; 163, 164; 163, 165; 163, 166; 164, identifier:value; 165, identifier:order; 166, identifier:it; 167, subscript; 167, 168; 167, 169; 168, identifier:h; 169, integer:0; 170, expression_statement; 170, 171; 171, yield; 171, 172; 172, identifier:value; 173, for_statement; 173, 174; 173, 175; 173, 176; 174, identifier:value; 175, identifier:it; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, yield; 178, 179; 179, identifier:value; 180, return_statement; 181, for_statement; 181, 182; 181, 185; 181, 193; 182, pattern_list; 182, 183; 182, 184; 183, identifier:order; 184, identifier:it; 185, call; 185, 186; 185, 187; 186, identifier:enumerate; 187, argument_list; 187, 188; 188, call; 188, 189; 188, 190; 189, identifier:map; 190, argument_list; 190, 191; 190, 192; 191, identifier:iter; 192, identifier:iterables; 193, block; 193, 194; 194, try_statement; 194, 195; 194, 217; 195, block; 195, 196; 195, 203; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:value; 199, call; 199, 200; 199, 201; 200, identifier:next; 201, argument_list; 201, 202; 202, identifier:it; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 206; 205, identifier:h_append; 206, argument_list; 206, 207; 207, list:[key(value), order * direction, value, it]; 207, 208; 207, 212; 207, 215; 207, 216; 208, call; 208, 209; 208, 210; 209, identifier:key; 210, argument_list; 210, 211; 211, identifier:value; 212, binary_operator:*; 212, 213; 212, 214; 213, identifier:order; 214, identifier:direction; 215, identifier:value; 216, identifier:it; 217, except_clause; 217, 218; 217, 219; 218, identifier:StopIteration; 219, block; 219, 220; 220, pass_statement; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 224; 223, identifier:_heapify; 224, argument_list; 224, 225; 225, identifier:h; 226, while_statement; 226, 227; 226, 233; 227, comparison_operator:>; 227, 228; 227, 232; 228, call; 228, 229; 228, 230; 229, identifier:len; 230, argument_list; 230, 231; 231, identifier:h; 232, integer:1; 233, block; 233, 234; 234, try_statement; 234, 235; 234, 282; 235, block; 235, 236; 236, while_statement; 236, 237; 236, 238; 237, True; 238, block; 238, 239; 238, 251; 238, 254; 238, 261; 238, 270; 238, 276; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 246; 241, pattern_list; 241, 242; 241, 243; 241, 244; 241, 245; 242, identifier:key_value; 243, identifier:order; 244, identifier:value; 245, identifier:it; 246, assignment; 246, 247; 246, 248; 247, identifier:s; 248, subscript; 248, 249; 248, 250; 249, identifier:h; 250, integer:0; 251, expression_statement; 251, 252; 252, yield; 252, 253; 253, identifier:value; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:value; 257, call; 257, 258; 257, 259; 258, identifier:next; 259, argument_list; 259, 260; 260, identifier:it; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 266; 263, subscript; 263, 264; 263, 265; 264, identifier:s; 265, integer:0; 266, call; 266, 267; 266, 268; 267, identifier:key; 268, argument_list; 268, 269; 269, identifier:value; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:s; 274, integer:2; 275, identifier:value; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 279; 278, identifier:_heapreplace; 279, argument_list; 279, 280; 279, 281; 280, identifier:h; 281, identifier:s; 282, except_clause; 282, 283; 282, 284; 283, identifier:StopIteration; 284, block; 284, 285; 285, expression_statement; 285, 286; 286, call; 286, 287; 286, 288; 287, identifier:_heappop; 288, argument_list; 288, 289; 289, identifier:h; 290, if_statement; 290, 291; 290, 292; 291, identifier:h; 292, block; 292, 293; 292, 303; 292, 306; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 300; 295, pattern_list; 295, 296; 295, 297; 295, 298; 295, 299; 296, identifier:key_value; 297, identifier:order; 298, identifier:value; 299, identifier:it; 300, subscript; 300, 301; 300, 302; 301, identifier:h; 302, integer:0; 303, expression_statement; 303, 304; 304, yield; 304, 305; 305, identifier:value; 306, for_statement; 306, 307; 306, 308; 306, 309; 307, identifier:value; 308, identifier:it; 309, block; 309, 310; 310, expression_statement; 310, 311; 311, yield; 311, 312; 312, identifier:value | def merge(iterables, key=None, reverse=False):
'''Merge multiple sorted inputs into a single sorted output.
Similar to sorted(itertools.chain(*iterables)) but returns a generator,
does not pull the data into memory all at once, and assumes that each of
the input streams is already sorted (smallest to largest).
>>> list(merge([1,3,5,7], [0,2,4,8], [5,10,15,20], [], [25]))
[0, 1, 2, 3, 4, 5, 5, 7, 8, 10, 15, 20, 25]
If *key* is not None, applies a key function to each element to determine
its sort order.
>>> list(merge(['dog', 'horse'], ['cat', 'fish', 'kangaroo'], key=len))
['dog', 'cat', 'fish', 'horse', 'kangaroo']
'''
h = []
h_append = h.append
if reverse:
_heapify = _heapify_max
_heappop = _heappop_max
_heapreplace = _heapreplace_max
direction = -1
else:
_heapify = heapify
_heappop = heappop
_heapreplace = heapreplace
direction = 1
if key is None:
for order, it in enumerate(map(iter, iterables)):
try:
h_append([next(it), order * direction, it])
except StopIteration:
pass
_heapify(h)
while len(h) > 1:
try:
while True:
value, order, it = s = h[0]
yield value
s[0] = next(it) # raises StopIteration when exhausted
_heapreplace(h, s) # restore heap condition
except StopIteration:
_heappop(h) # remove empty iterator
if h:
# fast case when only a single iterator remains
value, order, it = h[0]
yield value
for value in it:
yield value
return
for order, it in enumerate(map(iter, iterables)):
try:
value = next(it)
h_append([key(value), order * direction, value, it])
except StopIteration:
pass
_heapify(h)
while len(h) > 1:
try:
while True:
key_value, order, value, it = s = h[0]
yield value
value = next(it)
s[0] = key(value)
s[2] = value
_heapreplace(h, s)
except StopIteration:
_heappop(h)
if h:
key_value, order, value, it = h[0]
yield value
for value in it:
yield value |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:nsmallest; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:n; 5, identifier:iterable; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, block; 9, 10; 9, 12; 9, 13; 9, 69; 9, 70; 9, 104; 9, 105; 9, 208; 9, 209; 9, 216; 9, 239; 9, 245; 9, 250; 9, 258; 9, 262; 9, 266; 9, 303; 9, 309; 10, expression_statement; 10, 11; 11, comment; 12, comment; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:n; 16, integer:1; 17, block; 17, 18; 17, 25; 17, 31; 17, 61; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:it; 21, call; 21, 22; 21, 23; 22, identifier:iter; 23, argument_list; 23, 24; 24, identifier:iterable; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:sentinel; 28, call; 28, 29; 28, 30; 29, identifier:object; 30, argument_list; 31, if_statement; 31, 32; 31, 35; 31, 46; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:key; 34, None; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:result; 39, call; 39, 40; 39, 41; 40, identifier:min; 41, argument_list; 41, 42; 41, 43; 42, identifier:it; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:default; 45, identifier:sentinel; 46, else_clause; 46, 47; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:result; 51, call; 51, 52; 51, 53; 52, identifier:min; 53, argument_list; 53, 54; 53, 55; 53, 58; 54, identifier:it; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:default; 57, identifier:sentinel; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:key; 60, identifier:key; 61, return_statement; 61, 62; 62, conditional_expression:if; 62, 63; 62, 64; 62, 67; 63, list:[]; 64, comparison_operator:is; 64, 65; 64, 66; 65, identifier:result; 66, identifier:sentinel; 67, list:[result]; 67, 68; 68, identifier:result; 69, comment; 70, try_statement; 70, 71; 70, 79; 70, 85; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:size; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:iterable; 79, except_clause; 79, 80; 79, 83; 80, tuple; 80, 81; 80, 82; 81, identifier:TypeError; 82, identifier:AttributeError; 83, block; 83, 84; 84, pass_statement; 85, else_clause; 85, 86; 86, block; 86, 87; 87, if_statement; 87, 88; 87, 91; 88, comparison_operator:>=; 88, 89; 88, 90; 89, identifier:n; 90, identifier:size; 91, block; 91, 92; 92, return_statement; 92, 93; 93, subscript; 93, 94; 93, 101; 94, call; 94, 95; 94, 96; 95, identifier:sorted; 96, argument_list; 96, 97; 96, 98; 97, identifier:iterable; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:key; 100, identifier:key; 101, slice; 101, 102; 101, 103; 102, colon; 103, identifier:n; 104, comment; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:is; 106, 107; 106, 108; 107, identifier:key; 108, None; 109, block; 109, 110; 109, 117; 109, 118; 109, 119; 109, 138; 109, 144; 109, 149; 109, 157; 109, 161; 109, 165; 109, 194; 109, 200; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:it; 113, call; 113, 114; 113, 115; 114, identifier:iter; 115, argument_list; 115, 116; 116, identifier:iterable; 117, comment; 118, comment; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:result; 122, list_comprehension; 122, 123; 122, 126; 123, tuple; 123, 124; 123, 125; 124, identifier:elem; 125, identifier:i; 126, for_in_clause; 126, 127; 126, 130; 127, pattern_list; 127, 128; 127, 129; 128, identifier:i; 129, identifier:elem; 130, call; 130, 131; 130, 132; 131, identifier:zip; 132, argument_list; 132, 133; 132, 137; 133, call; 133, 134; 133, 135; 134, identifier:range; 135, argument_list; 135, 136; 136, identifier:n; 137, identifier:it; 138, if_statement; 138, 139; 138, 141; 139, not_operator; 139, 140; 140, identifier:result; 141, block; 141, 142; 142, return_statement; 142, 143; 143, identifier:result; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:_heapify_max; 147, argument_list; 147, 148; 148, identifier:result; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:top; 152, subscript; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:result; 155, integer:0; 156, integer:0; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:order; 160, identifier:n; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:_heapreplace; 164, identifier:_heapreplace_max; 165, for_statement; 165, 166; 165, 167; 165, 168; 166, identifier:elem; 167, identifier:it; 168, block; 168, 169; 169, if_statement; 169, 170; 169, 173; 170, comparison_operator:<; 170, 171; 170, 172; 171, identifier:elem; 172, identifier:top; 173, block; 173, 174; 173, 182; 173, 190; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:_heapreplace; 177, argument_list; 177, 178; 177, 179; 178, identifier:result; 179, tuple; 179, 180; 179, 181; 180, identifier:elem; 181, identifier:order; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:top; 185, subscript; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:result; 188, integer:0; 189, integer:0; 190, expression_statement; 190, 191; 191, augmented_assignment:+=; 191, 192; 191, 193; 192, identifier:order; 193, integer:1; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:result; 198, identifier:sort; 199, argument_list; 200, return_statement; 200, 201; 201, list_comprehension; 201, 202; 201, 205; 202, subscript; 202, 203; 202, 204; 203, identifier:r; 204, integer:0; 205, for_in_clause; 205, 206; 205, 207; 206, identifier:r; 207, identifier:result; 208, comment; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:it; 212, call; 212, 213; 212, 214; 213, identifier:iter; 214, argument_list; 214, 215; 215, identifier:iterable; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:result; 219, list_comprehension; 219, 220; 219, 227; 220, tuple; 220, 221; 220, 225; 220, 226; 221, call; 221, 222; 221, 223; 222, identifier:key; 223, argument_list; 223, 224; 224, identifier:elem; 225, identifier:i; 226, identifier:elem; 227, for_in_clause; 227, 228; 227, 231; 228, pattern_list; 228, 229; 228, 230; 229, identifier:i; 230, identifier:elem; 231, call; 231, 232; 231, 233; 232, identifier:zip; 233, argument_list; 233, 234; 233, 238; 234, call; 234, 235; 234, 236; 235, identifier:range; 236, argument_list; 236, 237; 237, identifier:n; 238, identifier:it; 239, if_statement; 239, 240; 239, 242; 240, not_operator; 240, 241; 241, identifier:result; 242, block; 242, 243; 243, return_statement; 243, 244; 244, identifier:result; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:_heapify_max; 248, argument_list; 248, 249; 249, identifier:result; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:top; 253, subscript; 253, 254; 253, 257; 254, subscript; 254, 255; 254, 256; 255, identifier:result; 256, integer:0; 257, integer:0; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:order; 261, identifier:n; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:_heapreplace; 265, identifier:_heapreplace_max; 266, for_statement; 266, 267; 266, 268; 266, 269; 267, identifier:elem; 268, identifier:it; 269, block; 269, 270; 269, 277; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:k; 273, call; 273, 274; 273, 275; 274, identifier:key; 275, argument_list; 275, 276; 276, identifier:elem; 277, if_statement; 277, 278; 277, 281; 278, comparison_operator:<; 278, 279; 278, 280; 279, identifier:k; 280, identifier:top; 281, block; 281, 282; 281, 291; 281, 299; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 285; 284, identifier:_heapreplace; 285, argument_list; 285, 286; 285, 287; 286, identifier:result; 287, tuple; 287, 288; 287, 289; 287, 290; 288, identifier:k; 289, identifier:order; 290, identifier:elem; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:top; 294, subscript; 294, 295; 294, 298; 295, subscript; 295, 296; 295, 297; 296, identifier:result; 297, integer:0; 298, integer:0; 299, expression_statement; 299, 300; 300, augmented_assignment:+=; 300, 301; 300, 302; 301, identifier:order; 302, integer:1; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:result; 307, identifier:sort; 308, argument_list; 309, return_statement; 309, 310; 310, list_comprehension; 310, 311; 310, 314; 311, subscript; 311, 312; 311, 313; 312, identifier:r; 313, integer:2; 314, for_in_clause; 314, 315; 314, 316; 315, identifier:r; 316, identifier:result | def nsmallest(n, iterable, key=None):
"""Find the n smallest elements in a dataset.
Equivalent to: sorted(iterable, key=key)[:n]
"""
# Short-cut for n==1 is to use min()
if n == 1:
it = iter(iterable)
sentinel = object()
if key is None:
result = min(it, default=sentinel)
else:
result = min(it, default=sentinel, key=key)
return [] if result is sentinel else [result]
# When n>=size, it's faster to use sorted()
try:
size = len(iterable)
except (TypeError, AttributeError):
pass
else:
if n >= size:
return sorted(iterable, key=key)[:n]
# When key is none, use simpler decoration
if key is None:
it = iter(iterable)
# put the range(n) first so that zip() doesn't
# consume one too many elements from the iterator
result = [(elem, i) for i, elem in zip(range(n), it)]
if not result:
return result
_heapify_max(result)
top = result[0][0]
order = n
_heapreplace = _heapreplace_max
for elem in it:
if elem < top:
_heapreplace(result, (elem, order))
top = result[0][0]
order += 1
result.sort()
return [r[0] for r in result]
# General case, slowest method
it = iter(iterable)
result = [(key(elem), i, elem) for i, elem in zip(range(n), it)]
if not result:
return result
_heapify_max(result)
top = result[0][0]
order = n
_heapreplace = _heapreplace_max
for elem in it:
k = key(elem)
if k < top:
_heapreplace(result, (k, order, elem))
top = result[0][0]
order += 1
result.sort()
return [r[2] for r in result] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:nlargest; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:n; 5, identifier:iterable; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, block; 9, 10; 9, 12; 9, 13; 9, 69; 9, 70; 9, 107; 9, 108; 9, 217; 9, 218; 9, 225; 9, 252; 9, 258; 9, 263; 9, 271; 9, 276; 9, 280; 9, 317; 9, 326; 10, expression_statement; 10, 11; 11, comment; 12, comment; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:n; 16, integer:1; 17, block; 17, 18; 17, 25; 17, 31; 17, 61; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:it; 21, call; 21, 22; 21, 23; 22, identifier:iter; 23, argument_list; 23, 24; 24, identifier:iterable; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:sentinel; 28, call; 28, 29; 28, 30; 29, identifier:object; 30, argument_list; 31, if_statement; 31, 32; 31, 35; 31, 46; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:key; 34, None; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:result; 39, call; 39, 40; 39, 41; 40, identifier:max; 41, argument_list; 41, 42; 41, 43; 42, identifier:it; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:default; 45, identifier:sentinel; 46, else_clause; 46, 47; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:result; 51, call; 51, 52; 51, 53; 52, identifier:max; 53, argument_list; 53, 54; 53, 55; 53, 58; 54, identifier:it; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:default; 57, identifier:sentinel; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:key; 60, identifier:key; 61, return_statement; 61, 62; 62, conditional_expression:if; 62, 63; 62, 64; 62, 67; 63, list:[]; 64, comparison_operator:is; 64, 65; 64, 66; 65, identifier:result; 66, identifier:sentinel; 67, list:[result]; 67, 68; 68, identifier:result; 69, comment; 70, try_statement; 70, 71; 70, 79; 70, 85; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:size; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:iterable; 79, except_clause; 79, 80; 79, 83; 80, tuple; 80, 81; 80, 82; 81, identifier:TypeError; 82, identifier:AttributeError; 83, block; 83, 84; 84, pass_statement; 85, else_clause; 85, 86; 86, block; 86, 87; 87, if_statement; 87, 88; 87, 91; 88, comparison_operator:>=; 88, 89; 88, 90; 89, identifier:n; 90, identifier:size; 91, block; 91, 92; 92, return_statement; 92, 93; 93, subscript; 93, 94; 93, 104; 94, call; 94, 95; 94, 96; 95, identifier:sorted; 96, argument_list; 96, 97; 96, 98; 96, 101; 97, identifier:iterable; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:key; 100, identifier:key; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:reverse; 103, True; 104, slice; 104, 105; 104, 106; 105, colon; 106, identifier:n; 107, comment; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:key; 111, None; 112, block; 112, 113; 112, 120; 112, 143; 112, 149; 112, 154; 112, 162; 112, 167; 112, 171; 112, 200; 112, 209; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:it; 116, call; 116, 117; 116, 118; 117, identifier:iter; 118, argument_list; 118, 119; 119, identifier:iterable; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:result; 123, list_comprehension; 123, 124; 123, 127; 124, tuple; 124, 125; 124, 126; 125, identifier:elem; 126, identifier:i; 127, for_in_clause; 127, 128; 127, 131; 128, pattern_list; 128, 129; 128, 130; 129, identifier:i; 130, identifier:elem; 131, call; 131, 132; 131, 133; 132, identifier:zip; 133, argument_list; 133, 134; 133, 142; 134, call; 134, 135; 134, 136; 135, identifier:range; 136, argument_list; 136, 137; 136, 138; 136, 140; 137, integer:0; 138, unary_operator:-; 138, 139; 139, identifier:n; 140, unary_operator:-; 140, 141; 141, integer:1; 142, identifier:it; 143, if_statement; 143, 144; 143, 146; 144, not_operator; 144, 145; 145, identifier:result; 146, block; 146, 147; 147, return_statement; 147, 148; 148, identifier:result; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:heapify; 152, argument_list; 152, 153; 153, identifier:result; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:top; 157, subscript; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:result; 160, integer:0; 161, integer:0; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:order; 165, unary_operator:-; 165, 166; 166, identifier:n; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:_heapreplace; 170, identifier:heapreplace; 171, for_statement; 171, 172; 171, 173; 171, 174; 172, identifier:elem; 173, identifier:it; 174, block; 174, 175; 175, if_statement; 175, 176; 175, 179; 176, comparison_operator:<; 176, 177; 176, 178; 177, identifier:top; 178, identifier:elem; 179, block; 179, 180; 179, 188; 179, 196; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:_heapreplace; 183, argument_list; 183, 184; 183, 185; 184, identifier:result; 185, tuple; 185, 186; 185, 187; 186, identifier:elem; 187, identifier:order; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:top; 191, subscript; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:result; 194, integer:0; 195, integer:0; 196, expression_statement; 196, 197; 197, augmented_assignment:-=; 197, 198; 197, 199; 198, identifier:order; 199, integer:1; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:result; 204, identifier:sort; 205, argument_list; 205, 206; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:reverse; 208, True; 209, return_statement; 209, 210; 210, list_comprehension; 210, 211; 210, 214; 211, subscript; 211, 212; 211, 213; 212, identifier:r; 213, integer:0; 214, for_in_clause; 214, 215; 214, 216; 215, identifier:r; 216, identifier:result; 217, comment; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:it; 221, call; 221, 222; 221, 223; 222, identifier:iter; 223, argument_list; 223, 224; 224, identifier:iterable; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:result; 228, list_comprehension; 228, 229; 228, 236; 229, tuple; 229, 230; 229, 234; 229, 235; 230, call; 230, 231; 230, 232; 231, identifier:key; 232, argument_list; 232, 233; 233, identifier:elem; 234, identifier:i; 235, identifier:elem; 236, for_in_clause; 236, 237; 236, 240; 237, pattern_list; 237, 238; 237, 239; 238, identifier:i; 239, identifier:elem; 240, call; 240, 241; 240, 242; 241, identifier:zip; 242, argument_list; 242, 243; 242, 251; 243, call; 243, 244; 243, 245; 244, identifier:range; 245, argument_list; 245, 246; 245, 247; 245, 249; 246, integer:0; 247, unary_operator:-; 247, 248; 248, identifier:n; 249, unary_operator:-; 249, 250; 250, integer:1; 251, identifier:it; 252, if_statement; 252, 253; 252, 255; 253, not_operator; 253, 254; 254, identifier:result; 255, block; 255, 256; 256, return_statement; 256, 257; 257, identifier:result; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 261; 260, identifier:heapify; 261, argument_list; 261, 262; 262, identifier:result; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:top; 266, subscript; 266, 267; 266, 270; 267, subscript; 267, 268; 267, 269; 268, identifier:result; 269, integer:0; 270, integer:0; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:order; 274, unary_operator:-; 274, 275; 275, identifier:n; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:_heapreplace; 279, identifier:heapreplace; 280, for_statement; 280, 281; 280, 282; 280, 283; 281, identifier:elem; 282, identifier:it; 283, block; 283, 284; 283, 291; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:k; 287, call; 287, 288; 287, 289; 288, identifier:key; 289, argument_list; 289, 290; 290, identifier:elem; 291, if_statement; 291, 292; 291, 295; 292, comparison_operator:<; 292, 293; 292, 294; 293, identifier:top; 294, identifier:k; 295, block; 295, 296; 295, 305; 295, 313; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 299; 298, identifier:_heapreplace; 299, argument_list; 299, 300; 299, 301; 300, identifier:result; 301, tuple; 301, 302; 301, 303; 301, 304; 302, identifier:k; 303, identifier:order; 304, identifier:elem; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:top; 308, subscript; 308, 309; 308, 312; 309, subscript; 309, 310; 309, 311; 310, identifier:result; 311, integer:0; 312, integer:0; 313, expression_statement; 313, 314; 314, augmented_assignment:-=; 314, 315; 314, 316; 315, identifier:order; 316, integer:1; 317, expression_statement; 317, 318; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:result; 321, identifier:sort; 322, argument_list; 322, 323; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:reverse; 325, True; 326, return_statement; 326, 327; 327, list_comprehension; 327, 328; 327, 331; 328, subscript; 328, 329; 328, 330; 329, identifier:r; 330, integer:2; 331, for_in_clause; 331, 332; 331, 333; 332, identifier:r; 333, identifier:result | def nlargest(n, iterable, key=None):
"""Find the n largest elements in a dataset.
Equivalent to: sorted(iterable, key=key, reverse=True)[:n]
"""
# Short-cut for n==1 is to use max()
if n == 1:
it = iter(iterable)
sentinel = object()
if key is None:
result = max(it, default=sentinel)
else:
result = max(it, default=sentinel, key=key)
return [] if result is sentinel else [result]
# When n>=size, it's faster to use sorted()
try:
size = len(iterable)
except (TypeError, AttributeError):
pass
else:
if n >= size:
return sorted(iterable, key=key, reverse=True)[:n]
# When key is none, use simpler decoration
if key is None:
it = iter(iterable)
result = [(elem, i) for i, elem in zip(range(0, -n, -1), it)]
if not result:
return result
heapify(result)
top = result[0][0]
order = -n
_heapreplace = heapreplace
for elem in it:
if top < elem:
_heapreplace(result, (elem, order))
top = result[0][0]
order -= 1
result.sort(reverse=True)
return [r[0] for r in result]
# General case, slowest method
it = iter(iterable)
result = [(key(elem), i, elem) for i, elem in zip(range(0, -n, -1), it)]
if not result:
return result
heapify(result)
top = result[0][0]
order = -n
_heapreplace = heapreplace
for elem in it:
k = key(elem)
if top < k:
_heapreplace(result, (k, order, elem))
top = result[0][0]
order -= 1
result.sort(reverse=True)
return [r[2] for r in result] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sortBy; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:col; 6, list_splat_pattern; 6, 7; 7, identifier:cols; 8, block; 8, 9; 8, 11; 8, 50; 8, 77; 8, 99; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 19; 12, call; 12, 13; 12, 14; 13, identifier:isinstance; 14, argument_list; 14, 15; 14, 16; 15, identifier:col; 16, tuple; 16, 17; 16, 18; 17, identifier:list; 18, identifier:tuple; 19, block; 19, 20; 19, 36; 20, if_statement; 20, 21; 20, 22; 21, identifier:cols; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:ValueError; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, string:"col is a {0} but cols are not empty"; 30, identifier:format; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:type; 34, argument_list; 34, 35; 35, identifier:col; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, pattern_list; 38, 39; 38, 40; 39, identifier:col; 40, identifier:cols; 41, expression_list; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:col; 44, integer:0; 45, subscript; 45, 46; 45, 47; 46, identifier:col; 47, slice; 47, 48; 47, 49; 48, integer:1; 49, colon; 50, if_statement; 50, 51; 50, 71; 51, boolean_operator:or; 51, 52; 51, 64; 52, not_operator; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:all; 55, generator_expression; 55, 56; 55, 61; 56, call; 56, 57; 56, 58; 57, identifier:isinstance; 58, argument_list; 58, 59; 58, 60; 59, identifier:c; 60, identifier:basestring; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:c; 63, identifier:cols; 64, not_operator; 64, 65; 65, parenthesized_expression; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:isinstance; 68, argument_list; 68, 69; 68, 70; 69, identifier:col; 70, identifier:basestring; 71, block; 71, 72; 72, raise_statement; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:TypeError; 75, argument_list; 75, 76; 76, string:"all names should be `str`"; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_jwrite; 82, call; 82, 83; 82, 88; 83, attribute; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:_jwrite; 87, identifier:sortBy; 88, argument_list; 88, 89; 88, 90; 89, identifier:col; 90, call; 90, 91; 90, 92; 91, identifier:_to_seq; 92, argument_list; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:_spark; 97, identifier:_sc; 98, identifier:cols; 99, return_statement; 99, 100; 100, identifier:self | def sortBy(self, col, *cols):
"""Sorts the output in each bucket by the given columns on the file system.
:param col: a name of a column, or a list of names.
:param cols: additional names (optional). If `col` is a list it should be empty.
>>> (df.write.format('parquet') # doctest: +SKIP
... .bucketBy(100, 'year', 'month')
... .sortBy('day')
... .mode("overwrite")
... .saveAsTable('sorted_bucketed_table'))
"""
if isinstance(col, (list, tuple)):
if cols:
raise ValueError("col is a {0} but cols are not empty".format(type(col)))
col, cols = col[0], col[1:]
if not all(isinstance(c, basestring) for c in cols) or not(isinstance(col, basestring)):
raise TypeError("all names should be `str`")
self._jwrite = self._jwrite.sortBy(col, _to_seq(self._spark._sc, cols))
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:saveAsLibSVMFile; 3, parameters; 3, 4; 3, 5; 4, identifier:data; 5, identifier:dir; 6, block; 6, 7; 6, 9; 6, 26; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:lines; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:data; 15, identifier:map; 16, argument_list; 16, 17; 17, lambda; 17, 18; 17, 20; 18, lambda_parameters; 18, 19; 19, identifier:p; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:MLUtils; 23, identifier:_convert_labeled_point_to_libsvm; 24, argument_list; 24, 25; 25, identifier:p; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:lines; 30, identifier:saveAsTextFile; 31, argument_list; 31, 32; 32, identifier:dir | def saveAsLibSVMFile(data, dir):
"""
Save labeled data in LIBSVM format.
:param data: an RDD of LabeledPoint to be saved
:param dir: directory to save the data
>>> from tempfile import NamedTemporaryFile
>>> from fileinput import input
>>> from pyspark.mllib.regression import LabeledPoint
>>> from glob import glob
>>> from pyspark.mllib.util import MLUtils
>>> examples = [LabeledPoint(1.1, Vectors.sparse(3, [(0, 1.23), (2, 4.56)])),
... LabeledPoint(0.0, Vectors.dense([1.01, 2.02, 3.03]))]
>>> tempFile = NamedTemporaryFile(delete=True)
>>> tempFile.close()
>>> MLUtils.saveAsLibSVMFile(sc.parallelize(examples), tempFile.name)
>>> ''.join(sorted(input(glob(tempFile.name + "/part-0000*"))))
'0.0 1:1.01 2:2.02 3:3.03\\n1.1 1:1.23 3:4.56\\n'
"""
lines = data.map(lambda p: MLUtils._convert_labeled_point_to_libsvm(p))
lines.saveAsTextFile(dir) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:union; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:rdds; 6, block; 6, 7; 6, 9; 6, 17; 6, 42; 6, 60; 6, 75; 6, 96; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:first_jrdd_deserializer; 12, attribute; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:rdds; 15, integer:0; 16, identifier:_jrdd_deserializer; 17, if_statement; 17, 18; 17, 29; 18, call; 18, 19; 18, 20; 19, identifier:any; 20, generator_expression; 20, 21; 20, 26; 21, comparison_operator:!=; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:x; 24, identifier:_jrdd_deserializer; 25, identifier:first_jrdd_deserializer; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:x; 28, identifier:rdds; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:rdds; 33, list_comprehension; 33, 34; 33, 39; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:x; 37, identifier:_reserialize; 38, argument_list; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:x; 41, identifier:rdds; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:cls; 45, attribute; 45, 46; 45, 59; 46, attribute; 46, 47; 46, 58; 47, attribute; 47, 48; 47, 57; 48, attribute; 48, 49; 48, 56; 49, attribute; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:SparkContext; 53, identifier:_jvm; 54, identifier:org; 55, identifier:apache; 56, identifier:spark; 57, identifier:api; 58, identifier:java; 59, identifier:JavaRDD; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:jrdds; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:SparkContext; 67, identifier:_gateway; 68, identifier:new_array; 69, argument_list; 69, 70; 69, 71; 70, identifier:cls; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:rdds; 75, for_statement; 75, 76; 75, 77; 75, 85; 76, identifier:i; 77, call; 77, 78; 77, 79; 78, identifier:range; 79, argument_list; 79, 80; 79, 81; 80, integer:0; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, identifier:rdds; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:jrdds; 90, identifier:i; 91, attribute; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:rdds; 94, identifier:i; 95, identifier:_jrdd; 96, return_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:RDD; 99, argument_list; 99, 100; 99, 108; 99, 109; 100, call; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_jsc; 105, identifier:union; 106, argument_list; 106, 107; 107, identifier:jrdds; 108, identifier:self; 109, attribute; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:rdds; 112, integer:0; 113, identifier:_jrdd_deserializer | def union(self, rdds):
"""
Build the union of a list of RDDs.
This supports unions() of RDDs with different serialized formats,
although this forces them to be reserialized using the default
serializer:
>>> path = os.path.join(tempdir, "union-text.txt")
>>> with open(path, "w") as testFile:
... _ = testFile.write("Hello")
>>> textFile = sc.textFile(path)
>>> textFile.collect()
[u'Hello']
>>> parallelized = sc.parallelize(["World!"])
>>> sorted(sc.union([textFile, parallelized]).collect())
[u'Hello', 'World!']
"""
first_jrdd_deserializer = rdds[0]._jrdd_deserializer
if any(x._jrdd_deserializer != first_jrdd_deserializer for x in rdds):
rdds = [x._reserialize() for x in rdds]
cls = SparkContext._jvm.org.apache.spark.api.java.JavaRDD
jrdds = SparkContext._gateway.new_array(cls, len(rdds))
for i in range(0, len(rdds)):
jrdds[i] = rdds[i]._jrdd
return RDD(self._jsc.union(jrdds), self, rdds[0]._jrdd_deserializer) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sortlevel; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:level; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort_remaining; 13, None; 14, block; 14, 15; 14, 17; 15, expression_statement; 15, 16; 16, comment; 17, return_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:sort_values; 22, argument_list; 22, 23; 22, 26; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:return_indexer; 25, True; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:ascending; 28, identifier:ascending | def sortlevel(self, level=None, ascending=True, sort_remaining=None):
"""
For internal compatibility with with the Index API.
Sort the Index. This is for compat with MultiIndex
Parameters
----------
ascending : boolean, default True
False to sort in descending order
level, sort_remaining are compat parameters
Returns
-------
Index
"""
return self.sort_values(return_indexer=True, ascending=ascending) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_duplicates; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 22; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:warnings; 12, identifier:warn; 13, argument_list; 13, 14; 13, 18; 13, 19; 14, concatenated_string; 14, 15; 14, 16; 14, 17; 15, string:"'get_duplicates' is deprecated and will be removed in "; 16, string:"a future release. You can use "; 17, string:"idx[idx.duplicated()].unique() instead"; 18, identifier:FutureWarning; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:stacklevel; 21, integer:2; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 33; 24, attribute; 24, 25; 24, 32; 25, subscript; 25, 26; 25, 27; 26, identifier:self; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:duplicated; 31, argument_list; 32, identifier:unique; 33, argument_list | def get_duplicates(self):
"""
Extract duplicated index elements.
.. deprecated:: 0.23.0
Use idx[idx.duplicated()].unique() instead
Returns a sorted list of index elements which appear more than once in
the index.
Returns
-------
array-like
List of duplicated indexes.
See Also
--------
Index.duplicated : Return boolean array denoting duplicates.
Index.drop_duplicates : Return Index with duplicates removed.
Examples
--------
Works on different Index of types.
>>> pd.Index([1, 2, 2, 3, 3, 3, 4]).get_duplicates() # doctest: +SKIP
[2, 3]
Note that for a DatetimeIndex, it does not return a list but a new
DatetimeIndex:
>>> dates = pd.to_datetime(['2018-01-01', '2018-01-02', '2018-01-03',
... '2018-01-03', '2018-01-04', '2018-01-04'],
... format='%Y-%m-%d')
>>> pd.Index(dates).get_duplicates() # doctest: +SKIP
DatetimeIndex(['2018-01-03', '2018-01-04'],
dtype='datetime64[ns]', freq=None)
Sorts duplicated elements even when indexes are unordered.
>>> pd.Index([1, 2, 3, 2, 3, 4, 3]).get_duplicates() # doctest: +SKIP
[2, 3]
Return empty array-like structure when all elements are unique.
>>> pd.Index([1, 2, 3, 4]).get_duplicates() # doctest: +SKIP
[]
>>> dates = pd.to_datetime(['2018-01-01', '2018-01-02', '2018-01-03'],
... format='%Y-%m-%d')
>>> pd.Index(dates).get_duplicates() # doctest: +SKIP
DatetimeIndex([], dtype='datetime64[ns]', freq=None)
"""
warnings.warn("'get_duplicates' is deprecated and will be removed in "
"a future release. You can use "
"idx[idx.duplicated()].unique() instead",
FutureWarning, stacklevel=2)
return self[self.duplicated()].unique() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:union; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, block; 9, 10; 9, 12; 9, 19; 9, 26; 9, 33; 9, 55; 9, 70; 9, 71; 9, 72; 9, 73; 9, 74; 9, 114; 9, 115; 9, 140; 9, 165; 9, 328; 9, 329; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_validate_sort_keyword; 17, argument_list; 17, 18; 18, identifier:sort; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_assert_can_do_setop; 24, argument_list; 24, 25; 25, identifier:other; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:other; 29, call; 29, 30; 29, 31; 30, identifier:ensure_index; 31, argument_list; 31, 32; 32, identifier:other; 33, if_statement; 33, 34; 33, 47; 34, boolean_operator:or; 34, 35; 34, 41; 35, comparison_operator:==; 35, 36; 35, 40; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:other; 40, integer:0; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:equals; 45, argument_list; 45, 46; 46, identifier:other; 47, block; 47, 48; 48, return_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_get_reconciled_name_object; 53, argument_list; 53, 54; 54, identifier:other; 55, if_statement; 55, 56; 55, 62; 56, comparison_operator:==; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:self; 61, integer:0; 62, block; 62, 63; 63, return_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:other; 67, identifier:_get_reconciled_name_object; 68, argument_list; 68, 69; 69, identifier:self; 70, comment; 71, comment; 72, comment; 73, comment; 74, if_statement; 74, 75; 74, 85; 75, not_operator; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:is_dtype_union_equal; 78, argument_list; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:dtype; 82, attribute; 82, 83; 82, 84; 83, identifier:other; 84, identifier:dtype; 85, block; 85, 86; 85, 95; 85, 104; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:this; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:astype; 93, argument_list; 93, 94; 94, string:'O'; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:other; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:other; 101, identifier:astype; 102, argument_list; 102, 103; 103, string:'O'; 104, return_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:this; 108, identifier:union; 109, argument_list; 109, 110; 109, 111; 110, identifier:other; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:sort; 113, identifier:sort; 114, comment; 115, if_statement; 115, 116; 115, 125; 115, 132; 116, boolean_operator:or; 116, 117; 116, 121; 117, call; 117, 118; 117, 119; 118, identifier:is_period_dtype; 119, argument_list; 119, 120; 120, identifier:self; 121, call; 121, 122; 121, 123; 122, identifier:is_datetime64tz_dtype; 123, argument_list; 123, 124; 124, identifier:self; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:lvals; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_ndarray_values; 132, else_clause; 132, 133; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:lvals; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:_values; 140, if_statement; 140, 141; 140, 150; 140, 157; 141, boolean_operator:or; 141, 142; 141, 146; 142, call; 142, 143; 142, 144; 143, identifier:is_period_dtype; 144, argument_list; 144, 145; 145, identifier:other; 146, call; 146, 147; 146, 148; 147, identifier:is_datetime64tz_dtype; 148, argument_list; 148, 149; 149, identifier:other; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:rvals; 154, attribute; 154, 155; 154, 156; 155, identifier:other; 156, identifier:_ndarray_values; 157, else_clause; 157, 158; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:rvals; 162, attribute; 162, 163; 162, 164; 163, identifier:other; 164, identifier:_values; 165, if_statement; 165, 166; 165, 177; 165, 226; 166, boolean_operator:and; 166, 167; 166, 174; 167, boolean_operator:and; 167, 168; 167, 171; 168, comparison_operator:is; 168, 169; 168, 170; 169, identifier:sort; 170, None; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:is_monotonic; 174, attribute; 174, 175; 174, 176; 175, identifier:other; 176, identifier:is_monotonic; 177, block; 177, 178; 178, try_statement; 178, 179; 178, 192; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:result; 183, subscript; 183, 184; 183, 191; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:_outer_indexer; 188, argument_list; 188, 189; 188, 190; 189, identifier:lvals; 190, identifier:rvals; 191, integer:0; 192, except_clause; 192, 193; 192, 194; 192, 195; 193, identifier:TypeError; 194, comment; 195, block; 195, 196; 195, 203; 195, 204; 195, 211; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:result; 199, call; 199, 200; 199, 201; 200, identifier:list; 201, argument_list; 201, 202; 202, identifier:lvals; 203, comment; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:value_set; 207, call; 207, 208; 207, 209; 208, identifier:set; 209, argument_list; 209, 210; 210, identifier:lvals; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:result; 215, identifier:extend; 216, argument_list; 216, 217; 217, list_comprehension; 217, 218; 217, 219; 217, 222; 218, identifier:x; 219, for_in_clause; 219, 220; 219, 221; 220, identifier:x; 221, identifier:rvals; 222, if_clause; 222, 223; 223, comparison_operator:not; 223, 224; 223, 225; 224, identifier:x; 225, identifier:value_set; 226, else_clause; 226, 227; 227, block; 227, 228; 227, 237; 227, 250; 227, 288; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:indexer; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:self; 234, identifier:get_indexer; 235, argument_list; 235, 236; 236, identifier:other; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 241; 239, pattern_list; 239, 240; 240, identifier:indexer; 241, call; 241, 242; 241, 249; 242, attribute; 242, 243; 242, 248; 243, parenthesized_expression; 243, 244; 244, comparison_operator:==; 244, 245; 244, 246; 245, identifier:indexer; 246, unary_operator:-; 246, 247; 247, integer:1; 248, identifier:nonzero; 249, argument_list; 250, if_statement; 250, 251; 250, 257; 250, 282; 251, comparison_operator:>; 251, 252; 251, 256; 252, call; 252, 253; 252, 254; 253, identifier:len; 254, argument_list; 254, 255; 255, identifier:indexer; 256, integer:0; 257, block; 257, 258; 257, 271; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:other_diff; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:algos; 264, identifier:take_nd; 265, argument_list; 265, 266; 265, 267; 265, 268; 266, identifier:rvals; 267, identifier:indexer; 268, keyword_argument; 268, 269; 268, 270; 269, identifier:allow_fill; 270, False; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:result; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:_concat; 277, identifier:_concat_compat; 278, argument_list; 278, 279; 279, tuple; 279, 280; 279, 281; 280, identifier:lvals; 281, identifier:other_diff; 282, else_clause; 282, 283; 283, block; 283, 284; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:result; 287, identifier:lvals; 288, if_statement; 288, 289; 288, 292; 289, comparison_operator:is; 289, 290; 289, 291; 290, identifier:sort; 291, None; 292, block; 292, 293; 293, try_statement; 293, 294; 293, 304; 294, block; 294, 295; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:result; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:sorting; 301, identifier:safe_sort; 302, argument_list; 302, 303; 303, identifier:result; 304, except_clause; 304, 305; 304, 309; 305, as_pattern; 305, 306; 305, 307; 306, identifier:TypeError; 307, as_pattern_target; 307, 308; 308, identifier:e; 309, block; 309, 310; 310, expression_statement; 310, 311; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:warnings; 314, identifier:warn; 315, argument_list; 315, 316; 315, 324; 315, 325; 316, call; 316, 317; 316, 322; 317, attribute; 317, 318; 317, 321; 318, concatenated_string; 318, 319; 318, 320; 319, string:"{}, sort order is undefined for "; 320, string:"incomparable objects"; 321, identifier:format; 322, argument_list; 322, 323; 323, identifier:e; 324, identifier:RuntimeWarning; 325, keyword_argument; 325, 326; 325, 327; 326, identifier:stacklevel; 327, integer:3; 328, comment; 329, return_statement; 329, 330; 330, call; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:self; 333, identifier:_wrap_setop_result; 334, argument_list; 334, 335; 334, 336; 335, identifier:other; 336, identifier:result | def union(self, other, sort=None):
"""
Form the union of two Index objects.
Parameters
----------
other : Index or array-like
sort : bool or None, default None
Whether to sort the resulting Index.
* None : Sort the result, except when
1. `self` and `other` are equal.
2. `self` or `other` has length 0.
3. Some values in `self` or `other` cannot be compared.
A RuntimeWarning is issued in this case.
* False : do not sort the result.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
Returns
-------
union : Index
Examples
--------
>>> idx1 = pd.Index([1, 2, 3, 4])
>>> idx2 = pd.Index([3, 4, 5, 6])
>>> idx1.union(idx2)
Int64Index([1, 2, 3, 4, 5, 6], dtype='int64')
"""
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
other = ensure_index(other)
if len(other) == 0 or self.equals(other):
return self._get_reconciled_name_object(other)
if len(self) == 0:
return other._get_reconciled_name_object(self)
# TODO: is_dtype_union_equal is a hack around
# 1. buggy set ops with duplicates (GH #13432)
# 2. CategoricalIndex lacking setops (GH #10186)
# Once those are fixed, this workaround can be removed
if not is_dtype_union_equal(self.dtype, other.dtype):
this = self.astype('O')
other = other.astype('O')
return this.union(other, sort=sort)
# TODO(EA): setops-refactor, clean all this up
if is_period_dtype(self) or is_datetime64tz_dtype(self):
lvals = self._ndarray_values
else:
lvals = self._values
if is_period_dtype(other) or is_datetime64tz_dtype(other):
rvals = other._ndarray_values
else:
rvals = other._values
if sort is None and self.is_monotonic and other.is_monotonic:
try:
result = self._outer_indexer(lvals, rvals)[0]
except TypeError:
# incomparable objects
result = list(lvals)
# worth making this faster? a very unusual case
value_set = set(lvals)
result.extend([x for x in rvals if x not in value_set])
else:
indexer = self.get_indexer(other)
indexer, = (indexer == -1).nonzero()
if len(indexer) > 0:
other_diff = algos.take_nd(rvals, indexer,
allow_fill=False)
result = _concat._concat_compat((lvals, other_diff))
else:
result = lvals
if sort is None:
try:
result = sorting.safe_sort(result)
except TypeError as e:
warnings.warn("{}, sort order is undefined for "
"incomparable objects".format(e),
RuntimeWarning, stacklevel=3)
# for subclasses
return self._wrap_setop_result(other, result) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:difference; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, block; 9, 10; 9, 12; 9, 19; 9, 26; 9, 48; 9, 59; 9, 67; 9, 76; 9, 95; 9, 115; 9, 126; 9, 146; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_validate_sort_keyword; 17, argument_list; 17, 18; 18, identifier:sort; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_assert_can_do_setop; 24, argument_list; 24, 25; 25, identifier:other; 26, if_statement; 26, 27; 26, 33; 26, 34; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:equals; 31, argument_list; 31, 32; 32, identifier:other; 33, comment; 34, block; 34, 35; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_shallow_copy; 40, argument_list; 40, 41; 41, subscript; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:_data; 45, slice; 45, 46; 45, 47; 46, colon; 47, integer:0; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, pattern_list; 50, 51; 50, 52; 51, identifier:other; 52, identifier:result_name; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:_convert_can_do_setop; 57, argument_list; 57, 58; 58, identifier:other; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:this; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:_get_unique_index; 66, argument_list; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:indexer; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:this; 73, identifier:get_indexer; 74, argument_list; 74, 75; 75, identifier:other; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:indexer; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:indexer; 82, identifier:take; 83, argument_list; 83, 84; 84, subscript; 84, 85; 84, 94; 85, call; 85, 86; 85, 93; 86, attribute; 86, 87; 86, 92; 87, parenthesized_expression; 87, 88; 88, comparison_operator:!=; 88, 89; 88, 90; 89, identifier:indexer; 90, unary_operator:-; 90, 91; 91, integer:1; 92, identifier:nonzero; 93, argument_list; 94, integer:0; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:label_diff; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:np; 101, identifier:setdiff1d; 102, argument_list; 102, 103; 102, 111; 102, 112; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:np; 106, identifier:arange; 107, argument_list; 107, 108; 108, attribute; 108, 109; 108, 110; 109, identifier:this; 110, identifier:size; 111, identifier:indexer; 112, keyword_argument; 112, 113; 112, 114; 113, identifier:assume_unique; 114, True; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:the_diff; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:this; 122, identifier:values; 123, identifier:take; 124, argument_list; 124, 125; 125, identifier:label_diff; 126, if_statement; 126, 127; 126, 130; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:sort; 129, None; 130, block; 130, 131; 131, try_statement; 131, 132; 131, 142; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:the_diff; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:sorting; 139, identifier:safe_sort; 140, argument_list; 140, 141; 141, identifier:the_diff; 142, except_clause; 142, 143; 142, 144; 143, identifier:TypeError; 144, block; 144, 145; 145, pass_statement; 146, return_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:this; 150, identifier:_shallow_copy; 151, argument_list; 151, 152; 151, 153; 151, 156; 152, identifier:the_diff; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:name; 155, identifier:result_name; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:freq; 158, None | def difference(self, other, sort=None):
"""
Return a new Index with elements from the index that are not in
`other`.
This is the set difference of two Index objects.
Parameters
----------
other : Index or array-like
sort : False or None, default None
Whether to sort the resulting index. By default, the
values are attempted to be sorted, but any TypeError from
incomparable elements is caught by pandas.
* None : Attempt to sort the result, but catch any TypeErrors
from comparing incomparable elements.
* False : Do not sort the result.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
Returns
-------
difference : Index
Examples
--------
>>> idx1 = pd.Index([2, 1, 3, 4])
>>> idx2 = pd.Index([3, 4, 5, 6])
>>> idx1.difference(idx2)
Int64Index([1, 2], dtype='int64')
>>> idx1.difference(idx2, sort=False)
Int64Index([2, 1], dtype='int64')
"""
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
if self.equals(other):
# pass an empty np.ndarray with the appropriate dtype
return self._shallow_copy(self._data[:0])
other, result_name = self._convert_can_do_setop(other)
this = self._get_unique_index()
indexer = this.get_indexer(other)
indexer = indexer.take((indexer != -1).nonzero()[0])
label_diff = np.setdiff1d(np.arange(this.size), indexer,
assume_unique=True)
the_diff = this.values.take(label_diff)
if sort is None:
try:
the_diff = sorting.safe_sort(the_diff)
except TypeError:
pass
return this._shallow_copy(the_diff, name=result_name, freq=None) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:symmetric_difference; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:result_name; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, block; 12, 13; 12, 15; 12, 22; 12, 29; 12, 40; 12, 49; 12, 57; 12, 65; 12, 74; 12, 75; 12, 94; 12, 114; 12, 125; 12, 126; 12, 140; 12, 151; 12, 162; 12, 182; 12, 190; 12, 196; 12, 207; 13, expression_statement; 13, 14; 14, comment; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_validate_sort_keyword; 20, argument_list; 20, 21; 21, identifier:sort; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_assert_can_do_setop; 27, argument_list; 27, 28; 28, identifier:other; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, pattern_list; 31, 32; 31, 33; 32, identifier:other; 33, identifier:result_name_update; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_convert_can_do_setop; 38, argument_list; 38, 39; 39, identifier:other; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:result_name; 43, None; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:result_name; 48, identifier:result_name_update; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:this; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_get_unique_index; 56, argument_list; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:other; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:other; 63, identifier:_get_unique_index; 64, argument_list; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:indexer; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:this; 71, identifier:get_indexer; 72, argument_list; 72, 73; 73, identifier:other; 74, comment; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:common_indexer; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:indexer; 81, identifier:take; 82, argument_list; 82, 83; 83, subscript; 83, 84; 83, 93; 84, call; 84, 85; 84, 92; 85, attribute; 85, 86; 85, 91; 86, parenthesized_expression; 86, 87; 87, comparison_operator:!=; 87, 88; 87, 89; 88, identifier:indexer; 89, unary_operator:-; 89, 90; 90, integer:1; 91, identifier:nonzero; 92, argument_list; 93, integer:0; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:left_indexer; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:np; 100, identifier:setdiff1d; 101, argument_list; 101, 102; 101, 110; 101, 111; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:np; 105, identifier:arange; 106, argument_list; 106, 107; 107, attribute; 107, 108; 107, 109; 108, identifier:this; 109, identifier:size; 110, identifier:common_indexer; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:assume_unique; 113, True; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:left_diff; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:this; 121, identifier:values; 122, identifier:take; 123, argument_list; 123, 124; 124, identifier:left_indexer; 125, comment; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:right_indexer; 129, subscript; 129, 130; 129, 139; 130, call; 130, 131; 130, 138; 131, attribute; 131, 132; 131, 137; 132, parenthesized_expression; 132, 133; 133, comparison_operator:==; 133, 134; 133, 135; 134, identifier:indexer; 135, unary_operator:-; 135, 136; 136, integer:1; 137, identifier:nonzero; 138, argument_list; 139, integer:0; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:right_diff; 143, call; 143, 144; 143, 149; 144, attribute; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:other; 147, identifier:values; 148, identifier:take; 149, argument_list; 149, 150; 150, identifier:right_indexer; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:the_diff; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:_concat; 157, identifier:_concat_compat; 158, argument_list; 158, 159; 159, list:[left_diff, right_diff]; 159, 160; 159, 161; 160, identifier:left_diff; 161, identifier:right_diff; 162, if_statement; 162, 163; 162, 166; 163, comparison_operator:is; 163, 164; 163, 165; 164, identifier:sort; 165, None; 166, block; 166, 167; 167, try_statement; 167, 168; 167, 178; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:the_diff; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:sorting; 175, identifier:safe_sort; 176, argument_list; 176, 177; 177, identifier:the_diff; 178, except_clause; 178, 179; 178, 180; 179, identifier:TypeError; 180, block; 180, 181; 181, pass_statement; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:attribs; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:_get_attributes_dict; 189, argument_list; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:attribs; 194, string:'name'; 195, identifier:result_name; 196, if_statement; 196, 197; 196, 200; 197, comparison_operator:in; 197, 198; 197, 199; 198, string:'freq'; 199, identifier:attribs; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 206; 203, subscript; 203, 204; 203, 205; 204, identifier:attribs; 205, string:'freq'; 206, None; 207, return_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:_shallow_copy_with_infer; 212, argument_list; 212, 213; 212, 214; 213, identifier:the_diff; 214, dictionary_splat; 214, 215; 215, identifier:attribs | def symmetric_difference(self, other, result_name=None, sort=None):
"""
Compute the symmetric difference of two Index objects.
Parameters
----------
other : Index or array-like
result_name : str
sort : False or None, default None
Whether to sort the resulting index. By default, the
values are attempted to be sorted, but any TypeError from
incomparable elements is caught by pandas.
* None : Attempt to sort the result, but catch any TypeErrors
from comparing incomparable elements.
* False : Do not sort the result.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
Returns
-------
symmetric_difference : Index
Notes
-----
``symmetric_difference`` contains elements that appear in either
``idx1`` or ``idx2`` but not both. Equivalent to the Index created by
``idx1.difference(idx2) | idx2.difference(idx1)`` with duplicates
dropped.
Examples
--------
>>> idx1 = pd.Index([1, 2, 3, 4])
>>> idx2 = pd.Index([2, 3, 4, 5])
>>> idx1.symmetric_difference(idx2)
Int64Index([1, 5], dtype='int64')
You can also use the ``^`` operator:
>>> idx1 ^ idx2
Int64Index([1, 5], dtype='int64')
"""
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
other, result_name_update = self._convert_can_do_setop(other)
if result_name is None:
result_name = result_name_update
this = self._get_unique_index()
other = other._get_unique_index()
indexer = this.get_indexer(other)
# {this} minus {other}
common_indexer = indexer.take((indexer != -1).nonzero()[0])
left_indexer = np.setdiff1d(np.arange(this.size), common_indexer,
assume_unique=True)
left_diff = this.values.take(left_indexer)
# {other} minus {this}
right_indexer = (indexer == -1).nonzero()[0]
right_diff = other.values.take(right_indexer)
the_diff = _concat._concat_compat([left_diff, right_diff])
if sort is None:
try:
the_diff = sorting.safe_sort(the_diff)
except TypeError:
pass
attribs = self._get_attributes_dict()
attribs['name'] = result_name
if 'freq' in attribs:
attribs['freq'] = None
return self._shallow_copy_with_infer(the_diff, **attribs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:asof; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:label; 6, block; 6, 7; 6, 9; 7, expression_statement; 7, 8; 8, comment; 9, try_statement; 9, 10; 9, 23; 9, 30; 10, block; 10, 11; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:loc; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:get_loc; 18, argument_list; 18, 19; 18, 20; 19, identifier:label; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:method; 22, string:'pad'; 23, except_clause; 23, 24; 23, 25; 24, identifier:KeyError; 25, block; 25, 26; 26, return_statement; 26, 27; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_na_value; 30, else_clause; 30, 31; 31, block; 31, 32; 31, 54; 32, if_statement; 32, 33; 32, 38; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:loc; 37, identifier:slice; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:loc; 42, subscript; 42, 43; 42, 52; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:loc; 46, identifier:indices; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:len; 50, argument_list; 50, 51; 51, identifier:self; 52, unary_operator:-; 52, 53; 53, integer:1; 54, return_statement; 54, 55; 55, subscript; 55, 56; 55, 57; 56, identifier:self; 57, identifier:loc | def asof(self, label):
"""
Return the label from the index, or, if not present, the previous one.
Assuming that the index is sorted, return the passed index label if it
is in the index, or return the previous index label if the passed one
is not in the index.
Parameters
----------
label : object
The label up to which the method returns the latest index label.
Returns
-------
object
The passed label if it is in the index. The previous label if the
passed label is not in the sorted index or `NaN` if there is no
such label.
See Also
--------
Series.asof : Return the latest value in a Series up to the
passed index.
merge_asof : Perform an asof merge (similar to left join but it
matches on nearest key rather than equal key).
Index.get_loc : An `asof` is a thin wrapper around `get_loc`
with method='pad'.
Examples
--------
`Index.asof` returns the latest index label up to the passed label.
>>> idx = pd.Index(['2013-12-31', '2014-01-02', '2014-01-03'])
>>> idx.asof('2014-01-01')
'2013-12-31'
If the label is in the index, the method returns the passed label.
>>> idx.asof('2014-01-02')
'2014-01-02'
If all of the labels in the index are later than the passed label,
NaN is returned.
>>> idx.asof('1999-01-02')
nan
If the index is not sorted, an error is raised.
>>> idx_not_sorted = pd.Index(['2013-12-31', '2015-01-02',
... '2014-01-03'])
>>> idx_not_sorted.asof('2013-12-31')
Traceback (most recent call last):
ValueError: index must be monotonic increasing or decreasing
"""
try:
loc = self.get_loc(label, method='pad')
except KeyError:
return self._na_value
else:
if isinstance(loc, slice):
loc = loc.indices(len(self))[-1]
return self[loc] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:return_indexer; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, block; 11, 12; 11, 14; 11, 22; 11, 36; 11, 45; 12, expression_statement; 12, 13; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:_as; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:argsort; 21, argument_list; 22, if_statement; 22, 23; 22, 25; 23, not_operator; 23, 24; 24, identifier:ascending; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:_as; 29, subscript; 29, 30; 29, 31; 30, identifier:_as; 31, slice; 31, 32; 31, 33; 31, 34; 32, colon; 33, colon; 34, unary_operator:-; 34, 35; 35, integer:1; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:sorted_index; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:take; 43, argument_list; 43, 44; 44, identifier:_as; 45, if_statement; 45, 46; 45, 47; 45, 52; 46, identifier:return_indexer; 47, block; 47, 48; 48, return_statement; 48, 49; 49, expression_list; 49, 50; 49, 51; 50, identifier:sorted_index; 51, identifier:_as; 52, else_clause; 52, 53; 53, block; 53, 54; 54, return_statement; 54, 55; 55, identifier:sorted_index | def sort_values(self, return_indexer=False, ascending=True):
"""
Return a sorted copy of the index.
Return a sorted copy of the index, and optionally return the indices
that sorted the index itself.
Parameters
----------
return_indexer : bool, default False
Should the indices that would sort the index be returned.
ascending : bool, default True
Should the index values be sorted in an ascending order.
Returns
-------
sorted_index : pandas.Index
Sorted copy of the index.
indexer : numpy.ndarray, optional
The indices that the index itself was sorted by.
See Also
--------
Series.sort_values : Sort values of a Series.
DataFrame.sort_values : Sort values in a DataFrame.
Examples
--------
>>> idx = pd.Index([10, 100, 1, 1000])
>>> idx
Int64Index([10, 100, 1, 1000], dtype='int64')
Sort values in ascending order (default behavior).
>>> idx.sort_values()
Int64Index([1, 10, 100, 1000], dtype='int64')
Sort values in descending order, and also get the indices `idx` was
sorted by.
>>> idx.sort_values(ascending=False, return_indexer=True)
(Int64Index([1000, 100, 10, 1], dtype='int64'), array([3, 1, 0, 2]))
"""
_as = self.argsort()
if not ascending:
_as = _as[::-1]
sorted_index = self.take(_as)
if return_indexer:
return sorted_index, _as
else:
return sorted_index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:argsort; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 12; 9, 18; 9, 32; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:result; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:asi8; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:result; 21, None; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:result; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:array; 30, argument_list; 30, 31; 31, identifier:self; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:result; 36, identifier:argsort; 37, argument_list; 37, 38; 37, 40; 38, list_splat; 38, 39; 39, identifier:args; 40, dictionary_splat; 40, 41; 41, identifier:kwargs | def argsort(self, *args, **kwargs):
"""
Return the integer indices that would sort the index.
Parameters
----------
*args
Passed to `numpy.ndarray.argsort`.
**kwargs
Passed to `numpy.ndarray.argsort`.
Returns
-------
numpy.ndarray
Integer indices that would sort the index if used as
an indexer.
See Also
--------
numpy.argsort : Similar method for NumPy arrays.
Index.sort_values : Return sorted copy of Index.
Examples
--------
>>> idx = pd.Index(['b', 'a', 'd', 'c'])
>>> idx
Index(['b', 'a', 'd', 'c'], dtype='object')
>>> order = idx.argsort()
>>> order
array([1, 0, 3, 2])
>>> idx[order]
Index(['a', 'b', 'c', 'd'], dtype='object')
"""
result = self.asi8
if result is None:
result = np.array(self)
return result.argsort(*args, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:slice_indexer; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:start; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:end; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:step; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:kind; 16, None; 17, block; 17, 18; 17, 20; 17, 38; 17, 39; 17, 51; 17, 63; 18, expression_statement; 18, 19; 19, comment; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 25; 22, pattern_list; 22, 23; 22, 24; 23, identifier:start_slice; 24, identifier:end_slice; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:slice_locs; 29, argument_list; 29, 30; 29, 31; 29, 32; 29, 35; 30, identifier:start; 31, identifier:end; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:step; 34, identifier:step; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:kind; 37, identifier:kind; 38, comment; 39, if_statement; 39, 40; 39, 45; 40, not_operator; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:is_scalar; 43, argument_list; 43, 44; 44, identifier:start_slice; 45, block; 45, 46; 46, raise_statement; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:AssertionError; 49, argument_list; 49, 50; 50, string:"Start slice bound is non-scalar"; 51, if_statement; 51, 52; 51, 57; 52, not_operator; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:is_scalar; 55, argument_list; 55, 56; 56, identifier:end_slice; 57, block; 57, 58; 58, raise_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:AssertionError; 61, argument_list; 61, 62; 62, string:"End slice bound is non-scalar"; 63, return_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:slice; 66, argument_list; 66, 67; 66, 68; 66, 69; 67, identifier:start_slice; 68, identifier:end_slice; 69, identifier:step | def slice_indexer(self, start=None, end=None, step=None, kind=None):
"""
For an ordered or unique index, compute the slice indexer for input
labels and step.
Parameters
----------
start : label, default None
If None, defaults to the beginning
end : label, default None
If None, defaults to the end
step : int, default None
kind : string, default None
Returns
-------
indexer : slice
Raises
------
KeyError : If key does not exist, or key is not unique and index is
not ordered.
Notes
-----
This function assumes that the data is sorted, so use at your own peril
Examples
---------
This is a method on all index types. For example you can do:
>>> idx = pd.Index(list('abcd'))
>>> idx.slice_indexer(start='b', end='c')
slice(1, 3)
>>> idx = pd.MultiIndex.from_arrays([list('abcd'), list('efgh')])
>>> idx.slice_indexer(start='b', end=('c', 'g'))
slice(1, 3)
"""
start_slice, end_slice = self.slice_locs(start, end, step=step,
kind=kind)
# return a slice
if not is_scalar(start_slice):
raise AssertionError("Start slice bound is non-scalar")
if not is_scalar(end_slice):
raise AssertionError("End slice bound is non-scalar")
return slice(start_slice, end_slice, step) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_set_grouper; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:obj; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, False; 9, block; 9, 10; 9, 12; 9, 30; 9, 31; 9, 46; 9, 47; 9, 208; 9, 209; 9, 264; 9, 270; 9, 276; 10, expression_statement; 10, 11; 11, comment; 12, if_statement; 12, 13; 12, 24; 13, boolean_operator:and; 13, 14; 13, 19; 14, comparison_operator:is; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:key; 18, None; 19, comparison_operator:is; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:level; 23, None; 24, block; 24, 25; 25, raise_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:ValueError; 28, argument_list; 28, 29; 29, string:"The Grouper cannot specify both a key and a level!"; 30, comment; 31, if_statement; 31, 32; 31, 37; 32, comparison_operator:is; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:_grouper; 36, None; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_grouper; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:grouper; 46, comment; 47, if_statement; 47, 48; 47, 53; 47, 124; 48, comparison_operator:is; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:key; 52, None; 53, block; 53, 54; 53, 60; 53, 61; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:key; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:key; 60, comment; 61, if_statement; 61, 62; 61, 79; 61, 93; 62, parenthesized_expression; 62, 63; 63, boolean_operator:and; 63, 64; 63, 74; 64, comparison_operator:==; 64, 65; 64, 73; 65, call; 65, 66; 65, 67; 66, identifier:getattr; 67, argument_list; 67, 68; 67, 71; 67, 72; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:grouper; 71, string:'name'; 72, None; 73, identifier:key; 74, call; 74, 75; 74, 76; 75, identifier:isinstance; 76, argument_list; 76, 77; 76, 78; 77, identifier:obj; 78, identifier:ABCSeries; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:ax; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:_grouper; 88, identifier:take; 89, argument_list; 89, 90; 90, attribute; 90, 91; 90, 92; 91, identifier:obj; 92, identifier:index; 93, else_clause; 93, 94; 94, block; 94, 95; 94, 112; 95, if_statement; 95, 96; 95, 101; 96, comparison_operator:not; 96, 97; 96, 98; 97, identifier:key; 98, attribute; 98, 99; 98, 100; 99, identifier:obj; 100, identifier:_info_axis; 101, block; 101, 102; 102, raise_statement; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:KeyError; 105, argument_list; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, string:"The grouper name {0} is not found"; 109, identifier:format; 110, argument_list; 110, 111; 111, identifier:key; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:ax; 115, call; 115, 116; 115, 117; 116, identifier:Index; 117, argument_list; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:obj; 120, identifier:key; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:name; 123, identifier:key; 124, else_clause; 124, 125; 125, block; 125, 126; 125, 137; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:ax; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:obj; 132, identifier:_get_axis; 133, argument_list; 133, 134; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:axis; 137, if_statement; 137, 138; 137, 143; 138, comparison_operator:is; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:level; 142, None; 143, block; 143, 144; 143, 150; 143, 151; 143, 152; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:level; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:level; 150, comment; 151, comment; 152, if_statement; 152, 153; 152, 158; 152, 187; 153, call; 153, 154; 153, 155; 154, identifier:isinstance; 155, argument_list; 155, 156; 155, 157; 156, identifier:ax; 157, identifier:MultiIndex; 158, block; 158, 159; 158, 168; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:level; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:ax; 165, identifier:_get_level_number; 166, argument_list; 166, 167; 167, identifier:level; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:ax; 171, call; 171, 172; 171, 173; 172, identifier:Index; 173, argument_list; 173, 174; 173, 180; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:ax; 177, identifier:_get_level_values; 178, argument_list; 178, 179; 179, identifier:level; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:name; 182, subscript; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:ax; 185, identifier:names; 186, identifier:level; 187, else_clause; 187, 188; 188, block; 188, 189; 189, if_statement; 189, 190; 189, 197; 190, comparison_operator:not; 190, 191; 190, 192; 191, identifier:level; 192, tuple; 192, 193; 192, 194; 193, integer:0; 194, attribute; 194, 195; 194, 196; 195, identifier:ax; 196, identifier:name; 197, block; 197, 198; 198, raise_statement; 198, 199; 199, call; 199, 200; 199, 201; 200, identifier:ValueError; 201, argument_list; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, string:"The level {0} is not valid"; 205, identifier:format; 206, argument_list; 206, 207; 207, identifier:level; 208, comment; 209, if_statement; 209, 210; 209, 221; 209, 222; 210, boolean_operator:and; 210, 211; 210, 217; 211, parenthesized_expression; 211, 212; 212, boolean_operator:or; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:self; 215, identifier:sort; 216, identifier:sort; 217, not_operator; 217, 218; 218, attribute; 218, 219; 218, 220; 219, identifier:ax; 220, identifier:is_monotonic; 221, comment; 222, block; 222, 223; 222, 238; 222, 247; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:indexer; 226, assignment; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:indexer; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:ax; 233, identifier:argsort; 234, argument_list; 234, 235; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:kind; 237, string:'mergesort'; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:ax; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:ax; 244, identifier:take; 245, argument_list; 245, 246; 246, identifier:indexer; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:obj; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:obj; 253, identifier:_take; 254, argument_list; 254, 255; 254, 256; 254, 261; 255, identifier:indexer; 256, keyword_argument; 256, 257; 256, 258; 257, identifier:axis; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:axis; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:is_copy; 263, False; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:self; 268, identifier:obj; 269, identifier:obj; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:self; 274, identifier:grouper; 275, identifier:ax; 276, return_statement; 276, 277; 277, attribute; 277, 278; 277, 279; 278, identifier:self; 279, identifier:grouper | def _set_grouper(self, obj, sort=False):
"""
given an object and the specifications, setup the internal grouper
for this particular specification
Parameters
----------
obj : the subject object
sort : bool, default False
whether the resulting grouper should be sorted
"""
if self.key is not None and self.level is not None:
raise ValueError(
"The Grouper cannot specify both a key and a level!")
# Keep self.grouper value before overriding
if self._grouper is None:
self._grouper = self.grouper
# the key must be a valid info item
if self.key is not None:
key = self.key
# The 'on' is already defined
if (getattr(self.grouper, 'name', None) == key and
isinstance(obj, ABCSeries)):
ax = self._grouper.take(obj.index)
else:
if key not in obj._info_axis:
raise KeyError(
"The grouper name {0} is not found".format(key))
ax = Index(obj[key], name=key)
else:
ax = obj._get_axis(self.axis)
if self.level is not None:
level = self.level
# if a level is given it must be a mi level or
# equivalent to the axis name
if isinstance(ax, MultiIndex):
level = ax._get_level_number(level)
ax = Index(ax._get_level_values(level),
name=ax.names[level])
else:
if level not in (0, ax.name):
raise ValueError(
"The level {0} is not valid".format(level))
# possibly sort
if (self.sort or sort) and not ax.is_monotonic:
# use stable sort to support first, last, nth
indexer = self.indexer = ax.argsort(kind='mergesort')
ax = ax.take(indexer)
obj = obj._take(indexer, axis=self.axis, is_copy=False)
self.obj = obj
self.grouper = ax
return self.grouper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:_from_derivatives; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:xi; 5, identifier:yi; 6, identifier:x; 7, default_parameter; 7, 8; 7, 9; 8, identifier:order; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:der; 12, integer:0; 13, default_parameter; 13, 14; 13, 15; 14, identifier:extrapolate; 15, False; 16, block; 16, 17; 16, 19; 16, 24; 16, 25; 16, 33; 16, 54; 17, expression_statement; 17, 18; 18, comment; 19, import_from_statement; 19, 20; 19, 22; 20, dotted_name; 20, 21; 21, identifier:scipy; 22, dotted_name; 22, 23; 23, identifier:interpolate; 24, comment; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:method; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:interpolate; 31, identifier:BPoly; 32, identifier:from_derivatives; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:m; 36, call; 36, 37; 36, 38; 37, identifier:method; 38, argument_list; 38, 39; 38, 40; 38, 48; 38, 51; 39, identifier:xi; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:yi; 43, identifier:reshape; 44, argument_list; 44, 45; 44, 47; 45, unary_operator:-; 45, 46; 46, integer:1; 47, integer:1; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:orders; 50, identifier:order; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:extrapolate; 53, identifier:extrapolate; 54, return_statement; 54, 55; 55, call; 55, 56; 55, 57; 56, identifier:m; 57, argument_list; 57, 58; 58, identifier:x | def _from_derivatives(xi, yi, x, order=None, der=0, extrapolate=False):
"""
Convenience function for interpolate.BPoly.from_derivatives.
Construct a piecewise polynomial in the Bernstein basis, compatible
with the specified values and derivatives at breakpoints.
Parameters
----------
xi : array_like
sorted 1D array of x-coordinates
yi : array_like or list of array-likes
yi[i][j] is the j-th derivative known at xi[i]
order: None or int or array_like of ints. Default: None.
Specifies the degree of local polynomials. If not None, some
derivatives are ignored.
der : int or list
How many derivatives to extract; None for all potentially nonzero
derivatives (that is a number equal to the number of points), or a
list of derivatives to extract. This numberincludes the function
value as 0th derivative.
extrapolate : bool, optional
Whether to extrapolate to ouf-of-bounds points based on first and last
intervals, or to return NaNs. Default: True.
See Also
--------
scipy.interpolate.BPoly.from_derivatives
Returns
-------
y : scalar or array_like
The result, of length R or length M or M by R.
"""
from scipy import interpolate
# return the method for compat with scipy version & backwards compat
method = interpolate.BPoly.from_derivatives
m = method(xi, yi.reshape(-1, 1),
orders=order, extrapolate=extrapolate)
return m(x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:recode_for_groupby; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:c; 5, identifier:sort; 6, identifier:observed; 7, block; 7, 8; 7, 10; 7, 11; 7, 98; 7, 99; 7, 106; 7, 107; 7, 115; 7, 116; 7, 117; 7, 118; 7, 141; 8, expression_statement; 8, 9; 9, comment; 10, comment; 11, if_statement; 11, 12; 11, 13; 12, identifier:observed; 13, block; 13, 14; 13, 23; 13, 32; 13, 46; 13, 47; 13, 58; 13, 71; 13, 72; 13, 73; 13, 85; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:unique_codes; 17, call; 17, 18; 17, 19; 18, identifier:unique1d; 19, argument_list; 19, 20; 20, attribute; 20, 21; 20, 22; 21, identifier:c; 22, identifier:codes; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:take_codes; 26, subscript; 26, 27; 26, 28; 27, identifier:unique_codes; 28, comparison_operator:!=; 28, 29; 28, 30; 29, identifier:unique_codes; 30, unary_operator:-; 30, 31; 31, integer:1; 32, if_statement; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:c; 35, identifier:ordered; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:take_codes; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:sort; 44, argument_list; 44, 45; 45, identifier:take_codes; 46, comment; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:categories; 50, call; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:c; 54, identifier:categories; 55, identifier:take; 56, argument_list; 56, 57; 57, identifier:take_codes; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:codes; 61, call; 61, 62; 61, 63; 62, identifier:_recode_for_categories; 63, argument_list; 63, 64; 63, 67; 63, 70; 64, attribute; 64, 65; 64, 66; 65, identifier:c; 66, identifier:codes; 67, attribute; 67, 68; 67, 69; 68, identifier:c; 69, identifier:categories; 70, identifier:categories; 71, comment; 72, comment; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:dtype; 76, call; 76, 77; 76, 78; 77, identifier:CategoricalDtype; 78, argument_list; 78, 79; 78, 80; 79, identifier:categories; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:ordered; 82, attribute; 82, 83; 82, 84; 83, identifier:c; 84, identifier:ordered; 85, return_statement; 85, 86; 86, expression_list; 86, 87; 86, 97; 87, call; 87, 88; 87, 89; 88, identifier:Categorical; 89, argument_list; 89, 90; 89, 91; 89, 94; 90, identifier:codes; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:dtype; 93, identifier:dtype; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:fastpath; 96, True; 97, identifier:c; 98, comment; 99, if_statement; 99, 100; 99, 101; 100, identifier:sort; 101, block; 101, 102; 102, return_statement; 102, 103; 103, expression_list; 103, 104; 103, 105; 104, identifier:c; 105, None; 106, comment; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:cat; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:c; 113, identifier:unique; 114, argument_list; 115, comment; 116, comment; 117, comment; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:cat; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:cat; 124, identifier:add_categories; 125, argument_list; 125, 126; 126, subscript; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:c; 129, identifier:categories; 130, unary_operator:~; 130, 131; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:c; 135, identifier:categories; 136, identifier:isin; 137, argument_list; 137, 138; 138, attribute; 138, 139; 138, 140; 139, identifier:cat; 140, identifier:categories; 141, return_statement; 141, 142; 142, expression_list; 142, 143; 142, 151; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:c; 146, identifier:reorder_categories; 147, argument_list; 147, 148; 148, attribute; 148, 149; 148, 150; 149, identifier:cat; 150, identifier:categories; 151, None | def recode_for_groupby(c, sort, observed):
"""
Code the categories to ensure we can groupby for categoricals.
If observed=True, we return a new Categorical with the observed
categories only.
If sort=False, return a copy of self, coded with categories as
returned by .unique(), followed by any categories not appearing in
the data. If sort=True, return self.
This method is needed solely to ensure the categorical index of the
GroupBy result has categories in the order of appearance in the data
(GH-8868).
Parameters
----------
c : Categorical
sort : boolean
The value of the sort parameter groupby was called with.
observed : boolean
Account only for the observed values
Returns
-------
New Categorical
If sort=False, the new categories are set to the order of
appearance in codes (unless ordered=True, in which case the
original order is preserved), followed by any unrepresented
categories in the original order.
Categorical or None
If we are observed, return the original categorical, otherwise None
"""
# we only care about observed values
if observed:
unique_codes = unique1d(c.codes)
take_codes = unique_codes[unique_codes != -1]
if c.ordered:
take_codes = np.sort(take_codes)
# we recode according to the uniques
categories = c.categories.take(take_codes)
codes = _recode_for_categories(c.codes,
c.categories,
categories)
# return a new categorical that maps our new codes
# and categories
dtype = CategoricalDtype(categories, ordered=c.ordered)
return Categorical(codes, dtype=dtype, fastpath=True), c
# Already sorted according to c.categories; all is fine
if sort:
return c, None
# sort=False should order groups in as-encountered order (GH-8868)
cat = c.unique()
# But for groupby to work, all categories should be present,
# including those missing from the data (GH-13179), which .unique()
# above dropped
cat = cat.add_categories(
c.categories[~c.categories.isin(cat.categories)])
return c.reorder_categories(cat.categories), None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:generate_bins_generic; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:values; 5, identifier:binner; 6, identifier:closed; 7, block; 7, 8; 7, 10; 7, 17; 7, 24; 7, 38; 7, 39; 7, 53; 7, 71; 7, 87; 7, 91; 7, 92; 7, 96; 7, 97; 7, 98; 7, 154; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:lenidx; 13, call; 13, 14; 13, 15; 14, identifier:len; 15, argument_list; 15, 16; 16, identifier:values; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:lenbin; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, identifier:binner; 24, if_statement; 24, 25; 24, 32; 25, boolean_operator:or; 25, 26; 25, 29; 26, comparison_operator:<=; 26, 27; 26, 28; 27, identifier:lenidx; 28, integer:0; 29, comparison_operator:<=; 29, 30; 29, 31; 30, identifier:lenbin; 31, integer:0; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:ValueError; 36, argument_list; 36, 37; 37, string:"Invalid length for values or for binner"; 38, comment; 39, if_statement; 39, 40; 39, 47; 40, comparison_operator:<; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:values; 43, integer:0; 44, subscript; 44, 45; 44, 46; 45, identifier:binner; 46, integer:0; 47, block; 47, 48; 48, raise_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:ValueError; 51, argument_list; 51, 52; 52, string:"Values falls before first bin"; 53, if_statement; 53, 54; 53, 65; 54, comparison_operator:>; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 57; 56, identifier:values; 57, binary_operator:-; 57, 58; 57, 59; 58, identifier:lenidx; 59, integer:1; 60, subscript; 60, 61; 60, 62; 61, identifier:binner; 62, binary_operator:-; 62, 63; 62, 64; 63, identifier:lenbin; 64, integer:1; 65, block; 65, 66; 66, raise_statement; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:ValueError; 69, argument_list; 69, 70; 70, string:"Values falls after last bin"; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:bins; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:np; 77, identifier:empty; 78, argument_list; 78, 79; 78, 82; 79, binary_operator:-; 79, 80; 79, 81; 80, identifier:lenbin; 81, integer:1; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:dtype; 84, attribute; 84, 85; 84, 86; 85, identifier:np; 86, identifier:int64; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:j; 90, integer:0; 91, comment; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:bc; 95, integer:0; 96, comment; 97, comment; 98, for_statement; 98, 99; 98, 100; 98, 107; 99, identifier:i; 100, call; 100, 101; 100, 102; 101, identifier:range; 102, argument_list; 102, 103; 102, 104; 103, integer:0; 104, binary_operator:-; 104, 105; 104, 106; 105, identifier:lenbin; 106, integer:1; 107, block; 107, 108; 107, 116; 107, 117; 107, 144; 107, 150; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:r_bin; 111, subscript; 111, 112; 111, 113; 112, identifier:binner; 113, binary_operator:+; 113, 114; 113, 115; 114, identifier:i; 115, integer:1; 116, comment; 117, while_statement; 117, 118; 117, 139; 118, boolean_operator:and; 118, 119; 118, 122; 119, comparison_operator:<; 119, 120; 119, 121; 120, identifier:j; 121, identifier:lenidx; 122, parenthesized_expression; 122, 123; 123, boolean_operator:or; 123, 124; 123, 129; 124, comparison_operator:<; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:values; 127, identifier:j; 128, identifier:r_bin; 129, parenthesized_expression; 129, 130; 130, boolean_operator:and; 130, 131; 130, 134; 131, comparison_operator:==; 131, 132; 131, 133; 132, identifier:closed; 133, string:'right'; 134, comparison_operator:==; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:values; 137, identifier:j; 138, identifier:r_bin; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, augmented_assignment:+=; 141, 142; 141, 143; 142, identifier:j; 143, integer:1; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:bins; 148, identifier:bc; 149, identifier:j; 150, expression_statement; 150, 151; 151, augmented_assignment:+=; 151, 152; 151, 153; 152, identifier:bc; 153, integer:1; 154, return_statement; 154, 155; 155, identifier:bins | def generate_bins_generic(values, binner, closed):
"""
Generate bin edge offsets and bin labels for one array using another array
which has bin edge values. Both arrays must be sorted.
Parameters
----------
values : array of values
binner : a comparable array of values representing bins into which to bin
the first array. Note, 'values' end-points must fall within 'binner'
end-points.
closed : which end of bin is closed; left (default), right
Returns
-------
bins : array of offsets (into 'values' argument) of bins.
Zero and last edge are excluded in result, so for instance the first
bin is values[0:bin[0]] and the last is values[bin[-1]:]
"""
lenidx = len(values)
lenbin = len(binner)
if lenidx <= 0 or lenbin <= 0:
raise ValueError("Invalid length for values or for binner")
# check binner fits data
if values[0] < binner[0]:
raise ValueError("Values falls before first bin")
if values[lenidx - 1] > binner[lenbin - 1]:
raise ValueError("Values falls after last bin")
bins = np.empty(lenbin - 1, dtype=np.int64)
j = 0 # index into values
bc = 0 # bin count
# linear scan, presume nothing about values/binner except that it fits ok
for i in range(0, lenbin - 1):
r_bin = binner[i + 1]
# count values in current bin, advance to next bin
while j < lenidx and (values[j] < r_bin or
(closed == 'right' and values[j] == r_bin)):
j += 1
bins[bc] = j
bc += 1
return bins |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:wide_to_long; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 4, identifier:df; 5, identifier:stubnames; 6, identifier:i; 7, identifier:j; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sep; 10, string:""; 11, default_parameter; 11, 12; 11, 13; 12, identifier:suffix; 13, string:r'\d+'; 14, block; 14, 15; 14, 17; 14, 76; 14, 169; 14, 190; 14, 208; 14, 229; 14, 247; 14, 261; 14, 272; 14, 293; 14, 315; 14, 333; 14, 359; 14, 385; 15, expression_statement; 15, 16; 16, comment; 17, function_definition; 17, 18; 17, 19; 17, 24; 18, function_name:get_var_names; 19, parameters; 19, 20; 19, 21; 19, 22; 19, 23; 20, identifier:df; 21, identifier:stub; 22, identifier:sep; 23, identifier:suffix; 24, block; 24, 25; 24, 52; 24, 61; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:regex; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, string:r'^{stub}{sep}{suffix}$'; 31, identifier:format; 32, argument_list; 32, 33; 32, 41; 32, 49; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:stub; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:re; 38, identifier:escape; 39, argument_list; 39, 40; 40, identifier:stub; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:sep; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:re; 46, identifier:escape; 47, argument_list; 47, 48; 48, identifier:sep; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:suffix; 51, identifier:suffix; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:pattern; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:re; 58, identifier:compile; 59, argument_list; 59, 60; 60, identifier:regex; 61, return_statement; 61, 62; 62, list_comprehension; 62, 63; 62, 64; 62, 69; 63, identifier:col; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:col; 66, attribute; 66, 67; 66, 68; 67, identifier:df; 68, identifier:columns; 69, if_clause; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:pattern; 73, identifier:match; 74, argument_list; 74, 75; 75, identifier:col; 76, function_definition; 76, 77; 76, 78; 76, 85; 77, function_name:melt_stub; 78, parameters; 78, 79; 78, 80; 78, 81; 78, 82; 78, 83; 78, 84; 79, identifier:df; 80, identifier:stub; 81, identifier:i; 82, identifier:j; 83, identifier:value_vars; 84, identifier:sep; 85, block; 85, 86; 85, 110; 85, 121; 85, 144; 85, 145; 85, 159; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:newdf; 89, call; 89, 90; 89, 91; 90, identifier:melt; 91, argument_list; 91, 92; 91, 93; 91, 96; 91, 99; 91, 107; 92, identifier:df; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:id_vars; 95, identifier:i; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:value_vars; 98, identifier:value_vars; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:value_name; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:stub; 104, identifier:rstrip; 105, argument_list; 105, 106; 106, identifier:sep; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:var_name; 109, identifier:j; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:newdf; 114, identifier:j; 115, call; 115, 116; 115, 117; 116, identifier:Categorical; 117, argument_list; 117, 118; 118, subscript; 118, 119; 118, 120; 119, identifier:newdf; 120, identifier:j; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:newdf; 125, identifier:j; 126, call; 126, 127; 126, 134; 127, attribute; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:newdf; 131, identifier:j; 132, identifier:str; 133, identifier:replace; 134, argument_list; 134, 135; 134, 143; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:re; 138, identifier:escape; 139, argument_list; 139, 140; 140, binary_operator:+; 140, 141; 140, 142; 141, identifier:stub; 142, identifier:sep; 143, string:""; 144, comment; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:newdf; 149, identifier:j; 150, call; 150, 151; 150, 152; 151, identifier:to_numeric; 152, argument_list; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:newdf; 155, identifier:j; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:errors; 158, string:'ignore'; 159, return_statement; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:newdf; 163, identifier:set_index; 164, argument_list; 164, 165; 165, binary_operator:+; 165, 166; 165, 167; 166, identifier:i; 167, list:[j]; 167, 168; 168, identifier:j; 169, if_statement; 169, 170; 169, 175; 169, 181; 170, not_operator; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:is_list_like; 173, argument_list; 173, 174; 174, identifier:stubnames; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:stubnames; 179, list:[stubnames]; 179, 180; 180, identifier:stubnames; 181, else_clause; 181, 182; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:stubnames; 186, call; 186, 187; 186, 188; 187, identifier:list; 188, argument_list; 188, 189; 189, identifier:stubnames; 190, if_statement; 190, 191; 190, 202; 191, call; 191, 192; 191, 193; 192, identifier:any; 193, generator_expression; 193, 194; 193, 197; 194, comparison_operator:in; 194, 195; 194, 196; 195, identifier:col; 196, identifier:stubnames; 197, for_in_clause; 197, 198; 197, 199; 198, identifier:col; 199, attribute; 199, 200; 199, 201; 200, identifier:df; 201, identifier:columns; 202, block; 202, 203; 203, raise_statement; 203, 204; 204, call; 204, 205; 204, 206; 205, identifier:ValueError; 206, argument_list; 206, 207; 207, string:"stubname can't be identical to a column name"; 208, if_statement; 208, 209; 208, 214; 208, 220; 209, not_operator; 209, 210; 210, call; 210, 211; 210, 212; 211, identifier:is_list_like; 212, argument_list; 212, 213; 213, identifier:i; 214, block; 214, 215; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:i; 218, list:[i]; 218, 219; 219, identifier:i; 220, else_clause; 220, 221; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:i; 225, call; 225, 226; 225, 227; 226, identifier:list; 227, argument_list; 227, 228; 228, identifier:i; 229, if_statement; 229, 230; 229, 241; 230, call; 230, 231; 230, 240; 231, attribute; 231, 232; 231, 239; 232, call; 232, 233; 232, 238; 233, attribute; 233, 234; 233, 237; 234, subscript; 234, 235; 234, 236; 235, identifier:df; 236, identifier:i; 237, identifier:duplicated; 238, argument_list; 239, identifier:any; 240, argument_list; 241, block; 241, 242; 242, raise_statement; 242, 243; 243, call; 243, 244; 243, 245; 244, identifier:ValueError; 245, argument_list; 245, 246; 246, string:"the id variables need to uniquely identify each row"; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:value_vars; 250, list_comprehension; 250, 251; 250, 258; 251, call; 251, 252; 251, 253; 252, identifier:get_var_names; 253, argument_list; 253, 254; 253, 255; 253, 256; 253, 257; 254, identifier:df; 255, identifier:stub; 256, identifier:sep; 257, identifier:suffix; 258, for_in_clause; 258, 259; 258, 260; 259, identifier:stub; 260, identifier:stubnames; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:value_vars_flattened; 264, list_comprehension; 264, 265; 264, 266; 264, 269; 265, identifier:e; 266, for_in_clause; 266, 267; 266, 268; 267, identifier:sublist; 268, identifier:value_vars; 269, for_in_clause; 269, 270; 269, 271; 270, identifier:e; 271, identifier:sublist; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:id_vars; 275, call; 275, 276; 275, 277; 276, identifier:list; 277, argument_list; 277, 278; 278, call; 278, 279; 278, 291; 279, attribute; 279, 280; 279, 290; 280, call; 280, 281; 280, 282; 281, identifier:set; 282, argument_list; 282, 283; 283, call; 283, 284; 283, 289; 284, attribute; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:df; 287, identifier:columns; 288, identifier:tolist; 289, argument_list; 290, identifier:difference; 291, argument_list; 291, 292; 292, identifier:value_vars_flattened; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:melted; 296, list_comprehension; 296, 297; 296, 306; 297, call; 297, 298; 297, 299; 298, identifier:melt_stub; 299, argument_list; 299, 300; 299, 301; 299, 302; 299, 303; 299, 304; 299, 305; 300, identifier:df; 301, identifier:s; 302, identifier:i; 303, identifier:j; 304, identifier:v; 305, identifier:sep; 306, for_in_clause; 306, 307; 306, 310; 307, pattern_list; 307, 308; 307, 309; 308, identifier:s; 309, identifier:v; 310, call; 310, 311; 310, 312; 311, identifier:zip; 312, argument_list; 312, 313; 312, 314; 313, identifier:stubnames; 314, identifier:value_vars; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:melted; 318, call; 318, 319; 318, 324; 319, attribute; 319, 320; 319, 323; 320, subscript; 320, 321; 320, 322; 321, identifier:melted; 322, integer:0; 323, identifier:join; 324, argument_list; 324, 325; 324, 330; 325, subscript; 325, 326; 325, 327; 326, identifier:melted; 327, slice; 327, 328; 327, 329; 328, integer:1; 329, colon; 330, keyword_argument; 330, 331; 330, 332; 331, identifier:how; 332, string:'outer'; 333, if_statement; 333, 334; 333, 340; 334, comparison_operator:==; 334, 335; 334, 339; 335, call; 335, 336; 335, 337; 336, identifier:len; 337, argument_list; 337, 338; 338, identifier:i; 339, integer:1; 340, block; 340, 341; 340, 357; 341, expression_statement; 341, 342; 342, assignment; 342, 343; 342, 344; 343, identifier:new; 344, call; 344, 345; 344, 355; 345, attribute; 345, 346; 345, 354; 346, call; 346, 347; 346, 352; 347, attribute; 347, 348; 347, 351; 348, subscript; 348, 349; 348, 350; 349, identifier:df; 350, identifier:id_vars; 351, identifier:set_index; 352, argument_list; 352, 353; 353, identifier:i; 354, identifier:join; 355, argument_list; 355, 356; 356, identifier:melted; 357, return_statement; 357, 358; 358, identifier:new; 359, expression_statement; 359, 360; 360, assignment; 360, 361; 360, 362; 361, identifier:new; 362, call; 362, 363; 362, 380; 363, attribute; 363, 364; 363, 379; 364, call; 364, 365; 364, 370; 365, attribute; 365, 366; 365, 369; 366, subscript; 366, 367; 366, 368; 367, identifier:df; 368, identifier:id_vars; 369, identifier:merge; 370, argument_list; 370, 371; 370, 376; 371, call; 371, 372; 371, 375; 372, attribute; 372, 373; 372, 374; 373, identifier:melted; 374, identifier:reset_index; 375, argument_list; 376, keyword_argument; 376, 377; 376, 378; 377, identifier:on; 378, identifier:i; 379, identifier:set_index; 380, argument_list; 380, 381; 381, binary_operator:+; 381, 382; 381, 383; 382, identifier:i; 383, list:[j]; 383, 384; 384, identifier:j; 385, return_statement; 385, 386; 386, identifier:new | def wide_to_long(df, stubnames, i, j, sep="", suffix=r'\d+'):
r"""
Wide panel to long format. Less flexible but more user-friendly than melt.
With stubnames ['A', 'B'], this function expects to find one or more
group of columns with format
A-suffix1, A-suffix2,..., B-suffix1, B-suffix2,...
You specify what you want to call this suffix in the resulting long format
with `j` (for example `j='year'`)
Each row of these wide variables are assumed to be uniquely identified by
`i` (can be a single column name or a list of column names)
All remaining variables in the data frame are left intact.
Parameters
----------
df : DataFrame
The wide-format DataFrame
stubnames : str or list-like
The stub name(s). The wide format variables are assumed to
start with the stub names.
i : str or list-like
Column(s) to use as id variable(s)
j : str
The name of the sub-observation variable. What you wish to name your
suffix in the long format.
sep : str, default ""
A character indicating the separation of the variable names
in the wide format, to be stripped from the names in the long format.
For example, if your column names are A-suffix1, A-suffix2, you
can strip the hyphen by specifying `sep='-'`
.. versionadded:: 0.20.0
suffix : str, default '\\d+'
A regular expression capturing the wanted suffixes. '\\d+' captures
numeric suffixes. Suffixes with no numbers could be specified with the
negated character class '\\D+'. You can also further disambiguate
suffixes, for example, if your wide variables are of the form
A-one, B-two,.., and you have an unrelated column A-rating, you can
ignore the last one by specifying `suffix='(!?one|two)'`
.. versionadded:: 0.20.0
.. versionchanged:: 0.23.0
When all suffixes are numeric, they are cast to int64/float64.
Returns
-------
DataFrame
A DataFrame that contains each stub name as a variable, with new index
(i, j).
Notes
-----
All extra variables are left untouched. This simply uses
`pandas.melt` under the hood, but is hard-coded to "do the right thing"
in a typical case.
Examples
--------
>>> np.random.seed(123)
>>> df = pd.DataFrame({"A1970" : {0 : "a", 1 : "b", 2 : "c"},
... "A1980" : {0 : "d", 1 : "e", 2 : "f"},
... "B1970" : {0 : 2.5, 1 : 1.2, 2 : .7},
... "B1980" : {0 : 3.2, 1 : 1.3, 2 : .1},
... "X" : dict(zip(range(3), np.random.randn(3)))
... })
>>> df["id"] = df.index
>>> df
A1970 A1980 B1970 B1980 X id
0 a d 2.5 3.2 -1.085631 0
1 b e 1.2 1.3 0.997345 1
2 c f 0.7 0.1 0.282978 2
>>> pd.wide_to_long(df, ["A", "B"], i="id", j="year")
... # doctest: +NORMALIZE_WHITESPACE
X A B
id year
0 1970 -1.085631 a 2.5
1 1970 0.997345 b 1.2
2 1970 0.282978 c 0.7
0 1980 -1.085631 d 3.2
1 1980 0.997345 e 1.3
2 1980 0.282978 f 0.1
With multiple id columns
>>> df = pd.DataFrame({
... 'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
... 'ht1': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
... 'ht2': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
... })
>>> df
birth famid ht1 ht2
0 1 1 2.8 3.4
1 2 1 2.9 3.8
2 3 1 2.2 2.9
3 1 2 2.0 3.2
4 2 2 1.8 2.8
5 3 2 1.9 2.4
6 1 3 2.2 3.3
7 2 3 2.3 3.4
8 3 3 2.1 2.9
>>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age')
>>> l
... # doctest: +NORMALIZE_WHITESPACE
ht
famid birth age
1 1 1 2.8
2 3.4
2 1 2.9
2 3.8
3 1 2.2
2 2.9
2 1 1 2.0
2 3.2
2 1 1.8
2 2.8
3 1 1.9
2 2.4
3 1 1 2.2
2 3.3
2 1 2.3
2 3.4
3 1 2.1
2 2.9
Going from long back to wide just takes some creative use of `unstack`
>>> w = l.unstack()
>>> w.columns = w.columns.map('{0[0]}{0[1]}'.format)
>>> w.reset_index()
famid birth ht1 ht2
0 1 1 2.8 3.4
1 1 2 2.9 3.8
2 1 3 2.2 2.9
3 2 1 2.0 3.2
4 2 2 1.8 2.8
5 2 3 1.9 2.4
6 3 1 2.2 3.3
7 3 2 2.3 3.4
8 3 3 2.1 2.9
Less wieldy column names are also handled
>>> np.random.seed(0)
>>> df = pd.DataFrame({'A(quarterly)-2010': np.random.rand(3),
... 'A(quarterly)-2011': np.random.rand(3),
... 'B(quarterly)-2010': np.random.rand(3),
... 'B(quarterly)-2011': np.random.rand(3),
... 'X' : np.random.randint(3, size=3)})
>>> df['id'] = df.index
>>> df # doctest: +NORMALIZE_WHITESPACE, +ELLIPSIS
A(quarterly)-2010 A(quarterly)-2011 B(quarterly)-2010 ...
0 0.548814 0.544883 0.437587 ...
1 0.715189 0.423655 0.891773 ...
2 0.602763 0.645894 0.963663 ...
X id
0 0 0
1 1 1
2 1 2
>>> pd.wide_to_long(df, ['A(quarterly)', 'B(quarterly)'], i='id',
... j='year', sep='-')
... # doctest: +NORMALIZE_WHITESPACE
X A(quarterly) B(quarterly)
id year
0 2010 0 0.548814 0.437587
1 2010 1 0.715189 0.891773
2 2010 1 0.602763 0.963663
0 2011 0 0.544883 0.383442
1 2011 1 0.423655 0.791725
2 2011 1 0.645894 0.528895
If we have many columns, we could also use a regex to find our
stubnames and pass that list on to wide_to_long
>>> stubnames = sorted(
... set([match[0] for match in df.columns.str.findall(
... r'[A-B]\(.*\)').values if match != [] ])
... )
>>> list(stubnames)
['A(quarterly)', 'B(quarterly)']
All of the above examples have integers as suffixes. It is possible to
have non-integers as suffixes.
>>> df = pd.DataFrame({
... 'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
... 'ht_one': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
... 'ht_two': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
... })
>>> df
birth famid ht_one ht_two
0 1 1 2.8 3.4
1 2 1 2.9 3.8
2 3 1 2.2 2.9
3 1 2 2.0 3.2
4 2 2 1.8 2.8
5 3 2 1.9 2.4
6 1 3 2.2 3.3
7 2 3 2.3 3.4
8 3 3 2.1 2.9
>>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age',
sep='_', suffix='\w')
>>> l
... # doctest: +NORMALIZE_WHITESPACE
ht
famid birth age
1 1 one 2.8
two 3.4
2 one 2.9
two 3.8
3 one 2.2
two 2.9
2 1 one 2.0
two 3.2
2 one 1.8
two 2.8
3 one 1.9
two 2.4
3 1 one 2.2
two 3.3
2 one 2.3
two 3.4
3 one 2.1
two 2.9
"""
def get_var_names(df, stub, sep, suffix):
regex = r'^{stub}{sep}{suffix}$'.format(
stub=re.escape(stub), sep=re.escape(sep), suffix=suffix)
pattern = re.compile(regex)
return [col for col in df.columns if pattern.match(col)]
def melt_stub(df, stub, i, j, value_vars, sep):
newdf = melt(df, id_vars=i, value_vars=value_vars,
value_name=stub.rstrip(sep), var_name=j)
newdf[j] = Categorical(newdf[j])
newdf[j] = newdf[j].str.replace(re.escape(stub + sep), "")
# GH17627 Cast numerics suffixes to int/float
newdf[j] = to_numeric(newdf[j], errors='ignore')
return newdf.set_index(i + [j])
if not is_list_like(stubnames):
stubnames = [stubnames]
else:
stubnames = list(stubnames)
if any(col in stubnames for col in df.columns):
raise ValueError("stubname can't be identical to a column name")
if not is_list_like(i):
i = [i]
else:
i = list(i)
if df[i].duplicated().any():
raise ValueError("the id variables need to uniquely identify each row")
value_vars = [get_var_names(df, stub, sep, suffix) for stub in stubnames]
value_vars_flattened = [e for sublist in value_vars for e in sublist]
id_vars = list(set(df.columns.tolist()).difference(value_vars_flattened))
melted = [melt_stub(df, s, i, j, v, sep)
for s, v in zip(stubnames, value_vars)]
melted = melted[0].join(melted[1:], how='outer')
if len(i) == 1:
new = df[id_vars].set_index(i).join(melted)
return new
new = df[id_vars].merge(melted.reset_index(), on=i).set_index(i + [j])
return new |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:argsort; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 12; 9, 20; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:nv; 16, identifier:validate_argsort; 17, argument_list; 17, 18; 17, 19; 18, identifier:args; 19, identifier:kwargs; 20, if_statement; 20, 21; 20, 26; 20, 37; 21, comparison_operator:>; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_step; 25, integer:0; 26, block; 26, 27; 27, return_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:np; 31, identifier:arange; 32, argument_list; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:len; 35, argument_list; 35, 36; 36, identifier:self; 37, else_clause; 37, 38; 38, block; 38, 39; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:arange; 44, argument_list; 44, 45; 44, 51; 44, 53; 45, binary_operator:-; 45, 46; 45, 50; 46, call; 46, 47; 46, 48; 47, identifier:len; 48, argument_list; 48, 49; 49, identifier:self; 50, integer:1; 51, unary_operator:-; 51, 52; 52, integer:1; 53, unary_operator:-; 53, 54; 54, integer:1 | def argsort(self, *args, **kwargs):
"""
Returns the indices that would sort the index and its
underlying data.
Returns
-------
argsorted : numpy array
See Also
--------
numpy.ndarray.argsort
"""
nv.validate_argsort(args, kwargs)
if self._step > 0:
return np.arange(len(self))
else:
return np.arange(len(self) - 1, -1, -1) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:union; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, block; 9, 10; 9, 12; 9, 19; 9, 53; 9, 397; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_assert_can_do_setop; 17, argument_list; 17, 18; 18, identifier:other; 19, if_statement; 19, 20; 19, 40; 20, boolean_operator:or; 20, 21; 20, 34; 21, boolean_operator:or; 21, 22; 21, 28; 22, comparison_operator:==; 22, 23; 22, 27; 23, call; 23, 24; 23, 25; 24, identifier:len; 25, argument_list; 25, 26; 26, identifier:other; 27, integer:0; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:equals; 32, argument_list; 32, 33; 33, identifier:other; 34, comparison_operator:==; 34, 35; 34, 39; 35, call; 35, 36; 35, 37; 36, identifier:len; 37, argument_list; 37, 38; 38, identifier:self; 39, integer:0; 40, block; 40, 41; 41, return_statement; 41, 42; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, call; 44, 45; 44, 46; 45, identifier:super; 46, argument_list; 47, identifier:union; 48, argument_list; 48, 49; 48, 50; 49, identifier:other; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:sort; 52, identifier:sort; 53, if_statement; 53, 54; 53, 63; 54, boolean_operator:and; 54, 55; 54, 60; 55, call; 55, 56; 55, 57; 56, identifier:isinstance; 57, argument_list; 57, 58; 57, 59; 58, identifier:other; 59, identifier:RangeIndex; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:sort; 62, None; 63, block; 63, 64; 63, 76; 63, 94; 63, 106; 63, 124; 63, 142; 63, 160; 63, 214; 63, 222; 63, 230; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, pattern_list; 66, 67; 66, 68; 67, identifier:start_s; 68, identifier:step_s; 69, expression_list; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:_start; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:_step; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:end_s; 79, binary_operator:+; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:_start; 83, binary_operator:*; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:_step; 87, parenthesized_expression; 87, 88; 88, binary_operator:-; 88, 89; 88, 93; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, identifier:self; 93, integer:1; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, pattern_list; 96, 97; 96, 98; 97, identifier:start_o; 98, identifier:step_o; 99, expression_list; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:other; 102, identifier:_start; 103, attribute; 103, 104; 103, 105; 104, identifier:other; 105, identifier:_step; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:end_o; 109, binary_operator:+; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:other; 112, identifier:_start; 113, binary_operator:*; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:other; 116, identifier:_step; 117, parenthesized_expression; 117, 118; 118, binary_operator:-; 118, 119; 118, 123; 119, call; 119, 120; 119, 121; 120, identifier:len; 121, argument_list; 121, 122; 122, identifier:other; 123, integer:1; 124, if_statement; 124, 125; 124, 130; 125, comparison_operator:<; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:_step; 129, integer:0; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 137; 133, pattern_list; 133, 134; 133, 135; 133, 136; 134, identifier:start_s; 135, identifier:step_s; 136, identifier:end_s; 137, expression_list; 137, 138; 137, 139; 137, 141; 138, identifier:end_s; 139, unary_operator:-; 139, 140; 140, identifier:step_s; 141, identifier:start_s; 142, if_statement; 142, 143; 142, 148; 143, comparison_operator:<; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:other; 146, identifier:_step; 147, integer:0; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 155; 151, pattern_list; 151, 152; 151, 153; 151, 154; 152, identifier:start_o; 153, identifier:step_o; 154, identifier:end_o; 155, expression_list; 155, 156; 155, 157; 155, 159; 156, identifier:end_o; 157, unary_operator:-; 157, 158; 158, identifier:step_o; 159, identifier:start_o; 160, if_statement; 160, 161; 160, 174; 160, 190; 160, 202; 161, boolean_operator:and; 161, 162; 161, 168; 162, comparison_operator:==; 162, 163; 162, 167; 163, call; 163, 164; 163, 165; 164, identifier:len; 165, argument_list; 165, 166; 166, identifier:self; 167, integer:1; 168, comparison_operator:==; 168, 169; 168, 173; 169, call; 169, 170; 169, 171; 170, identifier:len; 171, argument_list; 171, 172; 172, identifier:other; 173, integer:1; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:step_s; 178, assignment; 178, 179; 178, 180; 179, identifier:step_o; 180, call; 180, 181; 180, 182; 181, identifier:abs; 182, argument_list; 182, 183; 183, binary_operator:-; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:_start; 187, attribute; 187, 188; 187, 189; 188, identifier:other; 189, identifier:_start; 190, elif_clause; 190, 191; 190, 197; 191, comparison_operator:==; 191, 192; 191, 196; 192, call; 192, 193; 192, 194; 193, identifier:len; 194, argument_list; 194, 195; 195, identifier:self; 196, integer:1; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:step_s; 201, identifier:step_o; 202, elif_clause; 202, 203; 202, 209; 203, comparison_operator:==; 203, 204; 203, 208; 204, call; 204, 205; 204, 206; 205, identifier:len; 206, argument_list; 206, 207; 207, identifier:other; 208, integer:1; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:step_o; 213, identifier:step_s; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:start_r; 217, call; 217, 218; 217, 219; 218, identifier:min; 219, argument_list; 219, 220; 219, 221; 220, identifier:start_s; 221, identifier:start_o; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:end_r; 225, call; 225, 226; 225, 227; 226, identifier:max; 227, argument_list; 227, 228; 227, 229; 228, identifier:end_s; 229, identifier:end_o; 230, if_statement; 230, 231; 230, 234; 230, 315; 230, 356; 231, comparison_operator:==; 231, 232; 231, 233; 232, identifier:step_o; 233, identifier:step_s; 234, block; 234, 235; 234, 269; 235, if_statement; 235, 236; 235, 259; 236, parenthesized_expression; 236, 237; 237, boolean_operator:and; 237, 238; 237, 253; 238, boolean_operator:and; 238, 239; 238, 247; 239, comparison_operator:==; 239, 240; 239, 246; 240, binary_operator:%; 240, 241; 240, 245; 241, parenthesized_expression; 241, 242; 242, binary_operator:-; 242, 243; 242, 244; 243, identifier:start_s; 244, identifier:start_o; 245, identifier:step_s; 246, integer:0; 247, comparison_operator:<=; 247, 248; 247, 252; 248, parenthesized_expression; 248, 249; 249, binary_operator:-; 249, 250; 249, 251; 250, identifier:start_s; 251, identifier:end_o; 252, identifier:step_s; 253, comparison_operator:<=; 253, 254; 253, 258; 254, parenthesized_expression; 254, 255; 255, binary_operator:-; 255, 256; 255, 257; 256, identifier:start_o; 257, identifier:end_s; 258, identifier:step_s; 259, block; 259, 260; 260, return_statement; 260, 261; 261, call; 261, 262; 261, 263; 262, identifier:RangeIndex; 263, argument_list; 263, 264; 263, 265; 263, 268; 264, identifier:start_r; 265, binary_operator:+; 265, 266; 265, 267; 266, identifier:end_r; 267, identifier:step_s; 268, identifier:step_s; 269, if_statement; 269, 270; 269, 301; 270, parenthesized_expression; 270, 271; 271, boolean_operator:and; 271, 272; 271, 290; 272, boolean_operator:and; 272, 273; 272, 279; 273, parenthesized_expression; 273, 274; 274, comparison_operator:==; 274, 275; 274, 278; 275, binary_operator:%; 275, 276; 275, 277; 276, identifier:step_s; 277, integer:2; 278, integer:0; 279, parenthesized_expression; 279, 280; 280, comparison_operator:<=; 280, 281; 280, 287; 281, call; 281, 282; 281, 283; 282, identifier:abs; 283, argument_list; 283, 284; 284, binary_operator:-; 284, 285; 284, 286; 285, identifier:start_s; 286, identifier:start_o; 287, binary_operator:/; 287, 288; 287, 289; 288, identifier:step_s; 289, integer:2; 290, parenthesized_expression; 290, 291; 291, comparison_operator:<=; 291, 292; 291, 298; 292, call; 292, 293; 292, 294; 293, identifier:abs; 294, argument_list; 294, 295; 295, binary_operator:-; 295, 296; 295, 297; 296, identifier:end_s; 297, identifier:end_o; 298, binary_operator:/; 298, 299; 298, 300; 299, identifier:step_s; 300, integer:2; 301, block; 301, 302; 302, return_statement; 302, 303; 303, call; 303, 304; 303, 305; 304, identifier:RangeIndex; 305, argument_list; 305, 306; 305, 307; 305, 312; 306, identifier:start_r; 307, binary_operator:+; 307, 308; 307, 309; 308, identifier:end_r; 309, binary_operator:/; 309, 310; 309, 311; 310, identifier:step_s; 311, integer:2; 312, binary_operator:/; 312, 313; 312, 314; 313, identifier:step_s; 314, integer:2; 315, elif_clause; 315, 316; 315, 321; 316, comparison_operator:==; 316, 317; 316, 320; 317, binary_operator:%; 317, 318; 317, 319; 318, identifier:step_o; 319, identifier:step_s; 320, integer:0; 321, block; 321, 322; 322, if_statement; 322, 323; 322, 346; 323, parenthesized_expression; 323, 324; 324, boolean_operator:and; 324, 325; 324, 340; 325, boolean_operator:and; 325, 326; 325, 334; 326, comparison_operator:==; 326, 327; 326, 333; 327, binary_operator:%; 327, 328; 327, 332; 328, parenthesized_expression; 328, 329; 329, binary_operator:-; 329, 330; 329, 331; 330, identifier:start_o; 331, identifier:start_s; 332, identifier:step_s; 333, integer:0; 334, parenthesized_expression; 334, 335; 335, comparison_operator:>=; 335, 336; 335, 339; 336, binary_operator:+; 336, 337; 336, 338; 337, identifier:start_o; 338, identifier:step_s; 339, identifier:start_s; 340, parenthesized_expression; 340, 341; 341, comparison_operator:<=; 341, 342; 341, 345; 342, binary_operator:-; 342, 343; 342, 344; 343, identifier:end_o; 344, identifier:step_s; 345, identifier:end_s; 346, block; 346, 347; 347, return_statement; 347, 348; 348, call; 348, 349; 348, 350; 349, identifier:RangeIndex; 350, argument_list; 350, 351; 350, 352; 350, 355; 351, identifier:start_r; 352, binary_operator:+; 352, 353; 352, 354; 353, identifier:end_r; 354, identifier:step_s; 355, identifier:step_s; 356, elif_clause; 356, 357; 356, 362; 357, comparison_operator:==; 357, 358; 357, 361; 358, binary_operator:%; 358, 359; 358, 360; 359, identifier:step_s; 360, identifier:step_o; 361, integer:0; 362, block; 362, 363; 363, if_statement; 363, 364; 363, 387; 364, parenthesized_expression; 364, 365; 365, boolean_operator:and; 365, 366; 365, 381; 366, boolean_operator:and; 366, 367; 366, 375; 367, comparison_operator:==; 367, 368; 367, 374; 368, binary_operator:%; 368, 369; 368, 373; 369, parenthesized_expression; 369, 370; 370, binary_operator:-; 370, 371; 370, 372; 371, identifier:start_s; 372, identifier:start_o; 373, identifier:step_o; 374, integer:0; 375, parenthesized_expression; 375, 376; 376, comparison_operator:>=; 376, 377; 376, 380; 377, binary_operator:+; 377, 378; 377, 379; 378, identifier:start_s; 379, identifier:step_o; 380, identifier:start_o; 381, parenthesized_expression; 381, 382; 382, comparison_operator:<=; 382, 383; 382, 386; 383, binary_operator:-; 383, 384; 383, 385; 384, identifier:end_s; 385, identifier:step_o; 386, identifier:end_o; 387, block; 387, 388; 388, return_statement; 388, 389; 389, call; 389, 390; 389, 391; 390, identifier:RangeIndex; 391, argument_list; 391, 392; 391, 393; 391, 396; 392, identifier:start_r; 393, binary_operator:+; 393, 394; 393, 395; 394, identifier:end_r; 395, identifier:step_o; 396, identifier:step_o; 397, return_statement; 397, 398; 398, call; 398, 399; 398, 404; 399, attribute; 399, 400; 399, 403; 400, attribute; 400, 401; 400, 402; 401, identifier:self; 402, identifier:_int64index; 403, identifier:union; 404, argument_list; 404, 405; 404, 406; 405, identifier:other; 406, keyword_argument; 406, 407; 406, 408; 407, identifier:sort; 408, identifier:sort | def union(self, other, sort=None):
"""
Form the union of two Index objects and sorts if possible
Parameters
----------
other : Index or array-like
sort : False or None, default None
Whether to sort resulting index. ``sort=None`` returns a
mononotically increasing ``RangeIndex`` if possible or a sorted
``Int64Index`` if not. ``sort=False`` always returns an
unsorted ``Int64Index``
.. versionadded:: 0.25.0
Returns
-------
union : Index
"""
self._assert_can_do_setop(other)
if len(other) == 0 or self.equals(other) or len(self) == 0:
return super().union(other, sort=sort)
if isinstance(other, RangeIndex) and sort is None:
start_s, step_s = self._start, self._step
end_s = self._start + self._step * (len(self) - 1)
start_o, step_o = other._start, other._step
end_o = other._start + other._step * (len(other) - 1)
if self._step < 0:
start_s, step_s, end_s = end_s, -step_s, start_s
if other._step < 0:
start_o, step_o, end_o = end_o, -step_o, start_o
if len(self) == 1 and len(other) == 1:
step_s = step_o = abs(self._start - other._start)
elif len(self) == 1:
step_s = step_o
elif len(other) == 1:
step_o = step_s
start_r = min(start_s, start_o)
end_r = max(end_s, end_o)
if step_o == step_s:
if ((start_s - start_o) % step_s == 0 and
(start_s - end_o) <= step_s and
(start_o - end_s) <= step_s):
return RangeIndex(start_r, end_r + step_s, step_s)
if ((step_s % 2 == 0) and
(abs(start_s - start_o) <= step_s / 2) and
(abs(end_s - end_o) <= step_s / 2)):
return RangeIndex(start_r, end_r + step_s / 2, step_s / 2)
elif step_o % step_s == 0:
if ((start_o - start_s) % step_s == 0 and
(start_o + step_s >= start_s) and
(end_o - step_s <= end_s)):
return RangeIndex(start_r, end_r + step_s, step_s)
elif step_s % step_o == 0:
if ((start_s - start_o) % step_o == 0 and
(start_s + step_o >= start_o) and
(end_s - step_o <= end_o)):
return RangeIndex(start_r, end_r + step_o, step_o)
return self._int64index.union(other, sort=sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:nlargest; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:n; 6, identifier:columns; 7, default_parameter; 7, 8; 7, 9; 8, identifier:keep; 9, string:'first'; 10, block; 10, 11; 10, 13; 11, expression_statement; 11, 12; 12, comment; 13, return_statement; 13, 14; 14, call; 14, 15; 14, 32; 15, attribute; 15, 16; 15, 31; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:algorithms; 19, identifier:SelectNFrame; 20, argument_list; 20, 21; 20, 22; 20, 25; 20, 28; 21, identifier:self; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:n; 24, identifier:n; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:keep; 27, identifier:keep; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:columns; 30, identifier:columns; 31, identifier:nlargest; 32, argument_list | def nlargest(self, n, columns, keep='first'):
"""
Return the first `n` rows ordered by `columns` in descending order.
Return the first `n` rows with the largest values in `columns`, in
descending order. The columns that are not specified are returned as
well, but not used for ordering.
This method is equivalent to
``df.sort_values(columns, ascending=False).head(n)``, but more
performant.
Parameters
----------
n : int
Number of rows to return.
columns : label or list of labels
Column label(s) to order by.
keep : {'first', 'last', 'all'}, default 'first'
Where there are duplicate values:
- `first` : prioritize the first occurrence(s)
- `last` : prioritize the last occurrence(s)
- ``all`` : do not drop any duplicates, even it means
selecting more than `n` items.
.. versionadded:: 0.24.0
Returns
-------
DataFrame
The first `n` rows ordered by the given columns in descending
order.
See Also
--------
DataFrame.nsmallest : Return the first `n` rows ordered by `columns` in
ascending order.
DataFrame.sort_values : Sort DataFrame by the values.
DataFrame.head : Return the first `n` rows without re-ordering.
Notes
-----
This function cannot be used with all column types. For example, when
specifying columns with `object` or `category` dtypes, ``TypeError`` is
raised.
Examples
--------
>>> df = pd.DataFrame({'population': [59000000, 65000000, 434000,
... 434000, 434000, 337000, 11300,
... 11300, 11300],
... 'GDP': [1937894, 2583560 , 12011, 4520, 12128,
... 17036, 182, 38, 311],
... 'alpha-2': ["IT", "FR", "MT", "MV", "BN",
... "IS", "NR", "TV", "AI"]},
... index=["Italy", "France", "Malta",
... "Maldives", "Brunei", "Iceland",
... "Nauru", "Tuvalu", "Anguilla"])
>>> df
population GDP alpha-2
Italy 59000000 1937894 IT
France 65000000 2583560 FR
Malta 434000 12011 MT
Maldives 434000 4520 MV
Brunei 434000 12128 BN
Iceland 337000 17036 IS
Nauru 11300 182 NR
Tuvalu 11300 38 TV
Anguilla 11300 311 AI
In the following example, we will use ``nlargest`` to select the three
rows having the largest values in column "population".
>>> df.nlargest(3, 'population')
population GDP alpha-2
France 65000000 2583560 FR
Italy 59000000 1937894 IT
Malta 434000 12011 MT
When using ``keep='last'``, ties are resolved in reverse order:
>>> df.nlargest(3, 'population', keep='last')
population GDP alpha-2
France 65000000 2583560 FR
Italy 59000000 1937894 IT
Brunei 434000 12128 BN
When using ``keep='all'``, all duplicate items are maintained:
>>> df.nlargest(3, 'population', keep='all')
population GDP alpha-2
France 65000000 2583560 FR
Italy 59000000 1937894 IT
Malta 434000 12011 MT
Maldives 434000 4520 MV
Brunei 434000 12128 BN
To order by the largest values in column "population" and then "GDP",
we can specify multiple columns like in the next example.
>>> df.nlargest(3, ['population', 'GDP'])
population GDP alpha-2
France 65000000 2583560 FR
Italy 59000000 1937894 IT
Brunei 434000 12128 BN
"""
return algorithms.SelectNFrame(self,
n=n,
keep=keep,
columns=columns).nlargest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:nsmallest; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:n; 6, identifier:columns; 7, default_parameter; 7, 8; 7, 9; 8, identifier:keep; 9, string:'first'; 10, block; 10, 11; 10, 13; 11, expression_statement; 11, 12; 12, comment; 13, return_statement; 13, 14; 14, call; 14, 15; 14, 32; 15, attribute; 15, 16; 15, 31; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:algorithms; 19, identifier:SelectNFrame; 20, argument_list; 20, 21; 20, 22; 20, 25; 20, 28; 21, identifier:self; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:n; 24, identifier:n; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:keep; 27, identifier:keep; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:columns; 30, identifier:columns; 31, identifier:nsmallest; 32, argument_list | def nsmallest(self, n, columns, keep='first'):
"""
Return the first `n` rows ordered by `columns` in ascending order.
Return the first `n` rows with the smallest values in `columns`, in
ascending order. The columns that are not specified are returned as
well, but not used for ordering.
This method is equivalent to
``df.sort_values(columns, ascending=True).head(n)``, but more
performant.
Parameters
----------
n : int
Number of items to retrieve.
columns : list or str
Column name or names to order by.
keep : {'first', 'last', 'all'}, default 'first'
Where there are duplicate values:
- ``first`` : take the first occurrence.
- ``last`` : take the last occurrence.
- ``all`` : do not drop any duplicates, even it means
selecting more than `n` items.
.. versionadded:: 0.24.0
Returns
-------
DataFrame
See Also
--------
DataFrame.nlargest : Return the first `n` rows ordered by `columns` in
descending order.
DataFrame.sort_values : Sort DataFrame by the values.
DataFrame.head : Return the first `n` rows without re-ordering.
Examples
--------
>>> df = pd.DataFrame({'population': [59000000, 65000000, 434000,
... 434000, 434000, 337000, 11300,
... 11300, 11300],
... 'GDP': [1937894, 2583560 , 12011, 4520, 12128,
... 17036, 182, 38, 311],
... 'alpha-2': ["IT", "FR", "MT", "MV", "BN",
... "IS", "NR", "TV", "AI"]},
... index=["Italy", "France", "Malta",
... "Maldives", "Brunei", "Iceland",
... "Nauru", "Tuvalu", "Anguilla"])
>>> df
population GDP alpha-2
Italy 59000000 1937894 IT
France 65000000 2583560 FR
Malta 434000 12011 MT
Maldives 434000 4520 MV
Brunei 434000 12128 BN
Iceland 337000 17036 IS
Nauru 11300 182 NR
Tuvalu 11300 38 TV
Anguilla 11300 311 AI
In the following example, we will use ``nsmallest`` to select the
three rows having the smallest values in column "a".
>>> df.nsmallest(3, 'population')
population GDP alpha-2
Nauru 11300 182 NR
Tuvalu 11300 38 TV
Anguilla 11300 311 AI
When using ``keep='last'``, ties are resolved in reverse order:
>>> df.nsmallest(3, 'population', keep='last')
population GDP alpha-2
Anguilla 11300 311 AI
Tuvalu 11300 38 TV
Nauru 11300 182 NR
When using ``keep='all'``, all duplicate items are maintained:
>>> df.nsmallest(3, 'population', keep='all')
population GDP alpha-2
Nauru 11300 182 NR
Tuvalu 11300 38 TV
Anguilla 11300 311 AI
To order by the largest values in column "a" and then "c", we can
specify multiple columns like in the next example.
>>> df.nsmallest(3, ['population', 'GDP'])
population GDP alpha-2
Tuvalu 11300 38 TV
Nauru 11300 182 NR
Anguilla 11300 311 AI
"""
return algorithms.SelectNFrame(self,
n=n,
keep=keep,
columns=columns).nsmallest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:append; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ignore_index; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:verify_integrity; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:sort; 14, None; 15, block; 15, 16; 15, 18; 15, 263; 15, 271; 15, 295; 16, expression_statement; 16, 17; 17, comment; 18, if_statement; 18, 19; 18, 26; 18, 208; 19, call; 19, 20; 19, 21; 20, identifier:isinstance; 21, argument_list; 21, 22; 21, 23; 22, identifier:other; 23, tuple; 23, 24; 23, 25; 24, identifier:Series; 25, identifier:dict; 26, block; 26, 27; 26, 41; 26, 58; 26, 90; 26, 103; 26, 135; 26, 147; 26, 172; 26, 186; 27, if_statement; 27, 28; 27, 33; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:other; 32, identifier:dict; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:other; 37, call; 37, 38; 37, 39; 38, identifier:Series; 39, argument_list; 39, 40; 40, identifier:other; 41, if_statement; 41, 42; 41, 50; 42, boolean_operator:and; 42, 43; 42, 48; 43, comparison_operator:is; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:other; 46, identifier:name; 47, None; 48, not_operator; 48, 49; 49, identifier:ignore_index; 50, block; 50, 51; 51, raise_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:TypeError; 54, argument_list; 54, 55; 55, concatenated_string; 55, 56; 55, 57; 56, string:'Can only append a Series if ignore_index=True'; 57, string:' or if the Series has a name'; 58, if_statement; 58, 59; 58, 64; 58, 69; 59, comparison_operator:is; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:other; 62, identifier:name; 63, None; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:index; 68, None; 69, else_clause; 69, 70; 69, 71; 69, 72; 70, comment; 71, comment; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:index; 76, call; 76, 77; 76, 78; 77, identifier:Index; 78, argument_list; 78, 79; 78, 83; 79, list:[other.name]; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:other; 82, identifier:name; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:name; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:index; 89, identifier:name; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:idx_diff; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:other; 97, identifier:index; 98, identifier:difference; 99, argument_list; 99, 100; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:columns; 103, try_statement; 103, 104; 103, 116; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:combined_columns; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:columns; 113, identifier:append; 114, argument_list; 114, 115; 115, identifier:idx_diff; 116, except_clause; 116, 117; 116, 118; 117, identifier:TypeError; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:combined_columns; 122, call; 122, 123; 122, 133; 123, attribute; 123, 124; 123, 132; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:columns; 129, identifier:astype; 130, argument_list; 130, 131; 131, identifier:object; 132, identifier:append; 133, argument_list; 133, 134; 134, identifier:idx_diff; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:other; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:other; 141, identifier:reindex; 142, argument_list; 142, 143; 142, 144; 143, identifier:combined_columns; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:copy; 146, False; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:other; 150, call; 150, 151; 150, 152; 151, identifier:DataFrame; 152, argument_list; 152, 153; 152, 166; 152, 169; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:other; 157, identifier:values; 158, identifier:reshape; 159, argument_list; 159, 160; 160, tuple; 160, 161; 160, 162; 161, integer:1; 162, call; 162, 163; 162, 164; 163, identifier:len; 164, argument_list; 164, 165; 165, identifier:other; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:index; 168, identifier:index; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:columns; 171, identifier:combined_columns; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:other; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:other; 178, identifier:_convert; 179, argument_list; 179, 180; 179, 183; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:datetime; 182, True; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:timedelta; 185, True; 186, if_statement; 186, 187; 186, 196; 187, not_operator; 187, 188; 188, call; 188, 189; 188, 194; 189, attribute; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:self; 192, identifier:columns; 193, identifier:equals; 194, argument_list; 194, 195; 195, identifier:combined_columns; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:self; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:self; 203, identifier:reindex; 204, argument_list; 204, 205; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:columns; 207, identifier:combined_columns; 208, elif_clause; 208, 209; 208, 223; 209, boolean_operator:and; 209, 210; 209, 215; 210, call; 210, 211; 210, 212; 211, identifier:isinstance; 212, argument_list; 212, 213; 212, 214; 213, identifier:other; 214, identifier:list; 215, not_operator; 215, 216; 216, call; 216, 217; 216, 218; 217, identifier:isinstance; 218, argument_list; 218, 219; 218, 222; 219, subscript; 219, 220; 219, 221; 220, identifier:other; 221, integer:0; 222, identifier:DataFrame; 223, block; 223, 224; 223, 231; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:other; 227, call; 227, 228; 227, 229; 228, identifier:DataFrame; 229, argument_list; 229, 230; 230, identifier:other; 231, if_statement; 231, 232; 231, 249; 232, call; 232, 233; 232, 248; 233, attribute; 233, 234; 233, 247; 234, parenthesized_expression; 234, 235; 235, comparison_operator:>=; 235, 236; 235, 246; 236, call; 236, 237; 236, 242; 237, attribute; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:self; 240, identifier:columns; 241, identifier:get_indexer; 242, argument_list; 242, 243; 243, attribute; 243, 244; 243, 245; 244, identifier:other; 245, identifier:columns; 246, integer:0; 247, identifier:all; 248, argument_list; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:other; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:other; 256, identifier:reindex; 257, argument_list; 257, 258; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:columns; 260, attribute; 260, 261; 260, 262; 261, identifier:self; 262, identifier:columns; 263, import_from_statement; 263, 264; 263, 269; 264, dotted_name; 264, 265; 264, 266; 264, 267; 264, 268; 265, identifier:pandas; 266, identifier:core; 267, identifier:reshape; 268, identifier:concat; 269, dotted_name; 269, 270; 270, identifier:concat; 271, if_statement; 271, 272; 271, 279; 271, 287; 272, call; 272, 273; 272, 274; 273, identifier:isinstance; 274, argument_list; 274, 275; 274, 276; 275, identifier:other; 276, tuple; 276, 277; 276, 278; 277, identifier:list; 278, identifier:tuple; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:to_concat; 283, binary_operator:+; 283, 284; 283, 286; 284, list:[self]; 284, 285; 285, identifier:self; 286, identifier:other; 287, else_clause; 287, 288; 288, block; 288, 289; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:to_concat; 292, list:[self, other]; 292, 293; 292, 294; 293, identifier:self; 294, identifier:other; 295, return_statement; 295, 296; 296, call; 296, 297; 296, 298; 297, identifier:concat; 298, argument_list; 298, 299; 298, 300; 298, 303; 298, 306; 299, identifier:to_concat; 300, keyword_argument; 300, 301; 300, 302; 301, identifier:ignore_index; 302, identifier:ignore_index; 303, keyword_argument; 303, 304; 303, 305; 304, identifier:verify_integrity; 305, identifier:verify_integrity; 306, keyword_argument; 306, 307; 306, 308; 307, identifier:sort; 308, identifier:sort | def append(self, other, ignore_index=False,
verify_integrity=False, sort=None):
"""
Append rows of `other` to the end of caller, returning a new object.
Columns in `other` that are not in the caller are added as new columns.
Parameters
----------
other : DataFrame or Series/dict-like object, or list of these
The data to append.
ignore_index : boolean, default False
If True, do not use the index labels.
verify_integrity : boolean, default False
If True, raise ValueError on creating index with duplicates.
sort : boolean, default None
Sort columns if the columns of `self` and `other` are not aligned.
The default sorting is deprecated and will change to not-sorting
in a future version of pandas. Explicitly pass ``sort=True`` to
silence the warning and sort. Explicitly pass ``sort=False`` to
silence the warning and not sort.
.. versionadded:: 0.23.0
Returns
-------
DataFrame
See Also
--------
concat : General function to concatenate DataFrame, Series
or Panel objects.
Notes
-----
If a list of dict/series is passed and the keys are all contained in
the DataFrame's index, the order of the columns in the resulting
DataFrame will be unchanged.
Iteratively appending rows to a DataFrame can be more computationally
intensive than a single concatenate. A better solution is to append
those rows to a list and then concatenate the list with the original
DataFrame all at once.
Examples
--------
>>> df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
>>> df
A B
0 1 2
1 3 4
>>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
>>> df.append(df2)
A B
0 1 2
1 3 4
0 5 6
1 7 8
With `ignore_index` set to True:
>>> df.append(df2, ignore_index=True)
A B
0 1 2
1 3 4
2 5 6
3 7 8
The following, while not recommended methods for generating DataFrames,
show two ways to generate a DataFrame from multiple data sources.
Less efficient:
>>> df = pd.DataFrame(columns=['A'])
>>> for i in range(5):
... df = df.append({'A': i}, ignore_index=True)
>>> df
A
0 0
1 1
2 2
3 3
4 4
More efficient:
>>> pd.concat([pd.DataFrame([i], columns=['A']) for i in range(5)],
... ignore_index=True)
A
0 0
1 1
2 2
3 3
4 4
"""
if isinstance(other, (Series, dict)):
if isinstance(other, dict):
other = Series(other)
if other.name is None and not ignore_index:
raise TypeError('Can only append a Series if ignore_index=True'
' or if the Series has a name')
if other.name is None:
index = None
else:
# other must have the same index name as self, otherwise
# index name will be reset
index = Index([other.name], name=self.index.name)
idx_diff = other.index.difference(self.columns)
try:
combined_columns = self.columns.append(idx_diff)
except TypeError:
combined_columns = self.columns.astype(object).append(idx_diff)
other = other.reindex(combined_columns, copy=False)
other = DataFrame(other.values.reshape((1, len(other))),
index=index,
columns=combined_columns)
other = other._convert(datetime=True, timedelta=True)
if not self.columns.equals(combined_columns):
self = self.reindex(columns=combined_columns)
elif isinstance(other, list) and not isinstance(other[0], DataFrame):
other = DataFrame(other)
if (self.columns.get_indexer(other.columns) >= 0).all():
other = other.reindex(columns=self.columns)
from pandas.core.reshape.concat import concat
if isinstance(other, (list, tuple)):
to_concat = [self] + other
else:
to_concat = [self, other]
return concat(to_concat, ignore_index=ignore_index,
verify_integrity=verify_integrity,
sort=sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:join; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:on; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:how; 11, string:'left'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:lsuffix; 14, string:''; 15, default_parameter; 15, 16; 15, 17; 16, identifier:rsuffix; 17, string:''; 18, default_parameter; 18, 19; 18, 20; 19, identifier:sort; 20, False; 21, block; 21, 22; 21, 24; 21, 25; 22, expression_statement; 22, 23; 23, comment; 24, comment; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_join_compat; 30, argument_list; 30, 31; 30, 32; 30, 35; 30, 38; 30, 41; 30, 44; 31, identifier:other; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:on; 34, identifier:on; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:how; 37, identifier:how; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:lsuffix; 40, identifier:lsuffix; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:rsuffix; 43, identifier:rsuffix; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:sort; 46, identifier:sort | def join(self, other, on=None, how='left', lsuffix='', rsuffix='',
sort=False):
"""
Join columns of another DataFrame.
Join columns with `other` DataFrame either on index or on a key
column. Efficiently join multiple DataFrame objects by index at once by
passing a list.
Parameters
----------
other : DataFrame, Series, or list of DataFrame
Index should be similar to one of the columns in this one. If a
Series is passed, its name attribute must be set, and that will be
used as the column name in the resulting joined DataFrame.
on : str, list of str, or array-like, optional
Column or index level name(s) in the caller to join on the index
in `other`, otherwise joins index-on-index. If multiple
values given, the `other` DataFrame must have a MultiIndex. Can
pass an array as the join key if it is not already contained in
the calling DataFrame. Like an Excel VLOOKUP operation.
how : {'left', 'right', 'outer', 'inner'}, default 'left'
How to handle the operation of the two objects.
* left: use calling frame's index (or column if on is specified)
* right: use `other`'s index.
* outer: form union of calling frame's index (or column if on is
specified) with `other`'s index, and sort it.
lexicographically.
* inner: form intersection of calling frame's index (or column if
on is specified) with `other`'s index, preserving the order
of the calling's one.
lsuffix : str, default ''
Suffix to use from left frame's overlapping columns.
rsuffix : str, default ''
Suffix to use from right frame's overlapping columns.
sort : bool, default False
Order result DataFrame lexicographically by the join key. If False,
the order of the join key depends on the join type (how keyword).
Returns
-------
DataFrame
A dataframe containing columns from both the caller and `other`.
See Also
--------
DataFrame.merge : For column(s)-on-columns(s) operations.
Notes
-----
Parameters `on`, `lsuffix`, and `rsuffix` are not supported when
passing a list of `DataFrame` objects.
Support for specifying index levels as the `on` parameter was added
in version 0.23.0.
Examples
--------
>>> df = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'],
... 'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']})
>>> df
key A
0 K0 A0
1 K1 A1
2 K2 A2
3 K3 A3
4 K4 A4
5 K5 A5
>>> other = pd.DataFrame({'key': ['K0', 'K1', 'K2'],
... 'B': ['B0', 'B1', 'B2']})
>>> other
key B
0 K0 B0
1 K1 B1
2 K2 B2
Join DataFrames using their indexes.
>>> df.join(other, lsuffix='_caller', rsuffix='_other')
key_caller A key_other B
0 K0 A0 K0 B0
1 K1 A1 K1 B1
2 K2 A2 K2 B2
3 K3 A3 NaN NaN
4 K4 A4 NaN NaN
5 K5 A5 NaN NaN
If we want to join using the key columns, we need to set key to be
the index in both `df` and `other`. The joined DataFrame will have
key as its index.
>>> df.set_index('key').join(other.set_index('key'))
A B
key
K0 A0 B0
K1 A1 B1
K2 A2 B2
K3 A3 NaN
K4 A4 NaN
K5 A5 NaN
Another option to join using the key columns is to use the `on`
parameter. DataFrame.join always uses `other`'s index but we can use
any column in `df`. This method preserves the original DataFrame's
index in the result.
>>> df.join(other.set_index('key'), on='key')
key A B
0 K0 A0 B0
1 K1 A1 B1
2 K2 A2 B2
3 K3 A3 NaN
4 K4 A4 NaN
5 K5 A5 NaN
"""
# For SparseDataFrame's benefit
return self._join_compat(other, on=on, how=how, lsuffix=lsuffix,
rsuffix=rsuffix, sort=sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 1, 9; 2, function_name:_values_for_argsort; 3, parameters; 3, 4; 4, identifier:self; 5, type; 5, 6; 6, attribute; 6, 7; 6, 8; 7, identifier:np; 8, identifier:ndarray; 9, block; 9, 10; 9, 12; 9, 22; 9, 36; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:data; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_data; 20, identifier:copy; 21, argument_list; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 29; 24, subscript; 24, 25; 24, 26; 25, identifier:data; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_mask; 29, binary_operator:-; 29, 30; 29, 35; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:data; 33, identifier:min; 34, argument_list; 35, integer:1; 36, return_statement; 36, 37; 37, identifier:data | def _values_for_argsort(self) -> np.ndarray:
"""Return values for sorting.
Returns
-------
ndarray
The transformed values should maintain the ordering between values
within the array.
See Also
--------
ExtensionArray.argsort
"""
data = self._data.copy()
data[self._mask] = data.min() - 1
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_get_combined_index; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:indexes; 5, default_parameter; 5, 6; 5, 7; 6, identifier:intersect; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, False; 11, block; 11, 12; 11, 14; 11, 15; 11, 22; 11, 96; 11, 113; 12, expression_statement; 12, 13; 13, comment; 14, comment; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:indexes; 18, call; 18, 19; 18, 20; 19, identifier:_get_distinct_objs; 20, argument_list; 20, 21; 21, identifier:indexes; 22, if_statement; 22, 23; 22, 29; 22, 37; 22, 51; 22, 77; 23, comparison_operator:==; 23, 24; 23, 28; 24, call; 24, 25; 24, 26; 25, identifier:len; 26, argument_list; 26, 27; 27, identifier:indexes; 28, integer:0; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:index; 33, call; 33, 34; 33, 35; 34, identifier:Index; 35, argument_list; 35, 36; 36, list:[]; 37, elif_clause; 37, 38; 37, 44; 38, comparison_operator:==; 38, 39; 38, 43; 39, call; 39, 40; 39, 41; 40, identifier:len; 41, argument_list; 41, 42; 42, identifier:indexes; 43, integer:1; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:index; 48, subscript; 48, 49; 48, 50; 49, identifier:indexes; 50, integer:0; 51, elif_clause; 51, 52; 51, 53; 52, identifier:intersect; 53, block; 53, 54; 53, 60; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:index; 57, subscript; 57, 58; 57, 59; 58, identifier:indexes; 59, integer:0; 60, for_statement; 60, 61; 60, 62; 60, 67; 61, identifier:other; 62, subscript; 62, 63; 62, 64; 63, identifier:indexes; 64, slice; 64, 65; 64, 66; 65, integer:1; 66, colon; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:index; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:index; 74, identifier:intersection; 75, argument_list; 75, 76; 76, identifier:other; 77, else_clause; 77, 78; 78, block; 78, 79; 78, 89; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:index; 82, call; 82, 83; 82, 84; 83, identifier:_union_indexes; 84, argument_list; 84, 85; 84, 86; 85, identifier:indexes; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:sort; 88, identifier:sort; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:index; 92, call; 92, 93; 92, 94; 93, identifier:ensure_index; 94, argument_list; 94, 95; 95, identifier:index; 96, if_statement; 96, 97; 96, 98; 97, identifier:sort; 98, block; 98, 99; 99, try_statement; 99, 100; 99, 109; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:index; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:index; 107, identifier:sort_values; 108, argument_list; 109, except_clause; 109, 110; 109, 111; 110, identifier:TypeError; 111, block; 111, 112; 112, pass_statement; 113, return_statement; 113, 114; 114, identifier:index | def _get_combined_index(indexes, intersect=False, sort=False):
"""
Return the union or intersection of indexes.
Parameters
----------
indexes : list of Index or list objects
When intersect=True, do not accept list of lists.
intersect : bool, default False
If True, calculate the intersection between indexes. Otherwise,
calculate the union.
sort : bool, default False
Whether the result index should come out sorted or not.
Returns
-------
Index
"""
# TODO: handle index names!
indexes = _get_distinct_objs(indexes)
if len(indexes) == 0:
index = Index([])
elif len(indexes) == 1:
index = indexes[0]
elif intersect:
index = indexes[0]
for other in indexes[1:]:
index = index.intersection(other)
else:
index = _union_indexes(indexes, sort=sort)
index = ensure_index(index)
if sort:
try:
index = index.sort_values()
except TypeError:
pass
return index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_union_indexes; 3, parameters; 3, 4; 3, 5; 4, identifier:indexes; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, True; 8, block; 8, 9; 8, 11; 8, 24; 8, 57; 8, 66; 8, 115; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 18; 12, comparison_operator:==; 12, 13; 12, 17; 13, call; 13, 14; 13, 15; 14, identifier:len; 15, argument_list; 15, 16; 16, identifier:indexes; 17, integer:0; 18, block; 18, 19; 19, raise_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:AssertionError; 22, argument_list; 22, 23; 23, string:'Must have at least 1 Index to union'; 24, if_statement; 24, 25; 24, 31; 25, comparison_operator:==; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:indexes; 30, integer:1; 31, block; 31, 32; 31, 38; 31, 55; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:result; 35, subscript; 35, 36; 35, 37; 36, identifier:indexes; 37, integer:0; 38, if_statement; 38, 39; 38, 44; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 43; 42, identifier:result; 43, identifier:list; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:result; 48, call; 48, 49; 48, 50; 49, identifier:Index; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:sorted; 53, argument_list; 53, 54; 54, identifier:result; 55, return_statement; 55, 56; 56, identifier:result; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, pattern_list; 59, 60; 59, 61; 60, identifier:indexes; 61, identifier:kind; 62, call; 62, 63; 62, 64; 63, identifier:_sanitize_and_check; 64, argument_list; 64, 65; 65, identifier:indexes; 66, function_definition; 66, 67; 66, 68; 66, 70; 67, function_name:_unique_indices; 68, parameters; 68, 69; 69, identifier:inds; 70, block; 70, 71; 70, 73; 70, 95; 71, expression_statement; 71, 72; 72, comment; 73, function_definition; 73, 74; 73, 75; 73, 77; 74, function_name:conv; 75, parameters; 75, 76; 76, identifier:i; 77, block; 77, 78; 77, 93; 78, if_statement; 78, 79; 78, 84; 79, call; 79, 80; 79, 81; 80, identifier:isinstance; 81, argument_list; 81, 82; 81, 83; 82, identifier:i; 83, identifier:Index; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:i; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:i; 91, identifier:tolist; 92, argument_list; 93, return_statement; 93, 94; 94, identifier:i; 95, return_statement; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:Index; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:lib; 102, identifier:fast_unique_multiple_list; 103, argument_list; 103, 104; 103, 112; 104, list_comprehension; 104, 105; 104, 109; 105, call; 105, 106; 105, 107; 106, identifier:conv; 107, argument_list; 107, 108; 108, identifier:i; 109, for_in_clause; 109, 110; 109, 111; 110, identifier:i; 111, identifier:inds; 112, keyword_argument; 112, 113; 112, 114; 113, identifier:sort; 114, identifier:sort; 115, if_statement; 115, 116; 115, 119; 115, 165; 115, 248; 116, comparison_operator:==; 116, 117; 116, 118; 117, identifier:kind; 118, string:'special'; 119, block; 119, 120; 119, 126; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:result; 123, subscript; 123, 124; 123, 125; 124, identifier:indexes; 125, integer:0; 126, if_statement; 126, 127; 126, 132; 126, 144; 127, call; 127, 128; 127, 129; 128, identifier:hasattr; 129, argument_list; 129, 130; 129, 131; 130, identifier:result; 131, string:'union_many'; 132, block; 132, 133; 133, return_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:result; 137, identifier:union_many; 138, argument_list; 138, 139; 139, subscript; 139, 140; 139, 141; 140, identifier:indexes; 141, slice; 141, 142; 141, 143; 142, integer:1; 143, colon; 144, else_clause; 144, 145; 145, block; 145, 146; 145, 163; 146, for_statement; 146, 147; 146, 148; 146, 153; 147, identifier:other; 148, subscript; 148, 149; 148, 150; 149, identifier:indexes; 150, slice; 150, 151; 150, 152; 151, integer:1; 152, colon; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:result; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:result; 160, identifier:union; 161, argument_list; 161, 162; 162, identifier:other; 163, return_statement; 163, 164; 164, identifier:result; 165, elif_clause; 165, 166; 165, 169; 166, comparison_operator:==; 166, 167; 166, 168; 167, identifier:kind; 168, string:'array'; 169, block; 169, 170; 169, 176; 169, 219; 169, 228; 169, 246; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:index; 173, subscript; 173, 174; 173, 175; 174, identifier:indexes; 175, integer:0; 176, for_statement; 176, 177; 176, 178; 176, 183; 177, identifier:other; 178, subscript; 178, 179; 178, 180; 179, identifier:indexes; 180, slice; 180, 181; 180, 182; 181, integer:1; 182, colon; 183, block; 183, 184; 184, if_statement; 184, 185; 184, 192; 185, not_operator; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:index; 189, identifier:equals; 190, argument_list; 190, 191; 191, identifier:other; 192, block; 192, 193; 192, 214; 193, if_statement; 193, 194; 193, 197; 193, 198; 194, comparison_operator:is; 194, 195; 194, 196; 195, identifier:sort; 196, None; 197, comment; 198, block; 198, 199; 198, 210; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:warnings; 203, identifier:warn; 204, argument_list; 204, 205; 204, 206; 204, 207; 205, identifier:_sort_msg; 206, identifier:FutureWarning; 207, keyword_argument; 207, 208; 207, 209; 208, identifier:stacklevel; 209, integer:8; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:sort; 213, True; 214, return_statement; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:_unique_indices; 217, argument_list; 217, 218; 218, identifier:indexes; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:name; 222, subscript; 222, 223; 222, 227; 223, call; 223, 224; 223, 225; 224, identifier:_get_consensus_names; 225, argument_list; 225, 226; 226, identifier:indexes; 227, integer:0; 228, if_statement; 228, 229; 228, 234; 229, comparison_operator:!=; 229, 230; 229, 231; 230, identifier:name; 231, attribute; 231, 232; 231, 233; 232, identifier:index; 233, identifier:name; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:index; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:index; 241, identifier:_shallow_copy; 242, argument_list; 242, 243; 243, keyword_argument; 243, 244; 243, 245; 244, identifier:name; 245, identifier:name; 246, return_statement; 246, 247; 247, identifier:index; 248, else_clause; 248, 249; 248, 250; 249, comment; 250, block; 250, 251; 251, return_statement; 251, 252; 252, call; 252, 253; 252, 254; 253, identifier:_unique_indices; 254, argument_list; 254, 255; 255, identifier:indexes | def _union_indexes(indexes, sort=True):
"""
Return the union of indexes.
The behavior of sort and names is not consistent.
Parameters
----------
indexes : list of Index or list objects
sort : bool, default True
Whether the result index should come out sorted or not.
Returns
-------
Index
"""
if len(indexes) == 0:
raise AssertionError('Must have at least 1 Index to union')
if len(indexes) == 1:
result = indexes[0]
if isinstance(result, list):
result = Index(sorted(result))
return result
indexes, kind = _sanitize_and_check(indexes)
def _unique_indices(inds):
"""
Convert indexes to lists and concatenate them, removing duplicates.
The final dtype is inferred.
Parameters
----------
inds : list of Index or list objects
Returns
-------
Index
"""
def conv(i):
if isinstance(i, Index):
i = i.tolist()
return i
return Index(
lib.fast_unique_multiple_list([conv(i) for i in inds], sort=sort))
if kind == 'special':
result = indexes[0]
if hasattr(result, 'union_many'):
return result.union_many(indexes[1:])
else:
for other in indexes[1:]:
result = result.union(other)
return result
elif kind == 'array':
index = indexes[0]
for other in indexes[1:]:
if not index.equals(other):
if sort is None:
# TODO: remove once pd.concat sort default changes
warnings.warn(_sort_msg, FutureWarning, stacklevel=8)
sort = True
return _unique_indices(indexes)
name = _get_consensus_names(indexes)[0]
if name != index.name:
index = index._shallow_copy(name=name)
return index
else: # kind='list'
return _unique_indices(indexes) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sanitize_and_check; 3, parameters; 3, 4; 4, identifier:indexes; 5, block; 5, 6; 5, 8; 5, 22; 5, 72; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:kinds; 11, call; 11, 12; 11, 13; 12, identifier:list; 13, argument_list; 13, 14; 14, set_comprehension; 14, 15; 14, 19; 15, call; 15, 16; 15, 17; 16, identifier:type; 17, argument_list; 17, 18; 18, identifier:index; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:index; 21, identifier:indexes; 22, if_statement; 22, 23; 22, 26; 23, comparison_operator:in; 23, 24; 23, 25; 24, identifier:list; 25, identifier:kinds; 26, block; 26, 27; 27, if_statement; 27, 28; 27, 34; 27, 66; 28, comparison_operator:>; 28, 29; 28, 33; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:kinds; 33, integer:1; 34, block; 34, 35; 34, 59; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:indexes; 38, list_comprehension; 38, 39; 38, 56; 39, conditional_expression:if; 39, 40; 39, 49; 39, 55; 40, call; 40, 41; 40, 42; 41, identifier:Index; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:com; 46, identifier:try_sort; 47, argument_list; 47, 48; 48, identifier:x; 49, not_operator; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 54; 53, identifier:x; 54, identifier:Index; 55, identifier:x; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:x; 58, identifier:indexes; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:kinds; 63, identifier:remove; 64, argument_list; 64, 65; 65, identifier:list; 66, else_clause; 66, 67; 67, block; 67, 68; 68, return_statement; 68, 69; 69, expression_list; 69, 70; 69, 71; 70, identifier:indexes; 71, string:'list'; 72, if_statement; 72, 73; 72, 83; 72, 88; 73, boolean_operator:or; 73, 74; 73, 80; 74, comparison_operator:>; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:kinds; 79, integer:1; 80, comparison_operator:not; 80, 81; 80, 82; 81, identifier:Index; 82, identifier:kinds; 83, block; 83, 84; 84, return_statement; 84, 85; 85, expression_list; 85, 86; 85, 87; 86, identifier:indexes; 87, string:'special'; 88, else_clause; 88, 89; 89, block; 89, 90; 90, return_statement; 90, 91; 91, expression_list; 91, 92; 91, 93; 92, identifier:indexes; 93, string:'array' | def _sanitize_and_check(indexes):
"""
Verify the type of indexes and convert lists to Index.
Cases:
- [list, list, ...]: Return ([list, list, ...], 'list')
- [list, Index, ...]: Return _sanitize_and_check([Index, Index, ...])
Lists are sorted and converted to Index.
- [Index, Index, ...]: Return ([Index, Index, ...], TYPE)
TYPE = 'special' if at least one special type, 'array' otherwise.
Parameters
----------
indexes : list of Index or list objects
Returns
-------
sanitized_indexes : list of Index or list objects
type : {'list', 'array', 'special'}
"""
kinds = list({type(index) for index in indexes})
if list in kinds:
if len(kinds) > 1:
indexes = [Index(com.try_sort(x))
if not isinstance(x, Index) else
x for x in indexes]
kinds.remove(list)
else:
return indexes, 'list'
if len(kinds) > 1 or Index not in kinds:
return indexes, 'special'
else:
return indexes, 'array' |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_from_inferred_categories; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:cls; 5, identifier:inferred_categories; 6, identifier:inferred_codes; 7, identifier:dtype; 8, default_parameter; 8, 9; 8, 10; 9, identifier:true_values; 10, None; 11, block; 11, 12; 11, 14; 11, 25; 11, 32; 11, 47; 11, 136; 11, 213; 12, expression_statement; 12, 13; 13, comment; 14, import_from_statement; 14, 15; 14, 17; 14, 19; 14, 21; 14, 23; 15, dotted_name; 15, 16; 16, identifier:pandas; 17, dotted_name; 17, 18; 18, identifier:Index; 19, dotted_name; 19, 20; 20, identifier:to_numeric; 21, dotted_name; 21, 22; 22, identifier:to_datetime; 23, dotted_name; 23, 24; 24, identifier:to_timedelta; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:cats; 28, call; 28, 29; 28, 30; 29, identifier:Index; 30, argument_list; 30, 31; 31, identifier:inferred_categories; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:known_categories; 35, parenthesized_expression; 35, 36; 36, boolean_operator:and; 36, 37; 36, 42; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 41; 40, identifier:dtype; 41, identifier:CategoricalDtype; 42, comparison_operator:is; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:dtype; 45, identifier:categories; 46, None; 47, if_statement; 47, 48; 47, 49; 47, 50; 48, identifier:known_categories; 49, comment; 50, block; 50, 51; 51, if_statement; 51, 52; 51, 59; 51, 70; 51, 88; 51, 106; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:dtype; 56, identifier:categories; 57, identifier:is_numeric; 58, argument_list; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:cats; 63, call; 63, 64; 63, 65; 64, identifier:to_numeric; 65, argument_list; 65, 66; 65, 67; 66, identifier:inferred_categories; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:errors; 69, string:"coerce"; 70, elif_clause; 70, 71; 70, 77; 71, call; 71, 72; 71, 73; 72, identifier:is_datetime64_dtype; 73, argument_list; 73, 74; 74, attribute; 74, 75; 74, 76; 75, identifier:dtype; 76, identifier:categories; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:cats; 81, call; 81, 82; 81, 83; 82, identifier:to_datetime; 83, argument_list; 83, 84; 83, 85; 84, identifier:inferred_categories; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:errors; 87, string:"coerce"; 88, elif_clause; 88, 89; 88, 95; 89, call; 89, 90; 89, 91; 90, identifier:is_timedelta64_dtype; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:dtype; 94, identifier:categories; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:cats; 99, call; 99, 100; 99, 101; 100, identifier:to_timedelta; 101, argument_list; 101, 102; 101, 103; 102, identifier:inferred_categories; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:errors; 105, string:"coerce"; 106, elif_clause; 106, 107; 106, 114; 107, call; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:dtype; 111, identifier:categories; 112, identifier:is_boolean; 113, argument_list; 114, block; 114, 115; 114, 127; 115, if_statement; 115, 116; 115, 119; 116, comparison_operator:is; 116, 117; 116, 118; 117, identifier:true_values; 118, None; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:true_values; 123, list:["True", "TRUE", "true"]; 123, 124; 123, 125; 123, 126; 124, string:"True"; 125, string:"TRUE"; 126, string:"true"; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:cats; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:cats; 133, identifier:isin; 134, argument_list; 134, 135; 135, identifier:true_values; 136, if_statement; 136, 137; 136, 138; 136, 139; 136, 155; 136, 197; 137, identifier:known_categories; 138, comment; 139, block; 139, 140; 139, 146; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:categories; 143, attribute; 143, 144; 143, 145; 144, identifier:dtype; 145, identifier:categories; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:codes; 149, call; 149, 150; 149, 151; 150, identifier:_recode_for_categories; 151, argument_list; 151, 152; 151, 153; 151, 154; 152, identifier:inferred_codes; 153, identifier:cats; 154, identifier:categories; 155, elif_clause; 155, 156; 155, 160; 155, 161; 156, not_operator; 156, 157; 157, attribute; 157, 158; 157, 159; 158, identifier:cats; 159, identifier:is_monotonic_increasing; 160, comment; 161, block; 161, 162; 161, 170; 161, 178; 161, 187; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:unsorted; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:cats; 168, identifier:copy; 169, argument_list; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:categories; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:cats; 176, identifier:sort_values; 177, argument_list; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:codes; 181, call; 181, 182; 181, 183; 182, identifier:_recode_for_categories; 183, argument_list; 183, 184; 183, 185; 183, 186; 184, identifier:inferred_codes; 185, identifier:unsorted; 186, identifier:categories; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:dtype; 190, call; 190, 191; 190, 192; 191, identifier:CategoricalDtype; 192, argument_list; 192, 193; 192, 194; 193, identifier:categories; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:ordered; 196, False; 197, else_clause; 197, 198; 198, block; 198, 199; 198, 209; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:dtype; 202, call; 202, 203; 202, 204; 203, identifier:CategoricalDtype; 204, argument_list; 204, 205; 204, 206; 205, identifier:cats; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:ordered; 208, False; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:codes; 212, identifier:inferred_codes; 213, return_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:cls; 216, argument_list; 216, 217; 216, 218; 216, 221; 217, identifier:codes; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:dtype; 220, identifier:dtype; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:fastpath; 223, True | def _from_inferred_categories(cls, inferred_categories, inferred_codes,
dtype, true_values=None):
"""
Construct a Categorical from inferred values.
For inferred categories (`dtype` is None) the categories are sorted.
For explicit `dtype`, the `inferred_categories` are cast to the
appropriate type.
Parameters
----------
inferred_categories : Index
inferred_codes : Index
dtype : CategoricalDtype or 'category'
true_values : list, optional
If none are provided, the default ones are
"True", "TRUE", and "true."
Returns
-------
Categorical
"""
from pandas import Index, to_numeric, to_datetime, to_timedelta
cats = Index(inferred_categories)
known_categories = (isinstance(dtype, CategoricalDtype) and
dtype.categories is not None)
if known_categories:
# Convert to a specialized type with `dtype` if specified.
if dtype.categories.is_numeric():
cats = to_numeric(inferred_categories, errors="coerce")
elif is_datetime64_dtype(dtype.categories):
cats = to_datetime(inferred_categories, errors="coerce")
elif is_timedelta64_dtype(dtype.categories):
cats = to_timedelta(inferred_categories, errors="coerce")
elif dtype.categories.is_boolean():
if true_values is None:
true_values = ["True", "TRUE", "true"]
cats = cats.isin(true_values)
if known_categories:
# Recode from observation order to dtype.categories order.
categories = dtype.categories
codes = _recode_for_categories(inferred_codes, cats, categories)
elif not cats.is_monotonic_increasing:
# Sort categories and recode for unknown categories.
unsorted = cats.copy()
categories = cats.sort_values()
codes = _recode_for_categories(inferred_codes, unsorted,
categories)
dtype = CategoricalDtype(categories, ordered=False)
else:
dtype = CategoricalDtype(cats, ordered=False)
codes = inferred_codes
return cls(codes, dtype=dtype, fastpath=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:inplace; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:na_position; 13, string:'last'; 14, block; 14, 15; 14, 17; 14, 25; 14, 48; 14, 61; 15, expression_statement; 15, 16; 16, comment; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:inplace; 20, call; 20, 21; 20, 22; 21, identifier:validate_bool_kwarg; 22, argument_list; 22, 23; 22, 24; 23, identifier:inplace; 24, string:'inplace'; 25, if_statement; 25, 26; 25, 31; 26, comparison_operator:not; 26, 27; 26, 28; 27, identifier:na_position; 28, list:['last', 'first']; 28, 29; 28, 30; 29, string:'last'; 30, string:'first'; 31, block; 31, 32; 31, 36; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:msg; 35, string:'invalid na_position: {na_position!r}'; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:ValueError; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:msg; 43, identifier:format; 44, argument_list; 44, 45; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:na_position; 47, identifier:na_position; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:sorted_idx; 51, call; 51, 52; 51, 53; 52, identifier:nargsort; 53, argument_list; 53, 54; 53, 55; 53, 58; 54, identifier:self; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:ascending; 57, identifier:ascending; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:na_position; 60, identifier:na_position; 61, if_statement; 61, 62; 61, 63; 61, 74; 62, identifier:inplace; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:_codes; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:_codes; 73, identifier:sorted_idx; 74, else_clause; 74, 75; 75, block; 75, 76; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_constructor; 81, argument_list; 81, 82; 81, 89; 81, 94; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:values; 84, subscript; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:_codes; 88, identifier:sorted_idx; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:dtype; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:dtype; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:fastpath; 96, True | def sort_values(self, inplace=False, ascending=True, na_position='last'):
"""
Sort the Categorical by category value returning a new
Categorical by default.
While an ordering is applied to the category values, sorting in this
context refers more to organizing and grouping together based on
matching category values. Thus, this function can be called on an
unordered Categorical instance unlike the functions 'Categorical.min'
and 'Categorical.max'.
Parameters
----------
inplace : bool, default False
Do operation in place.
ascending : bool, default True
Order ascending. Passing False orders descending. The
ordering parameter provides the method by which the
category values are organized.
na_position : {'first', 'last'} (optional, default='last')
'first' puts NaNs at the beginning
'last' puts NaNs at the end
Returns
-------
Categorical or None
See Also
--------
Categorical.sort
Series.sort_values
Examples
--------
>>> c = pd.Categorical([1, 2, 2, 1, 5])
>>> c
[1, 2, 2, 1, 5]
Categories (3, int64): [1, 2, 5]
>>> c.sort_values()
[1, 1, 2, 2, 5]
Categories (3, int64): [1, 2, 5]
>>> c.sort_values(ascending=False)
[5, 2, 2, 1, 1]
Categories (3, int64): [1, 2, 5]
Inplace sorting can be done as well:
>>> c.sort_values(inplace=True)
>>> c
[1, 1, 2, 2, 5]
Categories (3, int64): [1, 2, 5]
>>>
>>> c = pd.Categorical([1, 2, 2, 1, 5])
'sort_values' behaviour with NaNs. Note that 'na_position'
is independent of the 'ascending' parameter:
>>> c = pd.Categorical([np.nan, 2, 2, np.nan, 5])
>>> c
[NaN, 2.0, 2.0, NaN, 5.0]
Categories (2, int64): [2, 5]
>>> c.sort_values()
[2.0, 2.0, 5.0, NaN, NaN]
Categories (2, int64): [2, 5]
>>> c.sort_values(ascending=False)
[5.0, 2.0, 2.0, NaN, NaN]
Categories (2, int64): [2, 5]
>>> c.sort_values(na_position='first')
[NaN, NaN, 2.0, 2.0, 5.0]
Categories (2, int64): [2, 5]
>>> c.sort_values(ascending=False, na_position='first')
[NaN, NaN, 5.0, 2.0, 2.0]
Categories (2, int64): [2, 5]
"""
inplace = validate_bool_kwarg(inplace, 'inplace')
if na_position not in ['last', 'first']:
msg = 'invalid na_position: {na_position!r}'
raise ValueError(msg.format(na_position=na_position))
sorted_idx = nargsort(self,
ascending=ascending,
na_position=na_position)
if inplace:
self._codes = self._codes[sorted_idx]
else:
return self._constructor(values=self._codes[sorted_idx],
dtype=self.dtype,
fastpath=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:unique; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 9; 5, 18; 5, 26; 5, 27; 5, 33; 5, 34; 5, 43; 5, 57; 6, expression_statement; 6, 7; 7, comment; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:unique_codes; 12, call; 12, 13; 12, 14; 13, identifier:unique1d; 14, argument_list; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:codes; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:cat; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:copy; 25, argument_list; 26, comment; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:cat; 31, identifier:_codes; 32, identifier:unique_codes; 33, comment; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:take_codes; 37, subscript; 37, 38; 37, 39; 38, identifier:unique_codes; 39, comparison_operator:!=; 39, 40; 39, 41; 40, identifier:unique_codes; 41, unary_operator:-; 41, 42; 42, integer:1; 43, if_statement; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:ordered; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:take_codes; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:sort; 55, argument_list; 55, 56; 56, identifier:take_codes; 57, return_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:cat; 61, identifier:set_categories; 62, argument_list; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:cat; 67, identifier:categories; 68, identifier:take; 69, argument_list; 69, 70; 70, identifier:take_codes | def unique(self):
"""
Return the ``Categorical`` which ``categories`` and ``codes`` are
unique. Unused categories are NOT returned.
- unordered category: values and categories are sorted by appearance
order.
- ordered category: values are sorted by appearance order, categories
keeps existing order.
Returns
-------
unique values : ``Categorical``
Examples
--------
An unordered Categorical will return categories in the
order of appearance.
>>> pd.Categorical(list('baabc'))
[b, a, c]
Categories (3, object): [b, a, c]
>>> pd.Categorical(list('baabc'), categories=list('abc'))
[b, a, c]
Categories (3, object): [b, a, c]
An ordered Categorical preserves the category ordering.
>>> pd.Categorical(list('baabc'),
... categories=list('abc'),
... ordered=True)
[b, a, c]
Categories (3, object): [a < b < c]
See Also
--------
unique
CategoricalIndex.unique
Series.unique
"""
# unlike np.unique, unique1d does not sort
unique_codes = unique1d(self.codes)
cat = self.copy()
# keep nan in codes
cat._codes = unique_codes
# exclude nan from indexer for categories
take_codes = unique_codes[unique_codes != -1]
if self.ordered:
take_codes = np.sort(take_codes)
return cat.set_categories(cat.categories.take(take_codes)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 35; 2, function_name:concat; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 4, identifier:objs; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:join; 10, string:'outer'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:join_axes; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:ignore_index; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:keys; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:levels; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:names; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:verify_integrity; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:sort; 31, None; 32, default_parameter; 32, 33; 32, 34; 33, identifier:copy; 34, True; 35, block; 35, 36; 35, 38; 35, 75; 36, expression_statement; 36, 37; 37, comment; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:op; 41, call; 41, 42; 41, 43; 42, identifier:_Concatenator; 43, argument_list; 43, 44; 43, 45; 43, 48; 43, 51; 43, 54; 43, 57; 43, 60; 43, 63; 43, 66; 43, 69; 43, 72; 44, identifier:objs; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:axis; 47, identifier:axis; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:join_axes; 50, identifier:join_axes; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:ignore_index; 53, identifier:ignore_index; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:join; 56, identifier:join; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:keys; 59, identifier:keys; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:levels; 62, identifier:levels; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:names; 65, identifier:names; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:verify_integrity; 68, identifier:verify_integrity; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:copy; 71, identifier:copy; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:sort; 74, identifier:sort; 75, return_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:op; 79, identifier:get_result; 80, argument_list | def concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False,
sort=None, copy=True):
"""
Concatenate pandas objects along a particular axis with optional set logic
along the other axes.
Can also add a layer of hierarchical indexing on the concatenation axis,
which may be useful if the labels are the same (or overlapping) on
the passed axis number.
Parameters
----------
objs : a sequence or mapping of Series, DataFrame, or Panel objects
If a dict is passed, the sorted keys will be used as the `keys`
argument, unless it is passed, in which case the values will be
selected (see below). Any None objects will be dropped silently unless
they are all None in which case a ValueError will be raised.
axis : {0/'index', 1/'columns'}, default 0
The axis to concatenate along.
join : {'inner', 'outer'}, default 'outer'
How to handle indexes on other axis (or axes).
join_axes : list of Index objects
Specific indexes to use for the other n - 1 axes instead of performing
inner/outer set logic.
ignore_index : bool, default False
If True, do not use the index values along the concatenation axis. The
resulting axis will be labeled 0, ..., n - 1. This is useful if you are
concatenating objects where the concatenation axis does not have
meaningful indexing information. Note the index values on the other
axes are still respected in the join.
keys : sequence, default None
If multiple levels passed, should contain tuples. Construct
hierarchical index using the passed keys as the outermost level.
levels : list of sequences, default None
Specific levels (unique values) to use for constructing a
MultiIndex. Otherwise they will be inferred from the keys.
names : list, default None
Names for the levels in the resulting hierarchical index.
verify_integrity : bool, default False
Check whether the new concatenated axis contains duplicates. This can
be very expensive relative to the actual data concatenation.
sort : bool, default None
Sort non-concatenation axis if it is not already aligned when `join`
is 'outer'. The current default of sorting is deprecated and will
change to not-sorting in a future version of pandas.
Explicitly pass ``sort=True`` to silence the warning and sort.
Explicitly pass ``sort=False`` to silence the warning and not sort.
This has no effect when ``join='inner'``, which already preserves
the order of the non-concatenation axis.
.. versionadded:: 0.23.0
copy : bool, default True
If False, do not copy data unnecessarily.
Returns
-------
object, type of objs
When concatenating all ``Series`` along the index (axis=0), a
``Series`` is returned. When ``objs`` contains at least one
``DataFrame``, a ``DataFrame`` is returned. When concatenating along
the columns (axis=1), a ``DataFrame`` is returned.
See Also
--------
Series.append : Concatenate Series.
DataFrame.append : Concatenate DataFrames.
DataFrame.join : Join DataFrames using indexes.
DataFrame.merge : Merge DataFrames by indexes or columns.
Notes
-----
The keys, levels, and names arguments are all optional.
A walkthrough of how this method fits in with other tools for combining
pandas objects can be found `here
<http://pandas.pydata.org/pandas-docs/stable/merging.html>`__.
Examples
--------
Combine two ``Series``.
>>> s1 = pd.Series(['a', 'b'])
>>> s2 = pd.Series(['c', 'd'])
>>> pd.concat([s1, s2])
0 a
1 b
0 c
1 d
dtype: object
Clear the existing index and reset it in the result
by setting the ``ignore_index`` option to ``True``.
>>> pd.concat([s1, s2], ignore_index=True)
0 a
1 b
2 c
3 d
dtype: object
Add a hierarchical index at the outermost level of
the data with the ``keys`` option.
>>> pd.concat([s1, s2], keys=['s1', 's2'])
s1 0 a
1 b
s2 0 c
1 d
dtype: object
Label the index keys you create with the ``names`` option.
>>> pd.concat([s1, s2], keys=['s1', 's2'],
... names=['Series name', 'Row ID'])
Series name Row ID
s1 0 a
1 b
s2 0 c
1 d
dtype: object
Combine two ``DataFrame`` objects with identical columns.
>>> df1 = pd.DataFrame([['a', 1], ['b', 2]],
... columns=['letter', 'number'])
>>> df1
letter number
0 a 1
1 b 2
>>> df2 = pd.DataFrame([['c', 3], ['d', 4]],
... columns=['letter', 'number'])
>>> df2
letter number
0 c 3
1 d 4
>>> pd.concat([df1, df2])
letter number
0 a 1
1 b 2
0 c 3
1 d 4
Combine ``DataFrame`` objects with overlapping columns
and return everything. Columns outside the intersection will
be filled with ``NaN`` values.
>>> df3 = pd.DataFrame([['c', 3, 'cat'], ['d', 4, 'dog']],
... columns=['letter', 'number', 'animal'])
>>> df3
letter number animal
0 c 3 cat
1 d 4 dog
>>> pd.concat([df1, df3], sort=False)
letter number animal
0 a 1 NaN
1 b 2 NaN
0 c 3 cat
1 d 4 dog
Combine ``DataFrame`` objects with overlapping columns
and return only those that are shared by passing ``inner`` to
the ``join`` keyword argument.
>>> pd.concat([df1, df3], join="inner")
letter number
0 a 1
1 b 2
0 c 3
1 d 4
Combine ``DataFrame`` objects horizontally along the x axis by
passing in ``axis=1``.
>>> df4 = pd.DataFrame([['bird', 'polly'], ['monkey', 'george']],
... columns=['animal', 'name'])
>>> pd.concat([df1, df4], axis=1)
letter number animal name
0 a 1 bird polly
1 b 2 monkey george
Prevent the result from including duplicate index values with the
``verify_integrity`` option.
>>> df5 = pd.DataFrame([1], index=['a'])
>>> df5
0
a 1
>>> df6 = pd.DataFrame([2], index=['a'])
>>> df6
0
a 2
>>> pd.concat([df5, df6], verify_integrity=True)
Traceback (most recent call last):
...
ValueError: Indexes have overlapping values: ['a']
"""
op = _Concatenator(objs, axis=axis, join_axes=join_axes,
ignore_index=ignore_index, join=join,
keys=keys, levels=levels, names=names,
verify_integrity=verify_integrity,
copy=copy, sort=sort)
return op.get_result() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 24; 2, function_name:cut; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 4, identifier:x; 5, identifier:bins; 6, default_parameter; 6, 7; 6, 8; 7, identifier:right; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:labels; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:retbins; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:precision; 17, integer:3; 18, default_parameter; 18, 19; 18, 20; 19, identifier:include_lowest; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:duplicates; 23, string:'raise'; 24, block; 24, 25; 24, 27; 24, 28; 24, 29; 24, 40; 24, 49; 24, 340; 24, 368; 25, expression_statement; 25, 26; 26, comment; 27, comment; 28, comment; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 36; 31, pattern_list; 31, 32; 31, 33; 31, 34; 31, 35; 32, identifier:x_is_series; 33, identifier:series_index; 34, identifier:name; 35, identifier:x; 36, call; 36, 37; 36, 38; 37, identifier:_preprocess_for_cut; 38, argument_list; 38, 39; 39, identifier:x; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, pattern_list; 42, 43; 42, 44; 43, identifier:x; 44, identifier:dtype; 45, call; 45, 46; 45, 47; 46, identifier:_coerce_to_type; 47, argument_list; 47, 48; 48, identifier:x; 49, if_statement; 49, 50; 49, 57; 49, 258; 49, 275; 50, not_operator; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:iterable; 55, argument_list; 55, 56; 56, identifier:bins; 57, block; 57, 58; 57, 73; 57, 100; 57, 110; 57, 126; 57, 138; 58, if_statement; 58, 59; 58, 67; 59, boolean_operator:and; 59, 60; 59, 64; 60, call; 60, 61; 60, 62; 61, identifier:is_scalar; 62, argument_list; 62, 63; 63, identifier:bins; 64, comparison_operator:<; 64, 65; 64, 66; 65, identifier:bins; 66, integer:1; 67, block; 67, 68; 68, raise_statement; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:ValueError; 71, argument_list; 71, 72; 72, string:"`bins` should be a positive integer."; 73, try_statement; 73, 74; 73, 75; 73, 82; 74, comment; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:sz; 79, attribute; 79, 80; 79, 81; 80, identifier:x; 81, identifier:size; 82, except_clause; 82, 83; 82, 84; 83, identifier:AttributeError; 84, block; 84, 85; 84, 94; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:x; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:np; 91, identifier:asarray; 92, argument_list; 92, 93; 93, identifier:x; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:sz; 97, attribute; 97, 98; 97, 99; 98, identifier:x; 99, identifier:size; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:==; 101, 102; 101, 103; 102, identifier:sz; 103, integer:0; 104, block; 104, 105; 105, raise_statement; 105, 106; 106, call; 106, 107; 106, 108; 107, identifier:ValueError; 108, argument_list; 108, 109; 109, string:'Cannot cut empty array'; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:rng; 113, tuple; 113, 114; 113, 120; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:nanops; 117, identifier:nanmin; 118, argument_list; 118, 119; 119, identifier:x; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:nanops; 123, identifier:nanmax; 124, argument_list; 124, 125; 125, identifier:x; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, pattern_list; 128, 129; 128, 130; 129, identifier:mn; 130, identifier:mx; 131, list_comprehension; 131, 132; 131, 135; 132, binary_operator:+; 132, 133; 132, 134; 133, identifier:mi; 134, float:0.0; 135, for_in_clause; 135, 136; 135, 137; 136, identifier:mi; 137, identifier:rng; 138, if_statement; 138, 139; 138, 152; 138, 153; 138, 161; 138, 211; 139, boolean_operator:or; 139, 140; 139, 146; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:np; 143, identifier:isinf; 144, argument_list; 144, 145; 145, identifier:mn; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:np; 149, identifier:isinf; 150, argument_list; 150, 151; 151, identifier:mx; 152, comment; 153, block; 153, 154; 154, raise_statement; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:ValueError; 157, argument_list; 157, 158; 158, concatenated_string; 158, 159; 158, 160; 159, string:'cannot specify integer `bins` when input data '; 160, string:'contains infinity'; 161, elif_clause; 161, 162; 161, 165; 161, 166; 162, comparison_operator:==; 162, 163; 162, 164; 163, identifier:mn; 164, identifier:mx; 165, comment; 166, block; 166, 167; 166, 181; 166, 195; 167, expression_statement; 167, 168; 168, augmented_assignment:-=; 168, 169; 168, 170; 169, identifier:mn; 170, conditional_expression:if; 170, 171; 170, 177; 170, 180; 171, binary_operator:*; 171, 172; 171, 173; 172, float:.001; 173, call; 173, 174; 173, 175; 174, identifier:abs; 175, argument_list; 175, 176; 176, identifier:mn; 177, comparison_operator:!=; 177, 178; 177, 179; 178, identifier:mn; 179, integer:0; 180, float:.001; 181, expression_statement; 181, 182; 182, augmented_assignment:+=; 182, 183; 182, 184; 183, identifier:mx; 184, conditional_expression:if; 184, 185; 184, 191; 184, 194; 185, binary_operator:*; 185, 186; 185, 187; 186, float:.001; 187, call; 187, 188; 187, 189; 188, identifier:abs; 189, argument_list; 189, 190; 190, identifier:mx; 191, comparison_operator:!=; 191, 192; 191, 193; 192, identifier:mx; 193, integer:0; 194, float:.001; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:bins; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:np; 201, identifier:linspace; 202, argument_list; 202, 203; 202, 204; 202, 205; 202, 208; 203, identifier:mn; 204, identifier:mx; 205, binary_operator:+; 205, 206; 205, 207; 206, identifier:bins; 207, integer:1; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:endpoint; 210, True; 211, else_clause; 211, 212; 211, 213; 212, comment; 213, block; 213, 214; 213, 230; 213, 239; 213, 240; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:bins; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:np; 220, identifier:linspace; 221, argument_list; 221, 222; 221, 223; 221, 224; 221, 227; 222, identifier:mn; 223, identifier:mx; 224, binary_operator:+; 224, 225; 224, 226; 225, identifier:bins; 226, integer:1; 227, keyword_argument; 227, 228; 227, 229; 228, identifier:endpoint; 229, True; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:adj; 233, binary_operator:*; 233, 234; 233, 238; 234, parenthesized_expression; 234, 235; 235, binary_operator:-; 235, 236; 235, 237; 236, identifier:mx; 237, identifier:mn; 238, float:0.001; 239, comment; 240, if_statement; 240, 241; 240, 242; 240, 249; 241, identifier:right; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, augmented_assignment:-=; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:bins; 247, integer:0; 248, identifier:adj; 249, else_clause; 249, 250; 250, block; 250, 251; 251, expression_statement; 251, 252; 252, augmented_assignment:+=; 252, 253; 252, 257; 253, subscript; 253, 254; 253, 255; 254, identifier:bins; 255, unary_operator:-; 255, 256; 256, integer:1; 257, identifier:adj; 258, elif_clause; 258, 259; 258, 264; 259, call; 259, 260; 259, 261; 260, identifier:isinstance; 261, argument_list; 261, 262; 261, 263; 262, identifier:bins; 263, identifier:IntervalIndex; 264, block; 264, 265; 265, if_statement; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:bins; 268, identifier:is_overlapping; 269, block; 269, 270; 270, raise_statement; 270, 271; 271, call; 271, 272; 271, 273; 272, identifier:ValueError; 273, argument_list; 273, 274; 274, string:'Overlapping IntervalIndex is not accepted.'; 275, else_clause; 275, 276; 276, block; 276, 277; 276, 306; 276, 314; 276, 315; 277, if_statement; 277, 278; 277, 282; 277, 295; 278, call; 278, 279; 278, 280; 279, identifier:is_datetime64tz_dtype; 280, argument_list; 280, 281; 281, identifier:bins; 282, block; 282, 283; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:bins; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:np; 289, identifier:asarray; 290, argument_list; 290, 291; 290, 292; 291, identifier:bins; 292, keyword_argument; 292, 293; 292, 294; 293, identifier:dtype; 294, identifier:_NS_DTYPE; 295, else_clause; 295, 296; 296, block; 296, 297; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:bins; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:np; 303, identifier:asarray; 304, argument_list; 304, 305; 305, identifier:bins; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 309; 308, identifier:bins; 309, call; 309, 310; 309, 311; 310, identifier:_convert_bin_to_numeric_type; 311, argument_list; 311, 312; 311, 313; 312, identifier:bins; 313, identifier:dtype; 314, comment; 315, if_statement; 315, 316; 315, 334; 316, call; 316, 317; 316, 333; 317, attribute; 317, 318; 317, 332; 318, parenthesized_expression; 318, 319; 319, comparison_operator:<; 319, 320; 319, 331; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:np; 323, identifier:diff; 324, argument_list; 324, 325; 325, call; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:bins; 328, identifier:astype; 329, argument_list; 329, 330; 330, string:'float64'; 331, integer:0; 332, identifier:any; 333, argument_list; 334, block; 334, 335; 335, raise_statement; 335, 336; 336, call; 336, 337; 336, 338; 337, identifier:ValueError; 338, argument_list; 338, 339; 339, string:'bins must increase monotonically.'; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 345; 342, pattern_list; 342, 343; 342, 344; 343, identifier:fac; 344, identifier:bins; 345, call; 345, 346; 345, 347; 346, identifier:_bins_to_cuts; 347, argument_list; 347, 348; 347, 349; 347, 350; 347, 353; 347, 356; 347, 359; 347, 362; 347, 365; 348, identifier:x; 349, identifier:bins; 350, keyword_argument; 350, 351; 350, 352; 351, identifier:right; 352, identifier:right; 353, keyword_argument; 353, 354; 353, 355; 354, identifier:labels; 355, identifier:labels; 356, keyword_argument; 356, 357; 356, 358; 357, identifier:precision; 358, identifier:precision; 359, keyword_argument; 359, 360; 359, 361; 360, identifier:include_lowest; 361, identifier:include_lowest; 362, keyword_argument; 362, 363; 362, 364; 363, identifier:dtype; 364, identifier:dtype; 365, keyword_argument; 365, 366; 365, 367; 366, identifier:duplicates; 367, identifier:duplicates; 368, return_statement; 368, 369; 369, call; 369, 370; 369, 371; 370, identifier:_postprocess_for_cut; 371, argument_list; 371, 372; 371, 373; 371, 374; 371, 375; 371, 376; 371, 377; 371, 378; 372, identifier:fac; 373, identifier:bins; 374, identifier:retbins; 375, identifier:x_is_series; 376, identifier:series_index; 377, identifier:name; 378, identifier:dtype | def cut(x, bins, right=True, labels=None, retbins=False, precision=3,
include_lowest=False, duplicates='raise'):
"""
Bin values into discrete intervals.
Use `cut` when you need to segment and sort data values into bins. This
function is also useful for going from a continuous variable to a
categorical variable. For example, `cut` could convert ages to groups of
age ranges. Supports binning into an equal number of bins, or a
pre-specified array of bins.
Parameters
----------
x : array-like
The input array to be binned. Must be 1-dimensional.
bins : int, sequence of scalars, or IntervalIndex
The criteria to bin by.
* int : Defines the number of equal-width bins in the range of `x`. The
range of `x` is extended by .1% on each side to include the minimum
and maximum values of `x`.
* sequence of scalars : Defines the bin edges allowing for non-uniform
width. No extension of the range of `x` is done.
* IntervalIndex : Defines the exact bins to be used. Note that
IntervalIndex for `bins` must be non-overlapping.
right : bool, default True
Indicates whether `bins` includes the rightmost edge or not. If
``right == True`` (the default), then the `bins` ``[1, 2, 3, 4]``
indicate (1,2], (2,3], (3,4]. This argument is ignored when
`bins` is an IntervalIndex.
labels : array or bool, optional
Specifies the labels for the returned bins. Must be the same length as
the resulting bins. If False, returns only integer indicators of the
bins. This affects the type of the output container (see below).
This argument is ignored when `bins` is an IntervalIndex.
retbins : bool, default False
Whether to return the bins or not. Useful when bins is provided
as a scalar.
precision : int, default 3
The precision at which to store and display the bins labels.
include_lowest : bool, default False
Whether the first interval should be left-inclusive or not.
duplicates : {default 'raise', 'drop'}, optional
If bin edges are not unique, raise ValueError or drop non-uniques.
.. versionadded:: 0.23.0
Returns
-------
out : Categorical, Series, or ndarray
An array-like object representing the respective bin for each value
of `x`. The type depends on the value of `labels`.
* True (default) : returns a Series for Series `x` or a
Categorical for all other inputs. The values stored within
are Interval dtype.
* sequence of scalars : returns a Series for Series `x` or a
Categorical for all other inputs. The values stored within
are whatever the type in the sequence is.
* False : returns an ndarray of integers.
bins : numpy.ndarray or IntervalIndex.
The computed or specified bins. Only returned when `retbins=True`.
For scalar or sequence `bins`, this is an ndarray with the computed
bins. If set `duplicates=drop`, `bins` will drop non-unique bin. For
an IntervalIndex `bins`, this is equal to `bins`.
See Also
--------
qcut : Discretize variable into equal-sized buckets based on rank
or based on sample quantiles.
Categorical : Array type for storing data that come from a
fixed set of values.
Series : One-dimensional array with axis labels (including time series).
IntervalIndex : Immutable Index implementing an ordered, sliceable set.
Notes
-----
Any NA values will be NA in the result. Out of bounds values will be NA in
the resulting Series or Categorical object.
Examples
--------
Discretize into three equal-sized bins.
>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3)
... # doctest: +ELLIPSIS
[(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
Categories (3, interval[float64]): [(0.994, 3.0] < (3.0, 5.0] ...
>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, retbins=True)
... # doctest: +ELLIPSIS
([(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
Categories (3, interval[float64]): [(0.994, 3.0] < (3.0, 5.0] ...
array([0.994, 3. , 5. , 7. ]))
Discovers the same bins, but assign them specific labels. Notice that
the returned Categorical's categories are `labels` and is ordered.
>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]),
... 3, labels=["bad", "medium", "good"])
[bad, good, medium, medium, good, bad]
Categories (3, object): [bad < medium < good]
``labels=False`` implies you just want the bins back.
>>> pd.cut([0, 1, 1, 2], bins=4, labels=False)
array([0, 1, 1, 3])
Passing a Series as an input returns a Series with categorical dtype:
>>> s = pd.Series(np.array([2, 4, 6, 8, 10]),
... index=['a', 'b', 'c', 'd', 'e'])
>>> pd.cut(s, 3)
... # doctest: +ELLIPSIS
a (1.992, 4.667]
b (1.992, 4.667]
c (4.667, 7.333]
d (7.333, 10.0]
e (7.333, 10.0]
dtype: category
Categories (3, interval[float64]): [(1.992, 4.667] < (4.667, ...
Passing a Series as an input returns a Series with mapping value.
It is used to map numerically to intervals based on bins.
>>> s = pd.Series(np.array([2, 4, 6, 8, 10]),
... index=['a', 'b', 'c', 'd', 'e'])
>>> pd.cut(s, [0, 2, 4, 6, 8, 10], labels=False, retbins=True, right=False)
... # doctest: +ELLIPSIS
(a 0.0
b 1.0
c 2.0
d 3.0
e 4.0
dtype: float64, array([0, 2, 4, 6, 8]))
Use `drop` optional when bins is not unique
>>> pd.cut(s, [0, 2, 4, 6, 10, 10], labels=False, retbins=True,
... right=False, duplicates='drop')
... # doctest: +ELLIPSIS
(a 0.0
b 1.0
c 2.0
d 3.0
e 3.0
dtype: float64, array([0, 2, 4, 6, 8]))
Passing an IntervalIndex for `bins` results in those categories exactly.
Notice that values not covered by the IntervalIndex are set to NaN. 0
is to the left of the first bin (which is closed on the right), and 1.5
falls between two bins.
>>> bins = pd.IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)])
>>> pd.cut([0, 0.5, 1.5, 2.5, 4.5], bins)
[NaN, (0, 1], NaN, (2, 3], (4, 5]]
Categories (3, interval[int64]): [(0, 1] < (2, 3] < (4, 5]]
"""
# NOTE: this binning code is changed a bit from histogram for var(x) == 0
# for handling the cut for datetime and timedelta objects
x_is_series, series_index, name, x = _preprocess_for_cut(x)
x, dtype = _coerce_to_type(x)
if not np.iterable(bins):
if is_scalar(bins) and bins < 1:
raise ValueError("`bins` should be a positive integer.")
try: # for array-like
sz = x.size
except AttributeError:
x = np.asarray(x)
sz = x.size
if sz == 0:
raise ValueError('Cannot cut empty array')
rng = (nanops.nanmin(x), nanops.nanmax(x))
mn, mx = [mi + 0.0 for mi in rng]
if np.isinf(mn) or np.isinf(mx):
# GH 24314
raise ValueError('cannot specify integer `bins` when input data '
'contains infinity')
elif mn == mx: # adjust end points before binning
mn -= .001 * abs(mn) if mn != 0 else .001
mx += .001 * abs(mx) if mx != 0 else .001
bins = np.linspace(mn, mx, bins + 1, endpoint=True)
else: # adjust end points after binning
bins = np.linspace(mn, mx, bins + 1, endpoint=True)
adj = (mx - mn) * 0.001 # 0.1% of the range
if right:
bins[0] -= adj
else:
bins[-1] += adj
elif isinstance(bins, IntervalIndex):
if bins.is_overlapping:
raise ValueError('Overlapping IntervalIndex is not accepted.')
else:
if is_datetime64tz_dtype(bins):
bins = np.asarray(bins, dtype=_NS_DTYPE)
else:
bins = np.asarray(bins)
bins = _convert_bin_to_numeric_type(bins, dtype)
# GH 26045: cast to float64 to avoid an overflow
if (np.diff(bins.astype('float64')) < 0).any():
raise ValueError('bins must increase monotonically.')
fac, bins = _bins_to_cuts(x, bins, right=right, labels=labels,
precision=precision,
include_lowest=include_lowest,
dtype=dtype,
duplicates=duplicates)
return _postprocess_for_cut(fac, bins, retbins, x_is_series,
series_index, name, dtype) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:union_categoricals; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:to_union; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_categories; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ignore_order; 10, False; 11, block; 11, 12; 11, 14; 11, 25; 11, 33; 11, 46; 11, 80; 11, 91; 11, 97; 11, 128; 11, 132; 11, 417; 11, 424; 12, expression_statement; 12, 13; 13, comment; 14, import_from_statement; 14, 15; 14, 17; 14, 19; 14, 21; 14, 23; 15, dotted_name; 15, 16; 16, identifier:pandas; 17, dotted_name; 17, 18; 18, identifier:Index; 19, dotted_name; 19, 20; 20, identifier:Categorical; 21, dotted_name; 21, 22; 22, identifier:CategoricalIndex; 23, dotted_name; 23, 24; 24, identifier:Series; 25, import_from_statement; 25, 26; 25, 31; 26, dotted_name; 26, 27; 26, 28; 26, 29; 26, 30; 27, identifier:pandas; 28, identifier:core; 29, identifier:arrays; 30, identifier:categorical; 31, dotted_name; 31, 32; 32, identifier:_recode_for_categories; 33, if_statement; 33, 34; 33, 40; 34, comparison_operator:==; 34, 35; 34, 39; 35, call; 35, 36; 35, 37; 36, identifier:len; 37, argument_list; 37, 38; 38, identifier:to_union; 39, integer:0; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:ValueError; 44, argument_list; 44, 45; 45, string:'No Categoricals to union'; 46, function_definition; 46, 47; 46, 48; 46, 50; 47, function_name:_maybe_unwrap; 48, parameters; 48, 49; 49, identifier:x; 50, block; 50, 51; 51, if_statement; 51, 52; 51, 59; 51, 64; 51, 73; 52, call; 52, 53; 52, 54; 53, identifier:isinstance; 54, argument_list; 54, 55; 54, 56; 55, identifier:x; 56, tuple; 56, 57; 56, 58; 57, identifier:CategoricalIndex; 58, identifier:Series; 59, block; 59, 60; 60, return_statement; 60, 61; 61, attribute; 61, 62; 61, 63; 62, identifier:x; 63, identifier:values; 64, elif_clause; 64, 65; 64, 70; 65, call; 65, 66; 65, 67; 66, identifier:isinstance; 67, argument_list; 67, 68; 67, 69; 68, identifier:x; 69, identifier:Categorical; 70, block; 70, 71; 71, return_statement; 71, 72; 72, identifier:x; 73, else_clause; 73, 74; 74, block; 74, 75; 75, raise_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:TypeError; 78, argument_list; 78, 79; 79, string:"all components to combine must be Categorical"; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:to_union; 83, list_comprehension; 83, 84; 83, 88; 84, call; 84, 85; 84, 86; 85, identifier:_maybe_unwrap; 86, argument_list; 86, 87; 87, identifier:x; 88, for_in_clause; 88, 89; 88, 90; 89, identifier:x; 90, identifier:to_union; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:first; 94, subscript; 94, 95; 94, 96; 95, identifier:to_union; 96, integer:0; 97, if_statement; 97, 98; 97, 122; 98, not_operator; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:all; 101, generator_expression; 101, 102; 101, 115; 102, call; 102, 103; 102, 104; 103, identifier:is_dtype_equal; 104, argument_list; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:other; 108, identifier:categories; 109, identifier:dtype; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:first; 113, identifier:categories; 114, identifier:dtype; 115, for_in_clause; 115, 116; 115, 117; 116, identifier:other; 117, subscript; 117, 118; 117, 119; 118, identifier:to_union; 119, slice; 119, 120; 119, 121; 120, integer:1; 121, colon; 122, block; 122, 123; 123, raise_statement; 123, 124; 124, call; 124, 125; 124, 126; 125, identifier:TypeError; 126, argument_list; 126, 127; 127, string:"dtype of categories must be the same"; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:ordered; 131, False; 132, if_statement; 132, 133; 132, 149; 132, 150; 132, 300; 132, 384; 133, call; 133, 134; 133, 135; 134, identifier:all; 135, generator_expression; 135, 136; 135, 142; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:first; 139, identifier:is_dtype_equal; 140, argument_list; 140, 141; 141, identifier:other; 142, for_in_clause; 142, 143; 142, 144; 143, identifier:other; 144, subscript; 144, 145; 144, 146; 145, identifier:to_union; 146, slice; 146, 147; 146, 148; 147, integer:1; 148, colon; 149, comment; 150, block; 150, 151; 150, 157; 150, 163; 150, 239; 150, 254; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:categories; 154, attribute; 154, 155; 154, 156; 155, identifier:first; 156, identifier:categories; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:ordered; 160, attribute; 160, 161; 160, 162; 161, identifier:first; 162, identifier:ordered; 163, if_statement; 163, 164; 163, 184; 163, 200; 164, call; 164, 165; 164, 166; 165, identifier:all; 166, generator_expression; 166, 167; 166, 177; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:first; 171, identifier:categories; 172, identifier:equals; 173, argument_list; 173, 174; 174, attribute; 174, 175; 174, 176; 175, identifier:other; 176, identifier:categories; 177, for_in_clause; 177, 178; 177, 179; 178, identifier:other; 179, subscript; 179, 180; 179, 181; 180, identifier:to_union; 181, slice; 181, 182; 181, 183; 182, integer:1; 183, colon; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:new_codes; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:np; 191, identifier:concatenate; 192, argument_list; 192, 193; 193, list_comprehension; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:c; 196, identifier:codes; 197, for_in_clause; 197, 198; 197, 199; 198, identifier:c; 199, identifier:to_union; 200, else_clause; 200, 201; 201, block; 201, 202; 201, 230; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:codes; 205, binary_operator:+; 205, 206; 205, 210; 206, list:[first.codes]; 206, 207; 207, attribute; 207, 208; 207, 209; 208, identifier:first; 209, identifier:codes; 210, list_comprehension; 210, 211; 210, 223; 211, call; 211, 212; 211, 213; 212, identifier:_recode_for_categories; 213, argument_list; 213, 214; 213, 217; 213, 220; 214, attribute; 214, 215; 214, 216; 215, identifier:other; 216, identifier:codes; 217, attribute; 217, 218; 217, 219; 218, identifier:other; 219, identifier:categories; 220, attribute; 220, 221; 220, 222; 221, identifier:first; 222, identifier:categories; 223, for_in_clause; 223, 224; 223, 225; 224, identifier:other; 225, subscript; 225, 226; 225, 227; 226, identifier:to_union; 227, slice; 227, 228; 227, 229; 228, integer:1; 229, colon; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:new_codes; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:np; 236, identifier:concatenate; 237, argument_list; 237, 238; 238, identifier:codes; 239, if_statement; 239, 240; 239, 246; 240, boolean_operator:and; 240, 241; 240, 245; 241, boolean_operator:and; 241, 242; 241, 243; 242, identifier:sort_categories; 243, not_operator; 243, 244; 244, identifier:ignore_order; 245, identifier:ordered; 246, block; 246, 247; 247, raise_statement; 247, 248; 248, call; 248, 249; 248, 250; 249, identifier:TypeError; 250, argument_list; 250, 251; 251, concatenated_string; 251, 252; 251, 253; 252, string:"Cannot use sort_categories=True with "; 253, string:"ordered Categoricals"; 254, if_statement; 254, 255; 254, 261; 255, boolean_operator:and; 255, 256; 255, 257; 256, identifier:sort_categories; 257, not_operator; 257, 258; 258, attribute; 258, 259; 258, 260; 259, identifier:categories; 260, identifier:is_monotonic_increasing; 261, block; 261, 262; 261, 270; 261, 281; 261, 288; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:categories; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:categories; 268, identifier:sort_values; 269, argument_list; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:indexer; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:categories; 276, identifier:get_indexer; 277, argument_list; 277, 278; 278, attribute; 278, 279; 278, 280; 279, identifier:first; 280, identifier:categories; 281, import_from_statement; 281, 282; 281, 286; 282, dotted_name; 282, 283; 282, 284; 282, 285; 283, identifier:pandas; 284, identifier:core; 285, identifier:algorithms; 286, dotted_name; 286, 287; 287, identifier:take_1d; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:new_codes; 291, call; 291, 292; 291, 293; 292, identifier:take_1d; 293, argument_list; 293, 294; 293, 295; 293, 296; 294, identifier:indexer; 295, identifier:new_codes; 296, keyword_argument; 296, 297; 296, 298; 297, identifier:fill_value; 298, unary_operator:-; 298, 299; 299, integer:1; 300, elif_clause; 300, 301; 300, 313; 300, 314; 301, boolean_operator:or; 301, 302; 301, 303; 302, identifier:ignore_order; 303, call; 303, 304; 303, 305; 304, identifier:all; 305, generator_expression; 305, 306; 305, 310; 306, not_operator; 306, 307; 307, attribute; 307, 308; 307, 309; 308, identifier:c; 309, identifier:ordered; 310, for_in_clause; 310, 311; 310, 312; 311, identifier:c; 312, identifier:to_union; 313, comment; 314, block; 314, 315; 314, 336; 314, 347; 314, 358; 314, 375; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:cats; 318, call; 318, 319; 318, 324; 319, attribute; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:first; 322, identifier:categories; 323, identifier:append; 324, argument_list; 324, 325; 325, list_comprehension; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:c; 328, identifier:categories; 329, for_in_clause; 329, 330; 329, 331; 330, identifier:c; 331, subscript; 331, 332; 331, 333; 332, identifier:to_union; 333, slice; 333, 334; 333, 335; 334, integer:1; 335, colon; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:categories; 339, call; 339, 340; 339, 341; 340, identifier:Index; 341, argument_list; 341, 342; 342, call; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:cats; 345, identifier:unique; 346, argument_list; 347, if_statement; 347, 348; 347, 349; 348, identifier:sort_categories; 349, block; 349, 350; 350, expression_statement; 350, 351; 351, assignment; 351, 352; 351, 353; 352, identifier:categories; 353, call; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:categories; 356, identifier:sort_values; 357, argument_list; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:new_codes; 361, list_comprehension; 361, 362; 361, 372; 362, call; 362, 363; 362, 364; 363, identifier:_recode_for_categories; 364, argument_list; 364, 365; 364, 368; 364, 371; 365, attribute; 365, 366; 365, 367; 366, identifier:c; 367, identifier:codes; 368, attribute; 368, 369; 368, 370; 369, identifier:c; 370, identifier:categories; 371, identifier:categories; 372, for_in_clause; 372, 373; 372, 374; 373, identifier:c; 374, identifier:to_union; 375, expression_statement; 375, 376; 376, assignment; 376, 377; 376, 378; 377, identifier:new_codes; 378, call; 378, 379; 378, 382; 379, attribute; 379, 380; 379, 381; 380, identifier:np; 381, identifier:concatenate; 382, argument_list; 382, 383; 383, identifier:new_codes; 384, else_clause; 384, 385; 384, 386; 385, comment; 386, block; 386, 387; 387, if_statement; 387, 388; 387, 397; 387, 410; 388, call; 388, 389; 388, 390; 389, identifier:all; 390, generator_expression; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:c; 393, identifier:ordered; 394, for_in_clause; 394, 395; 394, 396; 395, identifier:c; 396, identifier:to_union; 397, block; 397, 398; 397, 405; 398, expression_statement; 398, 399; 399, assignment; 399, 400; 399, 401; 400, identifier:msg; 401, parenthesized_expression; 401, 402; 402, concatenated_string; 402, 403; 402, 404; 403, string:"to union ordered Categoricals, "; 404, string:"all categories must be the same"; 405, raise_statement; 405, 406; 406, call; 406, 407; 406, 408; 407, identifier:TypeError; 408, argument_list; 408, 409; 409, identifier:msg; 410, else_clause; 410, 411; 411, block; 411, 412; 412, raise_statement; 412, 413; 413, call; 413, 414; 413, 415; 414, identifier:TypeError; 415, argument_list; 415, 416; 416, string:'Categorical.ordered must be the same'; 417, if_statement; 417, 418; 417, 419; 418, identifier:ignore_order; 419, block; 419, 420; 420, expression_statement; 420, 421; 421, assignment; 421, 422; 421, 423; 422, identifier:ordered; 423, False; 424, return_statement; 424, 425; 425, call; 425, 426; 425, 427; 426, identifier:Categorical; 427, argument_list; 427, 428; 427, 429; 427, 432; 427, 435; 428, identifier:new_codes; 429, keyword_argument; 429, 430; 429, 431; 430, identifier:categories; 431, identifier:categories; 432, keyword_argument; 432, 433; 432, 434; 433, identifier:ordered; 434, identifier:ordered; 435, keyword_argument; 435, 436; 435, 437; 436, identifier:fastpath; 437, True | def union_categoricals(to_union, sort_categories=False, ignore_order=False):
"""
Combine list-like of Categorical-like, unioning categories. All
categories must have the same dtype.
.. versionadded:: 0.19.0
Parameters
----------
to_union : list-like of Categorical, CategoricalIndex,
or Series with dtype='category'
sort_categories : boolean, default False
If true, resulting categories will be lexsorted, otherwise
they will be ordered as they appear in the data.
ignore_order : boolean, default False
If true, the ordered attribute of the Categoricals will be ignored.
Results in an unordered categorical.
.. versionadded:: 0.20.0
Returns
-------
result : Categorical
Raises
------
TypeError
- all inputs do not have the same dtype
- all inputs do not have the same ordered property
- all inputs are ordered and their categories are not identical
- sort_categories=True and Categoricals are ordered
ValueError
Empty list of categoricals passed
Notes
-----
To learn more about categories, see `link
<http://pandas.pydata.org/pandas-docs/stable/categorical.html#unioning>`__
Examples
--------
>>> from pandas.api.types import union_categoricals
If you want to combine categoricals that do not necessarily have
the same categories, `union_categoricals` will combine a list-like
of categoricals. The new categories will be the union of the
categories being combined.
>>> a = pd.Categorical(["b", "c"])
>>> b = pd.Categorical(["a", "b"])
>>> union_categoricals([a, b])
[b, c, a, b]
Categories (3, object): [b, c, a]
By default, the resulting categories will be ordered as they appear
in the `categories` of the data. If you want the categories to be
lexsorted, use `sort_categories=True` argument.
>>> union_categoricals([a, b], sort_categories=True)
[b, c, a, b]
Categories (3, object): [a, b, c]
`union_categoricals` also works with the case of combining two
categoricals of the same categories and order information (e.g. what
you could also `append` for).
>>> a = pd.Categorical(["a", "b"], ordered=True)
>>> b = pd.Categorical(["a", "b", "a"], ordered=True)
>>> union_categoricals([a, b])
[a, b, a, b, a]
Categories (2, object): [a < b]
Raises `TypeError` because the categories are ordered and not identical.
>>> a = pd.Categorical(["a", "b"], ordered=True)
>>> b = pd.Categorical(["a", "b", "c"], ordered=True)
>>> union_categoricals([a, b])
TypeError: to union ordered Categoricals, all categories must be the same
New in version 0.20.0
Ordered categoricals with different categories or orderings can be
combined by using the `ignore_ordered=True` argument.
>>> a = pd.Categorical(["a", "b", "c"], ordered=True)
>>> b = pd.Categorical(["c", "b", "a"], ordered=True)
>>> union_categoricals([a, b], ignore_order=True)
[a, b, c, c, b, a]
Categories (3, object): [a, b, c]
`union_categoricals` also works with a `CategoricalIndex`, or `Series`
containing categorical data, but note that the resulting array will
always be a plain `Categorical`
>>> a = pd.Series(["b", "c"], dtype='category')
>>> b = pd.Series(["a", "b"], dtype='category')
>>> union_categoricals([a, b])
[b, c, a, b]
Categories (3, object): [b, c, a]
"""
from pandas import Index, Categorical, CategoricalIndex, Series
from pandas.core.arrays.categorical import _recode_for_categories
if len(to_union) == 0:
raise ValueError('No Categoricals to union')
def _maybe_unwrap(x):
if isinstance(x, (CategoricalIndex, Series)):
return x.values
elif isinstance(x, Categorical):
return x
else:
raise TypeError("all components to combine must be Categorical")
to_union = [_maybe_unwrap(x) for x in to_union]
first = to_union[0]
if not all(is_dtype_equal(other.categories.dtype, first.categories.dtype)
for other in to_union[1:]):
raise TypeError("dtype of categories must be the same")
ordered = False
if all(first.is_dtype_equal(other) for other in to_union[1:]):
# identical categories - fastpath
categories = first.categories
ordered = first.ordered
if all(first.categories.equals(other.categories)
for other in to_union[1:]):
new_codes = np.concatenate([c.codes for c in to_union])
else:
codes = [first.codes] + [_recode_for_categories(other.codes,
other.categories,
first.categories)
for other in to_union[1:]]
new_codes = np.concatenate(codes)
if sort_categories and not ignore_order and ordered:
raise TypeError("Cannot use sort_categories=True with "
"ordered Categoricals")
if sort_categories and not categories.is_monotonic_increasing:
categories = categories.sort_values()
indexer = categories.get_indexer(first.categories)
from pandas.core.algorithms import take_1d
new_codes = take_1d(indexer, new_codes, fill_value=-1)
elif ignore_order or all(not c.ordered for c in to_union):
# different categories - union and recode
cats = first.categories.append([c.categories for c in to_union[1:]])
categories = Index(cats.unique())
if sort_categories:
categories = categories.sort_values()
new_codes = [_recode_for_categories(c.codes, c.categories, categories)
for c in to_union]
new_codes = np.concatenate(new_codes)
else:
# ordered - to show a proper error message
if all(c.ordered for c in to_union):
msg = ("to union ordered Categoricals, "
"all categories must be the same")
raise TypeError(msg)
else:
raise TypeError('Categorical.ordered must be the same')
if ignore_order:
ordered = False
return Categorical(new_codes, categories=categories, ordered=ordered,
fastpath=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:argsort; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 13; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ascending; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:kind; 10, string:'quicksort'; 11, list_splat_pattern; 11, 12; 12, identifier:args; 13, dictionary_splat_pattern; 13, 14; 14, identifier:kwargs; 15, block; 15, 16; 15, 18; 15, 19; 15, 20; 15, 21; 15, 22; 15, 33; 15, 41; 15, 55; 15, 69; 16, expression_statement; 16, 17; 17, comment; 18, comment; 19, comment; 20, comment; 21, comment; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:ascending; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:nv; 28, identifier:validate_argsort_with_ascending; 29, argument_list; 29, 30; 29, 31; 29, 32; 30, identifier:ascending; 31, identifier:args; 32, identifier:kwargs; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:values; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_values_for_argsort; 40, argument_list; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:result; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:np; 47, identifier:argsort; 48, argument_list; 48, 49; 48, 50; 48, 53; 49, identifier:values; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:kind; 52, identifier:kind; 53, dictionary_splat; 53, 54; 54, identifier:kwargs; 55, if_statement; 55, 56; 55, 58; 56, not_operator; 56, 57; 57, identifier:ascending; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:result; 62, subscript; 62, 63; 62, 64; 63, identifier:result; 64, slice; 64, 65; 64, 66; 64, 67; 65, colon; 66, colon; 67, unary_operator:-; 67, 68; 68, integer:1; 69, return_statement; 69, 70; 70, identifier:result | def argsort(self, ascending=True, kind='quicksort', *args, **kwargs):
"""
Return the indices that would sort this array.
Parameters
----------
ascending : bool, default True
Whether the indices should result in an ascending
or descending sort.
kind : {'quicksort', 'mergesort', 'heapsort'}, optional
Sorting algorithm.
*args, **kwargs:
passed through to :func:`numpy.argsort`.
Returns
-------
index_array : ndarray
Array of indices that sort ``self``.
See Also
--------
numpy.argsort : Sorting implementation used internally.
"""
# Implementor note: You have two places to override the behavior of
# argsort.
# 1. _values_for_argsort : construct the values passed to np.argsort
# 2. argsort : total control over sorting.
ascending = nv.validate_argsort_with_ascending(ascending, args, kwargs)
values = self._values_for_argsort()
result = np.argsort(values, kind=kind, **kwargs)
if not ascending:
result = result[::-1]
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 1, 21; 2, function_name:factorize; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 9; 6, identifier:na_sentinel; 7, type; 7, 8; 8, identifier:int; 9, unary_operator:-; 9, 10; 10, integer:1; 11, type; 11, 12; 12, generic_type; 12, 13; 12, 14; 13, identifier:Tuple; 14, type_parameter; 14, 15; 14, 19; 15, type; 15, 16; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:ndarray; 19, type; 19, 20; 20, identifier:ABCExtensionArray; 21, block; 21, 22; 21, 24; 21, 25; 21, 26; 21, 27; 21, 28; 21, 29; 21, 30; 21, 31; 21, 32; 21, 39; 21, 49; 21, 64; 21, 74; 22, expression_statement; 22, 23; 23, comment; 24, comment; 25, comment; 26, comment; 27, comment; 28, comment; 29, comment; 30, comment; 31, comment; 32, import_from_statement; 32, 33; 32, 37; 33, dotted_name; 33, 34; 33, 35; 33, 36; 34, identifier:pandas; 35, identifier:core; 36, identifier:algorithms; 37, dotted_name; 37, 38; 38, identifier:_factorize_array; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, pattern_list; 41, 42; 41, 43; 42, identifier:arr; 43, identifier:na_value; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_values_for_factorize; 48, argument_list; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, pattern_list; 51, 52; 51, 53; 52, identifier:labels; 53, identifier:uniques; 54, call; 54, 55; 54, 56; 55, identifier:_factorize_array; 56, argument_list; 56, 57; 56, 58; 56, 61; 57, identifier:arr; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:na_sentinel; 60, identifier:na_sentinel; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:na_value; 63, identifier:na_value; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:uniques; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_from_factorized; 71, argument_list; 71, 72; 71, 73; 72, identifier:uniques; 73, identifier:self; 74, return_statement; 74, 75; 75, expression_list; 75, 76; 75, 77; 76, identifier:labels; 77, identifier:uniques | def factorize(
self,
na_sentinel: int = -1,
) -> Tuple[np.ndarray, ABCExtensionArray]:
"""
Encode the extension array as an enumerated type.
Parameters
----------
na_sentinel : int, default -1
Value to use in the `labels` array to indicate missing values.
Returns
-------
labels : ndarray
An integer NumPy array that's an indexer into the original
ExtensionArray.
uniques : ExtensionArray
An ExtensionArray containing the unique values of `self`.
.. note::
uniques will *not* contain an entry for the NA value of
the ExtensionArray if there are any missing values present
in `self`.
See Also
--------
pandas.factorize : Top-level factorize method that dispatches here.
Notes
-----
:meth:`pandas.factorize` offers a `sort` keyword as well.
"""
# Impelmentor note: There are two ways to override the behavior of
# pandas.factorize
# 1. _values_for_factorize and _from_factorize.
# Specify the values passed to pandas' internal factorization
# routines, and how to convert from those values back to the
# original ExtensionArray.
# 2. ExtensionArray.factorize.
# Complete control over factorization.
from pandas.core.algorithms import _factorize_array
arr, na_value = self._values_for_factorize()
labels, uniques = _factorize_array(arr, na_sentinel=na_sentinel,
na_value=na_value)
uniques = self._from_factorized(uniques, self)
return labels, uniques |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:return_indexer; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, block; 11, 12; 11, 14; 12, expression_statement; 12, 13; 13, comment; 14, if_statement; 14, 15; 14, 16; 14, 52; 15, identifier:return_indexer; 16, block; 16, 17; 16, 25; 16, 39; 16, 48; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:_as; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:argsort; 24, argument_list; 25, if_statement; 25, 26; 25, 28; 26, not_operator; 26, 27; 27, identifier:ascending; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:_as; 32, subscript; 32, 33; 32, 34; 33, identifier:_as; 34, slice; 34, 35; 34, 36; 34, 37; 35, colon; 36, colon; 37, unary_operator:-; 37, 38; 38, integer:1; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:sorted_index; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:take; 46, argument_list; 46, 47; 47, identifier:_as; 48, return_statement; 48, 49; 49, expression_list; 49, 50; 49, 51; 50, identifier:sorted_index; 51, identifier:_as; 52, else_clause; 52, 53; 53, block; 53, 54; 53, 65; 53, 73; 53, 79; 53, 123; 53, 129; 53, 143; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:sorted_values; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:np; 60, identifier:sort; 61, argument_list; 61, 62; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_ndarray_values; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:attribs; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_get_attributes_dict; 72, argument_list; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:freq; 76, subscript; 76, 77; 76, 78; 77, identifier:attribs; 78, string:'freq'; 79, if_statement; 79, 80; 79, 89; 80, boolean_operator:and; 80, 81; 80, 84; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:freq; 83, None; 84, not_operator; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:is_period_dtype; 87, argument_list; 87, 88; 88, identifier:self; 89, block; 89, 90; 90, if_statement; 90, 91; 90, 99; 90, 107; 91, boolean_operator:and; 91, 92; 91, 97; 92, comparison_operator:>; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:freq; 95, identifier:n; 96, integer:0; 97, not_operator; 97, 98; 98, identifier:ascending; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:freq; 103, binary_operator:*; 103, 104; 103, 105; 104, identifier:freq; 105, unary_operator:-; 105, 106; 106, integer:1; 107, elif_clause; 107, 108; 107, 115; 108, boolean_operator:and; 108, 109; 108, 114; 109, comparison_operator:<; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:freq; 112, identifier:n; 113, integer:0; 114, identifier:ascending; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:freq; 119, binary_operator:*; 119, 120; 119, 121; 120, identifier:freq; 121, unary_operator:-; 121, 122; 122, integer:1; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:attribs; 127, string:'freq'; 128, identifier:freq; 129, if_statement; 129, 130; 129, 132; 130, not_operator; 130, 131; 131, identifier:ascending; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:sorted_values; 136, subscript; 136, 137; 136, 138; 137, identifier:sorted_values; 138, slice; 138, 139; 138, 140; 138, 141; 139, colon; 140, colon; 141, unary_operator:-; 141, 142; 142, integer:1; 143, return_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:_simple_new; 148, argument_list; 148, 149; 148, 150; 149, identifier:sorted_values; 150, dictionary_splat; 150, 151; 151, identifier:attribs | def sort_values(self, return_indexer=False, ascending=True):
"""
Return sorted copy of Index.
"""
if return_indexer:
_as = self.argsort()
if not ascending:
_as = _as[::-1]
sorted_index = self.take(_as)
return sorted_index, _as
else:
sorted_values = np.sort(self._ndarray_values)
attribs = self._get_attributes_dict()
freq = attribs['freq']
if freq is not None and not is_period_dtype(self):
if freq.n > 0 and not ascending:
freq = freq * -1
elif freq.n < 0 and ascending:
freq = freq * -1
attribs['freq'] = freq
if not ascending:
sorted_values = sorted_values[::-1]
return self._simple_new(sorted_values, **attribs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:axis; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ascending; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:inplace; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:kind; 19, string:'quicksort'; 20, default_parameter; 20, 21; 20, 22; 21, identifier:na_position; 22, string:'last'; 23, block; 23, 24; 23, 26; 24, expression_statement; 24, 25; 25, comment; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:NotImplementedError; 29, argument_list; 29, 30; 30, concatenated_string; 30, 31; 30, 32; 31, string:"sort_values has not been implemented "; 32, string:"on Panel or Panel4D objects." | def sort_values(self, by=None, axis=0, ascending=True, inplace=False,
kind='quicksort', na_position='last'):
"""
Sort by the values along either axis.
Parameters
----------%(optional_by)s
axis : %(axes_single_arg)s, default 0
Axis to be sorted.
ascending : bool or list of bool, default True
Sort ascending vs. descending. Specify list for multiple sort
orders. If this is a list of bools, must match the length of
the by.
inplace : bool, default False
If True, perform operation in-place.
kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
Choice of sorting algorithm. See also ndarray.np.sort for more
information. `mergesort` is the only stable algorithm. For
DataFrames, this option is only applied when sorting on a single
column or label.
na_position : {'first', 'last'}, default 'last'
Puts NaNs at the beginning if `first`; `last` puts NaNs at the
end.
Returns
-------
sorted_obj : DataFrame or None
DataFrame with sorted values if inplace=False, None otherwise.
Examples
--------
>>> df = pd.DataFrame({
... 'col1': ['A', 'A', 'B', np.nan, 'D', 'C'],
... 'col2': [2, 1, 9, 8, 7, 4],
... 'col3': [0, 1, 9, 4, 2, 3],
... })
>>> df
col1 col2 col3
0 A 2 0
1 A 1 1
2 B 9 9
3 NaN 8 4
4 D 7 2
5 C 4 3
Sort by col1
>>> df.sort_values(by=['col1'])
col1 col2 col3
0 A 2 0
1 A 1 1
2 B 9 9
5 C 4 3
4 D 7 2
3 NaN 8 4
Sort by multiple columns
>>> df.sort_values(by=['col1', 'col2'])
col1 col2 col3
1 A 1 1
0 A 2 0
2 B 9 9
5 C 4 3
4 D 7 2
3 NaN 8 4
Sort Descending
>>> df.sort_values(by='col1', ascending=False)
col1 col2 col3
4 D 7 2
5 C 4 3
2 B 9 9
0 A 2 0
1 A 1 1
3 NaN 8 4
Putting NAs first
>>> df.sort_values(by='col1', ascending=False, na_position='first')
col1 col2 col3
3 NaN 8 4
4 D 7 2
5 C 4 3
2 B 9 9
0 A 2 0
1 A 1 1
"""
raise NotImplementedError("sort_values has not been implemented "
"on Panel or Panel4D objects.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 31; 2, function_name:groupby; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:axis; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:level; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:as_index; 16, True; 17, default_parameter; 17, 18; 17, 19; 18, identifier:sort; 19, True; 20, default_parameter; 20, 21; 20, 22; 21, identifier:group_keys; 22, True; 23, default_parameter; 23, 24; 23, 25; 24, identifier:squeeze; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:observed; 28, False; 29, dictionary_splat_pattern; 29, 30; 30, identifier:kwargs; 31, block; 31, 32; 31, 34; 31, 42; 31, 56; 31, 65; 32, expression_statement; 32, 33; 33, comment; 34, import_from_statement; 34, 35; 34, 40; 35, dotted_name; 35, 36; 35, 37; 35, 38; 35, 39; 36, identifier:pandas; 37, identifier:core; 38, identifier:groupby; 39, identifier:groupby; 40, dotted_name; 40, 41; 41, identifier:groupby; 42, if_statement; 42, 43; 42, 50; 43, boolean_operator:and; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:level; 46, None; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:by; 49, None; 50, block; 50, 51; 51, raise_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:TypeError; 54, argument_list; 54, 55; 55, string:"You have to supply one of 'by' and 'level'"; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:axis; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_get_axis_number; 63, argument_list; 63, 64; 64, identifier:axis; 65, return_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:groupby; 68, argument_list; 68, 69; 68, 70; 68, 73; 68, 76; 68, 79; 68, 82; 68, 85; 68, 88; 68, 91; 68, 94; 69, identifier:self; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:by; 72, identifier:by; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:axis; 75, identifier:axis; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:level; 78, identifier:level; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:as_index; 81, identifier:as_index; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:sort; 84, identifier:sort; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:group_keys; 87, identifier:group_keys; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:squeeze; 90, identifier:squeeze; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:observed; 93, identifier:observed; 94, dictionary_splat; 94, 95; 95, identifier:kwargs | def groupby(self, by=None, axis=0, level=None, as_index=True, sort=True,
group_keys=True, squeeze=False, observed=False, **kwargs):
"""
Group DataFrame or Series using a mapper or by a Series of columns.
A groupby operation involves some combination of splitting the
object, applying a function, and combining the results. This can be
used to group large amounts of data and compute operations on these
groups.
Parameters
----------
by : mapping, function, label, or list of labels
Used to determine the groups for the groupby.
If ``by`` is a function, it's called on each value of the object's
index. If a dict or Series is passed, the Series or dict VALUES
will be used to determine the groups (the Series' values are first
aligned; see ``.align()`` method). If an ndarray is passed, the
values are used as-is determine the groups. A label or list of
labels may be passed to group by the columns in ``self``. Notice
that a tuple is interpreted a (single) key.
axis : {0 or 'index', 1 or 'columns'}, default 0
Split along rows (0) or columns (1).
level : int, level name, or sequence of such, default None
If the axis is a MultiIndex (hierarchical), group by a particular
level or levels.
as_index : bool, default True
For aggregated output, return object with group labels as the
index. Only relevant for DataFrame input. as_index=False is
effectively "SQL-style" grouped output.
sort : bool, default True
Sort group keys. Get better performance by turning this off.
Note this does not influence the order of observations within each
group. Groupby preserves the order of rows within each group.
group_keys : bool, default True
When calling apply, add group keys to index to identify pieces.
squeeze : bool, default False
Reduce the dimensionality of the return type if possible,
otherwise return a consistent type.
observed : bool, default False
This only applies if any of the groupers are Categoricals.
If True: only show observed values for categorical groupers.
If False: show all values for categorical groupers.
.. versionadded:: 0.23.0
**kwargs
Optional, only accepts keyword argument 'mutated' and is passed
to groupby.
Returns
-------
DataFrameGroupBy or SeriesGroupBy
Depends on the calling object and returns groupby object that
contains information about the groups.
See Also
--------
resample : Convenience method for frequency conversion and resampling
of time series.
Notes
-----
See the `user guide
<http://pandas.pydata.org/pandas-docs/stable/groupby.html>`_ for more.
Examples
--------
>>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',
... 'Parrot', 'Parrot'],
... 'Max Speed': [380., 370., 24., 26.]})
>>> df
Animal Max Speed
0 Falcon 380.0
1 Falcon 370.0
2 Parrot 24.0
3 Parrot 26.0
>>> df.groupby(['Animal']).mean()
Max Speed
Animal
Falcon 375.0
Parrot 25.0
**Hierarchical Indexes**
We can groupby different levels of a hierarchical index
using the `level` parameter:
>>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],
... ['Captive', 'Wild', 'Captive', 'Wild']]
>>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type'))
>>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]},
... index=index)
>>> df
Max Speed
Animal Type
Falcon Captive 390.0
Wild 350.0
Parrot Captive 30.0
Wild 20.0
>>> df.groupby(level=0).mean()
Max Speed
Animal
Falcon 370.0
Parrot 25.0
>>> df.groupby(level=1).mean()
Max Speed
Type
Captive 210.0
Wild 185.0
"""
from pandas.core.groupby.groupby import groupby
if level is None and by is None:
raise TypeError("You have to supply one of 'by' and 'level'")
axis = self._get_axis_number(axis)
return groupby(self, by=by, axis=axis, level=level, as_index=as_index,
sort=sort, group_keys=group_keys, squeeze=squeeze,
observed=observed, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:inplace; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:kind; 16, string:'quicksort'; 17, default_parameter; 17, 18; 17, 19; 18, identifier:na_position; 19, string:'last'; 20, block; 20, 21; 20, 23; 20, 31; 20, 32; 20, 39; 20, 40; 20, 54; 20, 86; 20, 92; 20, 109; 20, 116; 20, 121; 20, 133; 20, 142; 20, 175; 20, 187; 20, 201; 20, 283; 20, 301; 21, expression_statement; 21, 22; 22, comment; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:inplace; 26, call; 26, 27; 26, 28; 27, identifier:validate_bool_kwarg; 28, argument_list; 28, 29; 28, 30; 29, identifier:inplace; 30, string:'inplace'; 31, comment; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_get_axis_number; 37, argument_list; 37, 38; 38, identifier:axis; 39, comment; 40, if_statement; 40, 41; 40, 46; 41, boolean_operator:and; 41, 42; 41, 43; 42, identifier:inplace; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_is_cached; 46, block; 46, 47; 47, raise_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:ValueError; 50, argument_list; 50, 51; 51, concatenated_string; 51, 52; 51, 53; 52, string:"This Series is a view of some other array, to "; 53, string:"sort in-place you must create a copy"; 54, function_definition; 54, 55; 54, 56; 54, 58; 54, 59; 55, function_name:_try_kind_sort; 56, parameters; 56, 57; 57, identifier:arr; 58, comment; 59, block; 59, 60; 60, try_statement; 60, 61; 60, 62; 60, 72; 61, comment; 62, block; 62, 63; 63, return_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:arr; 67, identifier:argsort; 68, argument_list; 68, 69; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:kind; 71, identifier:kind; 72, except_clause; 72, 73; 72, 74; 72, 75; 72, 76; 73, identifier:TypeError; 74, comment; 75, comment; 76, block; 76, 77; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:arr; 81, identifier:argsort; 82, argument_list; 82, 83; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:kind; 85, string:'quicksort'; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:arr; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_values; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:sortedIdx; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:np; 98, identifier:empty; 99, argument_list; 99, 100; 99, 104; 100, call; 100, 101; 100, 102; 101, identifier:len; 102, argument_list; 102, 103; 103, identifier:self; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:dtype; 106, attribute; 106, 107; 106, 108; 107, identifier:np; 108, identifier:int32; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:bad; 112, call; 112, 113; 112, 114; 113, identifier:isna; 114, argument_list; 114, 115; 115, identifier:arr; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:good; 119, unary_operator:~; 119, 120; 120, identifier:bad; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:idx; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:ibase; 127, identifier:default_index; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:len; 131, argument_list; 131, 132; 132, identifier:self; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:argsorted; 136, call; 136, 137; 136, 138; 137, identifier:_try_kind_sort; 138, argument_list; 138, 139; 139, subscript; 139, 140; 139, 141; 140, identifier:arr; 141, identifier:good; 142, if_statement; 142, 143; 142, 147; 143, call; 143, 144; 143, 145; 144, identifier:is_list_like; 145, argument_list; 145, 146; 146, identifier:ascending; 147, block; 147, 148; 147, 169; 148, if_statement; 148, 149; 148, 155; 149, comparison_operator:!=; 149, 150; 149, 154; 150, call; 150, 151; 150, 152; 151, identifier:len; 152, argument_list; 152, 153; 153, identifier:ascending; 154, integer:1; 155, block; 155, 156; 156, raise_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:ValueError; 159, argument_list; 159, 160; 160, binary_operator:%; 160, 161; 160, 164; 161, concatenated_string; 161, 162; 161, 163; 162, string:'Length of ascending (%d) must be 1 '; 163, string:'for Series'; 164, parenthesized_expression; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:len; 167, argument_list; 167, 168; 168, identifier:ascending; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:ascending; 172, subscript; 172, 173; 172, 174; 173, identifier:ascending; 174, integer:0; 175, if_statement; 175, 176; 175, 181; 176, not_operator; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:is_bool; 179, argument_list; 179, 180; 180, identifier:ascending; 181, block; 181, 182; 182, raise_statement; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:ValueError; 185, argument_list; 185, 186; 186, string:'ascending must be boolean'; 187, if_statement; 187, 188; 187, 190; 188, not_operator; 188, 189; 189, identifier:ascending; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:argsorted; 194, subscript; 194, 195; 194, 196; 195, identifier:argsorted; 196, slice; 196, 197; 196, 198; 196, 199; 197, colon; 198, colon; 199, unary_operator:-; 199, 200; 200, integer:1; 201, if_statement; 201, 202; 201, 205; 201, 236; 201, 271; 202, comparison_operator:==; 202, 203; 202, 204; 203, identifier:na_position; 204, string:'last'; 205, block; 205, 206; 205, 214; 205, 226; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:n; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:good; 212, identifier:sum; 213, argument_list; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 221; 216, subscript; 216, 217; 216, 218; 217, identifier:sortedIdx; 218, slice; 218, 219; 218, 220; 219, colon; 220, identifier:n; 221, subscript; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:idx; 224, identifier:good; 225, identifier:argsorted; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 233; 228, subscript; 228, 229; 228, 230; 229, identifier:sortedIdx; 230, slice; 230, 231; 230, 232; 231, identifier:n; 232, colon; 233, subscript; 233, 234; 233, 235; 234, identifier:idx; 235, identifier:bad; 236, elif_clause; 236, 237; 236, 240; 237, comparison_operator:==; 237, 238; 237, 239; 238, identifier:na_position; 239, string:'first'; 240, block; 240, 241; 240, 249; 240, 261; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:n; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:bad; 247, identifier:sum; 248, argument_list; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 256; 251, subscript; 251, 252; 251, 253; 252, identifier:sortedIdx; 253, slice; 253, 254; 253, 255; 254, identifier:n; 255, colon; 256, subscript; 256, 257; 256, 260; 257, subscript; 257, 258; 257, 259; 258, identifier:idx; 259, identifier:good; 260, identifier:argsorted; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 268; 263, subscript; 263, 264; 263, 265; 264, identifier:sortedIdx; 265, slice; 265, 266; 265, 267; 266, colon; 267, identifier:n; 268, subscript; 268, 269; 268, 270; 269, identifier:idx; 270, identifier:bad; 271, else_clause; 271, 272; 272, block; 272, 273; 273, raise_statement; 273, 274; 274, call; 274, 275; 274, 276; 275, identifier:ValueError; 276, argument_list; 276, 277; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, string:'invalid na_position: {!r}'; 280, identifier:format; 281, argument_list; 281, 282; 282, identifier:na_position; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:result; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:self; 289, identifier:_constructor; 290, argument_list; 290, 291; 290, 294; 291, subscript; 291, 292; 291, 293; 292, identifier:arr; 293, identifier:sortedIdx; 294, keyword_argument; 294, 295; 294, 296; 295, identifier:index; 296, subscript; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:self; 299, identifier:index; 300, identifier:sortedIdx; 301, if_statement; 301, 302; 301, 303; 301, 311; 302, identifier:inplace; 303, block; 303, 304; 304, expression_statement; 304, 305; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:self; 308, identifier:_update_inplace; 309, argument_list; 309, 310; 310, identifier:result; 311, else_clause; 311, 312; 312, block; 312, 313; 313, return_statement; 313, 314; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:result; 317, identifier:__finalize__; 318, argument_list; 318, 319; 319, identifier:self | def sort_values(self, axis=0, ascending=True, inplace=False,
kind='quicksort', na_position='last'):
"""
Sort by the values.
Sort a Series in ascending or descending order by some
criterion.
Parameters
----------
axis : {0 or 'index'}, default 0
Axis to direct sorting. The value 'index' is accepted for
compatibility with DataFrame.sort_values.
ascending : bool, default True
If True, sort values in ascending order, otherwise descending.
inplace : bool, default False
If True, perform operation in-place.
kind : {'quicksort', 'mergesort' or 'heapsort'}, default 'quicksort'
Choice of sorting algorithm. See also :func:`numpy.sort` for more
information. 'mergesort' is the only stable algorithm.
na_position : {'first' or 'last'}, default 'last'
Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at
the end.
Returns
-------
Series
Series ordered by values.
See Also
--------
Series.sort_index : Sort by the Series indices.
DataFrame.sort_values : Sort DataFrame by the values along either axis.
DataFrame.sort_index : Sort DataFrame by indices.
Examples
--------
>>> s = pd.Series([np.nan, 1, 3, 10, 5])
>>> s
0 NaN
1 1.0
2 3.0
3 10.0
4 5.0
dtype: float64
Sort values ascending order (default behaviour)
>>> s.sort_values(ascending=True)
1 1.0
2 3.0
4 5.0
3 10.0
0 NaN
dtype: float64
Sort values descending order
>>> s.sort_values(ascending=False)
3 10.0
4 5.0
2 3.0
1 1.0
0 NaN
dtype: float64
Sort values inplace
>>> s.sort_values(ascending=False, inplace=True)
>>> s
3 10.0
4 5.0
2 3.0
1 1.0
0 NaN
dtype: float64
Sort values putting NAs first
>>> s.sort_values(na_position='first')
0 NaN
1 1.0
2 3.0
4 5.0
3 10.0
dtype: float64
Sort a series of strings
>>> s = pd.Series(['z', 'b', 'd', 'a', 'c'])
>>> s
0 z
1 b
2 d
3 a
4 c
dtype: object
>>> s.sort_values()
3 a
1 b
4 c
2 d
0 z
dtype: object
"""
inplace = validate_bool_kwarg(inplace, 'inplace')
# Validate the axis parameter
self._get_axis_number(axis)
# GH 5856/5853
if inplace and self._is_cached:
raise ValueError("This Series is a view of some other array, to "
"sort in-place you must create a copy")
def _try_kind_sort(arr):
# easier to ask forgiveness than permission
try:
# if kind==mergesort, it can fail for object dtype
return arr.argsort(kind=kind)
except TypeError:
# stable sort not available for object dtype
# uses the argsort default quicksort
return arr.argsort(kind='quicksort')
arr = self._values
sortedIdx = np.empty(len(self), dtype=np.int32)
bad = isna(arr)
good = ~bad
idx = ibase.default_index(len(self))
argsorted = _try_kind_sort(arr[good])
if is_list_like(ascending):
if len(ascending) != 1:
raise ValueError('Length of ascending (%d) must be 1 '
'for Series' % (len(ascending)))
ascending = ascending[0]
if not is_bool(ascending):
raise ValueError('ascending must be boolean')
if not ascending:
argsorted = argsorted[::-1]
if na_position == 'last':
n = good.sum()
sortedIdx[:n] = idx[good][argsorted]
sortedIdx[n:] = idx[bad]
elif na_position == 'first':
n = bad.sum()
sortedIdx[n:] = idx[good][argsorted]
sortedIdx[:n] = idx[bad]
else:
raise ValueError('invalid na_position: {!r}'.format(na_position))
result = self._constructor(arr[sortedIdx], index=self.index[sortedIdx])
if inplace:
self._update_inplace(result)
else:
return result.__finalize__(self) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:sort_index; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:level; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ascending; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:inplace; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:kind; 19, string:'quicksort'; 20, default_parameter; 20, 21; 20, 22; 21, identifier:na_position; 22, string:'last'; 23, default_parameter; 23, 24; 23, 25; 24, identifier:sort_remaining; 25, True; 26, block; 26, 27; 26, 29; 26, 30; 26, 31; 26, 39; 26, 40; 26, 47; 26, 53; 26, 170; 26, 177; 26, 186; 26, 194; 26, 205; 26, 217; 27, expression_statement; 27, 28; 28, comment; 29, comment; 30, comment; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:inplace; 34, call; 34, 35; 34, 36; 35, identifier:validate_bool_kwarg; 36, argument_list; 36, 37; 36, 38; 37, identifier:inplace; 38, string:'inplace'; 39, comment; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:_get_axis_number; 45, argument_list; 45, 46; 46, identifier:axis; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:index; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:index; 53, if_statement; 53, 54; 53, 57; 53, 75; 53, 114; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:level; 56, None; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 63; 60, pattern_list; 60, 61; 60, 62; 61, identifier:new_index; 62, identifier:indexer; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:index; 66, identifier:sortlevel; 67, argument_list; 67, 68; 67, 69; 67, 72; 68, identifier:level; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:ascending; 71, identifier:ascending; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:sort_remaining; 74, identifier:sort_remaining; 75, elif_clause; 75, 76; 75, 81; 76, call; 76, 77; 76, 78; 77, identifier:isinstance; 78, argument_list; 78, 79; 78, 80; 79, identifier:index; 80, identifier:MultiIndex; 81, block; 81, 82; 81, 89; 81, 97; 82, import_from_statement; 82, 83; 82, 87; 83, dotted_name; 83, 84; 83, 85; 83, 86; 84, identifier:pandas; 85, identifier:core; 86, identifier:sorting; 87, dotted_name; 87, 88; 88, identifier:lexsort_indexer; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:labels; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:index; 95, identifier:_sort_levels_monotonic; 96, argument_list; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:indexer; 100, call; 100, 101; 100, 102; 101, identifier:lexsort_indexer; 102, argument_list; 102, 103; 102, 108; 102, 111; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:labels; 106, identifier:_get_codes_for_sorting; 107, argument_list; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:orders; 110, identifier:ascending; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:na_position; 113, identifier:na_position; 114, else_clause; 114, 115; 115, block; 115, 116; 115, 123; 115, 124; 115, 125; 115, 154; 116, import_from_statement; 116, 117; 116, 121; 117, dotted_name; 117, 118; 117, 119; 117, 120; 118, identifier:pandas; 119, identifier:core; 120, identifier:sorting; 121, dotted_name; 121, 122; 122, identifier:nargsort; 123, comment; 124, comment; 125, if_statement; 125, 126; 125, 141; 126, parenthesized_expression; 126, 127; 127, boolean_operator:or; 127, 128; 127, 134; 128, parenthesized_expression; 128, 129; 129, boolean_operator:and; 129, 130; 129, 131; 130, identifier:ascending; 131, attribute; 131, 132; 131, 133; 132, identifier:index; 133, identifier:is_monotonic_increasing; 134, parenthesized_expression; 134, 135; 135, boolean_operator:and; 135, 136; 135, 138; 136, not_operator; 136, 137; 137, identifier:ascending; 138, attribute; 138, 139; 138, 140; 139, identifier:index; 140, identifier:is_monotonic_decreasing; 141, block; 141, 142; 142, if_statement; 142, 143; 142, 144; 142, 146; 143, identifier:inplace; 144, block; 144, 145; 145, return_statement; 146, else_clause; 146, 147; 147, block; 147, 148; 148, return_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:copy; 153, argument_list; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:indexer; 157, call; 157, 158; 157, 159; 158, identifier:nargsort; 159, argument_list; 159, 160; 159, 161; 159, 164; 159, 167; 160, identifier:index; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:kind; 163, identifier:kind; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:ascending; 166, identifier:ascending; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:na_position; 169, identifier:na_position; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:indexer; 173, call; 173, 174; 173, 175; 174, identifier:ensure_platform_int; 175, argument_list; 175, 176; 176, identifier:indexer; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:new_index; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:index; 183, identifier:take; 184, argument_list; 184, 185; 185, identifier:indexer; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:new_index; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:new_index; 192, identifier:_sort_levels_monotonic; 193, argument_list; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:new_values; 197, call; 197, 198; 197, 203; 198, attribute; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:self; 201, identifier:_values; 202, identifier:take; 203, argument_list; 203, 204; 204, identifier:indexer; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:result; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:_constructor; 212, argument_list; 212, 213; 212, 214; 213, identifier:new_values; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:index; 216, identifier:new_index; 217, if_statement; 217, 218; 217, 219; 217, 227; 218, identifier:inplace; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:self; 224, identifier:_update_inplace; 225, argument_list; 225, 226; 226, identifier:result; 227, else_clause; 227, 228; 228, block; 228, 229; 229, return_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:result; 233, identifier:__finalize__; 234, argument_list; 234, 235; 235, identifier:self | def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
kind='quicksort', na_position='last', sort_remaining=True):
"""
Sort Series by index labels.
Returns a new Series sorted by label if `inplace` argument is
``False``, otherwise updates the original series and returns None.
Parameters
----------
axis : int, default 0
Axis to direct sorting. This can only be 0 for Series.
level : int, optional
If not None, sort on values in specified index level(s).
ascending : bool, default true
Sort ascending vs. descending.
inplace : bool, default False
If True, perform operation in-place.
kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
Choice of sorting algorithm. See also :func:`numpy.sort` for more
information. 'mergesort' is the only stable algorithm. For
DataFrames, this option is only applied when sorting on a single
column or label.
na_position : {'first', 'last'}, default 'last'
If 'first' puts NaNs at the beginning, 'last' puts NaNs at the end.
Not implemented for MultiIndex.
sort_remaining : bool, default True
If True and sorting by level and index is multilevel, sort by other
levels too (in order) after sorting by specified level.
Returns
-------
Series
The original Series sorted by the labels.
See Also
--------
DataFrame.sort_index: Sort DataFrame by the index.
DataFrame.sort_values: Sort DataFrame by the value.
Series.sort_values : Sort Series by the value.
Examples
--------
>>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, 4])
>>> s.sort_index()
1 c
2 b
3 a
4 d
dtype: object
Sort Descending
>>> s.sort_index(ascending=False)
4 d
3 a
2 b
1 c
dtype: object
Sort Inplace
>>> s.sort_index(inplace=True)
>>> s
1 c
2 b
3 a
4 d
dtype: object
By default NaNs are put at the end, but use `na_position` to place
them at the beginning
>>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, np.nan])
>>> s.sort_index(na_position='first')
NaN d
1.0 c
2.0 b
3.0 a
dtype: object
Specify index level to sort
>>> arrays = [np.array(['qux', 'qux', 'foo', 'foo',
... 'baz', 'baz', 'bar', 'bar']),
... np.array(['two', 'one', 'two', 'one',
... 'two', 'one', 'two', 'one'])]
>>> s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index=arrays)
>>> s.sort_index(level=1)
bar one 8
baz one 6
foo one 4
qux one 2
bar two 7
baz two 5
foo two 3
qux two 1
dtype: int64
Does not sort by remaining levels when sorting by levels
>>> s.sort_index(level=1, sort_remaining=False)
qux one 2
foo one 4
baz one 6
bar one 8
qux two 1
foo two 3
baz two 5
bar two 7
dtype: int64
"""
# TODO: this can be combined with DataFrame.sort_index impl as
# almost identical
inplace = validate_bool_kwarg(inplace, 'inplace')
# Validate the axis parameter
self._get_axis_number(axis)
index = self.index
if level is not None:
new_index, indexer = index.sortlevel(level, ascending=ascending,
sort_remaining=sort_remaining)
elif isinstance(index, MultiIndex):
from pandas.core.sorting import lexsort_indexer
labels = index._sort_levels_monotonic()
indexer = lexsort_indexer(labels._get_codes_for_sorting(),
orders=ascending,
na_position=na_position)
else:
from pandas.core.sorting import nargsort
# Check monotonic-ness before sort an index
# GH11080
if ((ascending and index.is_monotonic_increasing) or
(not ascending and index.is_monotonic_decreasing)):
if inplace:
return
else:
return self.copy()
indexer = nargsort(index, kind=kind, ascending=ascending,
na_position=na_position)
indexer = ensure_platform_int(indexer)
new_index = index.take(indexer)
new_index = new_index._sort_levels_monotonic()
new_values = self._values.take(indexer)
result = self._constructor(new_values, index=new_index)
if inplace:
self._update_inplace(result)
else:
return result.__finalize__(self) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:nlargest; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:n; 7, integer:5; 8, default_parameter; 8, 9; 8, 10; 9, identifier:keep; 10, string:'first'; 11, block; 11, 12; 11, 14; 12, expression_statement; 12, 13; 13, comment; 14, return_statement; 14, 15; 15, call; 15, 16; 15, 30; 16, attribute; 16, 17; 16, 29; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:algorithms; 20, identifier:SelectNSeries; 21, argument_list; 21, 22; 21, 23; 21, 26; 22, identifier:self; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:n; 25, identifier:n; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:keep; 28, identifier:keep; 29, identifier:nlargest; 30, argument_list | def nlargest(self, n=5, keep='first'):
"""
Return the largest `n` elements.
Parameters
----------
n : int, default 5
Return this many descending sorted values.
keep : {'first', 'last', 'all'}, default 'first'
When there are duplicate values that cannot all fit in a
Series of `n` elements:
- ``first`` : return the first `n` occurrences in order
of appearance.
- ``last`` : return the last `n` occurrences in reverse
order of appearance.
- ``all`` : keep all occurrences. This can result in a Series of
size larger than `n`.
Returns
-------
Series
The `n` largest values in the Series, sorted in decreasing order.
See Also
--------
Series.nsmallest: Get the `n` smallest elements.
Series.sort_values: Sort Series by values.
Series.head: Return the first `n` rows.
Notes
-----
Faster than ``.sort_values(ascending=False).head(n)`` for small `n`
relative to the size of the ``Series`` object.
Examples
--------
>>> countries_population = {"Italy": 59000000, "France": 65000000,
... "Malta": 434000, "Maldives": 434000,
... "Brunei": 434000, "Iceland": 337000,
... "Nauru": 11300, "Tuvalu": 11300,
... "Anguilla": 11300, "Monserat": 5200}
>>> s = pd.Series(countries_population)
>>> s
Italy 59000000
France 65000000
Malta 434000
Maldives 434000
Brunei 434000
Iceland 337000
Nauru 11300
Tuvalu 11300
Anguilla 11300
Monserat 5200
dtype: int64
The `n` largest elements where ``n=5`` by default.
>>> s.nlargest()
France 65000000
Italy 59000000
Malta 434000
Maldives 434000
Brunei 434000
dtype: int64
The `n` largest elements where ``n=3``. Default `keep` value is 'first'
so Malta will be kept.
>>> s.nlargest(3)
France 65000000
Italy 59000000
Malta 434000
dtype: int64
The `n` largest elements where ``n=3`` and keeping the last duplicates.
Brunei will be kept since it is the last with value 434000 based on
the index order.
>>> s.nlargest(3, keep='last')
France 65000000
Italy 59000000
Brunei 434000
dtype: int64
The `n` largest elements where ``n=3`` with all duplicates kept. Note
that the returned Series has five elements due to the three duplicates.
>>> s.nlargest(3, keep='all')
France 65000000
Italy 59000000
Malta 434000
Maldives 434000
Brunei 434000
dtype: int64
"""
return algorithms.SelectNSeries(self, n=n, keep=keep).nlargest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:nsmallest; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:n; 7, integer:5; 8, default_parameter; 8, 9; 8, 10; 9, identifier:keep; 10, string:'first'; 11, block; 11, 12; 11, 14; 12, expression_statement; 12, 13; 13, comment; 14, return_statement; 14, 15; 15, call; 15, 16; 15, 30; 16, attribute; 16, 17; 16, 29; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:algorithms; 20, identifier:SelectNSeries; 21, argument_list; 21, 22; 21, 23; 21, 26; 22, identifier:self; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:n; 25, identifier:n; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:keep; 28, identifier:keep; 29, identifier:nsmallest; 30, argument_list | def nsmallest(self, n=5, keep='first'):
"""
Return the smallest `n` elements.
Parameters
----------
n : int, default 5
Return this many ascending sorted values.
keep : {'first', 'last', 'all'}, default 'first'
When there are duplicate values that cannot all fit in a
Series of `n` elements:
- ``first`` : return the first `n` occurrences in order
of appearance.
- ``last`` : return the last `n` occurrences in reverse
order of appearance.
- ``all`` : keep all occurrences. This can result in a Series of
size larger than `n`.
Returns
-------
Series
The `n` smallest values in the Series, sorted in increasing order.
See Also
--------
Series.nlargest: Get the `n` largest elements.
Series.sort_values: Sort Series by values.
Series.head: Return the first `n` rows.
Notes
-----
Faster than ``.sort_values().head(n)`` for small `n` relative to
the size of the ``Series`` object.
Examples
--------
>>> countries_population = {"Italy": 59000000, "France": 65000000,
... "Brunei": 434000, "Malta": 434000,
... "Maldives": 434000, "Iceland": 337000,
... "Nauru": 11300, "Tuvalu": 11300,
... "Anguilla": 11300, "Monserat": 5200}
>>> s = pd.Series(countries_population)
>>> s
Italy 59000000
France 65000000
Brunei 434000
Malta 434000
Maldives 434000
Iceland 337000
Nauru 11300
Tuvalu 11300
Anguilla 11300
Monserat 5200
dtype: int64
The `n` smallest elements where ``n=5`` by default.
>>> s.nsmallest()
Monserat 5200
Nauru 11300
Tuvalu 11300
Anguilla 11300
Iceland 337000
dtype: int64
The `n` smallest elements where ``n=3``. Default `keep` value is
'first' so Nauru and Tuvalu will be kept.
>>> s.nsmallest(3)
Monserat 5200
Nauru 11300
Tuvalu 11300
dtype: int64
The `n` smallest elements where ``n=3`` and keeping the last
duplicates. Anguilla and Tuvalu will be kept since they are the last
with value 11300 based on the index order.
>>> s.nsmallest(3, keep='last')
Monserat 5200
Anguilla 11300
Tuvalu 11300
dtype: int64
The `n` smallest elements where ``n=3`` with all duplicates kept. Note
that the returned Series has four elements due to the three duplicates.
>>> s.nsmallest(3, keep='all')
Monserat 5200
Nauru 11300
Tuvalu 11300
Anguilla 11300
dtype: int64
"""
return algorithms.SelectNSeries(self, n=n, keep=keep).nsmallest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:searchsorted; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:value; 6, default_parameter; 6, 7; 6, 8; 7, identifier:side; 8, string:"left"; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sorter; 11, None; 12, block; 12, 13; 12, 15; 12, 16; 12, 17; 12, 18; 12, 19; 12, 20; 12, 21; 12, 22; 12, 39; 13, expression_statement; 13, 14; 14, comment; 15, comment; 16, comment; 17, comment; 18, comment; 19, comment; 20, comment; 21, comment; 22, try_statement; 22, 23; 22, 35; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:value; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:dtype; 32, identifier:type; 33, argument_list; 33, 34; 34, identifier:value; 35, except_clause; 35, 36; 35, 37; 36, identifier:ValueError; 37, block; 37, 38; 38, pass_statement; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, call; 42, 43; 42, 44; 43, identifier:super; 44, argument_list; 45, identifier:searchsorted; 46, argument_list; 46, 47; 46, 48; 46, 51; 47, identifier:value; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:side; 50, identifier:side; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:sorter; 53, identifier:sorter | def searchsorted(self, value, side="left", sorter=None):
"""
Find indices to insert `value` so as to maintain order.
For full documentation, see `numpy.searchsorted`
See Also
--------
numpy.searchsorted : Equivalent function.
"""
# We are much more performant if the searched
# indexer is the same type as the array.
#
# This doesn't matter for int64, but DOES
# matter for smaller int dtypes.
#
# xref: https://github.com/numpy/numpy/issues/5370
try:
value = self.dtype.type(value)
except ValueError:
pass
return super().searchsorted(value, side=side, sorter=sorter) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:from_arrays; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:arrays; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sortorder; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:names; 11, None; 12, block; 12, 13; 12, 15; 12, 19; 12, 44; 12, 45; 12, 61; 12, 62; 12, 63; 12, 96; 12, 104; 12, 113; 12, 131; 13, expression_statement; 13, 14; 14, comment; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:error_msg; 18, string:"Input must be a list / sequence of array-likes."; 19, if_statement; 19, 20; 19, 25; 19, 31; 20, not_operator; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:is_list_like; 23, argument_list; 23, 24; 24, identifier:arrays; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:TypeError; 29, argument_list; 29, 30; 30, identifier:error_msg; 31, elif_clause; 31, 32; 31, 36; 32, call; 32, 33; 32, 34; 33, identifier:is_iterator; 34, argument_list; 34, 35; 35, identifier:arrays; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:arrays; 40, call; 40, 41; 40, 42; 41, identifier:list; 42, argument_list; 42, 43; 43, identifier:arrays; 44, comment; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:array; 47, identifier:arrays; 48, block; 48, 49; 49, if_statement; 49, 50; 49, 55; 50, not_operator; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:is_list_like; 53, argument_list; 53, 54; 54, identifier:array; 55, block; 55, 56; 56, raise_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:TypeError; 59, argument_list; 59, 60; 60, identifier:error_msg; 61, comment; 62, comment; 63, for_statement; 63, 64; 63, 65; 63, 73; 64, identifier:i; 65, call; 65, 66; 65, 67; 66, identifier:range; 67, argument_list; 67, 68; 67, 69; 68, integer:1; 69, call; 69, 70; 69, 71; 70, identifier:len; 71, argument_list; 71, 72; 72, identifier:arrays; 73, block; 73, 74; 74, if_statement; 74, 75; 74, 90; 75, comparison_operator:!=; 75, 76; 75, 82; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:arrays; 81, identifier:i; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, subscript; 85, 86; 85, 87; 86, identifier:arrays; 87, binary_operator:-; 87, 88; 87, 89; 88, identifier:i; 89, integer:1; 90, block; 90, 91; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:ValueError; 94, argument_list; 94, 95; 95, string:'all arrays must be same length'; 96, import_from_statement; 96, 97; 96, 102; 97, dotted_name; 97, 98; 97, 99; 97, 100; 97, 101; 98, identifier:pandas; 99, identifier:core; 100, identifier:arrays; 101, identifier:categorical; 102, dotted_name; 102, 103; 103, identifier:_factorize_from_iterables; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 109; 106, pattern_list; 106, 107; 106, 108; 107, identifier:codes; 108, identifier:levels; 109, call; 109, 110; 109, 111; 110, identifier:_factorize_from_iterables; 111, argument_list; 111, 112; 112, identifier:arrays; 113, if_statement; 113, 114; 113, 117; 114, comparison_operator:is; 114, 115; 114, 116; 115, identifier:names; 116, None; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:names; 121, list_comprehension; 121, 122; 121, 128; 122, call; 122, 123; 122, 124; 123, identifier:getattr; 124, argument_list; 124, 125; 124, 126; 124, 127; 125, identifier:arr; 126, string:"name"; 127, None; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:arr; 130, identifier:arrays; 131, return_statement; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:MultiIndex; 134, argument_list; 134, 135; 134, 138; 134, 141; 134, 144; 134, 147; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:levels; 137, identifier:levels; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:codes; 140, identifier:codes; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:sortorder; 143, identifier:sortorder; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:names; 146, identifier:names; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:verify_integrity; 149, False | def from_arrays(cls, arrays, sortorder=None, names=None):
"""
Convert arrays to MultiIndex.
Parameters
----------
arrays : list / sequence of array-likes
Each array-like gives one level's value for each data point.
len(arrays) is the number of levels.
sortorder : int or None
Level of sortedness (must be lexicographically sorted by that
level).
names : list / sequence of str, optional
Names for the levels in the index.
Returns
-------
index : MultiIndex
See Also
--------
MultiIndex.from_tuples : Convert list of tuples to MultiIndex.
MultiIndex.from_product : Make a MultiIndex from cartesian product
of iterables.
MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
Examples
--------
>>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
>>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
MultiIndex(levels=[[1, 2], ['blue', 'red']],
codes=[[0, 0, 1, 1], [1, 0, 1, 0]],
names=['number', 'color'])
"""
error_msg = "Input must be a list / sequence of array-likes."
if not is_list_like(arrays):
raise TypeError(error_msg)
elif is_iterator(arrays):
arrays = list(arrays)
# Check if elements of array are list-like
for array in arrays:
if not is_list_like(array):
raise TypeError(error_msg)
# Check if lengths of all arrays are equal or not,
# raise ValueError, if not
for i in range(1, len(arrays)):
if len(arrays[i]) != len(arrays[i - 1]):
raise ValueError('all arrays must be same length')
from pandas.core.arrays.categorical import _factorize_from_iterables
codes, levels = _factorize_from_iterables(arrays)
if names is None:
names = [getattr(arr, "name", None) for arr in arrays]
return MultiIndex(levels=levels, codes=codes, sortorder=sortorder,
names=names, verify_integrity=False) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:from_tuples; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:tuples; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sortorder; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:names; 11, None; 12, block; 12, 13; 12, 15; 12, 40; 12, 141; 13, expression_statement; 13, 14; 14, comment; 15, if_statement; 15, 16; 15, 21; 15, 27; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:is_list_like; 19, argument_list; 19, 20; 20, identifier:tuples; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:TypeError; 25, argument_list; 25, 26; 26, string:'Input must be a list / sequence of tuple-likes.'; 27, elif_clause; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:is_iterator; 30, argument_list; 30, 31; 31, identifier:tuples; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:tuples; 36, call; 36, 37; 36, 38; 37, identifier:list; 38, argument_list; 38, 39; 39, identifier:tuples; 40, if_statement; 40, 41; 40, 47; 40, 72; 40, 110; 40, 131; 41, comparison_operator:==; 41, 42; 41, 46; 42, call; 42, 43; 42, 44; 43, identifier:len; 44, argument_list; 44, 45; 45, identifier:tuples; 46, integer:0; 47, block; 47, 48; 47, 62; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:names; 51, None; 52, block; 52, 53; 52, 57; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:msg; 56, string:'Cannot infer number of levels from empty list'; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:TypeError; 60, argument_list; 60, 61; 61, identifier:msg; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:arrays; 65, binary_operator:*; 65, 66; 65, 68; 66, list:[[]]; 66, 67; 67, list:[]; 68, call; 68, 69; 68, 70; 69, identifier:len; 70, argument_list; 70, 71; 71, identifier:names; 72, elif_clause; 72, 73; 72, 82; 73, call; 73, 74; 73, 75; 74, identifier:isinstance; 75, argument_list; 75, 76; 75, 77; 76, identifier:tuples; 77, tuple; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:np; 80, identifier:ndarray; 81, identifier:Index; 82, block; 82, 83; 82, 96; 83, if_statement; 83, 84; 83, 89; 84, call; 84, 85; 84, 86; 85, identifier:isinstance; 86, argument_list; 86, 87; 86, 88; 87, identifier:tuples; 88, identifier:Index; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:tuples; 93, attribute; 93, 94; 93, 95; 94, identifier:tuples; 95, identifier:_values; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:arrays; 99, call; 99, 100; 99, 101; 100, identifier:list; 101, argument_list; 101, 102; 102, attribute; 102, 103; 102, 109; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:lib; 106, identifier:tuples_to_object_array; 107, argument_list; 107, 108; 108, identifier:tuples; 109, identifier:T; 110, elif_clause; 110, 111; 110, 116; 111, call; 111, 112; 111, 113; 112, identifier:isinstance; 113, argument_list; 113, 114; 113, 115; 114, identifier:tuples; 115, identifier:list; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:arrays; 120, call; 120, 121; 120, 122; 121, identifier:list; 122, argument_list; 122, 123; 123, attribute; 123, 124; 123, 130; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:lib; 127, identifier:to_object_array_tuples; 128, argument_list; 128, 129; 129, identifier:tuples; 130, identifier:T; 131, else_clause; 131, 132; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:arrays; 136, call; 136, 137; 136, 138; 137, identifier:lzip; 138, argument_list; 138, 139; 139, list_splat; 139, 140; 140, identifier:tuples; 141, return_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:MultiIndex; 145, identifier:from_arrays; 146, argument_list; 146, 147; 146, 148; 146, 151; 147, identifier:arrays; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:sortorder; 150, identifier:sortorder; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:names; 153, identifier:names | def from_tuples(cls, tuples, sortorder=None, names=None):
"""
Convert list of tuples to MultiIndex.
Parameters
----------
tuples : list / sequence of tuple-likes
Each tuple is the index of one row/column.
sortorder : int or None
Level of sortedness (must be lexicographically sorted by that
level).
names : list / sequence of str, optional
Names for the levels in the index.
Returns
-------
index : MultiIndex
See Also
--------
MultiIndex.from_arrays : Convert list of arrays to MultiIndex.
MultiIndex.from_product : Make a MultiIndex from cartesian product
of iterables.
MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
Examples
--------
>>> tuples = [(1, 'red'), (1, 'blue'),
... (2, 'red'), (2, 'blue')]
>>> pd.MultiIndex.from_tuples(tuples, names=('number', 'color'))
MultiIndex(levels=[[1, 2], ['blue', 'red']],
codes=[[0, 0, 1, 1], [1, 0, 1, 0]],
names=['number', 'color'])
"""
if not is_list_like(tuples):
raise TypeError('Input must be a list / sequence of tuple-likes.')
elif is_iterator(tuples):
tuples = list(tuples)
if len(tuples) == 0:
if names is None:
msg = 'Cannot infer number of levels from empty list'
raise TypeError(msg)
arrays = [[]] * len(names)
elif isinstance(tuples, (np.ndarray, Index)):
if isinstance(tuples, Index):
tuples = tuples._values
arrays = list(lib.tuples_to_object_array(tuples).T)
elif isinstance(tuples, list):
arrays = list(lib.to_object_array_tuples(tuples).T)
else:
arrays = lzip(*tuples)
return MultiIndex.from_arrays(arrays, sortorder=sortorder, names=names) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:from_product; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:iterables; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sortorder; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:names; 11, None; 12, block; 12, 13; 12, 15; 12, 23; 12, 31; 12, 56; 12, 65; 12, 72; 13, expression_statement; 13, 14; 14, comment; 15, import_from_statement; 15, 16; 15, 21; 16, dotted_name; 16, 17; 16, 18; 16, 19; 16, 20; 17, identifier:pandas; 18, identifier:core; 19, identifier:arrays; 20, identifier:categorical; 21, dotted_name; 21, 22; 22, identifier:_factorize_from_iterables; 23, import_from_statement; 23, 24; 23, 29; 24, dotted_name; 24, 25; 24, 26; 24, 27; 24, 28; 25, identifier:pandas; 26, identifier:core; 27, identifier:reshape; 28, identifier:util; 29, dotted_name; 29, 30; 30, identifier:cartesian_product; 31, if_statement; 31, 32; 31, 37; 31, 43; 32, not_operator; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:is_list_like; 35, argument_list; 35, 36; 36, identifier:iterables; 37, block; 37, 38; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:TypeError; 41, argument_list; 41, 42; 42, string:"Input must be a list / sequence of iterables."; 43, elif_clause; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:is_iterator; 46, argument_list; 46, 47; 47, identifier:iterables; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:iterables; 52, call; 52, 53; 52, 54; 53, identifier:list; 54, argument_list; 54, 55; 55, identifier:iterables; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, pattern_list; 58, 59; 58, 60; 59, identifier:codes; 60, identifier:levels; 61, call; 61, 62; 61, 63; 62, identifier:_factorize_from_iterables; 63, argument_list; 63, 64; 64, identifier:iterables; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:codes; 68, call; 68, 69; 68, 70; 69, identifier:cartesian_product; 70, argument_list; 70, 71; 71, identifier:codes; 72, return_statement; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:MultiIndex; 75, argument_list; 75, 76; 75, 77; 75, 78; 75, 81; 76, identifier:levels; 77, identifier:codes; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:sortorder; 80, identifier:sortorder; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:names; 83, identifier:names | def from_product(cls, iterables, sortorder=None, names=None):
"""
Make a MultiIndex from the cartesian product of multiple iterables.
Parameters
----------
iterables : list / sequence of iterables
Each iterable has unique labels for each level of the index.
sortorder : int or None
Level of sortedness (must be lexicographically sorted by that
level).
names : list / sequence of str, optional
Names for the levels in the index.
Returns
-------
index : MultiIndex
See Also
--------
MultiIndex.from_arrays : Convert list of arrays to MultiIndex.
MultiIndex.from_tuples : Convert list of tuples to MultiIndex.
MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
Examples
--------
>>> numbers = [0, 1, 2]
>>> colors = ['green', 'purple']
>>> pd.MultiIndex.from_product([numbers, colors],
... names=['number', 'color'])
MultiIndex(levels=[[0, 1, 2], ['green', 'purple']],
codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
names=['number', 'color'])
"""
from pandas.core.arrays.categorical import _factorize_from_iterables
from pandas.core.reshape.util import cartesian_product
if not is_list_like(iterables):
raise TypeError("Input must be a list / sequence of iterables.")
elif is_iterator(iterables):
iterables = list(iterables)
codes, levels = _factorize_from_iterables(iterables)
codes = cartesian_product(codes)
return MultiIndex(levels, codes, sortorder=sortorder, names=names) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:from_frame; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:df; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sortorder; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:names; 11, None; 12, block; 12, 13; 12, 15; 12, 28; 12, 42; 12, 51; 13, expression_statement; 13, 14; 14, comment; 15, if_statement; 15, 16; 15, 22; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:df; 21, identifier:ABCDataFrame; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:TypeError; 26, argument_list; 26, 27; 27, string:"Input must be a DataFrame"; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 33; 30, pattern_list; 30, 31; 30, 32; 31, identifier:column_names; 32, identifier:columns; 33, call; 33, 34; 33, 35; 34, identifier:lzip; 35, argument_list; 35, 36; 36, list_splat; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:df; 40, identifier:iteritems; 41, argument_list; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:names; 45, conditional_expression:if; 45, 46; 45, 47; 45, 50; 46, identifier:column_names; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:names; 49, None; 50, identifier:names; 51, return_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:cls; 55, identifier:from_arrays; 56, argument_list; 56, 57; 56, 58; 56, 61; 57, identifier:columns; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:sortorder; 60, identifier:sortorder; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:names; 63, identifier:names | def from_frame(cls, df, sortorder=None, names=None):
"""
Make a MultiIndex from a DataFrame.
.. versionadded:: 0.24.0
Parameters
----------
df : DataFrame
DataFrame to be converted to MultiIndex.
sortorder : int, optional
Level of sortedness (must be lexicographically sorted by that
level).
names : list-like, optional
If no names are provided, use the column names, or tuple of column
names if the columns is a MultiIndex. If a sequence, overwrite
names with the given sequence.
Returns
-------
MultiIndex
The MultiIndex representation of the given DataFrame.
See Also
--------
MultiIndex.from_arrays : Convert list of arrays to MultiIndex.
MultiIndex.from_tuples : Convert list of tuples to MultiIndex.
MultiIndex.from_product : Make a MultiIndex from cartesian product
of iterables.
Examples
--------
>>> df = pd.DataFrame([['HI', 'Temp'], ['HI', 'Precip'],
... ['NJ', 'Temp'], ['NJ', 'Precip']],
... columns=['a', 'b'])
>>> df
a b
0 HI Temp
1 HI Precip
2 NJ Temp
3 NJ Precip
>>> pd.MultiIndex.from_frame(df)
MultiIndex(levels=[['HI', 'NJ'], ['Precip', 'Temp']],
codes=[[0, 0, 1, 1], [1, 0, 1, 0]],
names=['a', 'b'])
Using explicit names, instead of the column names
>>> pd.MultiIndex.from_frame(df, names=['state', 'observation'])
MultiIndex(levels=[['HI', 'NJ'], ['Precip', 'Temp']],
codes=[[0, 0, 1, 1], [1, 0, 1, 0]],
names=['state', 'observation'])
"""
if not isinstance(df, ABCDataFrame):
raise TypeError("Input must be a DataFrame")
column_names, columns = lzip(*df.iteritems())
names = column_names if names is None else names
return cls.from_arrays(columns, sortorder=sortorder, names=names) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sortlevel; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:level; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort_remaining; 13, True; 14, block; 14, 15; 14, 17; 14, 24; 14, 38; 14, 51; 14, 55; 14, 56; 14, 231; 14, 238; 14, 253; 14, 278; 15, expression_statement; 15, 16; 16, comment; 17, import_from_statement; 17, 18; 17, 22; 18, dotted_name; 18, 19; 18, 20; 18, 21; 19, identifier:pandas; 20, identifier:core; 21, identifier:sorting; 22, dotted_name; 22, 23; 23, identifier:indexer_from_factorized; 24, if_statement; 24, 25; 24, 32; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:level; 29, tuple; 29, 30; 29, 31; 30, identifier:str; 31, identifier:int; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:level; 36, list:[level]; 36, 37; 37, identifier:level; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:level; 41, list_comprehension; 41, 42; 41, 48; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_get_level_number; 46, argument_list; 46, 47; 47, identifier:lev; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:lev; 50, identifier:level; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:sortorder; 54, None; 55, comment; 56, if_statement; 56, 57; 56, 62; 56, 105; 56, 106; 57, call; 57, 58; 57, 59; 58, identifier:isinstance; 59, argument_list; 59, 60; 59, 61; 60, identifier:ascending; 61, identifier:list; 62, block; 62, 63; 62, 80; 62, 87; 63, if_statement; 63, 64; 63, 74; 64, not_operator; 64, 65; 65, comparison_operator:==; 65, 66; 65, 70; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, identifier:level; 70, call; 70, 71; 70, 72; 71, identifier:len; 72, argument_list; 72, 73; 73, identifier:ascending; 74, block; 74, 75; 75, raise_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:ValueError; 78, argument_list; 78, 79; 79, string:"level must have same length as ascending"; 80, import_from_statement; 80, 81; 80, 85; 81, dotted_name; 81, 82; 81, 83; 81, 84; 82, identifier:pandas; 83, identifier:core; 84, identifier:sorting; 85, dotted_name; 85, 86; 86, identifier:lexsort_indexer; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:indexer; 90, call; 90, 91; 90, 92; 91, identifier:lexsort_indexer; 92, argument_list; 92, 93; 92, 102; 93, list_comprehension; 93, 94; 93, 99; 94, subscript; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:codes; 98, identifier:lev; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:lev; 101, identifier:level; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:orders; 104, identifier:ascending; 105, comment; 106, else_clause; 106, 107; 107, block; 107, 108; 107, 117; 107, 126; 107, 127; 107, 139; 107, 151; 107, 152; 107, 153; 107, 177; 107, 206; 107, 217; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:codes; 111, call; 111, 112; 111, 113; 112, identifier:list; 113, argument_list; 113, 114; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:codes; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:shape; 120, call; 120, 121; 120, 122; 121, identifier:list; 122, argument_list; 122, 123; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:levshape; 126, comment; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:primary; 130, call; 130, 131; 130, 132; 131, identifier:tuple; 132, generator_expression; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:codes; 135, identifier:lev; 136, for_in_clause; 136, 137; 136, 138; 137, identifier:lev; 138, identifier:level; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:primshp; 142, call; 142, 143; 142, 144; 143, identifier:tuple; 144, generator_expression; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:shape; 147, identifier:lev; 148, for_in_clause; 148, 149; 148, 150; 149, identifier:lev; 150, identifier:level; 151, comment; 152, comment; 153, for_statement; 153, 154; 153, 155; 153, 162; 154, identifier:lev; 155, call; 155, 156; 155, 157; 156, identifier:sorted; 157, argument_list; 157, 158; 157, 159; 158, identifier:level; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:reverse; 161, True; 162, block; 162, 163; 162, 170; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:codes; 167, identifier:pop; 168, argument_list; 168, 169; 169, identifier:lev; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:shape; 174, identifier:pop; 175, argument_list; 175, 176; 176, identifier:lev; 177, if_statement; 177, 178; 177, 179; 177, 198; 178, identifier:sort_remaining; 179, block; 179, 180; 179, 189; 180, expression_statement; 180, 181; 181, augmented_assignment:+=; 181, 182; 181, 183; 182, identifier:primary; 183, binary_operator:+; 183, 184; 183, 185; 184, identifier:primary; 185, call; 185, 186; 185, 187; 186, identifier:tuple; 187, argument_list; 187, 188; 188, identifier:codes; 189, expression_statement; 189, 190; 190, augmented_assignment:+=; 190, 191; 190, 192; 191, identifier:primshp; 192, binary_operator:+; 192, 193; 192, 194; 193, identifier:primshp; 194, call; 194, 195; 194, 196; 195, identifier:tuple; 196, argument_list; 196, 197; 197, identifier:shape; 198, else_clause; 198, 199; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:sortorder; 203, subscript; 203, 204; 203, 205; 204, identifier:level; 205, integer:0; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:indexer; 209, call; 209, 210; 209, 211; 210, identifier:indexer_from_factorized; 211, argument_list; 211, 212; 211, 213; 211, 214; 212, identifier:primary; 213, identifier:primshp; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:compress; 216, False; 217, if_statement; 217, 218; 217, 220; 218, not_operator; 218, 219; 219, identifier:ascending; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:indexer; 224, subscript; 224, 225; 224, 226; 225, identifier:indexer; 226, slice; 226, 227; 226, 228; 226, 229; 227, colon; 228, colon; 229, unary_operator:-; 229, 230; 230, integer:1; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:indexer; 234, call; 234, 235; 234, 236; 235, identifier:ensure_platform_int; 236, argument_list; 236, 237; 237, identifier:indexer; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:new_codes; 241, list_comprehension; 241, 242; 241, 248; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:level_codes; 245, identifier:take; 246, argument_list; 246, 247; 247, identifier:indexer; 248, for_in_clause; 248, 249; 248, 250; 249, identifier:level_codes; 250, attribute; 250, 251; 250, 252; 251, identifier:self; 252, identifier:codes; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:new_index; 256, call; 256, 257; 256, 258; 257, identifier:MultiIndex; 258, argument_list; 258, 259; 258, 262; 258, 267; 258, 272; 258, 275; 259, keyword_argument; 259, 260; 259, 261; 260, identifier:codes; 261, identifier:new_codes; 262, keyword_argument; 262, 263; 262, 264; 263, identifier:levels; 264, attribute; 264, 265; 264, 266; 265, identifier:self; 266, identifier:levels; 267, keyword_argument; 267, 268; 267, 269; 268, identifier:names; 269, attribute; 269, 270; 269, 271; 270, identifier:self; 271, identifier:names; 272, keyword_argument; 272, 273; 272, 274; 273, identifier:sortorder; 274, identifier:sortorder; 275, keyword_argument; 275, 276; 275, 277; 276, identifier:verify_integrity; 277, False; 278, return_statement; 278, 279; 279, expression_list; 279, 280; 279, 281; 280, identifier:new_index; 281, identifier:indexer | def sortlevel(self, level=0, ascending=True, sort_remaining=True):
"""
Sort MultiIndex at the requested level. The result will respect the
original ordering of the associated factor at that level.
Parameters
----------
level : list-like, int or str, default 0
If a string is given, must be a name of the level
If list-like must be names or ints of levels.
ascending : boolean, default True
False to sort in descending order
Can also be a list to specify a directed ordering
sort_remaining : sort by the remaining levels after level
Returns
-------
sorted_index : pd.MultiIndex
Resulting index.
indexer : np.ndarray
Indices of output values in original index.
"""
from pandas.core.sorting import indexer_from_factorized
if isinstance(level, (str, int)):
level = [level]
level = [self._get_level_number(lev) for lev in level]
sortorder = None
# we have a directed ordering via ascending
if isinstance(ascending, list):
if not len(level) == len(ascending):
raise ValueError("level must have same length as ascending")
from pandas.core.sorting import lexsort_indexer
indexer = lexsort_indexer([self.codes[lev] for lev in level],
orders=ascending)
# level ordering
else:
codes = list(self.codes)
shape = list(self.levshape)
# partition codes and shape
primary = tuple(codes[lev] for lev in level)
primshp = tuple(shape[lev] for lev in level)
# Reverse sorted to retain the order of
# smaller indices that needs to be removed
for lev in sorted(level, reverse=True):
codes.pop(lev)
shape.pop(lev)
if sort_remaining:
primary += primary + tuple(codes)
primshp += primshp + tuple(shape)
else:
sortorder = level[0]
indexer = indexer_from_factorized(primary, primshp,
compress=False)
if not ascending:
indexer = indexer[::-1]
indexer = ensure_platform_int(indexer)
new_codes = [level_codes.take(indexer) for level_codes in self.codes]
new_index = MultiIndex(codes=new_codes, levels=self.levels,
names=self.names, sortorder=sortorder,
verify_integrity=False)
return new_index, indexer |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:slice_locs; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:start; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:end; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:step; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:kind; 16, None; 17, block; 17, 18; 17, 20; 17, 21; 17, 22; 18, expression_statement; 18, 19; 19, comment; 20, comment; 21, comment; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, call; 25, 26; 25, 27; 26, identifier:super; 27, argument_list; 28, identifier:slice_locs; 29, argument_list; 29, 30; 29, 31; 29, 32; 29, 33; 30, identifier:start; 31, identifier:end; 32, identifier:step; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:kind; 35, identifier:kind | def slice_locs(self, start=None, end=None, step=None, kind=None):
"""
For an ordered MultiIndex, compute the slice locations for input
labels.
The input labels can be tuples representing partial levels, e.g. for a
MultiIndex with 3 levels, you can pass a single value (corresponding to
the first level), or a 1-, 2-, or 3-tuple.
Parameters
----------
start : label or tuple, default None
If None, defaults to the beginning
end : label or tuple
If None, defaults to the end
step : int or None
Slice step
kind : string, optional, defaults None
Returns
-------
(start, end) : (int, int)
Notes
-----
This method only works if the MultiIndex is properly lexsorted. So,
if only the first 2 levels of a 3-level MultiIndex are lexsorted,
you can only pass two levels to ``.slice_locs``.
Examples
--------
>>> mi = pd.MultiIndex.from_arrays([list('abbd'), list('deff')],
... names=['A', 'B'])
Get the slice locations from the beginning of 'b' in the first level
until the end of the multiindex:
>>> mi.slice_locs(start='b')
(1, 4)
Like above, but stop at the end of 'b' in the first level and 'f' in
the second level:
>>> mi.slice_locs(start='b', end=('b', 'f'))
(1, 3)
See Also
--------
MultiIndex.get_loc : Get location for a label or a tuple of labels.
MultiIndex.get_locs : Get location for a label/slice/list/mask or a
sequence of such.
"""
# This function adds nothing to its parent implementation (the magic
# happens in get_slice_bound method), but it adds meaningful doc.
return super().slice_locs(start, end, step, kind=kind) |
Subsets and Splits