polars-df 0.2.0-x86_64-darwin
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- data/.yardopts +3 -0
- data/CHANGELOG.md +33 -0
- data/Cargo.lock +2230 -0
- data/Cargo.toml +10 -0
- data/LICENSE-THIRD-PARTY.txt +38856 -0
- data/LICENSE.txt +20 -0
- data/README.md +91 -0
- data/lib/polars/3.0/polars.bundle +0 -0
- data/lib/polars/3.1/polars.bundle +0 -0
- data/lib/polars/3.2/polars.bundle +0 -0
- data/lib/polars/batched_csv_reader.rb +96 -0
- data/lib/polars/cat_expr.rb +52 -0
- data/lib/polars/cat_name_space.rb +54 -0
- data/lib/polars/convert.rb +100 -0
- data/lib/polars/data_frame.rb +4833 -0
- data/lib/polars/data_types.rb +122 -0
- data/lib/polars/date_time_expr.rb +1418 -0
- data/lib/polars/date_time_name_space.rb +1484 -0
- data/lib/polars/dynamic_group_by.rb +52 -0
- data/lib/polars/exceptions.rb +20 -0
- data/lib/polars/expr.rb +5307 -0
- data/lib/polars/expr_dispatch.rb +22 -0
- data/lib/polars/functions.rb +453 -0
- data/lib/polars/group_by.rb +558 -0
- data/lib/polars/io.rb +814 -0
- data/lib/polars/lazy_frame.rb +2442 -0
- data/lib/polars/lazy_functions.rb +1195 -0
- data/lib/polars/lazy_group_by.rb +93 -0
- data/lib/polars/list_expr.rb +610 -0
- data/lib/polars/list_name_space.rb +346 -0
- data/lib/polars/meta_expr.rb +54 -0
- data/lib/polars/rolling_group_by.rb +35 -0
- data/lib/polars/series.rb +3730 -0
- data/lib/polars/slice.rb +104 -0
- data/lib/polars/string_expr.rb +972 -0
- data/lib/polars/string_name_space.rb +690 -0
- data/lib/polars/struct_expr.rb +100 -0
- data/lib/polars/struct_name_space.rb +64 -0
- data/lib/polars/utils.rb +192 -0
- data/lib/polars/version.rb +4 -0
- data/lib/polars/when.rb +16 -0
- data/lib/polars/when_then.rb +19 -0
- data/lib/polars-df.rb +1 -0
- data/lib/polars.rb +50 -0
- metadata +89 -0
@@ -0,0 +1,690 @@
|
|
1
|
+
module Polars
|
2
|
+
# Series.str namespace.
|
3
|
+
class StringNameSpace
|
4
|
+
include ExprDispatch
|
5
|
+
|
6
|
+
self._accessor = "str"
|
7
|
+
|
8
|
+
# @private
|
9
|
+
def initialize(series)
|
10
|
+
self._s = series._s
|
11
|
+
end
|
12
|
+
|
13
|
+
# Parse a Series of dtype Utf8 to a Date/Datetime Series.
|
14
|
+
#
|
15
|
+
# @param datatype [Symbol]
|
16
|
+
# `:date`, `:dateime`, or `:time`.
|
17
|
+
# @param fmt [String]
|
18
|
+
# Format to use, refer to the
|
19
|
+
# [chrono strftime documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
|
20
|
+
# for specification. Example: `"%y-%m-%d"`.
|
21
|
+
# @param strict [Boolean]
|
22
|
+
# Raise an error if any conversion fails.
|
23
|
+
# @param exact [Boolean]
|
24
|
+
# - If true, require an exact format match.
|
25
|
+
# - If false, allow the format to match anywhere in the target string.
|
26
|
+
#
|
27
|
+
# @return [Series]
|
28
|
+
#
|
29
|
+
# @example
|
30
|
+
# s = Polars::Series.new(
|
31
|
+
# "date",
|
32
|
+
# [
|
33
|
+
# "2021-04-22",
|
34
|
+
# "2022-01-04 00:00:00",
|
35
|
+
# "01/31/22",
|
36
|
+
# "Sun Jul 8 00:34:60 2001"
|
37
|
+
# ]
|
38
|
+
# )
|
39
|
+
# s.to_frame.with_column(
|
40
|
+
# Polars.col("date")
|
41
|
+
# .str.strptime(:date, "%F", strict: false)
|
42
|
+
# .fill_null(
|
43
|
+
# Polars.col("date").str.strptime(:date, "%F %T", strict: false)
|
44
|
+
# )
|
45
|
+
# .fill_null(Polars.col("date").str.strptime(:date, "%D", strict: false))
|
46
|
+
# .fill_null(Polars.col("date").str.strptime(:date, "%c", strict: false))
|
47
|
+
# )
|
48
|
+
# # =>
|
49
|
+
# # shape: (4, 1)
|
50
|
+
# # ┌────────────┐
|
51
|
+
# # │ date │
|
52
|
+
# # │ --- │
|
53
|
+
# # │ date │
|
54
|
+
# # ╞════════════╡
|
55
|
+
# # │ 2021-04-22 │
|
56
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┤
|
57
|
+
# # │ 2022-01-04 │
|
58
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┤
|
59
|
+
# # │ 2022-01-31 │
|
60
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┤
|
61
|
+
# # │ 2001-07-08 │
|
62
|
+
# # └────────────┘
|
63
|
+
def strptime(datatype, fmt = nil, strict: true, exact: true, cache: true, tz_aware: false)
|
64
|
+
super
|
65
|
+
end
|
66
|
+
|
67
|
+
# Get length of the string values in the Series (as number of bytes).
|
68
|
+
#
|
69
|
+
# @return [Series]
|
70
|
+
#
|
71
|
+
# @note
|
72
|
+
# The returned lengths are equal to the number of bytes in the UTF8 string. If you
|
73
|
+
# need the length in terms of the number of characters, use `n_chars` instead.
|
74
|
+
#
|
75
|
+
# @example
|
76
|
+
# s = Polars::Series.new(["Café", nil, "345", "東京"])
|
77
|
+
# s.str.lengths
|
78
|
+
# # =>
|
79
|
+
# # shape: (4,)
|
80
|
+
# # Series: '' [u32]
|
81
|
+
# # [
|
82
|
+
# # 5
|
83
|
+
# # null
|
84
|
+
# # 3
|
85
|
+
# # 6
|
86
|
+
# # ]
|
87
|
+
def lengths
|
88
|
+
super
|
89
|
+
end
|
90
|
+
|
91
|
+
# Get length of the string values in the Series (as number of chars).
|
92
|
+
#
|
93
|
+
# @return [Series]
|
94
|
+
#
|
95
|
+
# @note
|
96
|
+
# If you know that you are working with ASCII text, `lengths` will be
|
97
|
+
# equivalent, and faster (returns length in terms of the number of bytes).
|
98
|
+
#
|
99
|
+
# @example
|
100
|
+
# s = Polars::Series.new(["Café", nil, "345", "東京"])
|
101
|
+
# s.str.n_chars
|
102
|
+
# # =>
|
103
|
+
# # shape: (4,)
|
104
|
+
# # Series: '' [u32]
|
105
|
+
# # [
|
106
|
+
# # 4
|
107
|
+
# # null
|
108
|
+
# # 3
|
109
|
+
# # 2
|
110
|
+
# # ]
|
111
|
+
def n_chars
|
112
|
+
super
|
113
|
+
end
|
114
|
+
|
115
|
+
# Vertically concat the values in the Series to a single string value.
|
116
|
+
#
|
117
|
+
# @param delimiter [String]
|
118
|
+
# The delimiter to insert between consecutive string values.
|
119
|
+
#
|
120
|
+
# @return [Series]
|
121
|
+
#
|
122
|
+
# @example
|
123
|
+
# Polars::Series.new([1, nil, 2]).str.concat("-")[0]
|
124
|
+
# # => "1-null-2"
|
125
|
+
def concat(delimiter = "-")
|
126
|
+
super
|
127
|
+
end
|
128
|
+
|
129
|
+
# Check if strings in Series contain a substring that matches a regex.
|
130
|
+
#
|
131
|
+
# @param pattern [String]
|
132
|
+
# A valid regex pattern.
|
133
|
+
# @param literal [Boolean]
|
134
|
+
# Treat pattern as a literal string.
|
135
|
+
#
|
136
|
+
# @return [Series]
|
137
|
+
#
|
138
|
+
# @example
|
139
|
+
# s = Polars::Series.new(["Crab", "cat and dog", "rab$bit", nil])
|
140
|
+
# s.str.contains("cat|bit")
|
141
|
+
# # =>
|
142
|
+
# # shape: (4,)
|
143
|
+
# # Series: '' [bool]
|
144
|
+
# # [
|
145
|
+
# # false
|
146
|
+
# # true
|
147
|
+
# # true
|
148
|
+
# # null
|
149
|
+
# # ]
|
150
|
+
#
|
151
|
+
# @example
|
152
|
+
# s.str.contains("rab$", literal: true)
|
153
|
+
# # =>
|
154
|
+
# # shape: (4,)
|
155
|
+
# # Series: '' [bool]
|
156
|
+
# # [
|
157
|
+
# # false
|
158
|
+
# # false
|
159
|
+
# # true
|
160
|
+
# # null
|
161
|
+
# # ]
|
162
|
+
def contains(pattern, literal: false)
|
163
|
+
super
|
164
|
+
end
|
165
|
+
|
166
|
+
# Check if string values end with a substring.
|
167
|
+
#
|
168
|
+
# @param sub [String]
|
169
|
+
# Suffix substring.
|
170
|
+
#
|
171
|
+
# @return [Series]
|
172
|
+
#
|
173
|
+
# @example
|
174
|
+
# s = Polars::Series.new("fruits", ["apple", "mango", nil])
|
175
|
+
# s.str.ends_with("go")
|
176
|
+
# # =>
|
177
|
+
# # shape: (3,)
|
178
|
+
# # Series: 'fruits' [bool]
|
179
|
+
# # [
|
180
|
+
# # false
|
181
|
+
# # true
|
182
|
+
# # null
|
183
|
+
# # ]
|
184
|
+
def ends_with(sub)
|
185
|
+
super
|
186
|
+
end
|
187
|
+
|
188
|
+
# Check if string values start with a substring.
|
189
|
+
#
|
190
|
+
# @param sub [String]
|
191
|
+
# Prefix substring.
|
192
|
+
#
|
193
|
+
# @return [Series]
|
194
|
+
#
|
195
|
+
# @example
|
196
|
+
# s = Polars::Series.new("fruits", ["apple", "mango", nil])
|
197
|
+
# s.str.starts_with("app")
|
198
|
+
# # =>
|
199
|
+
# # shape: (3,)
|
200
|
+
# # Series: 'fruits' [bool]
|
201
|
+
# # [
|
202
|
+
# # true
|
203
|
+
# # false
|
204
|
+
# # null
|
205
|
+
# # ]
|
206
|
+
def starts_with(sub)
|
207
|
+
super
|
208
|
+
end
|
209
|
+
|
210
|
+
# Decode a value using the provided encoding.
|
211
|
+
#
|
212
|
+
# @param encoding ["hex", "base64"]
|
213
|
+
# The encoding to use.
|
214
|
+
# @param strict [Boolean]
|
215
|
+
# How to handle invalid inputs:
|
216
|
+
#
|
217
|
+
# - `true`: An error will be thrown if unable to decode a value.
|
218
|
+
# - `false`: Unhandled values will be replaced with `nil`.
|
219
|
+
#
|
220
|
+
# @return [Series]
|
221
|
+
#
|
222
|
+
# @example
|
223
|
+
# s = Polars::Series.new(["666f6f", "626172", nil])
|
224
|
+
# s.str.decode("hex")
|
225
|
+
# # =>
|
226
|
+
# # shape: (3,)
|
227
|
+
# # Series: '' [str]
|
228
|
+
# # [
|
229
|
+
# # "foo"
|
230
|
+
# # "bar"
|
231
|
+
# # null
|
232
|
+
# # ]
|
233
|
+
def decode(encoding, strict: false)
|
234
|
+
super
|
235
|
+
end
|
236
|
+
|
237
|
+
# Encode a value using the provided encoding.
|
238
|
+
#
|
239
|
+
# @param encoding ["hex", "base64"]
|
240
|
+
# The encoding to use.
|
241
|
+
#
|
242
|
+
# @return [Series]
|
243
|
+
#
|
244
|
+
# @example
|
245
|
+
# s = Polars::Series.new(["foo", "bar", nil])
|
246
|
+
# s.str.encode("hex")
|
247
|
+
# # =>
|
248
|
+
# # shape: (3,)
|
249
|
+
# # Series: '' [str]
|
250
|
+
# # [
|
251
|
+
# # "666f6f"
|
252
|
+
# # "626172"
|
253
|
+
# # null
|
254
|
+
# # ]
|
255
|
+
def encode(encoding)
|
256
|
+
super
|
257
|
+
end
|
258
|
+
|
259
|
+
# Extract the first match of json string with provided JSONPath expression.
|
260
|
+
#
|
261
|
+
# Throw errors if encounter invalid json strings.
|
262
|
+
# All return value will be casted to Utf8 regardless of the original value.
|
263
|
+
#
|
264
|
+
# Documentation on JSONPath standard can be found
|
265
|
+
# [here](https://goessner.net/articles/JsonPath/).
|
266
|
+
#
|
267
|
+
# @param json_path [String]
|
268
|
+
# A valid JSON path query string.
|
269
|
+
#
|
270
|
+
# @return [Series]
|
271
|
+
#
|
272
|
+
# @example
|
273
|
+
# df = Polars::DataFrame.new(
|
274
|
+
# {"json_val" => ['{"a":"1"}', nil, '{"a":2}', '{"a":2.1}', '{"a":true}']}
|
275
|
+
# )
|
276
|
+
# df.select(Polars.col("json_val").str.json_path_match("$.a"))[0.., 0]
|
277
|
+
# # =>
|
278
|
+
# # shape: (5,)
|
279
|
+
# # Series: 'json_val' [str]
|
280
|
+
# # [
|
281
|
+
# # "1"
|
282
|
+
# # null
|
283
|
+
# # "2"
|
284
|
+
# # "2.1"
|
285
|
+
# # "true"
|
286
|
+
# # ]
|
287
|
+
def json_path_match(json_path)
|
288
|
+
super
|
289
|
+
end
|
290
|
+
|
291
|
+
# Extract the target capture group from provided patterns.
|
292
|
+
#
|
293
|
+
# @param pattern [String]
|
294
|
+
# A valid regex pattern
|
295
|
+
# @param group_index [Integer]
|
296
|
+
# Index of the targeted capture group.
|
297
|
+
# Group 0 mean the whole pattern, first group begin at index 1
|
298
|
+
# Default to the first capture group
|
299
|
+
#
|
300
|
+
# @return [Series]
|
301
|
+
#
|
302
|
+
# @example
|
303
|
+
# df = Polars::DataFrame.new({"foo" => ["123 bla 45 asd", "xyz 678 910t"]})
|
304
|
+
# df.select([Polars.col("foo").str.extract('(\d+)')])
|
305
|
+
# # =>
|
306
|
+
# # shape: (2, 1)
|
307
|
+
# # ┌─────┐
|
308
|
+
# # │ foo │
|
309
|
+
# # │ --- │
|
310
|
+
# # │ str │
|
311
|
+
# # ╞═════╡
|
312
|
+
# # │ 123 │
|
313
|
+
# # ├╌╌╌╌╌┤
|
314
|
+
# # │ 678 │
|
315
|
+
# # └─────┘
|
316
|
+
def extract(pattern, group_index: 1)
|
317
|
+
super
|
318
|
+
end
|
319
|
+
|
320
|
+
# Extracts all matches for the given regex pattern.
|
321
|
+
#
|
322
|
+
# Extract each successive non-overlapping regex match in an individual string as
|
323
|
+
# an array
|
324
|
+
#
|
325
|
+
# @param pattern [String]
|
326
|
+
# A valid regex pattern
|
327
|
+
#
|
328
|
+
# @return [Series]
|
329
|
+
#
|
330
|
+
# @example
|
331
|
+
# s = Polars::Series.new("foo", ["123 bla 45 asd", "xyz 678 910t"])
|
332
|
+
# s.str.extract_all('(\d+)')
|
333
|
+
# # =>
|
334
|
+
# # shape: (2,)
|
335
|
+
# # Series: 'foo' [list]
|
336
|
+
# # [
|
337
|
+
# # ["123", "45"]
|
338
|
+
# # ["678", "910"]
|
339
|
+
# # ]
|
340
|
+
def extract_all(pattern)
|
341
|
+
super
|
342
|
+
end
|
343
|
+
|
344
|
+
# Count all successive non-overlapping regex matches.
|
345
|
+
#
|
346
|
+
# @param pattern [String]
|
347
|
+
# A valid regex pattern
|
348
|
+
#
|
349
|
+
# @return [Series]
|
350
|
+
#
|
351
|
+
# @example
|
352
|
+
# s = Polars::Series.new("foo", ["123 bla 45 asd", "xyz 678 910t"])
|
353
|
+
# s.str.count_match('\d')
|
354
|
+
# # =>
|
355
|
+
# # shape: (2,)
|
356
|
+
# # Series: 'foo' [u32]
|
357
|
+
# # [
|
358
|
+
# # 5
|
359
|
+
# # 6
|
360
|
+
# # ]
|
361
|
+
def count_match(pattern)
|
362
|
+
super
|
363
|
+
end
|
364
|
+
|
365
|
+
# Split the string by a substring.
|
366
|
+
#
|
367
|
+
# @param by [String]
|
368
|
+
# Substring to split by.
|
369
|
+
# @param inclusive [Boolean]
|
370
|
+
# If true, include the split character/string in the results.
|
371
|
+
#
|
372
|
+
# @return [Series]
|
373
|
+
def split(by, inclusive: false)
|
374
|
+
super
|
375
|
+
end
|
376
|
+
|
377
|
+
# Split the string by a substring using `n` splits.
|
378
|
+
#
|
379
|
+
# Results in a struct of `n+1` fields.
|
380
|
+
#
|
381
|
+
# If it cannot make `n` splits, the remaining field elements will be null.
|
382
|
+
#
|
383
|
+
# @param by [String]
|
384
|
+
# Substring to split by.
|
385
|
+
# @param n [Integer]
|
386
|
+
# Number of splits to make.
|
387
|
+
# @param inclusive [Boolean]
|
388
|
+
# If true, include the split character/string in the results.
|
389
|
+
#
|
390
|
+
# @return [Series]
|
391
|
+
#
|
392
|
+
# @example
|
393
|
+
# df = Polars::DataFrame.new({"x" => ["a_1", nil, "c", "d_4"]})
|
394
|
+
# df["x"].str.split_exact("_", 1).alias("fields")
|
395
|
+
# # =>
|
396
|
+
# # shape: (4,)
|
397
|
+
# # Series: 'fields' [struct[2]]
|
398
|
+
# # [
|
399
|
+
# # {"a","1"}
|
400
|
+
# # {null,null}
|
401
|
+
# # {"c",null}
|
402
|
+
# # {"d","4"}
|
403
|
+
# # ]
|
404
|
+
#
|
405
|
+
# @example Split string values in column x in exactly 2 parts and assign each part to a new column.
|
406
|
+
# df["x"]
|
407
|
+
# .str.split_exact("_", 1)
|
408
|
+
# .struct.rename_fields(["first_part", "second_part"])
|
409
|
+
# .alias("fields")
|
410
|
+
# .to_frame
|
411
|
+
# .unnest("fields")
|
412
|
+
# # =>
|
413
|
+
# # shape: (4, 2)
|
414
|
+
# # ┌────────────┬─────────────┐
|
415
|
+
# # │ first_part ┆ second_part │
|
416
|
+
# # │ --- ┆ --- │
|
417
|
+
# # │ str ┆ str │
|
418
|
+
# # ╞════════════╪═════════════╡
|
419
|
+
# # │ a ┆ 1 │
|
420
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
|
421
|
+
# # │ null ┆ null │
|
422
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
|
423
|
+
# # │ c ┆ null │
|
424
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
|
425
|
+
# # │ d ┆ 4 │
|
426
|
+
# # └────────────┴─────────────┘
|
427
|
+
def split_exact(by, n, inclusive: false)
|
428
|
+
super
|
429
|
+
end
|
430
|
+
|
431
|
+
# Split the string by a substring, restricted to returning at most `n` items.
|
432
|
+
#
|
433
|
+
# If the number of possible splits is less than `n-1`, the remaining field
|
434
|
+
# elements will be null. If the number of possible splits is `n-1` or greater,
|
435
|
+
# the last (nth) substring will contain the remainder of the string.
|
436
|
+
#
|
437
|
+
# @param by [String]
|
438
|
+
# Substring to split by.
|
439
|
+
# @param n [Integer]
|
440
|
+
# Max number of items to return.
|
441
|
+
#
|
442
|
+
# @return [Series]
|
443
|
+
#
|
444
|
+
# @example
|
445
|
+
# df = Polars::DataFrame.new({"s" => ["foo bar", nil, "foo-bar", "foo bar baz"]})
|
446
|
+
# df["s"].str.splitn(" ", 2).alias("fields")
|
447
|
+
# # =>
|
448
|
+
# # shape: (4,)
|
449
|
+
# # Series: 'fields' [struct[2]]
|
450
|
+
# # [
|
451
|
+
# # {"foo","bar"}
|
452
|
+
# # {null,null}
|
453
|
+
# # {"foo-bar",null}
|
454
|
+
# # {"foo","bar baz"}
|
455
|
+
# # ]
|
456
|
+
#
|
457
|
+
# @example Split string values in column s in exactly 2 parts and assign each part to a new column.
|
458
|
+
# df["s"]
|
459
|
+
# .str.splitn(" ", 2)
|
460
|
+
# .struct.rename_fields(["first_part", "second_part"])
|
461
|
+
# .alias("fields")
|
462
|
+
# .to_frame
|
463
|
+
# .unnest("fields")
|
464
|
+
# # =>
|
465
|
+
# # shape: (4, 2)
|
466
|
+
# # ┌────────────┬─────────────┐
|
467
|
+
# # │ first_part ┆ second_part │
|
468
|
+
# # │ --- ┆ --- │
|
469
|
+
# # │ str ┆ str │
|
470
|
+
# # ╞════════════╪═════════════╡
|
471
|
+
# # │ foo ┆ bar │
|
472
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
|
473
|
+
# # │ null ┆ null │
|
474
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
|
475
|
+
# # │ foo-bar ┆ null │
|
476
|
+
# # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
|
477
|
+
# # │ foo ┆ bar baz │
|
478
|
+
# # └────────────┴─────────────┘
|
479
|
+
def splitn(by, n)
|
480
|
+
s = Utils.wrap_s(_s)
|
481
|
+
s.to_frame.select(Polars.col(s.name).str.splitn(by, n)).to_series
|
482
|
+
end
|
483
|
+
|
484
|
+
# Replace first matching regex/literal substring with a new string value.
|
485
|
+
#
|
486
|
+
# @param pattern [String]
|
487
|
+
# A valid regex pattern.
|
488
|
+
# @param value [String]
|
489
|
+
# Substring to replace.
|
490
|
+
# @param literal [Boolean]
|
491
|
+
# Treat pattern as a literal string.
|
492
|
+
#
|
493
|
+
# @return [Series]
|
494
|
+
#
|
495
|
+
# @example
|
496
|
+
# s = Polars::Series.new(["123abc", "abc456"])
|
497
|
+
# s.str.replace('abc\b', "ABC")
|
498
|
+
# # =>
|
499
|
+
# # shape: (2,)
|
500
|
+
# # Series: '' [str]
|
501
|
+
# # [
|
502
|
+
# # "123ABC"
|
503
|
+
# # "abc456"
|
504
|
+
# # ]
|
505
|
+
def replace(pattern, value, literal: false)
|
506
|
+
super
|
507
|
+
end
|
508
|
+
|
509
|
+
# Replace all matching regex/literal substrings with a new string value.
|
510
|
+
#
|
511
|
+
# @param pattern [String]
|
512
|
+
# A valid regex pattern.
|
513
|
+
# @param value [String]
|
514
|
+
# Substring to replace.
|
515
|
+
# @param literal [Boolean]
|
516
|
+
# Treat pattern as a literal string.
|
517
|
+
#
|
518
|
+
# @return [Series]
|
519
|
+
#
|
520
|
+
# @example
|
521
|
+
# df = Polars::Series.new(["abcabc", "123a123"])
|
522
|
+
# df.str.replace_all("a", "-")
|
523
|
+
# # =>
|
524
|
+
# # shape: (2,)
|
525
|
+
# # Series: '' [str]
|
526
|
+
# # [
|
527
|
+
# # "-bc-bc"
|
528
|
+
# # "123-123"
|
529
|
+
# # ]
|
530
|
+
def replace_all(pattern, value, literal: false)
|
531
|
+
super
|
532
|
+
end
|
533
|
+
|
534
|
+
# Remove leading and trailing whitespace.
|
535
|
+
#
|
536
|
+
# @param matches [String, nil]
|
537
|
+
# An optional single character that should be trimmed
|
538
|
+
#
|
539
|
+
# @return [Series]
|
540
|
+
def strip(matches = nil)
|
541
|
+
super
|
542
|
+
end
|
543
|
+
|
544
|
+
# Remove leading whitespace.
|
545
|
+
#
|
546
|
+
# @param matches [String, nil]
|
547
|
+
# An optional single character that should be trimmed
|
548
|
+
#
|
549
|
+
# @return [Series]
|
550
|
+
def lstrip(matches = nil)
|
551
|
+
super
|
552
|
+
end
|
553
|
+
|
554
|
+
# Remove trailing whitespace.
|
555
|
+
#
|
556
|
+
# @param matches [String, nil]
|
557
|
+
# An optional single character that should be trimmed
|
558
|
+
#
|
559
|
+
# @return [Series]
|
560
|
+
def rstrip(matches = nil)
|
561
|
+
super
|
562
|
+
end
|
563
|
+
|
564
|
+
# Fills the string with zeroes.
|
565
|
+
#
|
566
|
+
# Return a copy of the string left filled with ASCII '0' digits to make a string
|
567
|
+
# of length width.
|
568
|
+
#
|
569
|
+
# A leading sign prefix ('+'/'-') is handled by inserting the padding after the
|
570
|
+
# sign character rather than before. The original string is returned if width is
|
571
|
+
# less than or equal to `s.length`.
|
572
|
+
#
|
573
|
+
# @param alignment [Integer]
|
574
|
+
# Fill the value up to this length.
|
575
|
+
#
|
576
|
+
# @return [Series]
|
577
|
+
def zfill(alignment)
|
578
|
+
super
|
579
|
+
end
|
580
|
+
|
581
|
+
# Return the string left justified in a string of length `width`.
|
582
|
+
#
|
583
|
+
# Padding is done using the specified `fillchar`. The original string is
|
584
|
+
# returned if `width` is less than or equal to `s.length`.
|
585
|
+
#
|
586
|
+
# @param width [Integer]
|
587
|
+
# Justify left to this length.
|
588
|
+
# @param fillchar [String]
|
589
|
+
# Fill with this ASCII character.
|
590
|
+
#
|
591
|
+
# @return [Series]
|
592
|
+
#
|
593
|
+
# @example
|
594
|
+
# s = Polars::Series.new("a", ["cow", "monkey", nil, "hippopotamus"])
|
595
|
+
# s.str.ljust(8, "*")
|
596
|
+
# # =>
|
597
|
+
# # shape: (4,)
|
598
|
+
# # Series: 'a' [str]
|
599
|
+
# # [
|
600
|
+
# # "cow*****"
|
601
|
+
# # "monkey**"
|
602
|
+
# # null
|
603
|
+
# # "hippopotamus"
|
604
|
+
# # ]
|
605
|
+
def ljust(width, fillchar = " ")
|
606
|
+
super
|
607
|
+
end
|
608
|
+
|
609
|
+
# Return the string right justified in a string of length `width`.
|
610
|
+
#
|
611
|
+
# Padding is done using the specified `fillchar`. The original string is
|
612
|
+
# returned if `width` is less than or equal to `s.length`.
|
613
|
+
#
|
614
|
+
# @param width [Integer]
|
615
|
+
# Justify right to this length.
|
616
|
+
# @param fillchar [String]
|
617
|
+
# Fill with this ASCII character.
|
618
|
+
#
|
619
|
+
# @return [Series]
|
620
|
+
#
|
621
|
+
# @example
|
622
|
+
# s = Polars::Series.new("a", ["cow", "monkey", nil, "hippopotamus"])
|
623
|
+
# s.str.rjust(8, "*")
|
624
|
+
# # =>
|
625
|
+
# # shape: (4,)
|
626
|
+
# # Series: 'a' [str]
|
627
|
+
# # [
|
628
|
+
# # "*****cow"
|
629
|
+
# # "**monkey"
|
630
|
+
# # null
|
631
|
+
# # "hippopotamus"
|
632
|
+
# # ]
|
633
|
+
def rjust(width, fillchar = " ")
|
634
|
+
super
|
635
|
+
end
|
636
|
+
|
637
|
+
# Modify the strings to their lowercase equivalent.
|
638
|
+
#
|
639
|
+
# @return [Series]
|
640
|
+
def to_lowercase
|
641
|
+
super
|
642
|
+
end
|
643
|
+
|
644
|
+
# Modify the strings to their uppercase equivalent.
|
645
|
+
#
|
646
|
+
# @return [Series]
|
647
|
+
def to_uppercase
|
648
|
+
super
|
649
|
+
end
|
650
|
+
|
651
|
+
# Create subslices of the string values of a Utf8 Series.
|
652
|
+
#
|
653
|
+
# @param offset [Integer]
|
654
|
+
# Start index. Negative indexing is supported.
|
655
|
+
# @param length [Integer]
|
656
|
+
# Length of the slice. If set to `nil` (default), the slice is taken to the
|
657
|
+
# end of the string.
|
658
|
+
#
|
659
|
+
# @return [Series]
|
660
|
+
#
|
661
|
+
# @example
|
662
|
+
# s = Polars::Series.new("s", ["pear", nil, "papaya", "dragonfruit"])
|
663
|
+
# s.str.slice(-3)
|
664
|
+
# # =>
|
665
|
+
# # shape: (4,)
|
666
|
+
# # Series: 's' [str]
|
667
|
+
# # [
|
668
|
+
# # "ear"
|
669
|
+
# # null
|
670
|
+
# # "aya"
|
671
|
+
# # "uit"
|
672
|
+
# # ]
|
673
|
+
#
|
674
|
+
# @example Using the optional `length` parameter
|
675
|
+
# s.str.slice(4, 3)
|
676
|
+
# # =>
|
677
|
+
# # shape: (4,)
|
678
|
+
# # Series: 's' [str]
|
679
|
+
# # [
|
680
|
+
# # ""
|
681
|
+
# # null
|
682
|
+
# # "ya"
|
683
|
+
# # "onf"
|
684
|
+
# # ]
|
685
|
+
def slice(offset, length = nil)
|
686
|
+
s = Utils.wrap_s(_s)
|
687
|
+
s.to_frame.select(Polars.col(s.name).str.slice(offset, length)).to_series
|
688
|
+
end
|
689
|
+
end
|
690
|
+
end
|