devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

生信&数据挖掘——人工神经网络篇(2)GEO数据下载及注释_如何获取geo数据库中的gpl24676的探针数据并进行注释?

作者：IT小白 | 2024-03-14 16:41:53

赞

踩

如何获取geo数据库中的gpl24676的探针数据并进行注释?

目录

序言

GEO数据下载

GEO数据注释

序言

基因组学是一门研究基因组的科学，它涉及到基因组的结构，功能，表达，进化和疾病相关性等方面。基因组学的研究需要大量的基因数据，而这些数据可以从公共数据库中获得。

其中最常用的数据库是GEO（Gene Expression Omnibus），它提供了大量的基因表达数据，可以用于基因组学研究。 GEO数据库中的数据可以通过FTP或Web界面下载，下载的数据可以是原始数据，也可以是已经注释的数据。

下载的原始数据需要进行注释，以便更好地理解和分析数据。GEO数据库中的数据可以使用多种注释工具进行注释，如NCBI的GeneInfo，Ensembl，UniProt，KEGG，GO等。

本文将介绍如何从GEO数据库中下载基因数据，以及如何使用不同的注释工具对数据进行注释。首先，我们将介绍如何从GEO数据库中下载基因数据，包括如何搜索和下载数据，以及如何解压缩下载的数据。然后，我们将介绍如何使用不同的注释工具对数据进行注释，包括NCBI的GeneInfo，Ensembl，UniProt，KEGG，GO等。

最后，我们将介绍如何使用ANN技术对基因数据进行分析，以及如何利用注释的基因数据进行生物信息学研究。

GEO数据下载

https://www.ncbi.nlm.nih.gov/geo/ 

搜索关键字：gastric cancer

下载两个文件，平台文件和基因表达矩阵 

基因表达文件名为GSE54129_series_matrix.txt 

探针文件名字改成GPL570-55999.txt

GEO数据注释

对GEO数据库中的数据进行详细的解释和描述，以便更好地理解基因表达的调控机制。GEO数据注释可以帮助研究人员更好地分析和理解GEO数据库中的数据，从而更好地利用GEO数据库中的数据进行研究。

流程如下：

将基因表达文件改名为ann.txt  探针文件名字改成probe.txt

将perl脚本放下去

 先查看ann.txt中基因名称是第几列，在第11列

 打开cmd终端 输入perl 脚本名字即可注释完成

 

输入基因的名字在哪一列

 得到geneMatrix.txt改名为GSE54129.txt，即是注释好的文件

