voodoo 发表于 2015-3-3 08:14 
1. help rename group，具体实现为rename *, lower
2. help import：import excel或import delimited均有个 ...
许多求助的人就是不看help和manual的， user guide和data management 两本看看也花不了多长时间的
Syntax
Rename a single variable
rename old new [, options1]
Rename groups of variables
rename (old1 old2 ...) (new1 new2 ...) [, options1]
Change the case of groups of variable names
rename old1 old2 ..., {upper|lower|proper} [options2]
where old and new specify the existing and the new variable names. The rules for specifying them are
1. rename stat status: Renames stat to status.
Rule 1: This is the same rename command documented in [D] rename, with which you are familiar.
2. rename (stat inc) (status income): Renames stat to status and inc to income.
Rule 2: Use parentheses to specify multiple variables for old and new.
3. rename (v1 v2) (v2 v1): Swaps v1 and v2.
Rule 3: Variable names may be interchanged.
4. rename (a b c) (b c a): Swaps names. Renames a to b, b to c, and c to a.
Rule 4: There is no limit to how many names may be interchanged.
5. rename (a b c) (c b a): Renames a to c and c to a, but leaves b as is.
Rule 5: Renaming variables to themselves is allowed.
6. rename jan* *1: Renames all variables starting with jan to instead end with 1, for example, janstat to stat1, janinc to inc1, etc.
Rule 6.1: * in old selects the variables to be renamed. * means that zero or more characters go here.
Rule 6.2: * in new corresponds with * in old and stands for the text that * in old matched.
* in new or old is called a wildcard character, or just a wildcard.
rename jan* *: Removes prefix jan.
rename *jan *: Removes suffix jan.
7. rename jan? ?1: Renames all variables starting with jan and ending in one character by removing jan and adding 1 to the end; for example, jans
is renamed to s1, but janstat remains unchanged. ? means that exactly one character goes here, just as * means that zero or more characters
go here.
Rule 7: ? means exactly one character, ?? means exactly two characters, etc.
8. rename *jan* **: Removes prefix, midfix, and suffix jan, for example, janstat to stat, injanstat to instat, and subjan to sub.
Rule 8: You may specify more than one wildcard in old and in new. They correspond in the order given.
rename jan*s* *s*1: Renames all variables that start with jan and contain s to instead end in 1, dropping the jan, for example, janstat to
stat1 and janest to est1, but not janinc to inc1.
9. rename *jan* *: Removes jan and whatever follows from variable names, thereby renaming statjan to stat, incjan71 to inc, ....
Rule 9: You may specify more wildcards in old than in new.
10. rename *jan* .*: Removes jan and whatever precedes it from variable names, thereby renaming midjaninc to inc, ....
Rule 10: Wildcard . (dot) in new skips over the corresponding wildcard in old.
11. rename *pop jan=: Adds prefix jan to all variables ending in pop, for example, age1pop to janage1pop, ....
rename (status bp time) admit=: Renames status to admitstatus, bp to admitbp, and time to admittime.
rename whatever pre=: Adds prefix pre to all variables selected by whatever, however whatever is specified.
Rule 11: Wildcard = in new specifies the original variable name.
rename whatever =jan: Adds suffix jan to all variables selected by whatever.
rename whatever pre=fix: Adds prefix pre and suffix fix to all variables selected by whatever.
12. rename v# stat#: Renames v1 to stat1, v2 to stat2, ..., v10 to stat10, ....
Rule 12.1: # is like * but for digits. # in old selects one or more digits.
Rule 12.2: # in new copies the digits just as they appear in the corresponding old.
13. rename v(#) stat(#): Renames v1 to stat1, v2 to stat2, ..., but does not rename v10, ....
Rule 13.1: (#) in old selects exactly one digit. Similarly, (##) selects exactly two digits, and so on, up to ten # symbols.
Rule 13.2: (#) in new means reformat to one or more digits. Similarly, (##) reformats to two or more digits, and so on, up to ten #
symbols.
rename v(##) stat(##): Renames v01 to stat01, v02 to stat02, ..., v10 to stat10, ..., but does not rename v0, v1, v2, ..., v9, v100, ....
14. rename v# v(##): Renames v1 to v01, v2 to v02, ..., v10 to v10, v11 to v11, ..., v100 to v100, v101 to v101, ....
Rule 14: You may combine #, (#), (##), ... in old with any of #, (#), (##), ... in new.
rename v(##) v(#): Renames v01 to v1, v02 to v2, ..., v10 to v10, ..., but does not rename v001, etc.
rename stat(##) stat_20(##): Renames stat10 to stat_2010, stat11 to stat_2011, ..., but does not rename stat1, stat2, ....
rename stat(#) to stat_200(#): Renames stat1 to stat_2001, stat2 to stat_2002, ..., but does not rename stat10 or stat_2010.
15. rename v# (a b c): Renames v1 to a, v10 to b, and v2 to c if variables v1, v10, v2 appear in that order in the data. Because three variables
were specified in new, v# in old must select three variables or rename will issue an error.
Rule 15.1: You may mix syntaxes. Note that the explicit and implied numbers of variables must agree.
rename v# (a b c), sort: Renames (for instance) v1 to a, v2 to b, and v10 to c.
Rule 15.2: The sort option places the variables selected by old in order and does so smartly. In the case where #, (#), (##), ... appear
in old, sort places the variables in numeric order.
rename v* (a b c), sort: Renames (for instance) valpha to a, vbeta to b, and vgamma to c regardless of the order of the variables in the data.
Rule 15.3: In the case where * or ? appears in old, sort places the variables in alphabetical order.
16. rename v# v#, renumber: Renames (for instance) v9 to v1, v10 to v2, v8 to v3, ..., assuming that variables v9, v10, v8, ... appear in that
order in the data.
Rule 16.1: The renumber option resequences the numbers.
rename v# v#, renumber sort: Renames (for instance) v8 to v1, v9 to v2, v10 to v3, .... Concerning option sort, see rule 15.2 above.
rename v# v#, renumber(10) sort: Renames (for instance) v8 to v10, v9 to v11, v10 to v12, ....
Rule 16.2: The renumber(#) option allows you to specify the starting value.
17. rename v* v#, renumber: Renames (for instance) valpha to v1, vgamma to v2, vbeta to v3, ..., assuming variables valpha, vgamma, vbeta, ...
appear in that order in the data.
Rule 17: # in new may correspond to *, ?, #, (#), (##), ... in old.
rename v* v#, renumber sort: Renames (for instance) valpha to v1, vbeta to v2, vgamma to v3, .... Also see rule 15.3 above concerning the
sort option.
rename *stat stat#, renumber: Renames, for instance, janstat to stat1, febstat to stat2, .... Note that # in new corresponds to * in old,
just as in the previous example.
rename *stat stat(##), renumber: Renames, for instance, janstat to stat01, febstat to stat02, ....
rename *stat stat#, renumber(0): Renames, for instance, janstat to stat0, febstat to stat1, ....
rename *stat stat#, renumber sort: Renames, for instance, aprstat to stat1, augstat to stat2, ....
18. rename (a b c) v#, addnumber: Renames a to v1, b to v2, and c to v3.
Rule 18: The addnumber option allows you to add numbering. More formally, if you specify addnumber, you may specify one more wildcard in
new than is specified in old, and that extra wildcard must be #, (#), (##), ....
19. rename a(#)(#) a(#)[2](#)[1]: Renames a12 to a21, a13 to a31, a14 to a41, ..., a21 to a12, ....
Rule 19.1: You may specify explicit subscripts with wildcards in new to make explicit its matching wildcard in old. Subscripts are
specified in square brackets after a wildcard in new. The number refers to the number of the wildcard in old.
rename *stat* *[2]stat*[1]: Swaps prefixes and suffixes; it renames bpstata to astatbp, rstater to erstatr, etc.
rename *stat* *[2]stat*: Does the same as above; it swaps prefixes and suffixes.
Rule 19.2: After specifying a subscripted wildcard, subsequent unsubscripted wildcards correspond to the same wildcards in old as they
would if you had removed the subscripted wildcards altogether.
rename v#a# v#_#[1]_a#[2]: Renames v1a1 to v1_1_a1, v1a2 to v1_1_a2, ..., v2a1 to v2_2_a1, ....
Rule 19.3: Using subscripts, you may refer to the same wildcard in old more than once.
Subscripts are commonly used to interchange suffixes at the ends of variable names. For instance, you have districts and schools within them,
and many of the variable names in your data match *_#_#. The first number records district and the second records school within district. To
reverse the ordering, you type rename *_#_# *_#[3]_#[2]. When specifying subscripts, you refer to them by the position number in the original
name. For example, our original name was *_#_# so [1] refers to *, [2] refers to the first #, and [3] refers to the last #.
In summary, the pattern specifiers are
Specifier Meaning in old
-------------------------------------------------------------------
* 0 or more characters
? 1 character exactly
# 1 or more digits
(#) 1 digit exactly
(##) 2 digits exactly
(###) 3 digits exactly
...
(##########) 10 digits exactly
-------------------------------------------------------------------
May correspond
Specifier in old with Meaning in new
-------------------------------------------------------------------
* *, ?, #, (#), ... copies matched text
? ? copies a character
# #, (#), ... copies a number as is
(#) #, (#), ... reformats to 1 or more digits
(##) #, (#), ... reformats to 2 or more digits
...
(##########) #, (#), ... reformats to 10 digits
. *, ?, #, (#), ... skip
= nothing copies entire variable name
-------------------------------------------------------------------
Specifier # in any of its guises may also correspond with * or ? if the renumber option is specified.
The options are as follows:
options1 Description
-------------------------------------------------------------------------------------------------------------------------------------------------
addnumber add sequential numbering to end
addnumber(#) addnumber, starting at #
renumber renumber sequentially
renumber(#) renumber, starting at #
sort sort before numbering
dryrun do not rename, but instead produce a report
r store variable names in r() for programming use
-------------------------------------------------------------------------------------------------------------------------------------------------
These options correspond to the first and second syntaxes.
options2 Description
-------------------------------------------------------------------------------------------------------------------------------------------------
upper uppercase variable names (UPPERCASE)
lower lowercase variable names (lowercase)
proper propercase variable names (Propercase)
dryrun do not rename, but instead produce a report
r store variable names in r() for programming use
-------------------------------------------------------------------------------------------------------------------------------------------------
These options correspond to the third syntax. One of upper, lower, or proper must be specified.
发帖
雷达卡
加好友,备注jltj
京公网安备 11010802022788号
论坛法律顾问：王进律师
知识产权保护声明
免责及隐私声明
提升卡
置顶卡
沉默卡
变色卡
抢沙发
千斤顶
显身卡
