小编Sot*_*tos的帖子

还在学习R,但我个人认为这是不可能的,我希望你们中的一个能证明我的错.

我希望找到值<= 25th百分位数的平均值,以及值> = 75th百分位数的平均值; 但不是整个数据集.我想找到这些数据子集的方法,从中找到百分位数.

这将生成类似于我自己的数据:

library(data.table)
DT <- data.table(V1 <- c('AR','AR','AR','AR','AR','AR','AD','AD','AD','AD','AD','AD','BD',
                         'BD','BD','BD','BX','CX','DX','DX','DD','DD','DD','DD','DR','DR',
                         'DR','DR','DR','DR'),
                 V2 <- c(.12,.02,.03,.22,.44,.09,.11,.17,.15,.26,.29,.27,.16,.16,.02,.12,.02,
                         .03,.22,.44,.09,.11,.17,.15,.26,.29,.27,.16,.16,.02))

好像:

    V1   V2
 1: AR 0.12
 2: AR 0.02
 3: AR 0.03
 4: AR 0.22
 5: AR 0.44
 6: AR 0.09
 7: AD 0.11
 8: AD 0.17
 9: AD 0.15
10: AD 0.26
11: AD 0.29
12: AD 0.27
13: BD 0.16
14: BD 0.16
15: BD 0.02
16: BD 0.12
17: BX 0.02
18: CX 0.03
19: DX 0.22
20: …

我想基于元素之和小于或等于对矢量进行分组n.假设如下,

set.seed(1)
x <- sample(10, 20, replace = TRUE)
#[1]  3  4  6 10  3  9 10  7  7  1  3  2  7  4  8  5  8 10  4  8

#Where,
n = 15

预期输出将是组值,而它们的总和<= 15,即

y <- c(1, 1, 1, 2, 2, 3, 4, 5 ,5, 5, 6, 6, 6, 7, 7, 8, 8, 9, 9, 10)

如你所见,总和绝不会超过15,

sapply(split(x, y), sum)
# 1  2  3  4  5  6  7  8  9 10 
#13 13  9 10 15 …

我想在R中生成随机n×n矩阵,离散值范围从1到n.棘手的部分是我希望每个值在行和列中都是唯一的.

例如,如果n=3矩阵看起来像:

1 2 3 
2 3 1 
3 1 2 

或者看起来像这样:

2 3 1 
1 2 3 
3 1 2 

任何人都知道如何生成这种矩阵？

我是R的新手，目前正尝试根据预定义的排除标准对数据进行子集分析。我目前正在尝试删除ICD-10编码的所有患有痴呆症的病例。问题是，有多个变量包含有关每个人的疾病状况的信息（约70个变量），尽管由于它们以相同的方式编码，因此可以对所有变量应用相同的条件。

一些模拟数据：

#Create dataframe containing simulated data
df = data.frame(ID = c(1001, 1002, 1003, 1004, 1005,1006,1007,1008,1009,1010,1011),
                    disease_code_1 = c('I802','H356','G560','D235','B178','F011','F023','C761','H653','A049','J679'),
                    disease_code_2 = c('A071','NA','G20','NA','NA','A049','NA','NA','G300','G308','A045'),
                    disease_code_3 = c('H250','NA','NA','I802','NA','A481','NA','NA','NA','NA','D352'))

#data is structured as below:

     ID disease_code_1 disease_code_2 disease_code_3
1  1001           I802           A071           H250
2  1002           H356             NA             NA
3  1003           G560            G20             NA
4  1004           D235             NA           I802
5  1005           B178             NA             NA
6  1006           F011           A049           A481
7  1007           F023             NA             NA
8  1008           C761             NA             NA
9  1009           H653           G300             NA
10 …

我今天无意中遇到了这个问题，我注意到虽然我将数据框保存为df，但我可以用等效的希腊字母来调用它。（我忘记我将键盘设置为希腊语）。

经过一番调查后，我不明白为什么会这样。起初我认为它适用于相当于英语的希腊语。类似于b & \xce\xb2或a & \xce\xb1或 ，d & \xce\xb4但不适用于没有希腊语等价物的字母，例如j。然而这件事发生了，

知道这里发生了什么吗？

我的会话信息：