脚本代码如下：

  1. #!/usr/bin/perl
  2. #line 2 "C:\Strawberry\perl\site\bin\par.pl"
  3. eval 'exec /usr/bin/perl  -S $0 ${1+"$@"}'
  4.     if 0; # not running under some shell
  5.  
  6. package __par_pl;
  7.  
  8. # --- This script must not use any modules at compile time ---
  9. # use strict;
  10.  
  11. #line 156
  12.  
  13.  
  14. my ($PAR_MAGIC, $par_temp, $progname, @tmpfile, %ModuleCache);
  15. END { if ($ENV{PAR_CLEAN}) {
  16.     require File::Temp;
  17.     require File::Basename;
  18.     require File::Spec;
  19.     my $topdir = File::Basename::dirname($par_temp);
  20.     outs(qq[Removing files in "$par_temp"]);
  21.     File::Find::finddepth(sub { ( -d ) ? rmdir : unlink }, $par_temp);
  22.     rmdir $par_temp;
  23.     # Don't remove topdir because this causes a race with other apps
  24.     # that are trying to start.
  25.  
  26.     if (-d $par_temp && $^O ne 'MSWin32') {
  27.         # Something went wrong unlinking the temporary directory.  This
  28.         # typically happens on platforms that disallow unlinking shared
  29.         # libraries and executables that are in use. Unlink with a background
  30.         # shell command so the files are no longer in use by this process.
  31.         # Don't do anything on Windows because our parent process will
  32.         # take care of cleaning things up.
  33.  
  34.         my $tmp = new File::Temp(
  35.             TEMPLATE => 'tmpXXXXX',
  36.             DIR => File::Basename::dirname($topdir),
  37.             SUFFIX => '.cmd',
  38.             UNLINK => 0,
  39.         );
  40.         my $filename = $tmp->filename;
  41.  
  42.         print $tmp <<"...";
  43. #!/bin/sh
  44. x=1; while [ \$x -lt 10 ]; do
  45.    rm -rf '$par_temp'
  46.    if [ \! -d '$par_temp' ]; then
  47.        break
  48.    fi
  49.    sleep 1
  50.    x=`expr \$x + 1`
  51. done
  52. rm '$filename'
  53. ...
  54.         close $tmp;
  55.  
  56.         chmod 0700, $filename;
  57.         my $cmd = "$filename >/dev/null 2>&1 &";
  58.         system($cmd);
  59.         outs(qq[Spawned background process to perform cleanup: $filename]);
  60.     }
  61. } }
  62.  
  63. BEGIN {
  64.     Internals::PAR::BOOT() if defined &Internals::PAR::BOOT;
  65.     $PAR_MAGIC = "\nPAR.pm\n";
  66.  
  67.     eval {
  68.  
  69. _par_init_env();
  70.  
  71. my $quiet = !$ENV{PAR_DEBUG};
  72.  
  73. # fix $progname if invoked from PATH
  74. my %Config = (
  75.     path_sep    => ($^O =~ /^MSWin/ ? ';' : ':'),
  76.     _exe        => ($^O =~ /^(?:MSWin|OS2|cygwin)/ ? '.exe' : ''),
  77.     _delim      => ($^O =~ /^MSWin|OS2/ ? '\\' : '/'),
  78. );
  79.  
  80. _set_progname();
  81. _set_par_temp();
  82.  
  83. # Magic string checking and extracting bundled modules {{{
  84. my ($start_pos, $data_pos);
  85. {
  86.     local $SIG{__WARN__} = sub {};
  87.  
  88.     # Check file type, get start of data section {{{
  89.     open _FH, '<:raw', $progname or last;
  90.  
  91.     # Search for the "\nPAR.pm\n signature backward from the end of the file
  92.     my $buf;
  93.     my $size = -s $progname;
  94.     my $chunk_size = 64 * 1024;
  95.     my $magic_pos;
  96.  
  97.     if ($size <= $chunk_size) {
  98.         $magic_pos = 0;
  99.     } elsif ((my $m = $size % $chunk_size) > 0) {
  100.         $magic_pos = $size - $m;
  101.     } else {
  102.         $magic_pos = $size - $chunk_size;
  103.     }
  104.     # in any case, $magic_pos is a multiple of $chunk_size
  105.  
  106.     while ($magic_pos >= 0) {
  107.         seek _FH, $magic_pos, 0;
  108.         read _FH, $buf, $chunk_size + length($PAR_MAGIC);
  109.         if ((my $i = rindex($buf, $PAR_MAGIC)) >= 0) {
  110.             $magic_pos += $i;
  111.             last;
  112.         }
  113.         $magic_pos -= $chunk_size;
  114.     }
  115.     last if $magic_pos < 0;
  116.  
  117.     # Seek 4 bytes backward from the signature to get the offset of the
  118.     # first embedded FILE, then seek to it
  119.     seek _FH, $magic_pos - 4, 0;
  120.     read _FH, $buf, 4;
  121.     seek _FH, $magic_pos - 4 - unpack("N", $buf), 0;
  122.     $data_pos = tell _FH;
  123.  
  124.     # }}}
  125.  
  126.     # Extracting each file into memory {{{
  127.     my %require_list;
  128.     read _FH, $buf, 4;                           # read the first "FILE"
  129.     while ($buf eq "FILE") {
  130.         read _FH, $buf, 4;
  131.         read _FH, $buf, unpack("N", $buf);
  132.  
  133.         my $fullname = $buf;
  134.         outs(qq[Unpacking FILE "$fullname"...]);
  135.         my $crc = ( $fullname =~ s|^([a-f\d]{8})/|| ) ? $1 : undef;
  136.         my ($basename, $ext) = ($buf =~ m|(?:.*/)?(.*)(\..*)|);
  138.         read _FH, $buf, 4;
  139.         read _FH, $buf, unpack("N", $buf);
  141.         if (defined($ext) and $ext !~ /\.(?:pm|pl|ix|al)$/i) {
  142.             my $filename = _save_as("$crc$ext", $buf, 0755);
  143.             $PAR::Heavy::FullCache{$fullname} = $filename;
  144.             $PAR::Heavy::FullCache{$filename} = $fullname;
  145.         }
  146.         elsif ( $fullname =~ m|^/?shlib/| and defined $ENV{PAR_TEMP} ) {
  147.             my $filename = _save_as("$basename$ext", $buf, 0755);
  148.             outs("SHLIB: $filename\n");
  149.         }
  150.         else {
  151.             $require_list{$fullname} =
  152.             $ModuleCache{$fullname} = {
  153.                 buf => $buf,
  154.                 crc => $crc,
  155.                 name => $fullname,
  156.             };
  157.         }
  158.         read _FH, $buf, 4;
  159.     }
  160.     # }}}
  161.  
  162.     local @INC = (sub {
  163.         my ($self, $module) = @_;
  164.  
  165.         return if ref $module or !$module;
  166.  
  167.         my $info = delete $require_list{$module} or return;
  168.  
  169.         $INC{$module} = "/loader/$info/$module";
  170.  
  171.         if ($ENV{PAR_CLEAN} and defined(&IO::File::new)) {
  172.             my $fh = IO::File->new_tmpfile or die "Can't create temp file: $!";
  173.             $fh->binmode();
  174.             $fh->print($info->{buf});
  175.             $fh->seek(0, 0);
  176.             return $fh;
  177.         }
  178.         else {
  179.             my $filename = _save_as("$info->{crc}.pm", $info->{buf});
  180.  
  181.             open my $fh, '<:raw', $filename or die qq[Can't read "$filename": $!];
  182.             return $fh;
  183.         }
  184.  
  185.         die "Bootstrapping failed: can't find module $module!";
  186.     }, @INC);
  187.  
  188.     # Now load all bundled files {{{
  189.  
  190.     # initialize shared object processing
  191.     require XSLoader;
  192.     require PAR::Heavy;
  193.     require Carp::Heavy;
  194.     require Exporter::Heavy;
  195.     PAR::Heavy::_init_dynaloader();
  196.  
  197.     # now let's try getting helper modules from within
  198.     require IO::File;
  199.  
  200.     # load rest of the group in
  201.     while (my $filename = (sort keys %require_list)[0]) {
  202.         #local $INC{'Cwd.pm'} = __FILE__ if $^O ne 'MSWin32';
  203.         unless ($INC{$filename} or $filename =~ /BSDPAN/) {
  204.             # require modules, do other executable files
  205.             if ($filename =~ /\.pmc?$/i) {
  206.                 require $filename;
  207.             }
  208.             else {
  209.                 # Skip ActiveState's sitecustomize.pl file:
  210.                 do $filename unless $filename =~ /sitecustomize\.pl$/;
  211.             }
  212.         }
  213.         delete $require_list{$filename};
  214.     }
  215.  
  216.     # }}}
  217.  
  218.     last unless $buf eq "PK\003\004";
  219.     $start_pos = (tell _FH) - 4;                # start of zip
  220. }
  221. # }}}
  222.  
  223. # Argument processing {{{
  224. my @par_args;
  225. my ($out, $bundle, $logfh, $cache_name);
  226.  
  227. delete $ENV{PAR_APP_REUSE}; # sanitize (REUSE may be a security problem)
  228.  
  229. $quiet = 0 unless $ENV{PAR_DEBUG};
  230. # Don't swallow arguments for compiled executables without --par-options
  231. if (!$start_pos or ($ARGV[0] eq '--par-options' && shift)) {
  232.     my %dist_cmd = qw(
  233.         p   blib_to_par
  234.         i   install_par
  235.         u   uninstall_par
  236.         s   sign_par
  237.         v   verify_par
  238.     );
  239.  
  240.     # if the app is invoked as "appname --par-options --reuse PROGRAM @PROG_ARGV",
  241.     # use the app to run the given perl code instead of anything from the
  242.     # app itself (but still set up the normal app environment and @INC)
  243.     if (@ARGV and $ARGV[0] eq '--reuse') {
  244.         shift @ARGV;
  245.         $ENV{PAR_APP_REUSE} = shift @ARGV;
  246.     }
  247.     else { # normal parl behaviour
  248.  
  249.         my @add_to_inc;
  250.         while (@ARGV) {
  251.             $ARGV[0] =~ /^-([AIMOBLbqpiusTv])(.*)/ or last;
  252.  
  253.             if ($1 eq 'I') {
  254.                 push @add_to_inc, $2;
  255.             }
  256.             elsif ($1 eq 'M') {
  257.                 eval "use $2";
  258.             }
  259.             elsif ($1 eq 'A') {
  260.                 unshift @par_args, $2;
  261.             }
  262.             elsif ($1 eq 'O') {
  263.                 $out = $2;
  264.             }
  265.             elsif ($1 eq 'b') {
  266.                 $bundle = 'site';
  267.             }
  268.             elsif ($1 eq 'B') {
  269.                 $bundle = 'all';
  270.             }
  271.             elsif ($1 eq 'q') {
  272.                 $quiet = 1;
  273.             }
  274.             elsif ($1 eq 'L') {
  275.                 open $logfh, ">>", $2 or die qq[Can't open log file "$2": $!];
  276.             }
  277.             elsif ($1 eq 'T') {
  278.                 $cache_name = $2;
  279.             }
  280.  
  281.             shift(@ARGV);
  282.  
  283.             if (my $cmd = $dist_cmd{$1}) {
  284.                 delete $ENV{'PAR_TEMP'};
  285.                 init_inc();
  286.                 require PAR::Dist;
  287.                 &{"PAR::Dist::$cmd"}() unless @ARGV;
  288.                 &{"PAR::Dist::$cmd"}($_) for @ARGV;
  289.                 exit;
  290.             }
  291.         }
  292.  
  293.         unshift @INC, @add_to_inc;
  294.     }
  295. }
  296.  
  297. # XXX -- add --par-debug support!
  298.  
  299. # }}}
  300.  
  301. # Output mode (-O) handling {{{
  302. if ($out) {
  303.     {
  304.         #local $INC{'Cwd.pm'} = __FILE__ if $^O ne 'MSWin32';
  305.         require IO::File;
  306.         require Archive::Zip;
  307.         require Digest::SHA;
  308.     }
  309.  
  310.     my $par = shift(@ARGV);
  311.     my $zip;
  312.  
  313.  
  314.     if (defined $par) {
  315.         open my $fh, '<:raw', $par or die qq[Can't find par file "$par": $!];
  316.         bless($fh, 'IO::File');
  317.  
  318.         $zip = Archive::Zip->new;
  319.         ( $zip->readFromFileHandle($fh, $par) == Archive::Zip::AZ_OK() )
  320.             or die qq[Error reading zip archive "$par"];
  321.     }
  322.  
  323.  
  324.     my %env = do {
  325.         if ($zip and my $meta = $zip->contents('META.yml')) {
  326.             $meta =~ s/.*^par:$//ms;
  327.             $meta =~ s/^\S.*//ms;
  328.             $meta =~ /^  ([^:]+): (.+)$/mg;
  329.         }
  330.     };
  331.  
  332.     # Open input and output files {{{
  333.  
  334.     if (defined $par) {
  335.         open my $ph, '<:raw', $par or die qq[Can't read par file "$par": $!];
  336.         my $buf;
  337.         read $ph, $buf, 4;
  338.         die qq["$par" is not a par file] unless $buf eq "PK\003\004";
  339.         close $ph;
  340.     }
  341.  
  342.     CreatePath($out) ;
  343.  
  344.     my $fh = IO::File->new(
  345.         $out,
  346.         IO::File::O_CREAT() | IO::File::O_WRONLY() | IO::File::O_TRUNC(),
  347.         0777,
  348.     ) or die qq[Can't create file "$out": $!];
  349.     $fh->binmode();
  350.  
  351.     seek _FH, 0, 0;
  352.  
  353.     my $loader;
  354.     if (defined $data_pos) {
  355.         read _FH, $loader, $data_pos;
  356.     } else {
  357.         local $/ = undef;
  358.         $loader = <_FH>;
  359.     }
  360.  
  361.     if (!$ENV{PAR_VERBATIM} and $loader =~ /^(?:#!|\@rem)/) {
  362.         require PAR::Filter::PodStrip;
  363.         PAR::Filter::PodStrip->apply(\$loader, $0);
  364.     }
  365.     foreach my $key (sort keys %env) {
  366.         my $val = $env{$key} or next;
  367.         $val = eval $val if $val =~ /^['"]/;
  368.         my $magic = "__ENV_PAR_" . uc($key) . "__";
  369.         my $set = "PAR_" . uc($key) . "=$val";
  370.         $loader =~ s{$magic( +)}{
  371.             $magic . $set . (' ' x (length($1) - length($set)))
  372.         }eg;
  373.     }
  374.     $fh->print($loader);
  375.     # }}}
  376.  
  377.     # Write bundled modules {{{
  378.     if ($bundle) {
  379.         require PAR::Heavy;
  380.         PAR::Heavy::_init_dynaloader();
  381.  
  382.         init_inc();
  383.  
  384.         require_modules();
  385.  
  386.         my @inc = grep { !/BSDPAN/ }
  387.                        grep {
  388.                            ($bundle ne 'site') or
  389.                            ($_ ne $Config::Config{archlibexp} and
  390.                            $_ ne $Config::Config{privlibexp});
  391.                        } @INC;
  392.  
  393.         # normalize paths (remove trailing or multiple consecutive slashes)
  394.         s|/+|/|g, s|/$|| foreach @inc;
  396.         # Now determine the files loaded above by require_modules():
  397.         # Perl source files are found in values %INC and DLLs are
  398.         # found in @DynaLoader::dl_shared_objects.
  399.         my %files;
  400.         $files{$_}++ for @DynaLoader::dl_shared_objects, values %INC;
  402.         my $lib_ext = $Config::Config{lib_ext};         # XXX lib_ext vs dlext ?
  403.         my %written;
  405.         foreach my $key (sort keys %files) {
  406.             my ($file, $name);
  408.             if (defined(my $fc = $PAR::Heavy::FullCache{$key})) {
  409.                 ($file, $name) = ($key, $fc);
  410.             }
  411.             else {
  412.                 foreach my $dir (@inc) {
  413.                     if ($key =~ m|^\Q$dir\E/(.*)$|i) {
  414.                         ($file, $name) = ($key, $1);
  415.                         last;
  416.                     }
  417.                     if ($key =~ m|^/loader/[^/]+/(.*)$|) {
  418.                         if (my $ref = $ModuleCache{$1}) {
  419.                             ($file, $name) = ($ref, $1);
  420.                             last;
  421.                         }
  422.                         if (-f "$dir/$1") {
  423.                             ($file, $name) = ("$dir/$1", $1);
  424.                             last;
  425.                         }
  426.                     }
  427.                 }
  428.             }
  429.             # There are legitimate reasons why we couldn't find $name and $file for a $key:
  430.             # - cperl has e.g. $INC{"XSLoader.pm"} = "XSLoader.c",
  431.             #   $INC{"DynaLoader.pm"}' = "dlboot_c.PL"
  432.             next unless defined $name;
  433.  
  434.             next if $written{$name}++;
  435.             next if !ref($file) and $file =~ /\.\Q$lib_ext\E$/i;
  436.  
  437.             outs(sprintf(qq[Packing FILE "%s"...], ref $file ? $file->{name} : $file));
  438.             my $content;
  439.             if (ref($file)) {
  440.                 $content = $file->{buf};
  441.             }
  442.             else {
  443.                 local $/ = undef;
  444.                 open my $fh, '<:raw', $file or die qq[Can't read "$file": $!];
  445.                 $content = <$fh>;
  446.                 close $fh;
  447.  
  448.                 PAR::Filter::PodStrip->apply(\$content, "<embedded>/$name")
  449.                     if !$ENV{PAR_VERBATIM} and $name =~ /\.(?:pm|ix|al)$/i;
  450.  
  451.                 PAR::Filter::PatchContent->new->apply(\$content, $file, $name);
  452.             }
  453.  
  454.             $fh->print("FILE",
  455.                        pack('N', length($name) + 9),
  456.                        sprintf("%08x/%s", Archive::Zip::computeCRC32($content), $name),
  457.                        pack('N', length($content)),
  458.                        $content);
  459.             outs(qq[Written as "$name"]);
  460.         }
  461.     }
  462.     # }}}
  463.  
  464.     # Now write out the PAR and magic strings {{{
  465.     $zip->writeToFileHandle($fh) if $zip;
  466.  
  467.     $cache_name = substr $cache_name, 0, 40;
  468.     if (!$cache_name and my $mtime = (stat($out))[9]) {
  469.         my $ctx = Digest::SHA->new(1);
  470.         open my $fh, "<:raw", $out;
  471.         $ctx->addfile($fh);
  472.         close $fh;
  473.  
  474.         $cache_name = $ctx->hexdigest;
  475.     }
  476.     $cache_name .= "\0" x (41 - length $cache_name);
  477.     $cache_name .= "CACHE";
  478.     $fh->print($cache_name);
  479.     $fh->print(pack('N', $fh->tell - length($loader)));
  480.     $fh->print($PAR_MAGIC);
  481.     $fh->close;
  482.     chmod 0755, $out;
  483.     # }}}
  484.  
  485.     exit;
  486. }
  487. # }}}
  488.  
  489. # Prepare $progname into PAR file cache {{{
  490. {
  491.     last unless defined $start_pos;
  492.  
  493.     _fix_progname();
  494.  
  495.     # Now load the PAR file and put it into PAR::LibCache {{{
  496.     require PAR;
  497.     PAR::Heavy::_init_dynaloader();
  498.  
  499.  
  500.     {
  501.         #local $INC{'Cwd.pm'} = __FILE__ if $^O ne 'MSWin32';
  502.         require File::Find;
  503.         require Archive::Zip;
  504.     }
  505.  
  506.     my $fh = IO::File->new;                             # Archive::Zip operates on an IO::Handle
  507.     $fh->fdopen(fileno(_FH), 'r') or die qq[fdopen() failed: $!];
  508.  
  509.     # Temporarily increase the chunk size for Archive::Zip so that it will find the EOCD
  510.     # even if lots of stuff has been appended to the pp'ed exe (e.g. by OSX codesign).
  511.     Archive::Zip::setChunkSize(-s _FH);
  512.     my $zip = Archive::Zip->new;
  513.     ( $zip->readFromFileHandle($fh, $progname) == Archive::Zip::AZ_OK() )
  514.         or die qq[Error reading zip archive "$progname"];
  515.     Archive::Zip::setChunkSize(64 * 1024);
  516.  
  517.     push @PAR::LibCache, $zip;
  518.     $PAR::LibCache{$progname} = $zip;
  519.  
  520.     $quiet = !$ENV{PAR_DEBUG};
  521.     outs(qq[\$ENV{PAR_TEMP} = "$ENV{PAR_TEMP}"]);
  522.  
  523.     if (defined $ENV{PAR_TEMP}) { # should be set at this point!
  524.         foreach my $member ( $zip->members ) {
  525.             next if $member->isDirectory;
  526.             my $member_name = $member->fileName;
  527.             next unless $member_name =~ m{
  528.                 ^
  529.                 /?shlib/
  530.                 (?:$Config::Config{version}/)?
  531.                 (?:$Config::Config{archname}/)?
  532.                 ([^/]+)
  533.                 $
  534.             }x;
  535.             my $extract_name = $1;
  536.             my $dest_name = File::Spec->catfile($ENV{PAR_TEMP}, $extract_name);
  537.             if (-f $dest_name && -s _ == $member->uncompressedSize()) {
  538.                 outs(qq[Skipping "$member_name" since it already exists at "$dest_name"]);
  539.             } else {
  540.                 outs(qq[Extracting "$member_name" to "$dest_name"]);
  541.                 $member->extractToFileNamed($dest_name);
  542.                 chmod(0555, $dest_name) if $^O eq "hpux";
  543.             }
  544.         }
  545.     }
  546.     # }}}
  547. }
  548. # }}}
  550. # If there's no main.pl to run, show usage {{{
  551. unless ($PAR::LibCache{$progname}) {
  552.     die << "." unless @ARGV;
  553. Usage: $0 [ -Alib.par ] [ -Idir ] [ -Mmodule ] [ src.par ] [ program.pl ]
  554.        $0 [ -B|-b ] [-Ooutfile] src.par
  555. .
  556.     $ENV{PAR_PROGNAME} = $progname = $0 = shift(@ARGV);
  557. }
  558. # }}}
  560. sub CreatePath {
  561.     my ($name) = @_;
  563.     require File::Basename;
  564.     my ($basename, $path, $ext) = File::Basename::fileparse($name, ('\..*'));
  566.     require File::Path;
  568.     File::Path::mkpath($path) unless(-e $path); # mkpath dies with error
  569. }
  571. sub require_modules {
  573.     require lib;
  574.     require DynaLoader;
  575.     require integer;
  576.     require strict;
  577.     require warnings;
  578.     require vars;
  579.     require Carp;
  580.     require Carp::Heavy;
  581.     require Errno;
  582.     require Exporter::Heavy;
  583.     require Exporter;
  584.     require Fcntl;
  585.     require File::Temp;
  586.     require File::Spec;
  587.     require XSLoader;
  588.     require Config;
  589.     require IO::Handle;
  590.     require IO::File;
  591.     require Compress::Zlib;
  592.     require Archive::Zip;
  593.     require Digest::SHA;
  594.     require PAR;
  595.     require PAR::Heavy;
  596.     require PAR::Dist;
  597.     require PAR::Filter::PodStrip;
  598.     require PAR::Filter::PatchContent;
  599.     require attributes;
  600.     eval { require Cwd };
  601.     eval { require Win32 };
  602.     eval { require Scalar::Util };
  603.     eval { require Archive::Unzip::Burst };
  604.     eval { require Tie::Hash::NamedCapture };
  605.     eval { require PerlIO; require PerlIO::scalar };
  606.     eval { require utf8 };
  607. }
  609. # The C version of this code appears in myldr/mktmpdir.c
  610. # This code also lives in PAR::SetupTemp as set_par_temp_env!
  611. sub _set_par_temp {
  612.     if (defined $ENV{PAR_TEMP} and $ENV{PAR_TEMP} =~ /(.+)/) {
  613.         $par_temp = $1;
  614.         return;
  615.     }
  616.  
  617.     foreach my $path (
  618.         (map $ENV{$_}, qw( PAR_TMPDIR TMPDIR TEMPDIR TEMP TMP )),
  619.         qw( C:\\TEMP /tmp . )
  620.     ) {
  621.         next unless defined $path and -d $path and -w $path;
  622.         my $username;
  623.         my $pwuid;
  624.         # does not work everywhere:
  625.         eval {($pwuid) = getpwuid($>) if defined $>;};
  626.  
  627.         if ( defined(&Win32::LoginName) ) {
  628.             $username = &Win32::LoginName;
  629.         }
  630.         elsif (defined $pwuid) {
  631.             $username = $pwuid;
  632.         }
  633.         else {
  634.             $username = $ENV{USERNAME} || $ENV{USER} || 'SYSTEM';
  635.         }
  636.         $username =~ s/\W/_/g;
  637.  
  638.         my $stmpdir = "$path$Config{_delim}par-".unpack("H*", $username);
  639.         mkdir $stmpdir, 0755;
  640.         if (!$ENV{PAR_CLEAN} and my $mtime = (stat($progname))[9]) {
  641.             open my $fh, "<:raw", $progname or die qq[Can't read "$progname": $!];
  642.             seek $fh, -18, 2;
  643.             my $buf;
  644.             read $fh, $buf, 6;
  645.             if ($buf eq "\0CACHE") {
  646.                 seek $fh, -58, 2;
  647.                 read $fh, $buf, 41;
  648.                 $buf =~ s/\0//g;
  649.                 $stmpdir .= "$Config{_delim}cache-$buf";
  650.             }
  651.             else {
  652.                 my $digest = eval
  653.                 {
  654.                     require Digest::SHA;
  655.                     my $ctx = Digest::SHA->new(1);
  656.                     open my $fh, "<:raw", $progname or die qq[Can't read "$progname": $!];
  657.                     $ctx->addfile($fh);
  658.                     close($fh);
  659.                     $ctx->hexdigest;
  660.                 } || $mtime;
  661.  
  662.                 $stmpdir .= "$Config{_delim}cache-$digest";
  663.             }
  664.             close($fh);
  665.         }
  666.         else {
  667.             $ENV{PAR_CLEAN} = 1;
  668.             $stmpdir .= "$Config{_delim}temp-$$";
  669.         }
  670.  
  671.         $ENV{PAR_TEMP} = $stmpdir;
  672.         mkdir $stmpdir, 0755;
  673.         last;
  674.     }
  675.  
  676.     $par_temp = $1 if $ENV{PAR_TEMP} and $ENV{PAR_TEMP} =~ /(.+)/;
  677. }
  678.  
  679.  
  680. # check if $name (relative to $par_temp) already exists;
  681. # if not, create a file with a unique temporary name,
  682. # fill it with $contents, set its file mode to $mode if present;
  683. # finaly rename it to $name;
  684. # in any case return the absolute filename
  685. sub _save_as {
  686.     my ($name, $contents, $mode) = @_;
  687.  
  688.     my $fullname = "$par_temp/$name";
  689.     unless (-e $fullname) {
  690.         my $tempname = "$fullname.$$";
  691.  
  692.         open my $fh, '>:raw', $tempname or die qq[Can't write "$tempname": $!];
  693.         print $fh $contents;
  694.         close $fh;
  695.         chmod $mode, $tempname if defined $mode;
  696.  
  697.         rename($tempname, $fullname) or unlink($tempname);
  698.         # NOTE: The rename() error presumably is something like ETXTBSY
  699.         # (scenario: another process was faster at extraction $fullname
  700.         # than us and is already using it in some way); anyway,
  701.         # let's assume $fullname is "good" and clean up our copy.
  702.     }
  703.  
  704.     return $fullname;
  705. }
  706.  
  707. # same code lives in PAR::SetupProgname::set_progname
  708. sub _set_progname {
  709.     if (defined $ENV{PAR_PROGNAME} and $ENV{PAR_PROGNAME} =~ /(.+)/) {
  710.         $progname = $1;
  711.     }
  712.  
  713.     $progname ||= $0;
  714.  
  715.     if ($ENV{PAR_TEMP} and index($progname, $ENV{PAR_TEMP}) >= 0) {
  716.         $progname = substr($progname, rindex($progname, $Config{_delim}) + 1);
  717.     }
  718.  
  719.     if (!$ENV{PAR_PROGNAME} or index($progname, $Config{_delim}) >= 0) {
  720.         if (open my $fh, '<', $progname) {
  721.             return if -s $fh;
  722.         }
  723.         if (-s "$progname$Config{_exe}") {
  724.             $progname .= $Config{_exe};
  725.             return;
  726.         }
  727.     }
  728.  
  729.     foreach my $dir (split /\Q$Config{path_sep}\E/, $ENV{PATH}) {
  730.         next if exists $ENV{PAR_TEMP} and $dir eq $ENV{PAR_TEMP};
  731.         $dir =~ s/\Q$Config{_delim}\E$//;
  732.         (($progname = "$dir$Config{_delim}$progname$Config{_exe}"), last)
  733.             if -s "$dir$Config{_delim}$progname$Config{_exe}";
  734.         (($progname = "$dir$Config{_delim}$progname"), last)
  735.             if -s "$dir$Config{_delim}$progname";
  736.     }
  737. }
  738.  
  739. sub _fix_progname {
  740.     $0 = $progname ||= $ENV{PAR_PROGNAME};
  741.     if (index($progname, $Config{_delim}) < 0) {
  742.         $progname = ".$Config{_delim}$progname";
  743.     }
  744.  
  745.     # XXX - hack to make PWD work
  746.     my $pwd = (defined &Cwd::getcwd) ? Cwd::getcwd()
  747.                 : ((defined &Win32::GetCwd) ? Win32::GetCwd() : `pwd`);
  748.     chomp($pwd);
  749.     $progname =~ s/^(?=\.\.?\Q$Config{_delim}\E)/$pwd$Config{_delim}/;
  750.  
  751.     $ENV{PAR_PROGNAME} = $progname;
  752. }
  753.  
  754. sub _par_init_env {
  755.     if ( $ENV{PAR_INITIALIZED}++ == 1 ) {
  756.         return;
  757.     } else {
  758.         $ENV{PAR_INITIALIZED} = 2;
  759.     }
  760.  
  761.     for (qw( SPAWNED TEMP CLEAN DEBUG CACHE PROGNAME ) ) {
  762.         delete $ENV{'PAR_'.$_};
  763.     }
  764.     for (qw/ TMPDIR TEMP CLEAN DEBUG /) {
  765.         $ENV{'PAR_'.$_} = $ENV{'PAR_GLOBAL_'.$_} if exists $ENV{'PAR_GLOBAL_'.$_};
  766.     }
  767.  
  768.     my $par_clean = "__ENV_PAR_CLEAN__               ";
  769.  
  770.     if ($ENV{PAR_TEMP}) {
  771.         delete $ENV{PAR_CLEAN};
  772.     }
  773.     elsif (!exists $ENV{PAR_GLOBAL_CLEAN}) {
  774.         my $value = substr($par_clean, 12 + length("CLEAN"));
  775.         $ENV{PAR_CLEAN} = $1 if $value =~ /^PAR_CLEAN=(\S+)/;
  776.     }
  777. }
  778.  
  779. sub outs {
  780.     return if $quiet;
  781.     if ($logfh) {
  782.         print $logfh "@_\n";
  783.     }
  784.     else {
  785.         print "@_\n";
  786.     }
  787. }
  788.  
  789. sub init_inc {
  790.     require Config;
  791.     push @INC, grep defined, map $Config::Config{$_}, qw(
  792.         archlibexp privlibexp sitearchexp sitelibexp
  793.         vendorarchexp vendorlibexp
  794.     );
  795. }
  796.  
  797. ########################################################################
  798. # The main package for script execution
  799.  
  800. package main;
  801.  
  802. require PAR;
  803. unshift @INC, \&PAR::find_par;
  804. PAR->import(@par_args);
  805.  
  806. die qq[par.pl: Can't open perl script "$progname": No such file or directory\n]
  807.     unless -e $progname;
  808.  
  809. do $progname;
  810. CORE::exit($1) if ($@ =~/^_TK_EXIT_\((\d+)\)/);
  811. die $@ if $@;
  812.  
  813. };
  814.  
  815. $::__ERROR = $@ if $@;
  816. }
  817.  
  818. CORE::exit($1) if ($::__ERROR =~/^_TK_EXIT_\((\d+)\)/);
  819. die $::__ERROR if $::__ERROR;
  820.  
  821. 1;
  822.  
  823. #line 1006
  824.  
  825.  __END__
  826. PK

下一步是分组，分为对照组和实验组（简单来说就是癌症和非癌症一组）

先复制一份probe.txt副本，里面有病人的临床数据

将病人的临床信息复制一份

 

在目录下新建clincal.xlsx，将临床信息复制进去

 

 选择选择性粘贴，选择转置，然后点击确定

 

找到ID和病人情况两列，只要这两列

 进行排序，并且将对照组的病人id复制到一个新的空白的名为s1的txt中

将实验组组的病人id复制到一个新的空白的名为s2的txt中

 

 

准备完毕！！！ 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/235912
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号