R version 4.1.3 (2022-03-10)\nPlatform: x86_64-w64-mingw32/x64 (64-bit)\nRunning under: Windows 10 x64 (build 22000)\n\nMatrix products: default\n\nlocale:\n[1] LC_COLLATE=English_United Kingdom.1252  LC_CTYPE=English_United Kingdom.1252    LC_MONETARY=English_United Kingdom.1252 LC_NUMERIC=C                           \n[5] LC_TIME=English_United Kingdom.1252    \n\nattached base packages:\n[1] stats     graphics  grDevices utils     datasets  methods   base     \n\nother attached packages:\n [1] data.table_1.14.2 forcats_0.5.1     stringr_1.4.0     dplyr_1.0.8       purrr_0.3.4       readr_2.1.2       tidyr_1.2.0       tibble_3.1.6      ggplot2_3.3.5     tidyverse_1.3.1  \n\nloaded via a namespace (and …

有这样的数据框：

data.frame(text = c("separate1: and: more","another 20: 42")

如何在每一行中使用第一个 : 进行分隔？预期输出示例

data.frame(text1 = c("separate1","another 20"), text2 = c("and: more","42")

我有一个字符串,比方说MyString ="aabbccawww".我想使用gsub表达式将MyString中的最后一个"a"替换为"A",并且仅使用它.那就是"aabbccAwww".我在网站上发现了类似的问题,但他们都要求更换最后一次出现以及之后的所有内容.我尝试过gsub("a [^ a]*$","A",MyString),但它给出了"aabbccA".我知道我可以为此目的使用stringi函数,但我需要在代码的一部分中实现解决方案,其中使用这样的函数会很复杂,所以我想使用正则表达式.有什么建议吗？

我想替换匹配特定模式的字符串中的每个字符.请使用以下字符串

mystring <- c("000450")

我希望将所有单个零匹配到第一个非零的元素.我试过类似的东西

gsub("^0[^1-9]*", "x", mystring)
[1] "x450"

此表达式用一个替换所有前导零x.但相反,我想要替换所有三个前导零xxx.首选的结果是

[1] "xxx450"

谁能帮我吗？

我正在使用PySpark处理一个庞大的数据集,我希望根据另一个数据框中的字符串过滤数据帧.例如,

dd = spark.createDataFrame(["something.google.com","something.google.com.somethingelse.ac.uk","something.good.com.cy", "something.good.com.cy.mal.org"], StringType()).toDF('domains')
+----------------------------------------+
|domains                                 |
+----------------------------------------+
|something.google.com                    |
|something.google.com.somethingelse.ac.uk|
|something.good.com.cy                   |
|something.good.com.cy.mal.org           |
+----------------------------------------+  

dd1 =  spark.createDataFrame(["google.com", "good.com.cy"], StringType()).toDF('gooddomains')
+-----------+
|gooddomains|
+-----------+
|google.com |
|good.com.cy|
+-----------+

我认为domains和gooddomains有效的域名.

我想要做的是过滤掉dd不结束的匹配字符串dd1.所以在上面的例子中,我想过滤掉第1行和第3行,最后得到

+----------------------------------------+
|domains                                 |
+----------------------------------------+
|something.google.com.somethingelse.ac.uk|
|something.good.com.cy.mal.org           |
+----------------------------------------+  

我目前的解决方案(如下所示)只能考虑最多3个字的域名.如果我要添加say,verygood.co.ac.ukin dd1(即白名单),那么它将失败.

def split_filter(x, whitelist):
    splitted1 = x.select(F.split(x['domains'], '\.').alias('splitted_domains'))
    last_two = splitted1.select(F.concat(splitted1.splitted_domains[F.size(splitted1.splitted_domains)-2], \
       F.lit('.'), \
       splitted1.splitted_domains[F.size(splitted1.splitted_domains)-1]).alias('last_two'))
    last_three = splitted1.select(F.concat(splitted1.splitted_domains[F.size(splitted1.splitted_domains)-3], \
       F.lit('.'), \
       splitted1.splitted_domains[F.size(splitted1.splitted_domains)-2], \
       F.lit('.'), \
       splitted1.splitted_domains[F.size(splitted1.splitted_domains)-1]).alias('last_three'))
    x = …

dput(new)
structure(list(ID = c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 
13, 14, 15, 16, 17, 18, 19, 20, 21, 22), A1 = c(1, 1, 1, 1, 0, 
0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), A2 = c(1, 
1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
), A3 = c(0, 0, 0, 0, …